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

tactic: constructor
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
⊢ mk x = mk y ↔ ∃ W h1 h2, x.refine h1 = y.refine h2
state_after: case mp
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
⊢ mk x = mk y → ∃ W h1 h2, x.refine h1 = y.refine h2

case mpr
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
⊢ (∃ W h1 h2, x.refine h1 = y.refine h2) → mk x = mk y

tactic: intro h
state_before: case mp
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
⊢ mk x = mk y → ∃ W h1 h2, x.refine h1 = y.refine h2
state_after: case mp
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
⊢ ∃ W h1 h2, x.refine h1 = y.refine h2

tactic: obtain ⟨W, h1, h2, hh⟩ := Concrete.colimit_exists_of_rep_eq.{u} _ _ _ h
state_before: case mp
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
⊢ ∃ W h1 h2, x.refine h1 = y.refine h2
state_after: case mp.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
hh : ((J.diagram P X).map h1) ((Meq.equiv P S).symm x) = ((J.diagram P X).map h2) ((Meq.equiv P T).symm y)
⊢ ∃ W h1 h2, x.refine h1 = y.refine h2

tactic: use W.unop, h1.unop, h2.unop
state_before: case mp.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
hh : ((J.diagram P X).map h1) ((Meq.equiv P S).symm x) = ((J.diagram P X).map h2) ((Meq.equiv P T).symm y)
⊢ ∃ W h1 h2, x.refine h1 = y.refine h2
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
hh : ((J.diagram P X).map h1) ((Meq.equiv P S).symm x) = ((J.diagram P X).map h2) ((Meq.equiv P T).symm y)
⊢ x.refine h1.unop = y.refine h2.unop

tactic: ext I
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
hh : ((J.diagram P X).map h1) ((Meq.equiv P S).symm x) = ((J.diagram P X).map h2) ((Meq.equiv P T).symm y)
⊢ x.refine h1.unop = y.refine h2.unop
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
hh : ((J.diagram P X).map h1) ((Meq.equiv P S).symm x) = ((J.diagram P X).map h2) ((Meq.equiv P T).symm y)
I : W.unop.Arrow
⊢ ↑(x.refine h1.unop) I = ↑(y.refine h2.unop) I

tactic: apply_fun Multiequalizer.ι (W.unop.index P) I at hh
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
hh : ((J.diagram P X).map h1) ((Meq.equiv P S).symm x) = ((J.diagram P X).map h2) ((Meq.equiv P T).symm y)
I : W.unop.Arrow
⊢ ↑(x.refine h1.unop) I = ↑(y.refine h2.unop) I
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
⊢ ↑(x.refine h1.unop) I = ↑(y.refine h2.unop) I

tactic: convert hh
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
⊢ ↑(x.refine h1.unop) I = ↑(y.refine h2.unop) I
state_after: case h.e'_2.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ : (forget D).obj (P.obj { unop := I.Y }) = (forget D).obj ((W.unop.index P).left I)
⊢ ↑(x.refine h1.unop) I = (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x))

case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ : (forget D).obj (P.obj { unop := I.Y }) = (forget D).obj ((W.unop.index P).left I)
⊢ ↑(y.refine h2.unop) I = (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))

tactic: all_goals
  dsimp [diagram]
  erw [← comp_apply, Multiequalizer.lift_ι, Meq.equiv_symm_eq_apply]
  cases I; rfl
state_before: case h.e'_2.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ : (forget D).obj (P.obj { unop := I.Y }) = (forget D).obj ((W.unop.index P).left I)
⊢ ↑(x.refine h1.unop) I = (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x))

