File: Mathlib/Topology/Category/TopCat/Opens.lean

full_name: TopologicalSpace.Opens.opensHomHasCoeToFun
code: instance opensHomHasCoeToFun {U V : Opens X} : CoeFun (U ⟶ V) fun _ => U → V 
goal: CoeFun (U ⟶ V) fun x => ↥U → ↥V

full_name: TopologicalSpace.Opens.infLELeft
code: /-- The inclusion `U ⊓ V ⟶ U` as a morphism in the category of open sets.
-/
noncomputable def infLELeft (U V : Opens X) : U ⊓ V ⟶ U 
goal: U ⊓ V ⟶ U

full_name: TopologicalSpace.Opens.infLERight
code: /-- The inclusion `U ⊓ V ⟶ V` as a morphism in the category of open sets.
-/
noncomputable def infLERight (U V : Opens X) : U ⊓ V ⟶ V 
goal: U ⊓ V ⟶ V

full_name: TopologicalSpace.Opens.leSupr
code: /-- The inclusion `U i ⟶ supr U` as a morphism in the category of open sets.
-/
noncomputable def leSupr {ι : Type*} (U : ι → Opens X) (i : ι) : U i ⟶ iSup U 
goal: U i ⟶ iSup U

full_name: TopologicalSpace.Opens.botLE
code: /-- The inclusion `⊥ ⟶ U` as a morphism in the category of open sets.
-/
noncomputable def botLE (U : Opens X) : ⊥ ⟶ U 
goal: ⊥ ⟶ U

full_name: TopologicalSpace.Opens.leTop
code: /-- The inclusion `U ⟶ ⊤` as a morphism in the category of open sets.
-/
noncomputable def leTop (U : Opens X) : U ⟶ ⊤ 
goal: U ⟶ ⊤

full_name: TopologicalSpace.Opens.infLELeft_apply
code: theorem infLELeft_apply (U V : Opens X) (x) :
    (infLELeft U V) x = ⟨x.1, (@inf_le_left _ _ U V : _ ≤ _) x.2⟩ 
goal: (fun x => ⟨↑x, ⋯⟩) x = ⟨↑x, ⋯⟩

full_name: TopologicalSpace.Opens.infLELeft_apply_mk
code: @[simp]
theorem infLELeft_apply_mk (U V : Opens X) (x) (m) :
    (infLELeft U V) ⟨x, m⟩ = ⟨x, (@inf_le_left _ _ U V : _ ≤ _) m⟩ 
goal: (fun x => ⟨↑x, ⋯⟩) ⟨x, m⟩ = ⟨x, ⋯⟩

full_name: TopologicalSpace.Opens.leSupr_apply_mk
code: @[simp]
theorem leSupr_apply_mk {ι : Type*} (U : ι → Opens X) (i : ι) (x) (m) :
    (leSupr U i) ⟨x, m⟩ = ⟨x, (le_iSup U i : _) m⟩ 
goal: (fun x => ⟨↑x, ⋯⟩) ⟨x, m⟩ = ⟨x, ⋯⟩

full_name: TopologicalSpace.Opens.toTopCat
code: /-- The functor from open sets in `X` to `Top`,
realising each open set as a topological space itself.
-/
def toTopCat (X : TopCat.{u}) : Opens X ⥤ TopCat 
goal: TopologicalSpace.Opens ↑X ⥤ TopCat

full_name: TopologicalSpace.Opens.toTopCat_map
code: @[simp]
theorem toTopCat_map (X : TopCat.{u}) {U V : Opens X} {f : U ⟶ V} {x} {h} :
    ((toTopCat X).map f) ⟨x, h⟩ = ⟨x, f.le h⟩ 
goal: ((TopologicalSpace.Opens.toTopCat X).map f) ⟨x, h⟩ = ⟨x, ⋯⟩

full_name: TopologicalSpace.Opens.inclusion
code: /-- The inclusion map from an open subset to the whole space, as a morphism in `TopCat`.
-/
@[simps (config := .asFn)]
def inclusion {X : TopCat.{u}} (U : Opens X) : (toTopCat X).obj U ⟶ X 
goal: (TopologicalSpace.Opens.toTopCat X).obj U ⟶ X

