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

tactic: obtain ⟨Sx, x, rfl⟩ := exists_rep x
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
x y : (forget D).obj ((plusObj J P).obj X.op)
h : ∀ (I : Cover.Arrow S), (forget D).map ((plusObj J P).map I.f.op) x = (forget D).map ((plusObj J P).map I.f.op) y
⊢ x = y

tactic: obtain ⟨Sy, y, rfl⟩ := exists_rep y
state_before: case intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S : Cover J X
y : (forget D).obj ((plusObj J P).obj X.op)
Sx : Cover J X
x : Meq P Sx
h :
  ∀ (I : Cover.Arrow S), (forget D).map ((plusObj J P).map I.f.op) (mk x) = (forget D).map ((plusObj J P).map I.f.op) y
⊢ mk x = y

tactic: simp only [res_mk_eq_mk_pullback] at h
state_before: case intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h :
  ∀ (I : Cover.Arrow S),
    (forget D).map ((plusObj J P).map I.f.op) (mk x) = (forget D).map ((plusObj J P).map I.f.op) (mk y)
⊢ mk x = mk y

tactic: choose W h1 h2 hh using fun I : S.Arrow => (eq_mk_iff_exists _ _).mp (h I)
state_before: case intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
⊢ mk x = mk y

tactic: rw [eq_mk_iff_exists]
state_before: case intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
⊢ mk x = mk y

tactic: let B : J.Cover X := S.bind W
state_before: case intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
⊢ ∃ W h1 h2, Meq.refine x h1 = Meq.refine y h2

tactic: use B
state_before: case intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
⊢ ∃ W h1 h2, Meq.refine x h1 = Meq.refine y h2

tactic: let ex : B ⟶ Sx :=
  homOfLE
    (by
      rintro Y f ⟨Z, e1, e2, he2, he1, hee⟩
      rw [← hee]
      apply leOfHom (h1 ⟨_, _, he2⟩)
      exact he1)
state_before: case intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
⊢ ∃ h1 h2, Meq.refine x h1 = Meq.refine y h2

tactic: let ey : B ⟶ Sy :=
  homOfLE
    (by
      rintro Y f ⟨Z, e1, e2, he2, he1, hee⟩
      rw [← hee]
      apply leOfHom (h2 ⟨_, _, he2⟩)
      exact he1)
state_before: case intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
⊢ ∃ h1 h2, Meq.refine x h1 = Meq.refine y h2

tactic: use ex, ey
state_before: case intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
⊢ ∃ h1 h2, Meq.refine x h1 = Meq.refine y h2

tactic: ext1 I
state_before: case intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
⊢ Meq.refine x ex = Meq.refine y ey

tactic: let IS : S.Arrow := I.fromMiddle
state_before: case intro.intro.intro.intro.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine y ey) I

tactic: specialize hh IS
state_before: case intro.intro.intro.intro.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine y ey) I

tactic: let IW : (W IS).Arrow := I.toMiddle
state_before: case intro.intro.intro.intro.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
hh : Meq.refine (Meq.pullback x IS.f) (h1 IS) = Meq.refine (Meq.pullback y IS.f) (h2 IS)
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine y ey) I

tactic: apply_fun fun e => e IW  at hh
state_before: case intro.intro.intro.intro.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
hh : Meq.refine (Meq.pullback x IS.f) (h1 IS) = Meq.refine (Meq.pullback y IS.f) (h2 IS)
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine y ey) I

tactic: convert hh using 1
state_before: case intro.intro.intro.intro.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine y ey) I

tactic: rintro Y f ⟨Z, e1, e2, he2, he1, hee⟩
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
⊢ B ≤ Sx

tactic: rw [← hee]
state_before: case intro.intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) Sx).arrows f

tactic: apply leOfHom (h1 ⟨_, _, he2⟩)
state_before: case intro.intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) Sx).arrows (e1 ≫ e2)

