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

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

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

tactic: dsimp [mk]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
⊢ (Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯ ≫
        colimit.ι (J.diagram P I.Y) { unop := ⊤ })
      (↑x I) =
    (colimMap (J.diagramPullback P I.f.op.unop) ≫ colimit.pre (J.diagram P I.Y) (J.pullback I.f.op.unop).op) (mk x)
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
⊢ (Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯ ≫
        colimit.ι (J.diagram P I.Y) { unop := ⊤ })
      (↑x I) =
    (colimMap (J.diagramPullback P I.f) ≫ colimit.pre (J.diagram P I.Y) (J.pullback I.f).op)
      ((colimit.ι (J.diagram P X) { unop := S }) ((Meq.equiv P S).symm x))

tactic: erw [← comp_apply]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
⊢ (Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯ ≫
        colimit.ι (J.diagram P I.Y) { unop := ⊤ })
      (↑x I) =
    (colimMap (J.diagramPullback P I.f) ≫ colimit.pre (J.diagram P I.Y) (J.pullback I.f).op)
      ((colimit.ι (J.diagram P X) { unop := S }) ((Meq.equiv P S).symm x))
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
⊢ (Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯ ≫
        colimit.ι (J.diagram P I.Y) { unop := ⊤ })
      (↑x I) =
    (colimit.ι (J.diagram P X) { unop := S } ≫
        colimMap (J.diagramPullback P I.f) ≫ colimit.pre (J.diagram P I.Y) (J.pullback I.f).op)
      ((Meq.equiv P S).symm x)

tactic: rw [ι_colimMap_assoc, colimit.ι_pre, comp_apply, comp_apply]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
⊢ (Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯ ≫
        colimit.ι (J.diagram P I.Y) { unop := ⊤ })
      (↑x I) =
    (colimit.ι (J.diagram P X) { unop := S } ≫
        colimMap (J.diagramPullback P I.f) ≫ colimit.pre (J.diagram P I.Y) (J.pullback I.f).op)
      ((Meq.equiv P S).symm x)
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
⊢ (colimit.ι (J.diagram P I.Y) { unop := ⊤ })
      ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I)) =
    (colimit.ι (J.diagram P I.Y) ((J.pullback I.f).op.obj { unop := S }))
      (((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x))

tactic: dsimp only [Functor.op]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
⊢ (colimit.ι (J.diagram P I.Y) { unop := ⊤ })
      ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I)) =
    (colimit.ι (J.diagram P I.Y) ((J.pullback I.f).op.obj { unop := S }))
      (((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x))
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
⊢ (colimit.ι (J.diagram P I.Y) { unop := ⊤ })
      ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I)) =
    (colimit.ι (J.diagram P I.Y) { unop := (J.pullback I.f).obj S })
      (((J.diagramPullback P I.f).app { unop := S }) ((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.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
⊢ (colimit.ι (J.diagram P I.Y) { unop := ⊤ })
      ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I)) =
    (colimit.ι (J.diagram P I.Y) { unop := (J.pullback I.f).obj S })
      (((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x))
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
⊢ (colimit.ι (J.diagram P I.Y) { unop := ⊤ })
      ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I)) =
    (colimit.ι (J.diagram P I.Y) { unop := (J.pullback I.f).obj S })
      (((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x))

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

tactic: erw [comp_apply]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
⊢ ((J.diagram P I.Y).map e.op ≫ colimit.ι (J.diagram P I.Y) { unop := (J.pullback I.f).obj { unop := S }.unop })
      ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I)) =
    (colimit.ι (J.diagram P I.Y) { unop := (J.pullback I.f).obj S })
      (((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x))
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
⊢ (colimit.ι (J.diagram P I.Y) { unop := (J.pullback I.f).obj { unop := S }.unop })
      (((J.diagram P I.Y).map e.op)
        ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I))) =
    (colimit.ι (J.diagram P I.Y) { unop := (J.pullback I.f).obj S })
      (((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x))

tactic: apply congr_arg
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
⊢ (colimit.ι (J.diagram P I.Y) { unop := (J.pullback I.f).obj { unop := S }.unop })
      (((J.diagram P I.Y).map e.op)
        ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I))) =
    (colimit.ι (J.diagram P I.Y) { unop := (J.pullback I.f).obj S })
      (((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x))
state_after: case h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
⊢ ((J.diagram P I.Y).map e.op)
      ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I)) =
    ((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x)

tactic: apply Concrete.multiequalizer_ext
state_before: case h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
⊢ ((J.diagram P I.Y).map e.op)
      ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I)) =
    ((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x)
state_after: case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
⊢ ∀ (t : ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P).L),
    (Multiequalizer.ι ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P) t)
        (((J.diagram P I.Y).map e.op)
          ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I))) =
      (Multiequalizer.ι ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P) t)
        (((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x))

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

tactic: dsimp
state_before: case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
i : ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P).L
⊢ (Multiequalizer.ι ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P) i)
      (((J.diagram P I.Y).map e.op)
        ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I))) =
    (Multiequalizer.ι ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P) i)
      (((J.diagramPullback P I.f).app { unop := S }) ((Meq.equiv P S).symm x))
