Theorem: TopCat.Presheaf.SheafConditionEqualizerProducts.w
File: Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean

tactic: dsimp [res, leftRes, rightRes]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
⊢ res F U ≫ leftRes F U = res F U ≫ rightRes F U
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
⊢ ((Pi.lift fun i => F.map (leSupr U i).op) ≫
      Pi.lift fun p => Pi.π (fun i => F.obj { unop := U i }) p.1 ≫ F.map ((U p.1).infLELeft (U p.2)).op) =
    (Pi.lift fun i => F.map (leSupr U i).op) ≫
      Pi.lift fun p => Pi.π (fun i => F.obj { unop := U i }) p.2 ≫ F.map ((U p.1).infLERight (U p.2)).op

tactic: refine limit.hom_ext (fun _ => ?_)
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
⊢ ((Pi.lift fun i => F.map (leSupr U i).op) ≫
      Pi.lift fun p => Pi.π (fun i => F.obj { unop := U i }) p.1 ≫ F.map ((U p.1).infLELeft (U p.2)).op) =
    (Pi.lift fun i => F.map (leSupr U i).op) ≫
      Pi.lift fun p => Pi.π (fun i => F.obj { unop := U i }) p.2 ≫ F.map ((U p.1).infLERight (U p.2)).op
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ ((Pi.lift fun i => F.map (leSupr U i).op) ≫
        Pi.lift fun p => Pi.π (fun i => F.obj { unop := U i }) p.1 ≫ F.map ((U p.1).infLELeft (U p.2)).op) ≫
      limit.π (Discrete.functor fun p => F.obj { unop := U p.1 ⊓ U p.2 }) x✝ =
    ((Pi.lift fun i => F.map (leSupr U i).op) ≫
        Pi.lift fun p => Pi.π (fun i => F.obj { unop := U i }) p.2 ≫ F.map ((U p.1).infLERight (U p.2)).op) ≫
      limit.π (Discrete.functor fun p => F.obj { unop := U p.1 ⊓ U p.2 }) x✝

tactic: simp only [limit.lift_π, limit.lift_π_assoc, Fan.mk_π_app, Category.assoc]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ ((Pi.lift fun i => F.map (leSupr U i).op) ≫
        Pi.lift fun p => Pi.π (fun i => F.obj { unop := U i }) p.1 ≫ F.map ((U p.1).infLELeft (U p.2)).op) ≫
      limit.π (Discrete.functor fun p => F.obj { unop := U p.1 ⊓ U p.2 }) x✝ =
    ((Pi.lift fun i => F.map (leSupr U i).op) ≫
        Pi.lift fun p => Pi.π (fun i => F.obj { unop := U i }) p.2 ≫ F.map ((U p.1).infLERight (U p.2)).op) ≫
      limit.π (Discrete.functor fun p => F.obj { unop := U p.1 ⊓ U p.2 }) x✝
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ F.map (leSupr U x✝.as.1).op ≫ F.map ((U x✝.as.1).infLELeft (U x✝.as.2)).op =
    F.map (leSupr U x✝.as.2).op ≫ F.map ((U x✝.as.1).infLERight (U x✝.as.2)).op

tactic: rw [← F.map_comp]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ F.map (leSupr U x✝.as.1).op ≫ F.map ((U x✝.as.1).infLELeft (U x✝.as.2)).op =
    F.map (leSupr U x✝.as.2).op ≫ F.map ((U x✝.as.1).infLERight (U x✝.as.2)).op
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ F.map ((leSupr U x✝.as.1).op ≫ ((U x✝.as.1).infLELeft (U x✝.as.2)).op) =
    F.map (leSupr U x✝.as.2).op ≫ F.map ((U x✝.as.1).infLERight (U x✝.as.2)).op

tactic: rw [← F.map_comp]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ F.map ((leSupr U x✝.as.1).op ≫ ((U x✝.as.1).infLELeft (U x✝.as.2)).op) =
    F.map (leSupr U x✝.as.2).op ≫ F.map ((U x✝.as.1).infLERight (U x✝.as.2)).op
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ F.map ((leSupr U x✝.as.1).op ≫ ((U x✝.as.1).infLELeft (U x✝.as.2)).op) =
    F.map ((leSupr U x✝.as.2).op ≫ ((U x✝.as.1).infLERight (U x✝.as.2)).op)

tactic: congr 1
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
x✝ : Discrete (ι × ι)
⊢ F.map ((leSupr U x✝.as.1).op ≫ ((U x✝.as.1).infLELeft (U x✝.as.2)).op) =
    F.map ((leSupr U x✝.as.2).op ≫ ((U x✝.as.1).infLERight (U x✝.as.2)).op)
state_after: no goals