Theorem: CategoryTheory.CoverDense.Types.pushforwardFamily_compatible
File: Mathlib/CategoryTheory/Sites/DenseSubsite.lean

tactic: intro Y₁ Y₂ Z g₁ g₂ f₁ f₂ h₁ h₂ e
state_before: C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
⊢ FamilyOfElements.Compatible (pushforwardFamily α x)

tactic: apply H.ext
state_before: C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ ℱ'.val.map g₁.op (pushforwardFamily α x f₁ h₁) = ℱ'.val.map g₂.op (pushforwardFamily α x f₂ h₂)

tactic: intro Y f
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ ∀ ⦃Y : C⦄ (f : G.obj Y ⟶ Z),
    ℱ'.val.map f.op (ℱ'.val.map g₁.op (pushforwardFamily α x f₁ h₁)) =
      ℱ'.val.map f.op (ℱ'.val.map g₂.op (pushforwardFamily α x f₂ h₂))

tactic: simp only [pushforwardFamily, ← FunctorToTypes.map_comp_apply, ← op_comp]
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ ℱ'.val.map f.op (ℱ'.val.map g₁.op (pushforwardFamily α x f₁ h₁)) =
    ℱ'.val.map f.op (ℱ'.val.map g₂.op (pushforwardFamily α x f₂ h₂))

tactic: change (ℱ.map _ ≫ α.app (op _) ≫ ℱ'.val.map _) _ = (ℱ.map _ ≫ α.app (op _) ≫ ℱ'.val.map _) _
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ ℱ'.val.map (f ≫ g₁ ≫ (Nonempty.some h₁).lift).op (α.app (Nonempty.some h₁).1.op (ℱ.map (Nonempty.some h₁).map.op x)) =
    ℱ'.val.map (f ≫ g₂ ≫ (Nonempty.some h₂).lift).op (α.app (Nonempty.some h₂).1.op (ℱ.map (Nonempty.some h₂).map.op x))

