Theorem: TopCat.Sheaf.eq_of_locally_eq₂
File: Mathlib/Topology/Sheaves/SheafCondition/UniqueGluing.lean

tactic: fapply F.eq_of_locally_eq' fun t : ULift Bool => if t.1 then U₁ else U₂
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ s = t
state_after: case iUV
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (i : ULift.{v, 0} Bool) → (if i.down = true then U₁ else U₂) ⟶ V

case hcover
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ V ≤ ⨆ t, if t.down = true then U₁ else U₂

case h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ ∀ (i : ULift.{v, 0} Bool), (F.val.map (?iUV i).op) s = (F.val.map (?iUV i).op) t

tactic: exact fun i => if h : i.1 then eqToHom (if_pos h) ≫ i₁ else eqToHom (if_neg h) ≫ i₂
state_before: case iUV
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (i : ULift.{v, 0} Bool) → (if i.down = true then U₁ else U₂) ⟶ V
state_after: no goals

tactic: refine le_trans hcover ?_
state_before: case hcover
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ V ≤ ⨆ t, if t.down = true then U₁ else U₂
state_after: case hcover
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ U₁ ⊔ U₂ ≤ ⨆ t, if t.down = true then U₁ else U₂

tactic: rw [sup_le_iff]
state_before: case hcover
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ U₁ ⊔ U₂ ≤ ⨆ t, if t.down = true then U₁ else U₂
state_after: case hcover
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (U₁ ≤ ⨆ t, if t.down = true then U₁ else U₂) ∧ U₂ ≤ ⨆ t, if t.down = true then U₁ else U₂

tactic: constructor
state_before: case hcover
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (U₁ ≤ ⨆ t, if t.down = true then U₁ else U₂) ∧ U₂ ≤ ⨆ t, if t.down = true then U₁ else U₂
state_after: case hcover.left
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ U₁ ≤ ⨆ t, if t.down = true then U₁ else U₂

case hcover.right
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ U₂ ≤ ⨆ t, if t.down = true then U₁ else U₂

tactic: convert le_iSup (fun t : ULift Bool => if t.1 then U₁ else U₂) (ULift.up true)
state_before: case hcover.left
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ U₁ ≤ ⨆ t, if t.down = true then U₁ else U₂
state_after: no goals

tactic: convert le_iSup (fun t : ULift Bool => if t.1 then U₁ else U₂) (ULift.up false)
state_before: case hcover.right
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ U₂ ≤ ⨆ t, if t.down = true then U₁ else U₂
state_after: no goals

tactic: rintro ⟨_ | _⟩
state_before: case h
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ ∀ (i : ULift.{v, 0} Bool),
    (F.val.map (if h : i.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) s =
      (F.val.map (if h : i.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) t
state_after: case h.up.false
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (F.val.map (if h : { down := false }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) s =
    (F.val.map (if h : { down := false }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) t

case h.up.true
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (F.val.map (if h : { down := true }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) s =
    (F.val.map (if h : { down := true }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) t

tactic: any_goals exact h₁
state_before: case h.up.false
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (F.val.map (if h : { down := false }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) s =
    (F.val.map (if h : { down := false }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) t

case h.up.true
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (F.val.map (if h : { down := true }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) s =
    (F.val.map (if h : { down := true }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) t
state_after: case h.up.false
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (F.val.map (if h : { down := false }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) s =
    (F.val.map (if h : { down := false }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) t

tactic: any_goals exact h₂
state_before: case h.up.false
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (F.val.map (if h : { down := false }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) s =
    (F.val.map (if h : { down := false }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) t
state_after: no goals

tactic: exact h₁
state_before: case h.up.true
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (F.val.map (if h : { down := true }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) s =
    (F.val.map (if h : { down := true }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) t
state_after: no goals

tactic: exact h₂
state_before: case h.up.false
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : ConcreteCategory C
inst✝² : HasLimits C
inst✝¹ : ConcreteCategory.forget.ReflectsIsomorphisms
inst✝ : PreservesLimits ConcreteCategory.forget
X : TopCat
F : Sheaf C X
ι : Type v
U : ι → Opens ↑X
U₁ U₂ V : Opens ↑X
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t : (CategoryTheory.forget C).obj (F.val.obj { unop := V })
h₁ : (F.val.map i₁.op) s = (F.val.map i₁.op) t
h₂ : (F.val.map i₂.op) s = (F.val.map i₂.op) t
⊢ (F.val.map (if h : { down := false }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) s =
    (F.val.map (if h : { down := false }.down = true then eqToHom ⋯ ≫ i₁ else eqToHom ⋯ ≫ i₂).op) t
state_after: no goals