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

tactic: dsimp [mk, 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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ (forget D).map ((plusObj J P).map f.op) (mk x) = mk (Meq.pullback x f)

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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ (forget D).map (colimMap (diagramPullback J P f) ≫ colimit.pre (diagram J P Y) (Functor.op (pullback J f)))
      ((forget D).map (colimit.ι (diagram J P X) S.op) (↑(Meq.equiv P S).symm x)) =
    (forget D).map (colimit.ι (diagram J P Y) (Cover.pullback S f).op)
      (↑(Meq.equiv P (Cover.pullback S f)).symm (Meq.pullback x f))

tactic: simp_rw [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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ (forget D).map ((diagramPullback J P f).app S.op ≫ colimit.ι (diagram J P Y) ((Functor.op (pullback J f)).obj S.op))
      (↑(Meq.equiv P S).symm x) =
    (forget D).map (colimit.ι (diagram J P Y) (Cover.pullback S f).op)
      (↑(Meq.equiv P (Cover.pullback S f)).symm (Meq.pullback x f))

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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ (forget D).map (colimit.ι (diagram J P Y) ((Functor.op (pullback J f)).obj S.op))
      ((forget D).map ((diagramPullback J P f).app S.op) (↑(Meq.equiv P S).symm x)) =
    (forget D).map (colimit.ι (diagram J P Y) (Cover.pullback S f).op)
      (↑(Meq.equiv P (Cover.pullback S f)).symm (Meq.pullback x f))

tactic: apply (Meq.equiv P _).injective
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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ (forget D).map ((diagramPullback J P f).app S.op) (↑(Meq.equiv P S).symm x) =
    ↑(Meq.equiv P (Cover.pullback S f)).symm (Meq.pullback x f)

tactic: erw [Equiv.apply_symm_apply]
state_before: case h.a
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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ ↑(Meq.equiv P ((Functor.op (pullback J f)).obj S.op).unop)
      ((forget D).map ((diagramPullback J P f).app S.op) (↑(Meq.equiv P S).symm x)) =
    ↑(Meq.equiv P ((Functor.op (pullback J f)).obj S.op).unop)
      (↑(Meq.equiv P (Cover.pullback S f)).symm (Meq.pullback x f))

tactic: ext i
state_before: case h.a
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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
⊢ ↑(Meq.equiv P ((Functor.op (pullback J f)).obj S.op).unop)
      ((forget D).map ((diagramPullback J P f).app S.op) (↑(Meq.equiv P S).symm x)) =
    Meq.pullback x f

tactic: simp only [diagramPullback_app, Meq.pullback_apply, Meq.equiv_apply, ← comp_apply]
state_before: case h.a.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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
i : Cover.Arrow ((Functor.op (pullback J f)).obj S.op).unop
⊢ ↑(↑(Meq.equiv P ((Functor.op (pullback J f)).obj S.op).unop)
          ((forget D).map ((diagramPullback J P f).app S.op) (↑(Meq.equiv P S).symm x)))
      i =
    ↑(Meq.pullback x f) i

tactic: erw [Multiequalizer.lift_ι, Meq.equiv_symm_eq_apply]
state_before: case h.a.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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
i : Cover.Arrow ((Functor.op (pullback J f)).obj S.op).unop
⊢ (forget D).map
      (Multiequalizer.lift (Cover.index ((Functor.op (pullback J f)).obj S.op).unop P) ((diagram J P X).obj S.op)
          (fun I => Multiequalizer.ι (Cover.index S.op.unop P) (Cover.Arrow.base I))
          (_ :
            ∀ (I : (Cover.index ((Functor.op (pullback J 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)) ≫
                  MulticospanIndex.fst (Cover.index S.op.unop P) (Cover.Relation.base I) =
                Multiequalizer.ι (Cover.index S.op.unop P)
                    (MulticospanIndex.sndTo (Cover.index S.op.unop P) (Cover.Relation.base I)) ≫
                  MulticospanIndex.snd (Cover.index S.op.unop P) (Cover.Relation.base I)) ≫
        Multiequalizer.ι (Cover.index ((Functor.op (pullback J f)).obj S.op).unop P) i)
      (↑(Meq.equiv P S).symm x) =
    ↑x { Y := i.Y, f := i.f ≫ f, hf := (_ : (Cover.sieve ((pullback J f).obj S)).arrows i.f) }

tactic: cases i
state_before: case h.a.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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
i : Cover.Arrow ((Functor.op (pullback J f)).obj S.op).unop
⊢ ↑x (Cover.Arrow.base i) = ↑x { Y := i.Y, f := i.f ≫ f, hf := (_ : (Cover.sieve ((pullback J f).obj S)).arrows i.f) }

tactic: rfl
state_before: case h.a.h.mk
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)
Y X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x : Meq P S
f : Y ⟶ X
Y✝ : C
f✝ : Y✝ ⟶ Y
hf✝ : (Cover.sieve ((Functor.op (pullback J f)).obj S.op).unop).arrows f✝
⊢ ↑x (Cover.Arrow.base { Y := Y✝, f := f✝, hf := hf✝ }) =
    ↑x
      { Y := { Y := Y✝, f := f✝, hf := hf✝ }.Y, f := { Y := Y✝, f := f✝, hf := hf✝ }.f ≫ f,
        hf := (_ : (Cover.sieve ((pullback J f).obj S)).arrows { Y := Y✝, f := f✝, hf := hf✝ }.f) }