Theorem: CategoryTheory.GrothendieckTopology.over_map_compatiblePreserving
File: Mathlib/CategoryTheory/Sites/Over.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map f₂.op (x g₂ hg₂)
state_after: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map f₂.op (x g₂ hg₂)
tactic: let W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map f₂.op (x g₂ hg₂)
state_after: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map f₂.op (x g₂ hg₂)
tactic: let g₁' : W' ⟶ Y₁ := Over.homMk f₁.left
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map f₂.op (x g₂ hg₂)
state_after: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
g₂' : W' ⟶ Y₂ := Over.homMk f₂.left ⋯
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map f₂.op (x g₂ hg₂)
tactic: let g₂' : W' ⟶ Y₂ := Over.homMk f₂.left
      (by simpa using (Over.forget _).congr_map h.symm =≫ Z.hom)
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
g₂' : W' ⟶ Y₂ := Over.homMk f₂.left ⋯
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map f₂.op (x g₂ hg₂)
state_after: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
g₂' : W' ⟶ Y₂ := Over.homMk f₂.left ⋯
e : (Over.map f).obj W' ≅ W := Over.isoMk (Iso.refl ((Over.map f).obj W').left) ⋯
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map f₂.op (x g₂ hg₂)
tactic: let e : (Over.map f).obj W' ≅ W := Over.isoMk (Iso.refl _)
      (by simpa [W'] using (Over.w f₁).symm)
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
g₂' : W' ⟶ Y₂ := Over.homMk f₂.left ⋯
e : (Over.map f).obj W' ≅ W := Over.isoMk (Iso.refl ((Over.map f).obj W').left) ⋯
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map f₂.op (x g₂ hg₂)
state_after: case h.e'_2
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
g₂' : W' ⟶ Y₂ := Over.homMk f₂.left ⋯
e : (Over.map f).obj W' ≅ W := Over.isoMk (Iso.refl ((Over.map f).obj W').left) ⋯
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map e.inv.op (((Over.map f).op ⋙ F.val).map g₁'.op (x g₁ hg₁))

case h.e'_3
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
g₂' : W' ⟶ Y₂ := Over.homMk f₂.left ⋯
e : (Over.map f).obj W' ≅ W := Over.isoMk (Iso.refl ((Over.map f).obj W').left) ⋯
⊢ F.val.map f₂.op (x g₂ hg₂) = F.val.map e.inv.op (((Over.map f).op ⋙ F.val).map g₂'.op (x g₂ hg₂))
tactic: convert congr_arg (F.val.map e.inv.op)
      (hx g₁' g₂' hg₁ hg₂ (by ext; exact (Over.forget _).congr_map h)) using 1
state_before: case h.e'_2
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
g₂' : W' ⟶ Y₂ := Over.homMk f₂.left ⋯
e : (Over.map f).obj W' ≅ W := Over.isoMk (Iso.refl ((Over.map f).obj W').left) ⋯
⊢ F.val.map f₁.op (x g₁ hg₁) = F.val.map e.inv.op (((Over.map f).op ⋙ F.val).map g₁'.op (x g₁ hg₁))

case h.e'_3
C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
X Y : C
f : X ⟶ Y
F : SheafOfTypes (J.over Y)
Z : Over X
T : Presieve Z
x : Presieve.FamilyOfElements ((Over.map f).op ⋙ F.val) T
hx : x.Compatible
Y₁ Y₂ : Over X
W : Over Y
f₁ : W ⟶ (Over.map f).obj Y₁
f₂ : W ⟶ (Over.map f).obj Y₂
g₁ : Y₁ ⟶ Z
g₂ : Y₂ ⟶ Z
hg₁ : T g₁
hg₂ : T g₂
h : f₁ ≫ (Over.map f).map g₁ = f₂ ≫ (Over.map f).map g₂
W' : Over X := Over.mk (f₁.left ≫ Y₁.hom)
g₁' : W' ⟶ Y₁ := Over.homMk f₁.left ⋯
g₂' : W' ⟶ Y₂ := Over.homMk f₂.left ⋯
e : (Over.map f).obj W' ≅ W := Over.isoMk (Iso.refl ((Over.map f).obj W').left) ⋯
⊢ F.val.map f₂.op (x g₂ hg₂) = F.val.map e.inv.op (((Over.map f).op ⋙ F.val).map g₂'.op (x g₂ hg₂))
state_after: no goals
tactic: all_goals
      dsimp [e, W', g₁', g₂']
      rw [← FunctorToTypes.map_comp_apply]
      apply congr_fun
      congr 1
      rw [← op_comp]
      congr 1
      ext
      simp