tactic: rw [← G.image_preimage (f ≫ g₁ ≫ _)]
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ (ℱ.map (Nonempty.some h₁).map.op ≫ α.app (Nonempty.some h₁).1.op ≫ ℱ'.val.map (f ≫ g₁ ≫ (Nonempty.some h₁).lift).op)
      x =
    (ℱ.map (Nonempty.some h₂).map.op ≫ α.app (Nonempty.some h₂).1.op ≫ ℱ'.val.map (f ≫ g₂ ≫ (Nonempty.some h₂).lift).op)
      x

tactic: rw [← G.image_preimage (f ≫ g₂ ≫ _)]
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ (ℱ.map (Nonempty.some h₁).map.op ≫
        α.app (Nonempty.some h₁).1.op ≫ ℱ'.val.map (G.map (G.preimage (f ≫ g₁ ≫ (Nonempty.some h₁).lift))).op)
      x =
    (ℱ.map (Nonempty.some h₂).map.op ≫ α.app (Nonempty.some h₂).1.op ≫ ℱ'.val.map (f ≫ g₂ ≫ (Nonempty.some h₂).lift).op)
      x

tactic: erw [← α.naturality (G.preimage _).op]
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ (ℱ.map (Nonempty.some h₁).map.op ≫
        α.app (Nonempty.some h₁).1.op ≫ ℱ'.val.map (G.map (G.preimage (f ≫ g₁ ≫ (Nonempty.some h₁).lift))).op)
      x =
    (ℱ.map (Nonempty.some h₂).map.op ≫
        α.app (Nonempty.some h₂).1.op ≫ ℱ'.val.map (G.map (G.preimage (f ≫ g₂ ≫ (Nonempty.some h₂).lift))).op)
      x

tactic: erw [← α.naturality (G.preimage _).op]
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ (ℱ.map (Nonempty.some h₁).map.op ≫
        (Functor.op G ⋙ ℱ).map (G.preimage (f ≫ g₁ ≫ (Nonempty.some h₁).lift)).op ≫ α.app Y.op)
      x =
    (ℱ.map (Nonempty.some h₂).map.op ≫
        α.app (Nonempty.some h₂).1.op ≫ ℱ'.val.map (G.map (G.preimage (f ≫ g₂ ≫ (Nonempty.some h₂).lift))).op)
      x

tactic: refine' congr_fun _ x
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ (ℱ.map (Nonempty.some h₁).map.op ≫
        (Functor.op G ⋙ ℱ).map (G.preimage (f ≫ g₁ ≫ (Nonempty.some h₁).lift)).op ≫ α.app Y.op)
      x =
    (ℱ.map (Nonempty.some h₂).map.op ≫
        (Functor.op G ⋙ ℱ).map (G.preimage (f ≫ g₂ ≫ (Nonempty.some h₂).lift)).op ≫ α.app Y.op)
      x

tactic: simp only [Functor.comp_map, ← Category.assoc, Functor.op_map, Quiver.Hom.unop_op]
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ ℱ.map (Nonempty.some h₁).map.op ≫
      (Functor.op G ⋙ ℱ).map (G.preimage (f ≫ g₁ ≫ (Nonempty.some h₁).lift)).op ≫ α.app Y.op =
    ℱ.map (Nonempty.some h₂).map.op ≫
      (Functor.op G ⋙ ℱ).map (G.preimage (f ≫ g₂ ≫ (Nonempty.some h₂).lift)).op ≫ α.app Y.op

tactic: rw [← ℱ.map_comp, ← ℱ.map_comp]
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ (ℱ.map (Nonempty.some h₁).map.op ≫ ℱ.map (G.map (G.preimage ((f ≫ g₁) ≫ (Nonempty.some h₁).lift))).op) ≫ α.app Y.op =
    (ℱ.map (Nonempty.some h₂).map.op ≫ ℱ.map (G.map (G.preimage ((f ≫ g₂) ≫ (Nonempty.some h₂).lift))).op) ≫ α.app Y.op

tactic: simp only [← op_comp, G.image_preimage]
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ ℱ.map ((Nonempty.some h₁).map.op ≫ (G.map (G.preimage ((f ≫ g₁) ≫ (Nonempty.some h₁).lift))).op) ≫ α.app Y.op =
    ℱ.map ((Nonempty.some h₂).map.op ≫ (G.map (G.preimage ((f ≫ g₂) ≫ (Nonempty.some h₂).lift))).op) ≫ α.app Y.op

tactic: congr 3
state_before: case h
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ ℱ.map (((f ≫ g₁) ≫ (Nonempty.some h₁).lift) ≫ (Nonempty.some h₁).map).op ≫ α.app Y.op =
    ℱ.map (((f ≫ g₂) ≫ (Nonempty.some h₂).lift) ≫ (Nonempty.some h₂).map).op ≫ α.app Y.op

tactic: simp [e]
state_before: case h.e_a.e_a.e_f
C : Type u_3
inst✝⁴ : Category C
D : Type u_2
inst✝³ : Category D
E : Type ?u.49250
inst✝² : Category E
J : GrothendieckTopology C
K : GrothendieckTopology D
L : GrothendieckTopology E
A : Type ?u.49302
inst✝¹ : Category A
G : C ⥤ D
H : CoverDense K G
inst✝ : Full G
ℱ : Dᵒᵖ ⥤ Type v
ℱ' : SheafOfTypes K
α : Functor.op G ⋙ ℱ ⟶ Functor.op G ⋙ ℱ'.val
X : D
x : ℱ.obj X.op
Y₁ Y₂ Z : D
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
h₁ : coverByImage G X f₁
h₂ : coverByImage G X f₂
e : g₁ ≫ f₁ = g₂ ≫ f₂
Y : C
f : G.obj Y ⟶ Z
⊢ ((f ≫ g₁) ≫ (Nonempty.some h₁).lift) ≫ (Nonempty.some h₁).map =
    ((f ≫ g₂) ≫ (Nonempty.some h₂).lift) ≫ (Nonempty.some h₂).map