/-- Given a family of opens `U` and an open `Y` equal to the union of opens in `U`, we may
    take the presieve on `Y` associated to `U` and the sieve generated by it, and form the
    full subcategory (subposet) of opens contained in `Y` (`over Y`) consisting of arrows
    in the sieve. This full subcategory is equivalent to `OpensLeCover U`, the (poset)
    category of opens contained in some `U i`. -/
@[simps]
def generateEquivalenceOpensLe_inverse' :
    OpensLeCover U ⥤
    (FullSubcategory fun f : Over Y =>
      (Sieve.generate (presieveOfCoveringAux U Y)).arrows f.hom) where
  obj := fun V => ⟨⟨V.obj, ⟨⟨⟩⟩, homOfLE <| hY ▸ (V.2.choose_spec.trans (le_iSup U (V.2.choose)))⟩,
    ⟨U V.2.choose, V.2.choose_spec.hom, homOfLE <| hY ▸ le_iSup U V.2.choose,
      ⟨V.2.choose, rfl⟩, rfl⟩⟩
  map {_ _} g := Over.homMk g
  map_id _ := by
    refine Over.OverMorphism.ext ?_
    simp only [Functor.id_obj, Sieve.generate_apply, Functor.const_obj_obj, Over.homMk_left,
      eq_iff_true_of_subsingleton]
  map_comp {_ _ _} f g := by
    refine Over.OverMorphism.ext ?_
    

Proof state:
C : Type u
inst✝ : Category.{v, u} C
X : TopCat
F : Presheaf C X
ι : Type w
U : ι → Opens ↑X
Y : Opens ↑X
hY : Y = iSup U
x✝² x✝¹ x✝ : OpensLeCover U
f : x✝² ⟶ x✝¹
g : x✝¹ ⟶ x✝
⊢ ({
            obj := fun V =>
              {
                obj :=
                  { left := V.obj, right := { as := PUnit.unit },
                    hom := homOfLE (_ : (𝟭 (Opens ↑X)).obj V.obj ≤ (Functor.fromPUnit Y).obj { as := PUnit.unit }) },
                property :=
                  (_ :
                    ∃ Y_1 h g,
                      presieveOfCoveringAux U Y g ∧
                        h ≫ g =
                          { left := V.obj, right := { as := PUnit.unit },
                              hom :=
                                homOfLE
                                  (_ :
                                    (𝟭 (Opens ↑X)).obj V.obj ≤ (Functor.fromPUnit Y).obj { as := PUnit.unit }) }.hom) },
            map := fun {x x_1} g => Over.homMk g }.map
        (f ≫ g)).left =
    ({
              obj := fun V =>
                {
                  obj :=
                    { left := V.obj, right := { as := PUnit.unit },
                      hom := homOfLE (_ : (𝟭 (Opens ↑X)).obj V.obj ≤ (Functor.fromPUnit Y).obj { as := PUnit.unit }) },
                  property :=
                    (_ :
                      ∃ Y_1 h g,
                        presieveOfCoveringAux U Y g ∧
                          h ≫ g =
                            { left := V.obj, right := { as := PUnit.unit },
                                hom :=
                                  homOfLE
                                    (_ :
                                      (𝟭 (Opens ↑X)).obj V.obj ≤
                                        (Functor.fromPUnit Y).obj { as := PUnit.unit }) }.hom) },
              map := fun {x x_1} g => Over.homMk g }.map
          f ≫
        {
              obj := fun V =>
                {
                  obj :=
                    { left := V.obj, right := { as := PUnit.unit },
                      hom := homOfLE (_ : (𝟭 (Opens ↑X)).obj V.obj ≤ (Functor.fromPUnit Y).obj { as := PUnit.unit }) },
                  property :=
                    (_ :
                      ∃ Y_1 h g,
                        presieveOfCoveringAux U Y g ∧
                          h ≫ g =
                            { left := V.obj, right := { as := PUnit.unit },
                                hom :=
                                  homOfLE
                                    (_ :
                                      (𝟭 (Opens ↑X)).obj V.obj ≤
                                        (Functor.fromPUnit Y).obj { as := PUnit.unit }) }.hom) },
              map := fun {x x_1} g => Over.homMk g }.map
          g).left

Next tactic:
simp only [Functor.id_obj, Sieve.generate_apply, Functor.const_obj_obj, Over.homMk_left,
      eq_iff_true_of_subsingleton]