case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ : (forget D).obj (P.obj { unop := I.Y }) = (forget D).obj ((W.unop.index P).left I)
⊢ ↑(y.refine h2.unop) I = (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
state_after: no goals

tactic: dsimp [diagram]
state_before: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ : (forget D).obj (P.obj { unop := I.Y }) = (forget D).obj ((W.unop.index P).left I)
⊢ ↑(y.refine h2.unop) I = (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
state_after: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ : (forget D).obj (P.obj { unop := I.Y }) = (forget D).obj ((W.unop.index P).left I)
⊢ ↑y { Y := I.Y, f := I.f, hf := ⋯ } =
    (Multiequalizer.ι (W.unop.index P) I)
      ((Multiequalizer.lift (W.unop.index P) (multiequalizer (T.index P))
          (fun I => Multiequalizer.ι (T.index P) (I.map h2.unop)) ⋯)
        ((Meq.equiv P T).symm y))

tactic: erw [← comp_apply, Multiequalizer.lift_ι, Meq.equiv_symm_eq_apply]
state_before: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ : (forget D).obj (P.obj { unop := I.Y }) = (forget D).obj ((W.unop.index P).left I)
⊢ ↑y { Y := I.Y, f := I.f, hf := ⋯ } =
    (Multiequalizer.ι (W.unop.index P) I)
      ((Multiequalizer.lift (W.unop.index P) (multiequalizer (T.index P))
          (fun I => Multiequalizer.ι (T.index P) (I.map h2.unop)) ⋯)
        ((Meq.equiv P T).symm y))
state_after: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ : (forget D).obj (P.obj { unop := I.Y }) = (forget D).obj ((W.unop.index P).left I)
⊢ ↑y { Y := I.Y, f := I.f, hf := ⋯ } = ↑y (I.map h2.unop)

tactic: cases I
state_before: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
I : W.unop.Arrow
hh :
  (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) I) (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ : (forget D).obj (P.obj { unop := I.Y }) = (forget D).obj ((W.unop.index P).left I)
⊢ ↑y { Y := I.Y, f := I.f, hf := ⋯ } = ↑y (I.map h2.unop)
state_after: case h.e'_3.h.mk
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
Y✝ : C
f✝ : Y✝ ⟶ X
hf✝ : W.unop.sieve.arrows f✝
hh :
  (Multiequalizer.ι (W.unop.index P) { Y := Y✝, f := f✝, hf := hf✝ })
      (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) { Y := Y✝, f := f✝, hf := hf✝ })
      (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj { unop := { Y := Y✝, f := f✝, hf := hf✝ }.Y }) =
    (forget D).obj ((W.unop.index P).left { Y := Y✝, f := f✝, hf := hf✝ })
⊢ ↑y { Y := { Y := Y✝, f := f✝, hf := hf✝ }.Y, f := { Y := Y✝, f := f✝, hf := hf✝ }.f, hf := ⋯ } =
    ↑y ({ Y := Y✝, f := f✝, hf := hf✝ }.map h2.unop)

tactic: rfl
state_before: case h.e'_3.h.mk
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
h : mk x = mk y
W : (J.Cover X)ᵒᵖ
h1 : { unop := S } ⟶ W
h2 : { unop := T } ⟶ W
Y✝ : C
f✝ : Y✝ ⟶ X
hf✝ : W.unop.sieve.arrows f✝
hh :
  (Multiequalizer.ι (W.unop.index P) { Y := Y✝, f := f✝, hf := hf✝ })
      (((J.diagram P X).map h1) ((Meq.equiv P S).symm x)) =
    (Multiequalizer.ι (W.unop.index P) { Y := Y✝, f := f✝, hf := hf✝ })
      (((J.diagram P X).map h2) ((Meq.equiv P T).symm y))
e_1✝ :
  (forget D).obj (P.obj { unop := { Y := Y✝, f := f✝, hf := hf✝ }.Y }) =
    (forget D).obj ((W.unop.index P).left { Y := Y✝, f := f✝, hf := hf✝ })
⊢ ↑y { Y := { Y := Y✝, f := f✝, hf := hf✝ }.Y, f := { Y := Y✝, f := f✝, hf := hf✝ }.f, hf := ⋯ } =
    ↑y ({ Y := Y✝, f := f✝, hf := hf✝ }.map h2.unop)
state_after: no goals

tactic: rintro ⟨S, h1, h2, e⟩
state_before: case mpr
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S T : J.Cover X
x : Meq P S
y : Meq P T
⊢ (∃ W h1 h2, x.refine h1 = y.refine h2) → mk x = mk y
state_after: case mpr.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : x.refine h1 = y.refine h2
⊢ mk x = mk y

tactic: apply Concrete.colimit_rep_eq_of_exists
state_before: case mpr.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : x.refine h1 = y.refine h2
⊢ mk x = mk y
state_after: case mpr.intro.intro.intro.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : x.refine h1 = y.refine h2
⊢ ∃ k f g, ((J.diagram P X).map f) ((Meq.equiv P S✝).symm x) = ((J.diagram P X).map g) ((Meq.equiv P T).symm y)

tactic: use op S, h1.op, h2.op
state_before: case mpr.intro.intro.intro.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : x.refine h1 = y.refine h2
⊢ ∃ k f g, ((J.diagram P X).map f) ((Meq.equiv P S✝).symm x) = ((J.diagram P X).map g) ((Meq.equiv P T).symm y)
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : x.refine h1 = y.refine h2
⊢ ((J.diagram P X).map h1.op) ((Meq.equiv P S✝).symm x) = ((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y)

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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : x.refine h1 = y.refine h2
⊢ ((J.diagram P X).map h1.op) ((Meq.equiv P S✝).symm x) = ((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y)
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : x.refine h1 = y.refine h2
⊢ ∀ (t : ({ unop := S }.unop.index P).L),
    (Multiequalizer.ι ({ unop := S }.unop.index P) t) (((J.diagram P X).map h1.op) ((Meq.equiv P S✝).symm x)) =
      (Multiequalizer.ι ({ unop := S }.unop.index P) t) (((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y))

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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : x.refine h1 = y.refine h2
⊢ ∀ (t : ({ unop := S }.unop.index P).L),
    (Multiequalizer.ι ({ unop := S }.unop.index P) t) (((J.diagram P X).map h1.op) ((Meq.equiv P S✝).symm x)) =
      (Multiequalizer.ι ({ unop := S }.unop.index P) t) (((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y))
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : x.refine h1 = y.refine h2
i : ({ unop := S }.unop.index P).L
⊢ (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h1.op) ((Meq.equiv P S✝).symm x)) =
    (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y))

tactic: apply_fun fun ee => ee i at e
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
e : x.refine h1 = y.refine h2
i : ({ unop := S }.unop.index P).L
⊢ (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h1.op) ((Meq.equiv P S✝).symm x)) =
    (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y))
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
⊢ (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h1.op) ((Meq.equiv P S✝).symm x)) =
    (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y))

