/-- 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
    

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) =
    {
            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

Next tactic:
refine Over.OverMorphism.ext ?_