full_name: TopologicalSpace.Opens.inclusion_apply
code: /-- The inclusion map from an open subset to the whole space, as a morphism in `TopCat`.
-/
@[simps (config := .asFn)]
def inclusion {X : TopCat.{u}} (U : Opens X) : (toTopCat X).obj U ⟶ X 
goal: ⇑U.inclusion = Subtype.val

full_name: TopologicalSpace.Opens.coe_inclusion
code: @[simp]
theorem coe_inclusion {X : TopCat} {U : Opens X} :
    (inclusion U : U → X) = Subtype.val 
goal: ⇑U.inclusion = Subtype.val

full_name: TopologicalSpace.Opens.openEmbedding
code: theorem openEmbedding {X : TopCat.{u}} (U : Opens X) : OpenEmbedding (inclusion U) 
goal: OpenEmbedding ⇑U.inclusion

full_name: TopologicalSpace.Opens.inclusionTopIso
code: /-- The inclusion of the top open subset (i.e. the whole space) is an isomorphism.
-/
def inclusionTopIso (X : TopCat.{u}) : (toTopCat X).obj ⊤ ≅ X 
goal: (TopologicalSpace.Opens.toTopCat X).obj ⊤ ≅ X

full_name: TopologicalSpace.Opens.map
code: /-- `Opens.map f` gives the functor from open sets in Y to open set in X,
    given by taking preimages under f. -/
def map (f : X ⟶ Y) : Opens Y ⥤ Opens X 
goal: TopologicalSpace.Opens ↑Y ⥤ TopologicalSpace.Opens ↑X

full_name: TopologicalSpace.Opens.map_coe
code: @[simp]
theorem map_coe (f : X ⟶ Y) (U : Opens Y) : ((map f).obj U : Set X) = f ⁻¹' (U : Set Y) 
goal: ↑((TopologicalSpace.Opens.map f).obj U) = ⇑f ⁻¹' ↑U

