awhecmu/canonical-drafter-extract-mathlib huggingface dataset:
-- Lean 4 proof step from Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing (goal)
Goal:
C : Type u_1
inst : Category.{v_1, u_1} C
FC : C → C → Type u_2
CC : C → Type u_3
inst_1 : (X Y : C) → FunLike.{u_2 + 1, u_3 + 1, u_3 + 1} (FC X Y) (CC X) (CC Y)
inst_2 : ConcreteCategory.{u_3, v_1, u_1, u_2} C FC (CC := CC)
inst_3 : HasLimitsOfSize.{x, x, v_1, u_1} C
inst_4 : Functor.ReflectsIsomorphisms.{v_1, u_1, u_3, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesLimitsOfSize.{x, x, v_1, u_3, u_1, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
X : TopCat
F : Sheaf.{x, v_1, u_1} C X
U₁ U₂ V : Opens (↑X : Type x)
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t :
  ToType.{u_3, v_1, u_1, u_2} (FC := FC) (CC := CC)
    (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op V))
h₁ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
h₂ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
⊢ V ≤ ⨆ (t : Bool), if t = true then U₁ else U₂
have hcover₁ : U₁ ⊔ U₂ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂
Tactic: refine le_trans hcover ?_
-- Lean 4 proof step from Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing (goal)
Goal:
C : Type u_1
inst : Category.{v_1, u_1} C
FC : C → C → Type u_2
CC : C → Type u_3
inst_1 : (X Y : C) → FunLike.{u_2 + 1, u_3 + 1, u_3 + 1} (FC X Y) (CC X) (CC Y)
inst_2 : ConcreteCategory.{u_3, v_1, u_1, u_2} C FC (CC := CC)
inst_3 : HasLimitsOfSize.{x, x, v_1, u_1} C
inst_4 : Functor.ReflectsIsomorphisms.{v_1, u_1, u_3, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesLimitsOfSize.{x, x, v_1, u_3, u_1, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
X : TopCat
F : Sheaf.{x, v_1, u_1} C X
U₁ U₂ V : Opens (↑X : Type x)
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t :
  ToType.{u_3, v_1, u_1, u_2} (FC := FC) (CC := CC)
    (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op V))
h₁ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
h₂ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
⊢ U₁ ⊔ U₂ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂
have hcover₁ : (U₁ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂) ∧ U₂ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂
Tactic: rw [sup_le_iff]
-- Lean 4 proof step from Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing (goal)
Goal:
C : Type u_1
inst : Category.{v_1, u_1} C
FC : C → C → Type u_2
CC : C → Type u_3
inst_1 : (X Y : C) → FunLike.{u_2 + 1, u_3 + 1, u_3 + 1} (FC X Y) (CC X) (CC Y)
inst_2 : ConcreteCategory.{u_3, v_1, u_1, u_2} C FC (CC := CC)
inst_3 : HasLimitsOfSize.{x, x, v_1, u_1} C
inst_4 : Functor.ReflectsIsomorphisms.{v_1, u_1, u_3, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesLimitsOfSize.{x, x, v_1, u_3, u_1, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
X : TopCat
F : Sheaf.{x, v_1, u_1} C X
U₁ U₂ V : Opens (↑X : Type x)
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t :
  ToType.{u_3, v_1, u_1, u_2} (FC := FC) (CC := CC)
    (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op V))
h₁ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
h₂ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
⊢ (U₁ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂) ∧ U₂ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂
have hcover₁ : U₁ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂
Tactic: constructor
-- Lean 4 proof step from Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing (goal)
Goal:
C : Type u_1
inst : Category.{v_1, u_1} C
FC : C → C → Type u_2
CC : C → Type u_3
inst_1 : (X Y : C) → FunLike.{u_2 + 1, u_3 + 1, u_3 + 1} (FC X Y) (CC X) (CC Y)
inst_2 : ConcreteCategory.{u_3, v_1, u_1, u_2} C FC (CC := CC)
inst_3 : HasLimitsOfSize.{x, x, v_1, u_1} C
inst_4 : Functor.ReflectsIsomorphisms.{v_1, u_1, u_3, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesLimitsOfSize.{x, x, v_1, u_3, u_1, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
X : TopCat
F : Sheaf.{x, v_1, u_1} C X
U₁ U₂ V : Opens (↑X : Type x)
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t :
  ToType.{u_3, v_1, u_1, u_2} (FC := FC) (CC := CC)
    (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op V))
h₁ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
h₂ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
hcover₁ : U₁ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂
⊢ (U₁ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂) ∧ U₂ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂
have hcover₂ : U₂ ≤ ⨆ (t : Bool), if t = true then U₁ else U₂
Tactic: constructor
-- Lean 4 proof step from Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing (goal)
Goal:
C : Type u_1
inst : Category.{v_1, u_1} C
FC : C → C → Type u_2
CC : C → Type u_3
inst_1 : (X Y : C) → FunLike.{u_2 + 1, u_3 + 1, u_3 + 1} (FC X Y) (CC X) (CC Y)
inst_2 : ConcreteCategory.{u_3, v_1, u_1, u_2} C FC (CC := CC)
inst_3 : HasLimitsOfSize.{x, x, v_1, u_1} C
inst_4 : Functor.ReflectsIsomorphisms.{v_1, u_1, u_3, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesLimitsOfSize.{x, x, v_1, u_3, u_1, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
X : TopCat
F : Sheaf.{x, v_1, u_1} C X
U₁ U₂ V : Opens (↑X : Type x)
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t :
  ToType.{u_3, v_1, u_1, u_2} (FC := FC) (CC := CC)
    (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op V))
h₁ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
h₂ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
⊢ s = t
have iUV : (i : Bool) → (if i = true then U₁ else U₂) ⟶ V
Tactic: classical
    fapply F.eq_of_locally_eq' fun t : Bool => if t then U₁ else U₂
    · exact fun i => if h : i then eqToHom (if_pos h) ≫ i₁ else eqToHom (if_neg h) ≫ i₂
    · refine le_trans hcover ?_
      rw [sup_le_iff]
      constructor
      · exact le_iSup (fun t : Bool => if t then U₁ else U₂) true
      · exact le_iSup (fun t : Bool => if t then U₁ else U₂) false
    · rintro ⟨_ | _⟩
      any_goals exact h₁
      any_goals exact h₂
-- Lean 4 proof step from Mathlib.Topology.Sheaves.SheafCondition.UniqueGluing (goal)
Goal:
C : Type u_1
inst : Category.{v_1, u_1} C
FC : C → C → Type u_2
CC : C → Type u_3
inst_1 : (X Y : C) → FunLike.{u_2 + 1, u_3 + 1, u_3 + 1} (FC X Y) (CC X) (CC Y)
inst_2 : ConcreteCategory.{u_3, v_1, u_1, u_2} C FC (CC := CC)
inst_3 : HasLimitsOfSize.{x, x, v_1, u_1} C
inst_4 : Functor.ReflectsIsomorphisms.{v_1, u_1, u_3, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
inst_5 : PreservesLimitsOfSize.{x, x, v_1, u_3, u_1, u_3 + 1} (CategoryTheory.forget C (FC := FC) (CC := CC))
X : TopCat
F : Sheaf.{x, v_1, u_1} C X
U₁ U₂ V : Opens (↑X : Type x)
i₁ : U₁ ⟶ V
i₂ : U₂ ⟶ V
hcover : V ≤ U₁ ⊔ U₂
s t :
  ToType.{u_3, v_1, u_1, u_2} (FC := FC) (CC := CC)
    (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op V))
h₁ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₁.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₁)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₁)))
h₂ :
  Eq (α := CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        s :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
    ((ConcreteCategory.hom (FC := FC) (CC := CC)
            (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).map i₂.op) :
          (a : CC (F.obj.obj (op V))) → CC (F.obj.obj (op U₂)))
        t :
      CC (F.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type x))).obj (op U₂)))