tactic: convert e
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
⊢ (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h1.op) ((Meq.equiv P S✝).symm x)) =
    (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y))
state_after: case h.e'_2.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h1.op) ((Meq.equiv P S✝).symm x)) =
    ↑(x.refine h1) i

case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y)) =
    ↑(y.refine h2) i

tactic: all_goals
  dsimp
  erw [← comp_apply, Multiequalizer.lift_ι]
  erw [Meq.equiv_symm_eq_apply]
  cases i; rfl
state_before: case h.e'_2.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h1.op) ((Meq.equiv P S✝).symm x)) =
    ↑(x.refine h1) i

case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y)) =
    ↑(y.refine h2) i
state_after: no goals

tactic: dsimp
state_before: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ (Multiequalizer.ι ({ unop := S }.unop.index P) i) (((J.diagram P X).map h2.op) ((Meq.equiv P T).symm y)) =
    ↑(y.refine h2) i
state_after: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ (Multiequalizer.ι (S.index P) i)
      ((Multiequalizer.lift (S.index P) (multiequalizer (T.index P)) (fun I => Multiequalizer.ι (T.index P) (I.map h2))
          ⋯)
        ((Meq.equiv P T).symm y)) =
    ↑y { Y := i.Y, f := i.f, hf := ⋯ }