tactic: exact he1
state_before: case intro.intro.intro.intro.intro.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) (W { Y := Z, f := e2, hf := he2 })).arrows e1

tactic: rintro Y f ⟨Z, e1, e2, he2, he1, hee⟩
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
⊢ B ≤ Sy

tactic: rw [← hee]
state_before: case intro.intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) Sy).arrows f

tactic: apply leOfHom (h2 ⟨_, _, he2⟩)
state_before: case intro.intro.intro.intro.intro
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) Sy).arrows (e1 ≫ e2)

tactic: exact he1
state_before: case intro.intro.intro.intro.intro.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
hh : ∀ (I : Cover.Arrow S), Meq.refine (Meq.pullback x I.f) (h1 I) = Meq.refine (Meq.pullback y I.f) (h2 I)
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
Y : C
f : Y ⟶ X
Z : C
e1 : Y ⟶ Z
e2 : Z ⟶ X
he2 : (Cover.sieve S).arrows e2
he1 : ((fun Y f hf => Cover.sieve (W { Y := Y, f := f, hf := hf })) Z e2 he2).arrows e1
hee : e1 ≫ e2 = f
⊢ ((fun a => ↑a) (W { Y := Z, f := e2, hf := he2 })).arrows e1

tactic: let Rx : Sx.Relation :=
  ⟨I.Y, I.Y, I.Y, 𝟙 _, 𝟙 _, I.f, I.toMiddleHom ≫ I.fromMiddleHom, leOfHom ex _ I.hf,
    by simpa only [I.middle_spec] using leOfHom ex _ I.hf, by simp [I.middle_spec]⟩
state_before: case h.e'_2.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj I.Y.op) = (forget D).obj (P.obj IW.Y.op)
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW

tactic: have := x.condition Rx
state_before: case h.e'_2.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj I.Y.op) = (forget D).obj (P.obj IW.Y.op)
Rx : Cover.Relation Sx :=
  { Y₁ := I.Y, Y₂ := I.Y, Z := I.Y, g₁ := 𝟙 I.Y, g₂ := 𝟙 I.Y, f₁ := I.f,
    f₂ := Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I, h₁ := (_ : ((fun a => ↑a) Sx).arrows I.f),
    h₂ := (_ : (Cover.sieve Sx).arrows (Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I)),
    w := (_ : 𝟙 I.Y ≫ I.f = 𝟙 I.Y ≫ Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I) }
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW

tactic: simpa using this
state_before: case h.e'_2.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj I.Y.op) = (forget D).obj (P.obj IW.Y.op)
Rx : Cover.Relation Sx :=
  { Y₁ := I.Y, Y₂ := I.Y, Z := I.Y, g₁ := 𝟙 I.Y, g₂ := 𝟙 I.Y, f₁ := I.f,
    f₂ := Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I, h₁ := (_ : ((fun a => ↑a) Sx).arrows I.f),
    h₂ := (_ : (Cover.sieve Sx).arrows (Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I)),
    w := (_ : 𝟙 I.Y ≫ I.f = 𝟙 I.Y ≫ Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I) }
this :
  (forget D).map (P.map Rx.g₁.op) (↑x (MulticospanIndex.fstTo (Cover.index Sx P) Rx)) =
    (forget D).map (P.map Rx.g₂.op) (↑x (MulticospanIndex.sndTo (Cover.index Sx P) Rx))
⊢ ↑(Meq.refine x ex) I = ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW

tactic: simpa only [I.middle_spec] using leOfHom ex _ I.hf
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj I.Y.op) = (forget D).obj (P.obj IW.Y.op)
⊢ (Cover.sieve Sx).arrows (Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I)

tactic: simp [I.middle_spec]
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj I.Y.op) = (forget D).obj (P.obj IW.Y.op)
⊢ 𝟙 I.Y ≫ I.f = 𝟙 I.Y ≫ Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I