state_after: case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
i : ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P).L
⊢ (Multiequalizer.ι ((S.pullback I.f).index P) i)
      ((Multiequalizer.lift ((S.pullback I.f).index P) (multiequalizer (⊤.index P))
          (fun I_1 => Multiequalizer.ι (⊤.index P) (I_1.map e)) ⋯)
        ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I))) =
    (Multiequalizer.ι ((S.pullback I.f).index P) i)
      ((Multiequalizer.lift ((S.pullback I.f).index P) (multiequalizer (S.index P))
          (fun I_1 => Multiequalizer.ι (S.index P) I_1.base) ⋯)
        ((Meq.equiv P S).symm x))

tactic: erw [← comp_apply, ← comp_apply, ← comp_apply]
state_before: case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
i : ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P).L
⊢ (Multiequalizer.ι ((S.pullback I.f).index P) i)
      ((Multiequalizer.lift ((S.pullback I.f).index P) (multiequalizer (⊤.index P))
          (fun I_1 => Multiequalizer.ι (⊤.index P) (I_1.map e)) ⋯)
        ((Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯) (↑x I))) =
    (Multiequalizer.ι ((S.pullback I.f).index P) i)
      ((Multiequalizer.lift ((S.pullback I.f).index P) (multiequalizer (S.index P))
          (fun I_1 => Multiequalizer.ι (S.index P) I_1.base) ⋯)
        ((Meq.equiv P S).symm x))
state_after: case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
i : ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P).L
⊢ (Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯ ≫
        Multiequalizer.lift ((S.pullback I.f).index P) (multiequalizer (⊤.index P))
            (fun I_1 => Multiequalizer.ι (⊤.index P) (I_1.map e)) ⋯ ≫
          Multiequalizer.ι ((S.pullback I.f).index P) i)
      (↑x I) =
    (Multiequalizer.lift ((S.pullback I.f).index P) (multiequalizer (S.index P))
          (fun I_1 => Multiequalizer.ι (S.index P) I_1.base) ⋯ ≫
        Multiequalizer.ι ((S.pullback I.f).index P) i)
      ((Meq.equiv P S).symm x)

tactic: rw [Multiequalizer.lift_ι, Multiequalizer.lift_ι, Multiequalizer.lift_ι]
state_before: case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
i : ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P).L
⊢ (Multiequalizer.lift (⊤.index P) (P.obj { unop := I.Y }) (fun I_1 => P.map I_1.f.op) ⋯ ≫
        Multiequalizer.lift ((S.pullback I.f).index P) (multiequalizer (⊤.index P))
            (fun I_1 => Multiequalizer.ι (⊤.index P) (I_1.map e)) ⋯ ≫
          Multiequalizer.ι ((S.pullback I.f).index P) i)
      (↑x I) =
    (Multiequalizer.lift ((S.pullback I.f).index P) (multiequalizer (S.index P))
          (fun I_1 => Multiequalizer.ι (S.index P) I_1.base) ⋯ ≫
        Multiequalizer.ι ((S.pullback I.f).index P) i)
      ((Meq.equiv P S).symm x)
state_after: case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
i : ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P).L
⊢ (P.map (Cover.Arrow.map i e).f.op) (↑x I) =
    (Multiequalizer.ι (S.index P) (Cover.Arrow.base i)) ((Meq.equiv P S).symm x)

tactic: erw [Meq.equiv_symm_eq_apply]
state_before: case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
i : ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P).L
⊢ (P.map (Cover.Arrow.map i e).f.op) (↑x I) =
    (Multiequalizer.ι (S.index P) (Cover.Arrow.base i)) ((Meq.equiv P S).symm x)
state_after: case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
i : ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P).L
⊢ (P.map (Cover.Arrow.map i e).f.op) (↑x I) = ↑x (Cover.Arrow.base i)

tactic: simpa using (x.condition (Cover.Relation.mk' (I.precompRelation i.f))).symm
state_before: case h.h
C : Type u
inst✝⁵ : Category.{v, u} C
J : GrothendieckTopology C
D : Type w
inst✝⁴ : Category.{max v u, w} D
inst✝³ : ConcreteCategory D
inst✝² : PreservesLimits (forget D)
inst✝¹ : ∀ (X : C), HasColimitsOfShape (J.Cover X)ᵒᵖ D
inst✝ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : J.Cover X), HasMultiequalizer (S.index P)
X : C
P : Cᵒᵖ ⥤ D
S : J.Cover X
x : Meq P S
I : S.Arrow
e : (J.pullback I.f).obj { unop := S }.unop ⟶ ⊤ := homOfLE ⋯
i : ({ unop := (J.pullback I.f).obj { unop := S }.unop }.unop.index P).L
⊢ (P.map (Cover.Arrow.map i e).f.op) (↑x I) = ↑x (Cover.Arrow.base i)
state_after: no goals