full_name: TopologicalSpace.Opens.map_obj
code: @[simp]
theorem map_obj (f : X ⟶ Y) (U) (p) : (map f).obj ⟨U, p⟩ = ⟨f ⁻¹' U, p.preimage f.continuous⟩ 
goal: (TopologicalSpace.Opens.map f).obj { carrier := U, is_open' := p } = { carrier := ⇑f ⁻¹' U, is_open' := ⋯ }

full_name: TopologicalSpace.Opens.map_homOfLE
code: @[simp]
lemma map_homOfLE (f : X ⟶ Y) {U V : Opens Y} (e : U ≤ V) :
    (TopologicalSpace.Opens.map f).map (homOfLE e) =
      homOfLE (show (Opens.map f).obj U ≤ (Opens.map f).obj V from fun _ hx ↦ e hx) 
goal: (TopologicalSpace.Opens.map f).map (CategoryTheory.homOfLE e) = CategoryTheory.homOfLE ⋯

full_name: TopologicalSpace.Opens.map_id_obj
code: @[simp]
theorem map_id_obj (U : Opens X) : (map (𝟙 X)).obj U = U 
goal: (TopologicalSpace.Opens.map (𝟙 X)).obj U = U

full_name: TopologicalSpace.Opens.map_id_obj'
code: @[simp 1100]
theorem map_id_obj' (U) (p) : (map (𝟙 X)).obj ⟨U, p⟩ = ⟨U, p⟩ 
goal: (TopologicalSpace.Opens.map (𝟙 X)).obj { carrier := U, is_open' := p } = { carrier := U, is_open' := p }

full_name: TopologicalSpace.Opens.map_id_obj_unop
code: @[simp 1100]
theorem map_id_obj_unop (U : (Opens X)ᵒᵖ) : (map (𝟙 X)).obj (unop U) = unop U 
goal: (TopologicalSpace.Opens.map (𝟙 X)).obj (Opposite.unop U) = Opposite.unop U

full_name: TopologicalSpace.Opens.op_map_id_obj
code: @[simp 1100]
theorem op_map_id_obj (U : (Opens X)ᵒᵖ) : (map (𝟙 X)).op.obj U = U 
goal: (TopologicalSpace.Opens.map (𝟙 X)).op.obj U = U

full_name: TopologicalSpace.Opens.map_top
code: @[simp]
lemma map_top (f : X ⟶ Y) : (Opens.map f).obj ⊤ = ⊤ 
goal: (TopologicalSpace.Opens.map f).obj ⊤ = ⊤

full_name: TopologicalSpace.Opens.leMapTop
code: /-- The inclusion `U ⟶ (map f).obj ⊤` as a morphism in the category of open sets.
-/
noncomputable def leMapTop (f : X ⟶ Y) (U : Opens X) : U ⟶ (map f).obj ⊤ 
goal: U ⟶ (TopologicalSpace.Opens.map f).obj ⊤

full_name: TopologicalSpace.Opens.map_comp_obj
code: @[simp]
theorem map_comp_obj (f : X ⟶ Y) (g : Y ⟶ Z) (U) :
    (map (f ≫ g)).obj U = (map f).obj ((map g).obj U) 
goal: (TopologicalSpace.Opens.map (f ≫ g)).obj U = (TopologicalSpace.Opens.map f).obj ((TopologicalSpace.Opens.map g).obj U)

full_name: TopologicalSpace.Opens.map_comp_obj'
code: @[simp]
theorem map_comp_obj' (f : X ⟶ Y) (g : Y ⟶ Z) (U) (p) :
    (map (f ≫ g)).obj ⟨U, p⟩ = (map f).obj ((map g).obj ⟨U, p⟩) 
goal: (TopologicalSpace.Opens.map (f ≫ g)).obj { carrier := U, is_open' := p } =
  (TopologicalSpace.Opens.map f).obj ((TopologicalSpace.Opens.map g).obj { carrier := U, is_open' := p })

full_name: TopologicalSpace.Opens.map_comp_map
code: @[simp]
theorem map_comp_map (f : X ⟶ Y) (g : Y ⟶ Z) {U V} (i : U ⟶ V) :
    (map (f ≫ g)).map i = (map f).map ((map g).map i) 
goal: (TopologicalSpace.Opens.map (f ≫ g)).map i = (TopologicalSpace.Opens.map f).map ((TopologicalSpace.Opens.map g).map i)

full_name: TopologicalSpace.Opens.map_comp_obj_unop
code: @[simp]
theorem map_comp_obj_unop (f : X ⟶ Y) (g : Y ⟶ Z) (U) :
    (map (f ≫ g)).obj (unop U) = (map f).obj ((map g).obj (unop U)) 
goal: (TopologicalSpace.Opens.map (f ≫ g)).obj (Opposite.unop U) =
  (TopologicalSpace.Opens.map f).obj ((TopologicalSpace.Opens.map g).obj (Opposite.unop U))

full_name: TopologicalSpace.Opens.op_map_comp_obj
code: @[simp]
theorem op_map_comp_obj (f : X ⟶ Y) (g : Y ⟶ Z) (U) :
    (map (f ≫ g)).op.obj U = (map f).op.obj ((map g).op.obj U) 
goal: (TopologicalSpace.Opens.map (f ≫ g)).op.obj U =
  (TopologicalSpace.Opens.map f).op.obj ((TopologicalSpace.Opens.map g).op.obj U)

full_name: TopologicalSpace.Opens.map_iSup
code: theorem map_iSup (f : X ⟶ Y) {ι : Type*} (U : ι → Opens Y) :
    (map f).obj (iSup U) = iSup ((map f).obj ∘ U) 
goal: (TopologicalSpace.Opens.map f).obj (iSup U) = iSup ((TopologicalSpace.Opens.map f).obj ∘ U)

full_name: TopologicalSpace.Opens.mapId_inv_app
code: /-- The functor `Opens X ⥤ Opens X` given by taking preimages under the identity function
is naturally isomorphic to the identity functor.
-/
@[simps]
def mapId : map (𝟙 X) ≅ 𝟭 (Opens X) 
goal: (TopologicalSpace.Opens.mapId X).inv.app U = CategoryTheory.eqToHom ⋯

full_name: TopologicalSpace.Opens.mapId_hom_app
code: /-- The functor `Opens X ⥤ Opens X` given by taking preimages under the identity function
is naturally isomorphic to the identity functor.
-/
@[simps]
def mapId : map (𝟙 X) ≅ 𝟭 (Opens X) 
goal: (TopologicalSpace.Opens.mapId X).hom.app U = CategoryTheory.eqToHom ⋯

full_name: TopologicalSpace.Opens.mapId
code: /-- The functor `Opens X ⥤ Opens X` given by taking preimages under the identity function
is naturally isomorphic to the identity functor.
-/
@[simps]
def mapId : map (𝟙 X) ≅ 𝟭 (Opens X) 
goal: TopologicalSpace.Opens.map (𝟙 X) ≅ 𝟭 (TopologicalSpace.Opens ↑X)

full_name: TopologicalSpace.Opens.map_id_eq
code: theorem map_id_eq : map (𝟙 X) = 𝟭 (Opens X) 
goal: TopologicalSpace.Opens.map (𝟙 X) = 𝟭 (TopologicalSpace.Opens ↑X)

full_name: TopologicalSpace.Opens.mapComp
code: /-- The natural isomorphism between taking preimages under `f ≫ g`, and the composite
of taking preimages under `g`, then preimages under `f`.
-/
@[simps]
def mapComp (f : X ⟶ Y) (g : Y ⟶ Z) : map (f ≫ g) ≅ map g ⋙ map f 
goal: TopologicalSpace.Opens.map (f ≫ g) ≅ TopologicalSpace.Opens.map g ⋙ TopologicalSpace.Opens.map f

full_name: TopologicalSpace.Opens.mapComp_inv_app
code: /-- The natural isomorphism between taking preimages under `f ≫ g`, and the composite
of taking preimages under `g`, then preimages under `f`.
-/
@[simps]
def mapComp (f : X ⟶ Y) (g : Y ⟶ Z) : map (f ≫ g) ≅ map g ⋙ map f 
goal: (TopologicalSpace.Opens.mapComp f g).inv.app U = CategoryTheory.eqToHom ⋯

full_name: TopologicalSpace.Opens.mapComp_hom_app
code: /-- The natural isomorphism between taking preimages under `f ≫ g`, and the composite
of taking preimages under `g`, then preimages under `f`.
-/
@[simps]
def mapComp (f : X ⟶ Y) (g : Y ⟶ Z) : map (f ≫ g) ≅ map g ⋙ map f 
goal: (TopologicalSpace.Opens.mapComp f g).hom.app U = CategoryTheory.eqToHom ⋯

full_name: TopologicalSpace.Opens.map_comp_eq
code: theorem map_comp_eq (f : X ⟶ Y) (g : Y ⟶ Z) : map (f ≫ g) = map g ⋙ map f 
goal: TopologicalSpace.Opens.map (f ≫ g) = TopologicalSpace.Opens.map g ⋙ TopologicalSpace.Opens.map f

full_name: TopologicalSpace.Opens.mapIso
code: /-- If two continuous maps `f g : X ⟶ Y` are equal,
then the functors `Opens Y ⥤ Opens X` they induce are isomorphic.
-/
def mapIso (f g : X ⟶ Y) (h : f = g) : map f ≅ map g 
goal: TopologicalSpace.Opens.map f ≅ TopologicalSpace.Opens.map g

full_name: TopologicalSpace.Opens.map_eq
code: theorem map_eq (f g : X ⟶ Y) (h : f = g) : map f = map g 
goal: TopologicalSpace.Opens.map f = TopologicalSpace.Opens.map g

full_name: TopologicalSpace.Opens.mapIso_refl
code: @[simp]
theorem mapIso_refl (f : X ⟶ Y) (h) : mapIso f f h = Iso.refl (map _) 
goal: TopologicalSpace.Opens.mapIso f f h = CategoryTheory.Iso.refl (TopologicalSpace.Opens.map f)

full_name: TopologicalSpace.Opens.mapIso_hom_app
code: @[simp]
theorem mapIso_hom_app (f g : X ⟶ Y) (h : f = g) (U : Opens Y) :
    (mapIso f g h).hom.app U = eqToHom (by rw [h]) 
goal: (TopologicalSpace.Opens.mapIso f g h).hom.app U = CategoryTheory.eqToHom ⋯

full_name: TopologicalSpace.Opens.mapIso_inv_app
code: @[simp]
theorem mapIso_inv_app (f g : X ⟶ Y) (h : f = g) (U : Opens Y) :
    (mapIso f g h).inv.app U = eqToHom (by rw [h]) 
goal: (TopologicalSpace.Opens.mapIso f g h).inv.app U = CategoryTheory.eqToHom ⋯

full_name: TopologicalSpace.Opens.mapMapIso_functor
code: /-- A homeomorphism of spaces gives an equivalence of categories of open sets.

TODO: define `OrderIso.equivalence`, use it.
-/
@[simps]
def mapMapIso {X Y : TopCat.{u}} (H : X ≅ Y) : Opens Y ≌ Opens X 
goal: (TopologicalSpace.Opens.mapMapIso H).functor = TopologicalSpace.Opens.map H.hom

full_name: TopologicalSpace.Opens.mapMapIso
code: /-- A homeomorphism of spaces gives an equivalence of categories of open sets.

TODO: define `OrderIso.equivalence`, use it.
-/
@[simps]
def mapMapIso {X Y : TopCat.{u}} (H : X ≅ Y) : Opens Y ≌ Opens X 
goal: TopologicalSpace.Opens ↑Y ≌ TopologicalSpace.Opens ↑X

full_name: TopologicalSpace.Opens.mapMapIso_inverse
code: /-- A homeomorphism of spaces gives an equivalence of categories of open sets.

TODO: define `OrderIso.equivalence`, use it.
-/
@[simps]
def mapMapIso {X Y : TopCat.{u}} (H : X ≅ Y) : Opens Y ≌ Opens X 
goal: (TopologicalSpace.Opens.mapMapIso H).inverse = TopologicalSpace.Opens.map H.inv

full_name: TopologicalSpace.Opens.mapMapIso_unitIso
code: /-- A homeomorphism of spaces gives an equivalence of categories of open sets.

TODO: define `OrderIso.equivalence`, use it.
-/
@[simps]
def mapMapIso {X Y : TopCat.{u}} (H : X ≅ Y) : Opens Y ≌ Opens X 
goal: (TopologicalSpace.Opens.mapMapIso H).unitIso = CategoryTheory.NatIso.ofComponents (fun U => CategoryTheory.eqToIso ⋯) ⋯

full_name: TopologicalSpace.Opens.mapMapIso_counitIso
code: /-- A homeomorphism of spaces gives an equivalence of categories of open sets.

TODO: define `OrderIso.equivalence`, use it.
-/
@[simps]
def mapMapIso {X Y : TopCat.{u}} (H : X ≅ Y) : Opens Y ≌ Opens X 
goal: (TopologicalSpace.Opens.mapMapIso H).counitIso =
  CategoryTheory.NatIso.ofComponents (fun U => CategoryTheory.eqToIso ⋯) ⋯

full_name: IsOpenMap.functor_obj_coe
code: /-- An open map `f : X ⟶ Y` induces a functor `Opens X ⥤ Opens Y`.
-/
@[simps obj_coe]
def IsOpenMap.functor {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap f) : Opens X ⥤ Opens Y 
goal: ↑(hf.functor.obj U) = ⇑f '' ↑U

full_name: IsOpenMap.functor
code: /-- An open map `f : X ⟶ Y` induces a functor `Opens X ⥤ Opens Y`.
-/
@[simps obj_coe]
def IsOpenMap.functor {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap f) : Opens X ⥤ Opens Y 
goal: TopologicalSpace.Opens ↑X ⥤ TopologicalSpace.Opens ↑Y

full_name: IsOpenMap.adjunction
code: /-- An open map `f : X ⟶ Y` induces an adjunction between `Opens X` and `Opens Y`.
-/
def IsOpenMap.adjunction {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap f) :
    Adjunction hf.functor (TopologicalSpace.Opens.map f) 
goal: hf.functor ⊣ TopologicalSpace.Opens.map f

full_name: IsOpenMap.functorFullOfMono
code: instance IsOpenMap.functorFullOfMono {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap f) [H : Mono f] :
    hf.functor.Full 
goal: hf.functor.Full

full_name: IsOpenMap.functor_faithful
code: instance IsOpenMap.functor_faithful {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap f) :
    hf.functor.Faithful 
goal: hf.functor.Faithful

full_name: OpenEmbedding.functor_obj_injective
code: lemma OpenEmbedding.functor_obj_injective {X Y : TopCat} {f : X ⟶ Y} (hf : OpenEmbedding f) :
    Function.Injective hf.isOpenMap.functor.obj 
goal: Function.Injective ⋯.functor.obj

full_name: TopologicalSpace.Opens.openEmbedding_obj_top
code: @[simp]
theorem openEmbedding_obj_top {X : TopCat} (U : Opens X) :
    U.openEmbedding.isOpenMap.functor.obj ⊤ = U 
goal: ⋯.functor.obj ⊤ = U

full_name: TopologicalSpace.Opens.inclusion_map_eq_top
code: @[simp]
theorem inclusion_map_eq_top {X : TopCat} (U : Opens X) : (Opens.map U.inclusion).obj U = ⊤ 
goal: (TopologicalSpace.Opens.map U.inclusion).obj U = ⊤

full_name: TopologicalSpace.Opens.adjunction_counit_app_self
code: @[simp]
theorem adjunction_counit_app_self {X : TopCat} (U : Opens X) :
    U.openEmbedding.isOpenMap.adjunction.counit.app U = eqToHom (by simp) 
goal: ⋯.adjunction.counit.app U = CategoryTheory.eqToHom ⋯

full_name: TopologicalSpace.Opens.inclusion_top_functor
code: theorem inclusion_top_functor (X : TopCat) :
    (@Opens.openEmbedding X ⊤).isOpenMap.functor = map (inclusionTopIso X).inv 
goal: ⋯.functor = TopologicalSpace.Opens.map (TopologicalSpace.Opens.inclusionTopIso X).inv

full_name: TopologicalSpace.Opens.functor_obj_map_obj
code: theorem functor_obj_map_obj {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap f) (U : Opens Y) :
    hf.functor.obj ((Opens.map f).obj U) = hf.functor.obj ⊤ ⊓ U 
goal: hf.functor.obj ((TopologicalSpace.Opens.map f).obj U) = hf.functor.obj ⊤ ⊓ U

full_name: TopologicalSpace.Opens.set_range_forget_map_inclusion
code: lemma set_range_forget_map_inclusion {X : TopCat} (U : Opens X) :
    Set.range ((forget TopCat).map (inclusion U)) = (U : Set X) 
goal: Set.range ((CategoryTheory.forget TopCat).map U.inclusion) = ↑U

full_name: TopologicalSpace.Opens.functor_map_eq_inf
code: @[simp]
theorem functor_map_eq_inf {X : TopCat} (U V : Opens X) :
    U.openEmbedding.isOpenMap.functor.obj ((Opens.map U.inclusion).obj V) = V ⊓ U 
goal: ⋯.functor.obj ((TopologicalSpace.Opens.map U.inclusion).obj V) = V ⊓ U

full_name: TopologicalSpace.Opens.map_functor_eq'
code: theorem map_functor_eq' {X U : TopCat} (f : U ⟶ X) (hf : OpenEmbedding f) (V) :
    ((Opens.map f).obj <| hf.isOpenMap.functor.obj V) = V 
goal: (TopologicalSpace.Opens.map f).obj (⋯.functor.obj V) = V

full_name: TopologicalSpace.Opens.map_functor_eq
code: @[simp]
theorem map_functor_eq {X : TopCat} {U : Opens X} (V : Opens U) :
    ((Opens.map U.inclusion).obj <| U.openEmbedding.isOpenMap.functor.obj V) = V 
goal: (TopologicalSpace.Opens.map U.inclusion).obj (⋯.functor.obj V) = V

full_name: TopologicalSpace.Opens.adjunction_counit_map_functor
code: @[simp]
theorem adjunction_counit_map_functor {X : TopCat} {U : Opens X} (V : Opens U) :
    U.openEmbedding.isOpenMap.adjunction.counit.app (U.openEmbedding.isOpenMap.functor.obj V) =
      eqToHom (by dsimp; rw [map_functor_eq V]) 
goal: ⋯.adjunction.counit.app (⋯.functor.obj V) = CategoryTheory.eqToHom ⋯