tactic: let Ry : Sy.Relation :=
  ⟨I.Y, I.Y, I.Y, 𝟙 _, 𝟙 _, I.f, I.toMiddleHom ≫ I.fromMiddleHom, leOfHom ey _ I.hf,
    by simpa only [I.middle_spec] using leOfHom ey _ I.hf, by simp [I.middle_spec]⟩
state_before: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj I.Y.op) = (forget D).obj (P.obj IW.Y.op)
⊢ ↑(Meq.refine y ey) I = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW

tactic: have := y.condition Ry
state_before: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj I.Y.op) = (forget D).obj (P.obj IW.Y.op)
Ry : Cover.Relation Sy :=
  { Y₁ := I.Y, Y₂ := I.Y, Z := I.Y, g₁ := 𝟙 I.Y, g₂ := 𝟙 I.Y, f₁ := I.f,
    f₂ := Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I, h₁ := (_ : ((fun a => ↑a) Sy).arrows I.f),
    h₂ := (_ : (Cover.sieve Sy).arrows (Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I)),
    w := (_ : 𝟙 I.Y ≫ I.f = 𝟙 I.Y ≫ Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I) }
⊢ ↑(Meq.refine y ey) I = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW

tactic: simpa using this
state_before: case h.e'_3.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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj I.Y.op) = (forget D).obj (P.obj IW.Y.op)
Ry : Cover.Relation Sy :=
  { Y₁ := I.Y, Y₂ := I.Y, Z := I.Y, g₁ := 𝟙 I.Y, g₂ := 𝟙 I.Y, f₁ := I.f,
    f₂ := Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I, h₁ := (_ : ((fun a => ↑a) Sy).arrows I.f),
    h₂ := (_ : (Cover.sieve Sy).arrows (Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I)),
    w := (_ : 𝟙 I.Y ≫ I.f = 𝟙 I.Y ≫ Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I) }
this :
  (forget D).map (P.map Ry.g₁.op) (↑y (MulticospanIndex.fstTo (Cover.index Sy P) Ry)) =
    (forget D).map (P.map Ry.g₂.op) (↑y (MulticospanIndex.sndTo (Cover.index Sy P) Ry))
⊢ ↑(Meq.refine y ey) I = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW

tactic: simpa only [I.middle_spec] using leOfHom ey _ I.hf
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj I.Y.op) = (forget D).obj (P.obj IW.Y.op)
⊢ (Cover.sieve Sy).arrows (Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I)

tactic: simp [I.middle_spec]
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)
inst✝ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
X : C
P : Cᵒᵖ ⥤ D
S Sx : Cover J X
x : Meq P Sx
Sy : Cover J X
y : Meq P Sy
h : ∀ (I : Cover.Arrow S), mk (Meq.pullback x I.f) = mk (Meq.pullback y I.f)
W : (I : Cover.Arrow S) → Cover J I.Y
h1 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sx
h2 : (I : Cover.Arrow S) → W I ⟶ (pullback J I.f).obj Sy
B : Cover J X := Cover.bind S W
ex : B ⟶ Sx := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sx).arrows f)
ey : B ⟶ Sy := homOfLE (_ : ∀ ⦃Y : C⦄ (f : Y ⟶ X), ((fun a => ↑a) B).arrows f → ((fun a => ↑a) Sy).arrows f)
I : Cover.Arrow B
IS : Cover.Arrow S := Cover.Arrow.fromMiddle I
IW : Cover.Arrow (W IS) := Cover.Arrow.toMiddle I
hh : ↑(Meq.refine (Meq.pullback x IS.f) (h1 IS)) IW = ↑(Meq.refine (Meq.pullback y IS.f) (h2 IS)) IW
e_1✝ : (forget D).obj (P.obj I.Y.op) = (forget D).obj (P.obj IW.Y.op)
⊢ 𝟙 I.Y ≫ I.f = 𝟙 I.Y ≫ Cover.Arrow.toMiddleHom I ≫ Cover.Arrow.fromMiddleHom I