tactic: erw [← comp_apply, Multiequalizer.lift_ι]
state_before: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ (Multiequalizer.ι (S.index P) i)
      ((Multiequalizer.lift (S.index P) (multiequalizer (T.index P)) (fun I => Multiequalizer.ι (T.index P) (I.map h2))
          ⋯)
        ((Meq.equiv P T).symm y)) =
    ↑y { Y := i.Y, f := i.f, hf := ⋯ }
state_after: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ (Multiequalizer.ι (T.index P) (Cover.Arrow.map i h2)) ((Meq.equiv P T).symm y) = ↑y { Y := i.Y, f := i.f, hf := ⋯ }

tactic: erw [Meq.equiv_symm_eq_apply]
state_before: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ (Multiequalizer.ι (T.index P) (Cover.Arrow.map i h2)) ((Meq.equiv P T).symm y) = ↑y { Y := i.Y, f := i.f, hf := ⋯ }
state_after: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ ↑y (Cover.Arrow.map i h2) = ↑y { Y := i.Y, f := i.f, hf := ⋯ }

tactic: cases i
state_before: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
i : ({ unop := S }.unop.index P).L
e : ↑(x.refine h1) i = ↑(y.refine h2) i
e_1✝ : (forget D).obj (({ unop := S }.unop.index P).left i) = (forget D).obj (P.obj { unop := i.Y })
⊢ ↑y (Cover.Arrow.map i h2) = ↑y { Y := i.Y, f := i.f, hf := ⋯ }
state_after: case h.e'_3.h.mk
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
Y✝ : C
f✝ : Y✝ ⟶ X
hf✝ : { unop := S }.unop.sieve.arrows f✝
e : ↑(x.refine h1) { Y := Y✝, f := f✝, hf := hf✝ } = ↑(y.refine h2) { Y := Y✝, f := f✝, hf := hf✝ }
e_1✝ :
  (forget D).obj (({ unop := S }.unop.index P).left { Y := Y✝, f := f✝, hf := hf✝ }) =
    (forget D).obj (P.obj { unop := { Y := Y✝, f := f✝, hf := hf✝ }.Y })
⊢ ↑y ({ Y := Y✝, f := f✝, hf := hf✝ }.map h2) =
    ↑y { Y := { Y := Y✝, f := f✝, hf := hf✝ }.Y, f := { Y := Y✝, f := f✝, hf := hf✝ }.f, hf := ⋯ }

tactic: rfl
state_before: case h.e'_3.h.mk
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)
inst✝ : (X : C) → PreservesColimitsOfShape (J.Cover X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S✝ T : J.Cover X
x : Meq P S✝
y : Meq P T
S : J.Cover X
h1 : S ⟶ S✝
h2 : S ⟶ T
Y✝ : C
f✝ : Y✝ ⟶ X
hf✝ : { unop := S }.unop.sieve.arrows f✝
e : ↑(x.refine h1) { Y := Y✝, f := f✝, hf := hf✝ } = ↑(y.refine h2) { Y := Y✝, f := f✝, hf := hf✝ }
e_1✝ :
  (forget D).obj (({ unop := S }.unop.index P).left { Y := Y✝, f := f✝, hf := hf✝ }) =
    (forget D).obj (P.obj { unop := { Y := Y✝, f := f✝, hf := hf✝ }.Y })
⊢ ↑y ({ Y := Y✝, f := f✝, hf := hf✝ }.map h2) =
    ↑y { Y := { Y := Y✝, f := f✝, hf := hf✝ }.Y, f := { Y := Y✝, f := f✝, hf := hf✝ }.f, hf := ⋯ }
state_after: no goals