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

tactic: dsimp [mk, toPlus]
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 : (forget D).obj (P.obj X.op)
⊢ (forget D).map ((toPlus J P).app X.op) x = mk (Meq.mk S x)

tactic: let e : 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 : (forget D).obj (P.obj X.op)
⊢ (forget D).map (Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X) ⊤.op) x =
    (forget D).map (colimit.ι (diagram J P X) S.op) (↑(Meq.equiv P S).symm (Meq.mk S 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 : (forget D).obj (P.obj X.op)
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ (forget D).map (Cover.toMultiequalizer ⊤ P ≫ colimit.ι (diagram J P X) ⊤.op) x =
    (forget D).map (colimit.ι (diagram J P X) S.op) (↑(Meq.equiv P S).symm (Meq.mk S 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 : (forget D).obj (P.obj X.op)
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ (forget D).map (Cover.toMultiequalizer ⊤ P ≫ (diagram J P X).map e.op ≫ colimit.ι (diagram J P X) S.op) x =
    (forget D).map (colimit.ι (diagram J P X) S.op) (↑(Meq.equiv P S).symm (Meq.mk S 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 : (forget D).obj (P.obj X.op)
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ (forget D).map
      (Multiequalizer.lift (Cover.index ⊤ P) (P.obj X.op) (fun I => P.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ P).R),
              (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I =
                (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I) ≫
        (diagram J P X).map e.op ≫ colimit.ι (diagram J P X) S.op)
      x =
    (forget D).map (colimit.ι (diagram J P X) S.op) (↑(Meq.equiv P S).symm (Meq.mk S 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 : (forget D).obj (P.obj X.op)
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ (forget D).map (colimit.ι (diagram J P X) S.op)
      ((forget D).map ((diagram J P X).map (homOfLE (_ : S ≤ ⊤)).op)
        ((forget D).map
          (Multiequalizer.lift (Cover.index ⊤ P) (P.obj X.op) (fun I => P.map I.f.op)
            (_ :
              ∀ (I : (Cover.index ⊤ P).R),
                (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I =
                  (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I))
          x)) =
    (forget D).map (colimit.ι (diagram J P X) S.op) (↑(Meq.equiv P S).symm (Meq.mk S x))

tactic: dsimp [diagram]
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 : (forget D).obj (P.obj X.op)
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ (forget D).map ((diagram J P X).map (homOfLE (_ : S ≤ ⊤)).op)
      ((forget D).map
        (Multiequalizer.lift (Cover.index ⊤ P) (P.obj X.op) (fun I => P.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ P).R),
              (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I =
                (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I))
        x) =
    ↑(Meq.equiv P S).symm (Meq.mk S 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 : (forget D).obj (P.obj X.op)
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ (forget D).map
      (Multiequalizer.lift (Cover.index S P) (multiequalizer (Cover.index ⊤ P))
        (fun I => Multiequalizer.ι (Cover.index ⊤ P) (Cover.Arrow.map I (homOfLE (_ : S ≤ ⊤))))
        (_ :
          ∀ (I : (Cover.index S.op.unop P).R),
            Multiequalizer.ι (Cover.index ⊤.op.unop P)
                  (MulticospanIndex.fstTo (Cover.index ⊤.op.unop P)
                    (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                MulticospanIndex.fst (Cover.index ⊤.op.unop P) (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop) =
              Multiequalizer.ι (Cover.index ⊤.op.unop P)
                  (MulticospanIndex.sndTo (Cover.index ⊤.op.unop P)
                    (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                MulticospanIndex.snd (Cover.index ⊤.op.unop P) (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)))
      ((forget D).map
        (Multiequalizer.lift (Cover.index ⊤ P) (P.obj X.op) (fun I => P.map I.f.op)
          (_ :
            ∀ (I : (Cover.index ⊤ P).R),
              (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.fst (Cover.index ⊤ P) I =
                (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                  MulticospanIndex.snd (Cover.index ⊤ P) I))
        x) =
    ↑(Meq.equiv P S).symm (Meq.mk S 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 : (forget D).obj (P.obj X.op)
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
⊢ ∀ (t : (Cover.index S P).L),
    (forget D).map (Multiequalizer.ι (Cover.index S P) t)
        ((forget D).map
          (Multiequalizer.lift (Cover.index S P) (multiequalizer (Cover.index ⊤ P))
            (fun I => Multiequalizer.ι (Cover.index ⊤ P) (Cover.Arrow.map I (homOfLE (_ : S ≤ ⊤))))
            (_ :
              ∀ (I : (Cover.index S.op.unop P).R),
                Multiequalizer.ι (Cover.index ⊤.op.unop P)
                      (MulticospanIndex.fstTo (Cover.index ⊤.op.unop P)
                        (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                    MulticospanIndex.fst (Cover.index ⊤.op.unop P)
                      (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop) =
                  Multiequalizer.ι (Cover.index ⊤.op.unop P)
                      (MulticospanIndex.sndTo (Cover.index ⊤.op.unop P)
                        (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                    MulticospanIndex.snd (Cover.index ⊤.op.unop P)
                      (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)))
          ((forget D).map
            (Multiequalizer.lift (Cover.index ⊤ P) (P.obj X.op) (fun I => P.map I.f.op)
              (_ :
                ∀ (I : (Cover.index ⊤ P).R),
                  (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                      MulticospanIndex.fst (Cover.index ⊤ P) I =
                    (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                      MulticospanIndex.snd (Cover.index ⊤ P) I))
            x)) =
      (forget D).map (Multiequalizer.ι (Cover.index S P) t) (↑(Meq.equiv P S).symm (Meq.mk S 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 : (forget D).obj (P.obj X.op)
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
i : (Cover.index S P).L
⊢ (forget D).map (Multiequalizer.ι (Cover.index S P) i)
      ((forget D).map
        (Multiequalizer.lift (Cover.index S P) (multiequalizer (Cover.index ⊤ P))
          (fun I => Multiequalizer.ι (Cover.index ⊤ P) (Cover.Arrow.map I (homOfLE (_ : S ≤ ⊤))))
          (_ :
            ∀ (I : (Cover.index S.op.unop P).R),
              Multiequalizer.ι (Cover.index ⊤.op.unop P)
                    (MulticospanIndex.fstTo (Cover.index ⊤.op.unop P)
                      (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                  MulticospanIndex.fst (Cover.index ⊤.op.unop P) (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop) =
                Multiequalizer.ι (Cover.index ⊤.op.unop P)
                    (MulticospanIndex.sndTo (Cover.index ⊤.op.unop P)
                      (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)) ≫
                  MulticospanIndex.snd (Cover.index ⊤.op.unop P) (Cover.Relation.map I (homOfLE (_ : S ≤ ⊤)).op.unop)))
        ((forget D).map
          (Multiequalizer.lift (Cover.index ⊤ P) (P.obj X.op) (fun I => P.map I.f.op)
            (_ :
              ∀ (I : (Cover.index ⊤ P).R),
                (fun I => P.map I.f.op) (MulticospanIndex.fstTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.fst (Cover.index ⊤ P) I =
                  (fun I => P.map I.f.op) (MulticospanIndex.sndTo (Cover.index ⊤ P) I) ≫
                    MulticospanIndex.snd (Cover.index ⊤ P) I))
          x)) =
    (forget D).map (Multiequalizer.ι (Cover.index S P) i) (↑(Meq.equiv P S).symm (Meq.mk S x))

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 : (forget D).obj (P.obj X.op)
e : S ⟶ ⊤ := homOfLE (_ : S ≤ ⊤)
i : (Cover.index S P).L
⊢ (forget D).map (P.map (Cover.Arrow.map i (homOfLE (_ : S ≤ ⊤))).f.op) x = ↑(Meq.mk S x) i