iUV : (i : Bool) → (if i = true then U₁ else U₂) ⟶ V
⊢ s = t
have hcover₁ : V ≤ ⨆ (t : Bool), if t = true then U₁ else U₂
Tactic: classical
    fapply F.eq_of_locally_eq' fun t : Bool => if t then U₁ else U₂
    · exact fun i => if h : i then eqToHom (if_pos h) ≫ i₁ else eqToHom (if_neg h) ≫ i₂
    · refine le_trans hcover ?_
      rw [sup_le_iff]
      constructor
      · exact le_iSup (fun t : Bool => if t then U₁ else U₂) true
      · exact le_iSup (fun t : Bool => if t then U₁ else U₂) false
    · rintro ⟨_ | _⟩
      any_goals exact h₁
      any_goals exact h₂
-- Lean 4 proof step from Mathlib.Topology.Sheaves.Sheafify (goal)
Goal:
X : TopCat
F : Presheaf (Type v) X
U U' : (Opens (↑X : Type v))ᵒᵖ
f : U ⟶ U'
⊢ (F.map f ≫
      ↾fun (f : F.obj U') ↦
        Subtype.mk (p := fun (f : (x : ↥(unop U')) → (fun (x : (↑X : Type v)) ↦ F.stalk x) (↑x : (↑X : Type v))) ↦
          (Sheafify.isLocallyGerm F).toPrelocalPredicate (T := fun (x : (↑X : Type v)) ↦ F.stalk x).pred (T :=
            fun (x : (↑X : Type v)) ↦ F.stalk x) f)
          (fun (x : ↥(unop U')) ↦
            (ConcreteCategory.hom (FC := TypeCat.Fun) (F.germ (unop U') (↑x : (↑X : Type v)) ⋯) :
                (a : (fun (X : Type v) ↦ X) (F.obj (op (unop U')))) →
                  (fun (X : Type v) ↦ X) (F.stalk (↑x : (↑X : Type v))))
              f)
          ⋯) =
    (↾fun (f : F.obj U) ↦
        Subtype.mk (p := fun (f : (x : ↥(unop U)) → (fun (x : (↑X : Type v)) ↦ F.stalk x) (↑x : (↑X : Type v))) ↦
          (Sheafify.isLocallyGerm F).toPrelocalPredicate (T := fun (x : (↑X : Type v)) ↦ F.stalk x).pred (T :=
            fun (x : (↑X : Type v)) ↦ F.stalk x) f)
          (fun (x : ↥(unop U)) ↦
            (ConcreteCategory.hom (FC := TypeCat.Fun) (F.germ (unop U) (↑x : (↑X : Type v)) ⋯) :
                (a : (fun (X : Type v) ↦ X) (F.obj (op (unop U)))) →
                  (fun (X : Type v) ↦ X) (F.stalk (↑x : (↑X : Type v))))
              f)
          ⋯) ≫
      F.sheafify.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type v))).map f
have h : ∀ (x : F.obj U),
  TypeCat.Fun.toFun
      (ConcreteCategory.hom (FC := TypeCat.Fun)
        (F.map f ≫
          ↾fun (f : F.obj U') ↦
            Subtype.mk (p := fun (f : (x : ↥(unop U')) → (fun (x : (↑X : Type v)) ↦ F.stalk x) (↑x : (↑X : Type v))) ↦
              (Sheafify.isLocallyGerm F).toPrelocalPredicate (T := fun (x : (↑X : Type v)) ↦ F.stalk x).pred (T :=
                fun (x : (↑X : Type v)) ↦ F.stalk x) f)
              (fun (x : ↥(unop U')) ↦
                (ConcreteCategory.hom (FC := TypeCat.Fun) (F.germ (unop U') (↑x : (↑X : Type v)) sorry) :
                    (a : (fun (X : Type v) ↦ X) (F.obj (op (unop U')))) →
                      (fun (X : Type v) ↦ X) (F.stalk (↑x : (↑X : Type v))))
                  f)
              sorry))
      x =
    TypeCat.Fun.toFun
      (ConcreteCategory.hom (FC := TypeCat.Fun)
        ((↾fun (f : F.obj U) ↦
            Subtype.mk (p := fun (f : (x : ↥(unop U)) → (fun (x : (↑X : Type v)) ↦ F.stalk x) (↑x : (↑X : Type v))) ↦
              (Sheafify.isLocallyGerm F).toPrelocalPredicate (T := fun (x : (↑X : Type v)) ↦ F.stalk x).pred (T :=
                fun (x : (↑X : Type v)) ↦ F.stalk x) f)
              (fun (x : ↥(unop U)) ↦
                (ConcreteCategory.hom (FC := TypeCat.Fun) (F.germ (unop U) (↑x : (↑X : Type v)) sorry) :
                    (a : (fun (X : Type v) ↦ X) (F.obj (op (unop U)))) →
                      (fun (X : Type v) ↦ X) (F.stalk (↑x : (↑X : Type v))))
                  f)
              sorry) ≫
          F.sheafify.obj (P := CategoryTheory.Presheaf.IsSheaf (Opens.grothendieckTopology (↑X : Type v))).map f))
      x
Tactic: ext x
-- Lean 4 proof step from Mathlib.Topology.Sheaves.Sheafify (goal)
Goal:
X : TopCat
F : Presheaf (Type v) X
x : (↑X : Type v)
⊢ Function.Surjective (α := (fun (X : Type v) ↦ X) (F.sheafify.presheaf.stalk x)) (β :=
    (fun (X : Type v) ↦ X) (F.stalk x))
    (⇑(ConcreteCategory.hom (FC := TypeCat.Fun) (F.stalkToFiber x)) :
      (a : (fun (X : Type v) ↦ X) (F.sheafify.presheaf.stalk x)) → (fun (X : Type v) ↦ X) (F.stalk x))
have w : ∀ (t : F.stalk x),
  ∃ (U : OpenNhds x) (f : (y : ↥(↑U : Opens (↑X : Type v))) → F.stalk (↑y : (↑X : Type v))) (_ :
    (Sheafify.isLocallyGerm F).toPrelocalPredicate (T := fun (x : (↑X : Type v)) ↦ F.stalk x).pred (T :=
      fun (x : (↑X : Type v)) ↦ F.stalk x) f),
    f (Subtype.mk (p := fun (x_2 : (↑X : Type v)) ↦ x_2 ∈ (↑U : Opens (↑X : Type v))) x sorry) = t
Tactic: apply TopCat.stalkToFiber_surjective
-- Lean 4 proof step from Mathlib.Topology.Sheaves.Sheafify (goal)
Goal:
X : TopCat
F : Presheaf (Type v) X
x : (↑X : Type v)
t : F.stalk x
⊢ ∃ (U : OpenNhds x) (f : (y : ↥(↑U : Opens (↑X : Type v))) → F.stalk (↑y : (↑X : Type v))) (_ :
    (Sheafify.isLocallyGerm F).toPrelocalPredicate (T := fun (x : (↑X : Type v)) ↦ F.stalk x).pred (T :=
      fun (x : (↑X : Type v)) ↦ F.stalk x) f),
    f (Subtype.mk (p := fun (x_2 : (↑X : Type v)) ↦ x_2 ∈ (↑U : Opens (↑X : Type v))) x ⋯) = t
have w : ∀ (U : Opens (↑X : Type v)) (m : x ∈ U) (s : ToType (FC := TypeCat.Fun) (F.obj (op U))),
  ∃ (U_1 : OpenNhds x) (f : (y : ↥(↑U_1 : Opens (↑X : Type v))) → F.stalk (↑y : (↑X : Type v))) (_ :
    (Sheafify.isLocallyGerm F).toPrelocalPredicate (T := fun (x : (↑X : Type v)) ↦ F.stalk x).pred (T :=
      fun (x : (↑X : Type v)) ↦ F.stalk x) f),
    Eq.{v + 1} (α :=
      F.stalk (↑(Subtype.mk (p := fun (x_2 : (↑X : Type v)) ↦ x_2 ∈ (↑U_1 : Opens (↑X : Type v))) x sorry) : (↑X : Type v)))
      (f (Subtype.mk (p := fun (x_2 : (↑X : Type v)) ↦ x_2 ∈ (↑U_1 : Opens (↑X : Type v))) x sorry))
      ((ConcreteCategory.hom (FC := TypeCat.Fun) (F.germ U x m) : (a : F.obj (op U)) → F.stalk x) s)
Tactic: obtain ⟨U, m, s, rfl⟩ := F.exists_germ_eq t
Cleared hypotheses: t
-- Lean 4 proof step from Mathlib.Topology.Sheaves.Sheafify (goal)
Goal:
X : TopCat
F : Presheaf (Type v) X
x : (↑X : Type v)
U : Opens (↑X : Type v)
m : x ∈ U
s : ToType (FC := TypeCat.Fun) (F.obj (op U))
⊢ ∃ (U_1 : OpenNhds x) (f : (y : ↥(↑U_1 : Opens (↑X : Type v))) → F.stalk (↑y : (↑X : Type v))) (_ :
    (Sheafify.isLocallyGerm F).toPrelocalPredicate (T := fun (x : (↑X : Type v)) ↦ F.stalk x).pred (T :=
      fun (x : (↑X : Type v)) ↦ F.stalk x) f),
    Eq.{v + 1} (α :=
      F.stalk (↑(Subtype.mk (p := fun (x_2 : (↑X : Type v)) ↦ x_2 ∈ (↑U_1 : Opens (↑X : Type v))) x ⋯) : (↑X : Type v)))
      (f (Subtype.mk (p := fun (x_2 : (↑X : Type v)) ↦ x_2 ∈ (↑U_1 : Opens (↑X : Type v))) x ⋯))
      ((ConcreteCategory.hom (FC := TypeCat.Fun) (F.germ U x m) : (a : F.obj (op U)) → F.stalk x) s)
have h : ∃ (f :
  (y : ↥(↑(Subtype.mk (p := fun (U : Opens (↑X : Type v)) ↦ x ∈ U) U m) : Opens (↑X : Type v))) →
    F.stalk (↑y : (↑X : Type v)))
  (_ :
  (Sheafify.isLocallyGerm F).toPrelocalPredicate (T := fun (x : (↑X : Type v)) ↦ F.stalk x).pred (T :=
    fun (x : (↑X : Type v)) ↦ F.stalk x) f),
  Eq.{v + 1} (α :=
    F.stalk
      (↑(Subtype.mk (p := fun (x_2 : (↑X : Type v)) ↦
            x_2 ∈ (↑(Subtype.mk (p := fun (U : Opens (↑X : Type v)) ↦ x ∈ U) U m) : Opens (↑X : Type v))) x sorry) :
        (↑X : Type v)))
    (f
      (Subtype.mk (p := fun (x_2 : (↑X : Type v)) ↦
        x_2 ∈ (↑(Subtype.mk (p := fun (U : Opens (↑X : Type v)) ↦ x ∈ U) U m) : Opens (↑X : Type v))) x sorry))
    ((ConcreteCategory.hom (FC := TypeCat.Fun) (F.germ U x m) : (a : F.obj (op U)) → F.stalk x) s)
Tactic: use ⟨U, m⟩