File: Mathlib/Topology/Constructions.lean

full_name: instTopologicalSpaceQuot
code: instance {r : X → X → Prop} [t : TopologicalSpace X] : TopologicalSpace (Quot r) 
goal: TopologicalSpace (Quot r)

full_name: instTopologicalSpaceQuotient
code: instance instTopologicalSpaceQuotient {s : Setoid X} [t : TopologicalSpace X] :
    TopologicalSpace (Quotient s) 
goal: TopologicalSpace (Quotient s)

full_name: instTopologicalSpaceProd
code: instance instTopologicalSpaceProd [t₁ : TopologicalSpace X] [t₂ : TopologicalSpace Y] :
    TopologicalSpace (X × Y) 
goal: TopologicalSpace (X × Y)

full_name: instTopologicalSpaceSum
code: instance instTopologicalSpaceSum [t₁ : TopologicalSpace X] [t₂ : TopologicalSpace Y] :
    TopologicalSpace (X ⊕ Y) 
goal: TopologicalSpace (X ⊕ Y)

full_name: instTopologicalSpaceSigma
code: instance instTopologicalSpaceSigma {ι : Type*} {X : ι → Type v} [t₂ : ∀ i, TopologicalSpace (X i)] :
    TopologicalSpace (Sigma X) 
goal: TopologicalSpace (Sigma X)

full_name: Pi.topologicalSpace
code: instance Pi.topologicalSpace {ι : Type*} {Y : ι → Type v} [t₂ : (i : ι) → TopologicalSpace (Y i)] :
    TopologicalSpace ((i : ι) → Y i) 
goal: TopologicalSpace ((i : ι) → Y i)

full_name: ULift.topologicalSpace
code: instance ULift.topologicalSpace [t : TopologicalSpace X] : TopologicalSpace (ULift.{v, u} X) 
goal: TopologicalSpace (ULift.{v, u} X)

full_name: instTopologicalSpaceAdditive
code: instance : TopologicalSpace (Additive X) 
goal: TopologicalSpace (Additive X)

full_name: instTopologicalSpaceMultiplicative
code: instance : TopologicalSpace (Multiplicative X) 
goal: TopologicalSpace (Multiplicative X)

full_name: instDiscreteTopologyAdditive
code: instance [DiscreteTopology X] : DiscreteTopology (Additive X) 
goal: DiscreteTopology (Additive X)

full_name: instDiscreteTopologyMultiplicative
code: instance [DiscreteTopology X] : DiscreteTopology (Multiplicative X) 
goal: DiscreteTopology (Multiplicative X)

full_name: continuous_ofMul
code: theorem continuous_ofMul : Continuous (ofMul : X → Additive X) 
goal: Continuous ⇑Additive.ofMul

full_name: continuous_toMul
code: theorem continuous_toMul : Continuous (toMul : Additive X → X) 
goal: Continuous ⇑Additive.toMul

full_name: continuous_ofAdd
code: theorem continuous_ofAdd : Continuous (ofAdd : X → Multiplicative X) 
goal: Continuous ⇑Multiplicative.ofAdd

full_name: continuous_toAdd
code: theorem continuous_toAdd : Continuous (toAdd : Multiplicative X → X) 
goal: Continuous ⇑Multiplicative.toAdd

full_name: isOpenMap_ofMul
code: theorem isOpenMap_ofMul : IsOpenMap (ofMul : X → Additive X) 
goal: IsOpenMap ⇑Additive.ofMul

full_name: isOpenMap_toMul
code: theorem isOpenMap_toMul : IsOpenMap (toMul : Additive X → X) 
goal: IsOpenMap ⇑Additive.toMul

full_name: isOpenMap_ofAdd
code: theorem isOpenMap_ofAdd : IsOpenMap (ofAdd : X → Multiplicative X) 
goal: IsOpenMap ⇑Multiplicative.ofAdd

full_name: isOpenMap_toAdd
code: theorem isOpenMap_toAdd : IsOpenMap (toAdd : Multiplicative X → X) 
goal: IsOpenMap ⇑Multiplicative.toAdd

full_name: isClosedMap_ofMul
code: theorem isClosedMap_ofMul : IsClosedMap (ofMul : X → Additive X) 
goal: IsClosedMap ⇑Additive.ofMul

full_name: isClosedMap_toMul
code: theorem isClosedMap_toMul : IsClosedMap (toMul : Additive X → X) 
goal: IsClosedMap ⇑Additive.toMul

full_name: isClosedMap_ofAdd
code: theorem isClosedMap_ofAdd : IsClosedMap (ofAdd : X → Multiplicative X) 
goal: IsClosedMap ⇑Multiplicative.ofAdd

full_name: isClosedMap_toAdd
code: theorem isClosedMap_toAdd : IsClosedMap (toAdd : Multiplicative X → X) 
goal: IsClosedMap ⇑Multiplicative.toAdd

full_name: nhds_ofMul
code: theorem nhds_ofMul (x : X) : 𝓝 (ofMul x) = map ofMul (𝓝 x) 
goal: 𝓝 (Additive.ofMul x) = Filter.map (⇑Additive.ofMul) (𝓝 x)

full_name: nhds_ofAdd
code: theorem nhds_ofAdd (x : X) : 𝓝 (ofAdd x) = map ofAdd (𝓝 x) 
goal: 𝓝 (Multiplicative.ofAdd x) = Filter.map (⇑Multiplicative.ofAdd) (𝓝 x)

full_name: nhds_toMul
code: theorem nhds_toMul (x : Additive X) : 𝓝 (toMul x) = map toMul (𝓝 x) 
goal: 𝓝 (Additive.toMul x) = Filter.map (⇑Additive.toMul) (𝓝 x)

full_name: nhds_toAdd
code: theorem nhds_toAdd (x : Multiplicative X) : 𝓝 (toAdd x) = map toAdd (𝓝 x) 
goal: 𝓝 (Multiplicative.toAdd x) = Filter.map (⇑Multiplicative.toAdd) (𝓝 x)

full_name: OrderDual.instTopologicalSpace
code: instance OrderDual.instTopologicalSpace : TopologicalSpace Xᵒᵈ 
goal: TopologicalSpace Xᵒᵈ

full_name: OrderDual.instDiscreteTopology
code: instance OrderDual.instDiscreteTopology [DiscreteTopology X] : DiscreteTopology Xᵒᵈ 
goal: DiscreteTopology Xᵒᵈ

full_name: continuous_toDual
code: theorem continuous_toDual : Continuous (toDual : X → Xᵒᵈ) 
goal: Continuous ⇑OrderDual.toDual

full_name: continuous_ofDual
code: theorem continuous_ofDual : Continuous (ofDual : Xᵒᵈ → X) 
goal: Continuous ⇑OrderDual.ofDual

full_name: isOpenMap_toDual
code: theorem isOpenMap_toDual : IsOpenMap (toDual : X → Xᵒᵈ) 
goal: IsOpenMap ⇑OrderDual.toDual

full_name: isOpenMap_ofDual
code: theorem isOpenMap_ofDual : IsOpenMap (ofDual : Xᵒᵈ → X) 
goal: IsOpenMap ⇑OrderDual.ofDual

full_name: isClosedMap_toDual
code: theorem isClosedMap_toDual : IsClosedMap (toDual : X → Xᵒᵈ) 
goal: IsClosedMap ⇑OrderDual.toDual

full_name: isClosedMap_ofDual
code: theorem isClosedMap_ofDual : IsClosedMap (ofDual : Xᵒᵈ → X) 
goal: IsClosedMap ⇑OrderDual.ofDual

full_name: nhds_toDual
code: theorem nhds_toDual (x : X) : 𝓝 (toDual x) = map toDual (𝓝 x) 
goal: 𝓝 (OrderDual.toDual x) = Filter.map (⇑OrderDual.toDual) (𝓝 x)

full_name: nhds_ofDual
code: theorem nhds_ofDual (x : X) : 𝓝 (ofDual x) = map ofDual (𝓝 x) 
goal: 𝓝 (OrderDual.ofDual x) = Filter.map (⇑OrderDual.ofDual) (𝓝 x)

full_name: OrderDual.instNeBotNhdsWithinIoi
code: instance OrderDual.instNeBotNhdsWithinIoi [(𝓝[<] x).NeBot] : (𝓝[>] toDual x).NeBot 
goal: (𝓝[>] OrderDual.toDual x).NeBot

full_name: OrderDual.instNeBotNhdsWithinIio
code: instance OrderDual.instNeBotNhdsWithinIio [(𝓝[>] x).NeBot] : (𝓝[<] toDual x).NeBot 
goal: (𝓝[<] OrderDual.toDual x).NeBot

full_name: Quotient.preimage_mem_nhds
code: theorem Quotient.preimage_mem_nhds [TopologicalSpace X] [s : Setoid X] {V : Set <| Quotient s}
    {x : X} (hs : V ∈ 𝓝 (Quotient.mk' x)) : Quotient.mk' ⁻¹' V ∈ 𝓝 x 
goal: Quotient.mk' ⁻¹' V ∈ 𝓝 x

full_name: Dense.quotient
code: /-- The image of a dense set under `Quotient.mk'` is a dense set. -/
theorem Dense.quotient [Setoid X] [TopologicalSpace X] {s : Set X} (H : Dense s) :
    Dense (Quotient.mk' '' s) 
goal: Dense (Quotient.mk' '' s)

full_name: DenseRange.quotient
code: /-- The composition of `Quotient.mk'` and a function with dense range has dense range. -/
theorem DenseRange.quotient [Setoid X] [TopologicalSpace X] {f : Y → X} (hf : DenseRange f) :
    DenseRange (Quotient.mk' ∘ f) 
goal: DenseRange (Quotient.mk' ∘ f)

full_name: continuous_map_of_le
code: theorem continuous_map_of_le {α : Type*} [TopologicalSpace α]
    {s t : Setoid α} (h : s ≤ t) : Continuous (Setoid.map_of_le h) 
goal: Continuous (Setoid.map_of_le h)

full_name: continuous_map_sInf
code: theorem continuous_map_sInf {α : Type*} [TopologicalSpace α]
    {S : Set (Setoid α)} {s : Setoid α} (h : s ∈ S) : Continuous (Setoid.map_sInf h) 
goal: Continuous (Setoid.map_sInf h)

full_name: instDiscreteTopologySubtype
code: instance {p : X → Prop} [TopologicalSpace X] [DiscreteTopology X] : DiscreteTopology (Subtype p) 
goal: DiscreteTopology (Subtype p)

full_name: Sum.discreteTopology
code: instance Sum.discreteTopology [TopologicalSpace X] [TopologicalSpace Y] [h : DiscreteTopology X]
    [hY : DiscreteTopology Y] : DiscreteTopology (X ⊕ Y) 
goal: DiscreteTopology (X ⊕ Y)

full_name: Sigma.discreteTopology
code: instance Sigma.discreteTopology {ι : Type*} {Y : ι → Type v} [∀ i, TopologicalSpace (Y i)]
    [h : ∀ i, DiscreteTopology (Y i)] : DiscreteTopology (Sigma Y) 
goal: DiscreteTopology (Sigma Y)

full_name: comap_nhdsWithin_range
code: @[simp] lemma comap_nhdsWithin_range {α β} [TopologicalSpace β] (f : α → β) (y : β) :
    comap f (𝓝[range f] y) = comap f (𝓝 y) 
goal: Filter.comap f (𝓝[Set.range f] y) = Filter.comap f (𝓝 y)

full_name: mem_nhds_subtype
code: theorem mem_nhds_subtype (s : Set X) (x : { x // x ∈ s }) (t : Set { x // x ∈ s }) :
    t ∈ 𝓝 x ↔ ∃ u ∈ 𝓝 (x : X), Subtype.val ⁻¹' u ⊆ t 
goal: t ∈ 𝓝 x ↔ ∃ u ∈ 𝓝 ↑x, Subtype.val ⁻¹' u ⊆ t

full_name: nhds_subtype
code: theorem nhds_subtype (s : Set X) (x : { x // x ∈ s }) : 𝓝 x = comap (↑) (𝓝 (x : X)) 
goal: 𝓝 x = Filter.comap Subtype.val (𝓝 ↑x)

full_name: nhds_subtype_eq_comap_nhdsWithin
code: lemma nhds_subtype_eq_comap_nhdsWithin (s : Set X) (x : { x // x ∈ s }) :
    𝓝 x = comap (↑) (𝓝[s] (x : X)) 
goal: 𝓝 x = Filter.comap Subtype.val (𝓝[s] ↑x)

full_name: nhdsWithin_subtype_eq_bot_iff
code: theorem nhdsWithin_subtype_eq_bot_iff {s t : Set X} {x : s} :
    𝓝[((↑) : s → X) ⁻¹' t] x = ⊥ ↔ 𝓝[t] (x : X) ⊓ 𝓟 s = ⊥ 
goal: 𝓝[Subtype.val ⁻¹' t] x = ⊥ ↔ 𝓝[t] ↑x ⊓ 𝓟 s = ⊥

full_name: nhds_ne_subtype_eq_bot_iff
code: theorem nhds_ne_subtype_eq_bot_iff {S : Set X} {x : S} :
    𝓝[≠] x = ⊥ ↔ 𝓝[≠] (x : X) ⊓ 𝓟 S = ⊥ 
goal: 𝓝[≠] x = ⊥ ↔ 𝓝[≠] ↑x ⊓ 𝓟 S = ⊥

full_name: nhds_ne_subtype_neBot_iff
code: theorem nhds_ne_subtype_neBot_iff {S : Set X} {x : S} :
    (𝓝[≠] x).NeBot ↔ (𝓝[≠] (x : X) ⊓ 𝓟 S).NeBot 
goal: (𝓝[≠] x).NeBot ↔ (𝓝[≠] ↑x ⊓ 𝓟 S).NeBot

full_name: discreteTopology_subtype_iff
code: theorem discreteTopology_subtype_iff {S : Set X} :
    DiscreteTopology S ↔ ∀ x ∈ S, 𝓝[≠] x ⊓ 𝓟 S = ⊥ 
goal: DiscreteTopology ↑S ↔ ∀ x ∈ S, 𝓝[≠] x ⊓ 𝓟 S = ⊥

full_name: CofiniteTopology
code: /-- A type synonym equipped with the topology whose open sets are the empty set and the sets with
finite complements. -/
def CofiniteTopology (X : Type*) 
goal: Type u_5

full_name: CofiniteTopology.of
code: /-- The identity equivalence between `` and `CofiniteTopology `. -/
def of : X ≃ CofiniteTopology X 
goal: X ≃ CofiniteTopology X

full_name: CofiniteTopology.instInhabited
code: instance [Inhabited X] : Inhabited (CofiniteTopology X) 
goal: Inhabited (CofiniteTopology X)

full_name: CofiniteTopology.instTopologicalSpace
code: instance : TopologicalSpace (CofiniteTopology X) 
goal: TopologicalSpace (CofiniteTopology X)

full_name: CofiniteTopology.isOpen_iff
code: theorem isOpen_iff {s : Set (CofiniteTopology X)} : IsOpen s ↔ s.Nonempty → sᶜ.Finite 
goal: IsOpen s ↔ s.Nonempty → sᶜ.Finite

full_name: CofiniteTopology.isOpen_iff'
code: theorem isOpen_iff' {s : Set (CofiniteTopology X)} : IsOpen s ↔ s = ∅ ∨ sᶜ.Finite 
goal: IsOpen s ↔ s = ∅ ∨ sᶜ.Finite

full_name: CofiniteTopology.isClosed_iff
code: theorem isClosed_iff {s : Set (CofiniteTopology X)} : IsClosed s ↔ s = univ ∨ s.Finite 
goal: IsClosed s ↔ s = Set.univ ∨ s.Finite

full_name: CofiniteTopology.nhds_eq
code: theorem nhds_eq (x : CofiniteTopology X) : 𝓝 x = pure x ⊔ cofinite 
goal: 𝓝 x = pure x ⊔ Filter.cofinite

full_name: CofiniteTopology.mem_nhds_iff
code: theorem mem_nhds_iff {x : CofiniteTopology X} {s : Set (CofiniteTopology X)} :
    s ∈ 𝓝 x ↔ x ∈ s ∧ sᶜ.Finite 
goal: s ∈ 𝓝 x ↔ x ∈ s ∧ sᶜ.Finite

full_name: continuous_prod_mk
code: @[simp] theorem continuous_prod_mk {f : X → Y} {g : X → Z} :
    (Continuous fun x => (f x, g x)) ↔ Continuous f ∧ Continuous g 
goal: (Continuous fun x => (f x, g x)) ↔ Continuous f ∧ Continuous g

full_name: continuous_fst
code: @[continuity]
theorem continuous_fst : Continuous (@Prod.fst X Y) 
goal: Continuous Prod.fst

full_name: Continuous.fst
code: /-- Postcomposing `f` with `Prod.fst` is continuous -/
@[fun_prop]
theorem Continuous.fst {f : X → Y × Z} (hf : Continuous f) : Continuous fun x : X => (f x).1 
goal: Continuous fun x => (f x).1

full_name: Continuous.fst'
code: /-- Precomposing `f` with `Prod.fst` is continuous -/
theorem Continuous.fst' {f : X → Z} (hf : Continuous f) : Continuous fun x : X × Y => f x.fst 
goal: Continuous fun x => f x.1

full_name: continuousAt_fst
code: theorem continuousAt_fst {p : X × Y} : ContinuousAt Prod.fst p 
goal: ContinuousAt Prod.fst p

full_name: ContinuousAt.fst
code: /-- Postcomposing `f` with `Prod.fst` is continuous at `x` -/
@[fun_prop]
theorem ContinuousAt.fst {f : X → Y × Z} {x : X} (hf : ContinuousAt f x) :
    ContinuousAt (fun x : X => (f x).1) x 
goal: ContinuousAt (fun x => (f x).1) x

full_name: ContinuousAt.fst'
code: /-- Precomposing `f` with `Prod.fst` is continuous at `(x, y)` -/
theorem ContinuousAt.fst' {f : X → Z} {x : X} {y : Y} (hf : ContinuousAt f x) :
    ContinuousAt (fun x : X × Y => f x.fst) (x, y) 
goal: ContinuousAt (fun x => f x.1) (x, y)

full_name: ContinuousAt.fst''
code: /-- Precomposing `f` with `Prod.fst` is continuous at `x : X × Y` -/
theorem ContinuousAt.fst'' {f : X → Z} {x : X × Y} (hf : ContinuousAt f x.fst) :
    ContinuousAt (fun x : X × Y => f x.fst) x 
goal: ContinuousAt (fun x => f x.1) x

full_name: Filter.Tendsto.fst_nhds
code: theorem Filter.Tendsto.fst_nhds {l : Filter X} {f : X → Y × Z} {p : Y × Z}
    (h : Tendsto f l (𝓝 p)) : Tendsto (fun a ↦ (f a).1) l (𝓝 <| p.1) 
goal: Filter.Tendsto (fun a => (f a).1) l (𝓝 p.1)

full_name: continuous_snd
code: @[continuity]
theorem continuous_snd : Continuous (@Prod.snd X Y) 
goal: Continuous Prod.snd

full_name: Continuous.snd
code: /-- Postcomposing `f` with `Prod.snd` is continuous -/
@[fun_prop]
theorem Continuous.snd {f : X → Y × Z} (hf : Continuous f) : Continuous fun x : X => (f x).2 
goal: Continuous fun x => (f x).2

full_name: Continuous.snd'
code: /-- Precomposing `f` with `Prod.snd` is continuous -/
theorem Continuous.snd' {f : Y → Z} (hf : Continuous f) : Continuous fun x : X × Y => f x.snd 
goal: Continuous fun x => f x.2

full_name: continuousAt_snd
code: theorem continuousAt_snd {p : X × Y} : ContinuousAt Prod.snd p 
goal: ContinuousAt Prod.snd p

full_name: ContinuousAt.snd
code: /-- Postcomposing `f` with `Prod.snd` is continuous at `x` -/
@[fun_prop]
theorem ContinuousAt.snd {f : X → Y × Z} {x : X} (hf : ContinuousAt f x) :
    ContinuousAt (fun x : X => (f x).2) x 
goal: ContinuousAt (fun x => (f x).2) x

full_name: ContinuousAt.snd'
code: /-- Precomposing `f` with `Prod.snd` is continuous at `(x, y)` -/
theorem ContinuousAt.snd' {f : Y → Z} {x : X} {y : Y} (hf : ContinuousAt f y) :
    ContinuousAt (fun x : X × Y => f x.snd) (x, y) 
goal: ContinuousAt (fun x => f x.2) (x, y)

full_name: ContinuousAt.snd''
code: /-- Precomposing `f` with `Prod.snd` is continuous at `x : X × Y` -/
theorem ContinuousAt.snd'' {f : Y → Z} {x : X × Y} (hf : ContinuousAt f x.snd) :
    ContinuousAt (fun x : X × Y => f x.snd) x 
goal: ContinuousAt (fun x => f x.2) x

full_name: Filter.Tendsto.snd_nhds
code: theorem Filter.Tendsto.snd_nhds {l : Filter X} {f : X → Y × Z} {p : Y × Z}
    (h : Tendsto f l (𝓝 p)) : Tendsto (fun a ↦ (f a).2) l (𝓝 <| p.2) 
goal: Filter.Tendsto (fun a => (f a).2) l (𝓝 p.2)

full_name: Continuous.prod_mk
code: @[continuity, fun_prop]
theorem Continuous.prod_mk {f : Z → X} {g : Z → Y} (hf : Continuous f) (hg : Continuous g) :
    Continuous fun x => (f x, g x) 
goal: Continuous fun x => (f x, g x)

full_name: Continuous.Prod.mk
code: @[continuity]
theorem Continuous.Prod.mk (x : X) : Continuous fun y : Y => (x, y) 
goal: Continuous fun y => (x, y)

full_name: Continuous.Prod.mk_left
code: @[continuity]
theorem Continuous.Prod.mk_left (y : Y) : Continuous fun x : X => (x, y) 
goal: Continuous fun x => (x, y)

full_name: IsClosed.setOf_mapsTo
code: /-- If `f x y` is continuous in `x` for all `y ∈ s`,
then the set of `x` such that `f x` maps `s` to `t` is closed. -/
lemma IsClosed.setOf_mapsTo {α : Type*} {f : X → α → Z} {s : Set α} {t : Set Z} (ht : IsClosed t)
    (hf : ∀ a ∈ s, Continuous (f · a)) : IsClosed {x | MapsTo (f x) s t} 
goal: IsClosed {x | Set.MapsTo (f x) s t}

full_name: Continuous.comp₂
code: theorem Continuous.comp₂ {g : X × Y → Z} (hg : Continuous g) {e : W → X} (he : Continuous e)
    {f : W → Y} (hf : Continuous f) : Continuous fun w => g (e w, f w) 
goal: Continuous fun w => g (e w, f w)

full_name: Continuous.comp₃
code: theorem Continuous.comp₃ {g : X × Y × Z → ε} (hg : Continuous g) {e : W → X} (he : Continuous e)
    {f : W → Y} (hf : Continuous f) {k : W → Z} (hk : Continuous k) :
    Continuous fun w => g (e w, f w, k w) 
goal: Continuous fun w => g (e w, f w, k w)

full_name: Continuous.comp₄
code: theorem Continuous.comp₄ {g : X × Y × Z × ζ → ε} (hg : Continuous g) {e : W → X} (he : Continuous e)
    {f : W → Y} (hf : Continuous f) {k : W → Z} (hk : Continuous k) {l : W → ζ}
    (hl : Continuous l) : Continuous fun w => g (e w, f w, k w, l w) 
goal: Continuous fun w => g (e w, f w, k w, l w)

full_name: Continuous.prod_map
code: @[continuity]
theorem Continuous.prod_map {f : Z → X} {g : W → Y} (hf : Continuous f) (hg : Continuous g) :
    Continuous fun p : Z × W => (f p.1, g p.2) 
goal: Continuous fun p => (f p.1, g p.2)

full_name: continuous_inf_dom_left₂
code: /-- A version of `continuous_inf_dom_left` for binary functions -/
theorem continuous_inf_dom_left₂ {X Y Z} {f : X → Y → Z} {ta1 ta2 : TopologicalSpace X}
    {tb1 tb2 : TopologicalSpace Y} {tc1 : TopologicalSpace Z}
    (h : by haveI := ta1; haveI := tb1; exact Continuous fun p : X × Y => f p.1 p.2) : by
    haveI := ta1 ⊓ ta2; haveI := tb1 ⊓ tb2; exact Continuous fun p : X × Y => f p.1 p.2 
goal: Continuous fun p => f p.1 p.2

full_name: continuous_inf_dom_right₂
code: /-- A version of `continuous_inf_dom_right` for binary functions -/
theorem continuous_inf_dom_right₂ {X Y Z} {f : X → Y → Z} {ta1 ta2 : TopologicalSpace X}
    {tb1 tb2 : TopologicalSpace Y} {tc1 : TopologicalSpace Z}
    (h : by haveI := ta2; haveI := tb2; exact Continuous fun p : X × Y => f p.1 p.2) : by
    haveI := ta1 ⊓ ta2; haveI := tb1 ⊓ tb2; exact Continuous fun p : X × Y => f p.1 p.2 
goal: Continuous fun p => f p.1 p.2

full_name: continuous_sInf_dom₂
code: /-- A version of `continuous_sInf_dom` for binary functions -/
theorem continuous_sInf_dom₂ {X Y Z} {f : X → Y → Z} {tas : Set (TopologicalSpace X)}
    {tbs : Set (TopologicalSpace Y)} {tX : TopologicalSpace X} {tY : TopologicalSpace Y}
    {tc : TopologicalSpace Z} (hX : tX ∈ tas) (hY : tY ∈ tbs)
    (hf : Continuous fun p : X × Y => f p.1 p.2) : by
    haveI := sInf tas; haveI := sInf tbs
    exact @Continuous _ _ _ tc fun p : X × Y => f p.1 p.2 
goal: Continuous fun p => f p.1 p.2

full_name: Filter.Eventually.prod_inl_nhds
code: theorem Filter.Eventually.prod_inl_nhds {p : X → Prop} {x : X} (h : ∀ᶠ x in 𝓝 x, p x) (y : Y) :
    ∀ᶠ x in 𝓝 (x, y), p (x : X × Y).1 
goal: ∀ᶠ (x : X × Y) in 𝓝 (x, y), p x.1

full_name: Filter.Eventually.prod_inr_nhds
code: theorem Filter.Eventually.prod_inr_nhds {p : Y → Prop} {y : Y} (h : ∀ᶠ x in 𝓝 y, p x) (x : X) :
    ∀ᶠ x in 𝓝 (x, y), p (x : X × Y).2 
goal: ∀ᶠ (x : X × Y) in 𝓝 (x, y), p x.2

full_name: Filter.Eventually.prod_mk_nhds
code: theorem Filter.Eventually.prod_mk_nhds {px : X → Prop} {x} (hx : ∀ᶠ x in 𝓝 x, px x) {py : Y → Prop}
    {y} (hy : ∀ᶠ y in 𝓝 y, py y) : ∀ᶠ p in 𝓝 (x, y), px (p : X × Y).1 ∧ py p.2 
goal: ∀ᶠ (p : X × Y) in 𝓝 (x, y), px p.1 ∧ py p.2

full_name: continuous_swap
code: theorem continuous_swap : Continuous (Prod.swap : X × Y → Y × X) 
goal: Continuous Prod.swap

full_name: isClosedMap_swap
code: lemma isClosedMap_swap : IsClosedMap (Prod.swap : X × Y → Y × X) 
goal: IsClosedMap Prod.swap

full_name: Continuous.uncurry_left
code: theorem Continuous.uncurry_left {f : X → Y → Z} (x : X) (h : Continuous (uncurry f)) :
    Continuous (f x) 
goal: Continuous (f x)

full_name: Continuous.uncurry_right
code: theorem Continuous.uncurry_right {f : X → Y → Z} (y : Y) (h : Continuous (uncurry f)) :
    Continuous fun a => f a y 
goal: Continuous fun a => f a y

full_name: continuous_curry
code: theorem continuous_curry {g : X × Y → Z} (x : X) (h : Continuous g) : Continuous (curry g x) 
goal: Continuous (Function.curry g x)

full_name: IsOpen.prod
code: theorem IsOpen.prod {s : Set X} {t : Set Y} (hs : IsOpen s) (ht : IsOpen t) : IsOpen (s ×ˢ t) 
goal: IsOpen (s ×ˢ t)

full_name: nhds_prod_eq
code: theorem nhds_prod_eq {x : X} {y : Y} : 𝓝 (x, y) = 𝓝 x ×ˢ 𝓝 y 
goal: 𝓝 (x, y) = 𝓝 x ×ˢ 𝓝 y

full_name: nhdsWithin_prod_eq
code: theorem nhdsWithin_prod_eq (x : X) (y : Y) (s : Set X) (t : Set Y) :
    𝓝[s ×ˢ t] (x, y) = 𝓝[s] x ×ˢ 𝓝[t] y 
goal: 𝓝[s ×ˢ t] (x, y) = 𝓝[s] x ×ˢ 𝓝[t] y

full_name: Prod.instNeBotNhdsWithinIio
code: instance Prod.instNeBotNhdsWithinIio [Preorder X] [Preorder Y] {x : X × Y}
    [hx₁ : (𝓝[<] x.1).NeBot] [hx₂ : (𝓝[<] x.2).NeBot] : (𝓝[<] x).NeBot 
goal: (𝓝[<] x).NeBot

full_name: Prod.instNeBotNhdsWithinIoi
code: instance Prod.instNeBotNhdsWithinIoi [Preorder X] [Preorder Y] {x : X × Y}
    [(𝓝[>] x.1).NeBot] [(𝓝[>] x.2).NeBot] : (𝓝[>] x).NeBot 
goal: (𝓝[>] x).NeBot

full_name: mem_nhds_prod_iff
code: theorem mem_nhds_prod_iff {x : X} {y : Y} {s : Set (X × Y)} :
    s ∈ 𝓝 (x, y) ↔ ∃ u ∈ 𝓝 x, ∃ v ∈ 𝓝 y, u ×ˢ v ⊆ s 
goal: s ∈ 𝓝 (x, y) ↔ ∃ u ∈ 𝓝 x, ∃ v ∈ 𝓝 y, u ×ˢ v ⊆ s

full_name: mem_nhdsWithin_prod_iff
code: theorem mem_nhdsWithin_prod_iff {x : X} {y : Y} {s : Set (X × Y)} {tx : Set X} {ty : Set Y} :
    s ∈ 𝓝[tx ×ˢ ty] (x, y) ↔ ∃ u ∈ 𝓝[tx] x, ∃ v ∈ 𝓝[ty] y, u ×ˢ v ⊆ s 
goal: s ∈ 𝓝[tx ×ˢ ty] (x, y) ↔ ∃ u ∈ 𝓝[tx] x, ∃ v ∈ 𝓝[ty] y, u ×ˢ v ⊆ s

full_name: Filter.HasBasis.prod_nhds
code: theorem Filter.HasBasis.prod_nhds {ιX ιY : Type*} {px : ιX → Prop} {py : ιY → Prop}
    {sx : ιX → Set X} {sy : ιY → Set Y} {x : X} {y : Y} (hx : (𝓝 x).HasBasis px sx)
    (hy : (𝓝 y).HasBasis py sy) :
    (𝓝 (x, y)).HasBasis (fun i : ιX × ιY => px i.1 ∧ py i.2) fun i => sx i.1 ×ˢ sy i.2 
goal: (𝓝 (x, y)).HasBasis (fun i => px i.1 ∧ py i.2) fun i => sx i.1 ×ˢ sy i.2

full_name: Filter.HasBasis.prod_nhds'
code: theorem Filter.HasBasis.prod_nhds' {ιX ιY : Type*} {pX : ιX → Prop} {pY : ιY → Prop}
    {sx : ιX → Set X} {sy : ιY → Set Y} {p : X × Y} (hx : (𝓝 p.1).HasBasis pX sx)
    (hy : (𝓝 p.2).HasBasis pY sy) :
    (𝓝 p).HasBasis (fun i : ιX × ιY => pX i.1 ∧ pY i.2) fun i => sx i.1 ×ˢ sy i.2 
goal: (𝓝 p).HasBasis (fun i => pX i.1 ∧ pY i.2) fun i => sx i.1 ×ˢ sy i.2

full_name: mem_nhds_prod_iff'
code: theorem mem_nhds_prod_iff' {x : X} {y : Y} {s : Set (X × Y)} :
    s ∈ 𝓝 (x, y) ↔ ∃ u v, IsOpen u ∧ x ∈ u ∧ IsOpen v ∧ y ∈ v ∧ u ×ˢ v ⊆ s 
goal: s ∈ 𝓝 (x, y) ↔ ∃ u v, IsOpen u ∧ x ∈ u ∧ IsOpen v ∧ y ∈ v ∧ u ×ˢ v ⊆ s

full_name: Prod.tendsto_iff
code: theorem Prod.tendsto_iff {X} (seq : X → Y × Z) {f : Filter X} (p : Y × Z) :
    Tendsto seq f (𝓝 p) ↔
      Tendsto (fun n => (seq n).fst) f (𝓝 p.fst) ∧ Tendsto (fun n => (seq n).snd) f (𝓝 p.snd) 
goal: Filter.Tendsto seq f (𝓝 p) ↔
  Filter.Tendsto (fun n => (seq n).1) f (𝓝 p.1) ∧ Filter.Tendsto (fun n => (seq n).2) f (𝓝 p.2)

full_name: instDiscreteTopologyProd
code: instance [DiscreteTopology X] [DiscreteTopology Y] : DiscreteTopology (X × Y) 
goal: DiscreteTopology (X × Y)

full_name: prod_mem_nhds_iff
code: theorem prod_mem_nhds_iff {s : Set X} {t : Set Y} {x : X} {y : Y} :
    s ×ˢ t ∈ 𝓝 (x, y) ↔ s ∈ 𝓝 x ∧ t ∈ 𝓝 y 
goal: s ×ˢ t ∈ 𝓝 (x, y) ↔ s ∈ 𝓝 x ∧ t ∈ 𝓝 y

full_name: prod_mem_nhds
code: theorem prod_mem_nhds {s : Set X} {t : Set Y} {x : X} {y : Y} (hx : s ∈ 𝓝 x) (hy : t ∈ 𝓝 y) :
    s ×ˢ t ∈ 𝓝 (x, y) 
goal: s ×ˢ t ∈ 𝓝 (x, y)

full_name: isOpen_setOf_disjoint_nhds_nhds
code: theorem isOpen_setOf_disjoint_nhds_nhds : IsOpen { p : X × X | Disjoint (𝓝 p.1) (𝓝 p.2) } 
goal: IsOpen {p | Disjoint (𝓝 p.1) (𝓝 p.2)}

full_name: Filter.Eventually.prod_nhds
code: theorem Filter.Eventually.prod_nhds {p : X → Prop} {q : Y → Prop} {x : X} {y : Y}
    (hx : ∀ᶠ x in 𝓝 x, p x) (hy : ∀ᶠ y in 𝓝 y, q y) : ∀ᶠ z : X × Y in 𝓝 (x, y), p z.1 ∧ q z.2 
goal: ∀ᶠ (z : X × Y) in 𝓝 (x, y), p z.1 ∧ q z.2

full_name: nhds_swap
code: theorem nhds_swap (x : X) (y : Y) : 𝓝 (x, y) = (𝓝 (y, x)).map Prod.swap 
goal: 𝓝 (x, y) = Filter.map Prod.swap (𝓝 (y, x))

full_name: Filter.Tendsto.prod_mk_nhds
code: theorem Filter.Tendsto.prod_mk_nhds {γ} {x : X} {y : Y} {f : Filter γ} {mx : γ → X} {my : γ → Y}
    (hx : Tendsto mx f (𝓝 x)) (hy : Tendsto my f (𝓝 y)) :
    Tendsto (fun c => (mx c, my c)) f (𝓝 (x, y)) 
goal: Filter.Tendsto (fun c => (mx c, my c)) f (𝓝 (x, y))

full_name: Filter.Eventually.curry_nhds
code: theorem Filter.Eventually.curry_nhds {p : X × Y → Prop} {x : X} {y : Y}
    (h : ∀ᶠ x in 𝓝 (x, y), p x) : ∀ᶠ x' in 𝓝 x, ∀ᶠ y' in 𝓝 y, p (x', y') 
goal: ∀ᶠ (x' : X) in 𝓝 x, ∀ᶠ (y' : Y) in 𝓝 y, p (x', y')

full_name: ContinuousAt.prod
code: @[fun_prop]
theorem ContinuousAt.prod {f : X → Y} {g : X → Z} {x : X} (hf : ContinuousAt f x)
    (hg : ContinuousAt g x) : ContinuousAt (fun x => (f x, g x)) x 
goal: ContinuousAt (fun x => (f x, g x)) x

full_name: ContinuousAt.prod_map
code: theorem ContinuousAt.prod_map {f : X → Z} {g : Y → W} {p : X × Y} (hf : ContinuousAt f p.fst)
    (hg : ContinuousAt g p.snd) : ContinuousAt (fun p : X × Y => (f p.1, g p.2)) p 
goal: ContinuousAt (fun p => (f p.1, g p.2)) p

full_name: ContinuousAt.prod_map'
code: theorem ContinuousAt.prod_map' {f : X → Z} {g : Y → W} {x : X} {y : Y} (hf : ContinuousAt f x)
    (hg : ContinuousAt g y) : ContinuousAt (fun p : X × Y => (f p.1, g p.2)) (x, y) 
goal: ContinuousAt (fun p => (f p.1, g p.2)) (x, y)

full_name: ContinuousAt.comp₂
code: theorem ContinuousAt.comp₂ {f : Y × Z → W} {g : X → Y} {h : X → Z} {x : X}
    (hf : ContinuousAt f (g x, h x)) (hg : ContinuousAt g x) (hh : ContinuousAt h x) :
    ContinuousAt (fun x ↦ f (g x, h x)) x 
goal: ContinuousAt (fun x => f (g x, h x)) x

full_name: ContinuousAt.comp₂_of_eq
code: theorem ContinuousAt.comp₂_of_eq {f : Y × Z → W} {g : X → Y} {h : X → Z} {x : X} {y : Y × Z}
    (hf : ContinuousAt f y) (hg : ContinuousAt g x) (hh : ContinuousAt h x) (e : (g x, h x) = y) :
    ContinuousAt (fun x ↦ f (g x, h x)) x 
goal: ContinuousAt (fun x => f (g x, h x)) x

full_name: Continuous.curry_left
code: /-- Continuous functions on products are continuous in their first argument -/
theorem Continuous.curry_left {f : X × Y → Z} (hf : Continuous f) {y : Y} :
    Continuous fun x ↦ f (x, y) 
goal: Continuous fun x => f (x, y)

full_name: Continuous.curry_right
code: /-- Continuous functions on products are continuous in their second argument -/
theorem Continuous.curry_right {f : X × Y → Z} (hf : Continuous f) {x : X} :
    Continuous fun y ↦ f (x, y) 
goal: Continuous fun y => f (x, y)

full_name: prod_generateFrom_generateFrom_eq
code: theorem prod_generateFrom_generateFrom_eq {X Y : Type*} {s : Set (Set X)} {t : Set (Set Y)}
    (hs : ⋃₀ s = univ) (ht : ⋃₀ t = univ) :
    @instTopologicalSpaceProd X Y (generateFrom s) (generateFrom t) =
      generateFrom (image2 (·  ×ˢ ·) s t) 
goal: instTopologicalSpaceProd = TopologicalSpace.generateFrom (Set.image2 (fun x x_1 => x ×ˢ x_1) s t)

full_name: prod_eq_generateFrom
code: theorem prod_eq_generateFrom :
    instTopologicalSpaceProd =
      generateFrom { g | ∃ (s : Set X) (t : Set Y), IsOpen s ∧ IsOpen t ∧ g = s ×ˢ t } 
goal: instTopologicalSpaceProd = TopologicalSpace.generateFrom {g | ∃ s t, IsOpen s ∧ IsOpen t ∧ g = s ×ˢ t}

full_name: isOpen_prod_iff
code: theorem isOpen_prod_iff {s : Set (X × Y)} :
    IsOpen s ↔ ∀ a b, (a, b) ∈ s →
      ∃ u v, IsOpen u ∧ IsOpen v ∧ a ∈ u ∧ b ∈ v ∧ u ×ˢ v ⊆ s 
goal: IsOpen s ↔ ∀ (a : X) (b : Y), (a, b) ∈ s → ∃ u v, IsOpen u ∧ IsOpen v ∧ a ∈ u ∧ b ∈ v ∧ u ×ˢ v ⊆ s

full_name: prod_induced_induced
code: /-- A product of induced topologies is induced by the product map -/
theorem prod_induced_induced (f : X → Y) (g : Z → W) :
    @instTopologicalSpaceProd X Z (induced f ‹_›) (induced g ‹_›) =
      induced (fun p => (f p.1, g p.2)) instTopologicalSpaceProd 
goal: instTopologicalSpaceProd = TopologicalSpace.induced (fun p => (f p.1, g p.2)) instTopologicalSpaceProd

full_name: exists_nhds_square
code: /-- Given a neighborhood `s` of `(x, x)`, then `(x, x)` has a square open neighborhood
  that is a subset of `s`. -/
theorem exists_nhds_square {s : Set (X × X)} {x : X} (hx : s ∈ 𝓝 (x, x)) :
    ∃ U : Set X, IsOpen U ∧ x ∈ U ∧ U ×ˢ U ⊆ s 
goal: ∃ U, IsOpen U ∧ x ∈ U ∧ U ×ˢ U ⊆ s

full_name: map_fst_nhdsWithin
code: /-- `Prod.fst` maps neighborhood of `x : X × Y` within the section `Prod.snd ⁻¹' {x.2}`
to `𝓝 x.1`. -/
theorem map_fst_nhdsWithin (x : X × Y) : map Prod.fst (𝓝[Prod.snd ⁻¹' {x.2}] x) = 𝓝 x.1 
goal: Filter.map Prod.fst (𝓝[Prod.snd ⁻¹' {x.2}] x) = 𝓝 x.1

full_name: map_fst_nhds
code: @[simp]
theorem map_fst_nhds (x : X × Y) : map Prod.fst (𝓝 x) = 𝓝 x.1 
goal: Filter.map Prod.fst (𝓝 x) = 𝓝 x.1

full_name: isOpenMap_fst
code: /-- The first projection in a product of topological spaces sends open sets to open sets. -/
theorem isOpenMap_fst : IsOpenMap (@Prod.fst X Y) 
goal: IsOpenMap Prod.fst

full_name: map_snd_nhdsWithin
code: /-- `Prod.snd` maps neighborhood of `x : X × Y` within the section `Prod.fst ⁻¹' {x.1}`
to `𝓝 x.2`. -/
theorem map_snd_nhdsWithin (x : X × Y) : map Prod.snd (𝓝[Prod.fst ⁻¹' {x.1}] x) = 𝓝 x.2 
goal: Filter.map Prod.snd (𝓝[Prod.fst ⁻¹' {x.1}] x) = 𝓝 x.2

full_name: map_snd_nhds
code: @[simp]
theorem map_snd_nhds (x : X × Y) : map Prod.snd (𝓝 x) = 𝓝 x.2 
goal: Filter.map Prod.snd (𝓝 x) = 𝓝 x.2

full_name: isOpenMap_snd
code: /-- The second projection in a product of topological spaces sends open sets to open sets. -/
theorem isOpenMap_snd : IsOpenMap (@Prod.snd X Y) 
goal: IsOpenMap Prod.snd

full_name: isOpen_prod_iff'
code: /-- A product set is open in a product space if and only if each factor is open, or one of them is
empty -/
theorem isOpen_prod_iff' {s : Set X} {t : Set Y} :
    IsOpen (s ×ˢ t) ↔ IsOpen s ∧ IsOpen t ∨ s = ∅ ∨ t = ∅ 
goal: IsOpen (s ×ˢ t) ↔ IsOpen s ∧ IsOpen t ∨ s = ∅ ∨ t = ∅

full_name: closure_prod_eq
code: theorem closure_prod_eq {s : Set X} {t : Set Y} : closure (s ×ˢ t) = closure s ×ˢ closure t 
goal: closure (s ×ˢ t) = closure s ×ˢ closure t

full_name: interior_prod_eq
code: theorem interior_prod_eq (s : Set X) (t : Set Y) : interior (s ×ˢ t) = interior s ×ˢ interior t 
goal: interior (s ×ˢ t) = interior s ×ˢ interior t

full_name: frontier_prod_eq
code: theorem frontier_prod_eq (s : Set X) (t : Set Y) :
    frontier (s ×ˢ t) = closure s ×ˢ frontier t ∪ frontier s ×ˢ closure t 
goal: frontier (s ×ˢ t) = closure s ×ˢ frontier t ∪ frontier s ×ˢ closure t

full_name: frontier_prod_univ_eq
code: @[simp]
theorem frontier_prod_univ_eq (s : Set X) :
    frontier (s ×ˢ (univ : Set Y)) = frontier s ×ˢ univ 
goal: frontier (s ×ˢ Set.univ) = frontier s ×ˢ Set.univ

full_name: frontier_univ_prod_eq
code: @[simp]
theorem frontier_univ_prod_eq (s : Set Y) :
    frontier ((univ : Set X) ×ˢ s) = univ ×ˢ frontier s 
goal: frontier (Set.univ ×ˢ s) = Set.univ ×ˢ frontier s

full_name: map_mem_closure₂
code: theorem map_mem_closure₂ {f : X → Y → Z} {x : X} {y : Y} {s : Set X} {t : Set Y} {u : Set Z}
    (hf : Continuous (uncurry f)) (hx : x ∈ closure s) (hy : y ∈ closure t)
    (h : ∀ a ∈ s, ∀ b ∈ t, f a b ∈ u) : f x y ∈ closure u 
goal: f x y ∈ closure u

full_name: IsClosed.prod
code: theorem IsClosed.prod {s₁ : Set X} {s₂ : Set Y} (h₁ : IsClosed s₁) (h₂ : IsClosed s₂) :
    IsClosed (s₁ ×ˢ s₂) 
goal: IsClosed (s₁ ×ˢ s₂)

full_name: Dense.prod
code: /-- The product of two dense sets is a dense set. -/
theorem Dense.prod {s : Set X} {t : Set Y} (hs : Dense s) (ht : Dense t) : Dense (s ×ˢ t) 
goal: Dense (s ×ˢ t)

full_name: DenseRange.prod_map
code: /-- If `f` and `g` are maps with dense range, then `Prod.map f g` has dense range. -/
theorem DenseRange.prod_map {ι : Type*} {κ : Type*} {f : ι → Y} {g : κ → Z} (hf : DenseRange f)
    (hg : DenseRange g) : DenseRange (Prod.map f g) 
goal: DenseRange (Prod.map f g)

full_name: Inducing.prod_map
code: theorem Inducing.prod_map {f : X → Y} {g : Z → W} (hf : Inducing f) (hg : Inducing g) :
    Inducing (Prod.map f g) 
goal: Inducing (Prod.map f g)

full_name: inducing_const_prod
code: @[simp]
theorem inducing_const_prod {x : X} {f : Y → Z} : (Inducing fun x' => (x, f x')) ↔ Inducing f 
goal: (Inducing fun x' => (x, f x')) ↔ Inducing f

full_name: inducing_prod_const
code: @[simp]
theorem inducing_prod_const {y : Y} {f : X → Z} : (Inducing fun x => (f x, y)) ↔ Inducing f 
goal: (Inducing fun x => (f x, y)) ↔ Inducing f

full_name: Embedding.prod_map
code: theorem Embedding.prod_map {f : X → Y} {g : Z → W} (hf : Embedding f) (hg : Embedding g) :
    Embedding (Prod.map f g) 
goal: Embedding (Prod.map f g)

full_name: IsOpenMap.prod
code: protected theorem IsOpenMap.prod {f : X → Y} {g : Z → W} (hf : IsOpenMap f) (hg : IsOpenMap g) :
    IsOpenMap fun p : X × Z => (f p.1, g p.2) 
goal: IsOpenMap fun p => (f p.1, g p.2)

full_name: OpenEmbedding.prod
code: protected theorem OpenEmbedding.prod {f : X → Y} {g : Z → W} (hf : OpenEmbedding f)
    (hg : OpenEmbedding g) : OpenEmbedding fun x : X × Z => (f x.1, g x.2) 
goal: OpenEmbedding fun x => (f x.1, g x.2)

full_name: embedding_graph
code: theorem embedding_graph {f : X → Y} (hf : Continuous f) : Embedding fun x => (x, f x) 
goal: Embedding fun x => (x, f x)

full_name: embedding_prod_mk
code: theorem embedding_prod_mk (x : X) : Embedding (Prod.mk x : Y → X × Y) 
goal: Embedding (Prod.mk x)

full_name: continuous_bool_rng
code: lemma continuous_bool_rng [TopologicalSpace X] {f : X → Bool} (b : Bool) :
    Continuous f ↔ IsClopen (f ⁻¹' {b}) 
goal: Continuous f ↔ IsClopen (f ⁻¹' {b})

full_name: continuous_sum_dom
code: theorem continuous_sum_dom {f : X ⊕ Y → Z} :
    Continuous f ↔ Continuous (f ∘ Sum.inl) ∧ Continuous (f ∘ Sum.inr) 
goal: Continuous f ↔ Continuous (f ∘ Sum.inl) ∧ Continuous (f ∘ Sum.inr)

full_name: continuous_sum_elim
code: theorem continuous_sum_elim {f : X → Z} {g : Y → Z} :
    Continuous (Sum.elim f g) ↔ Continuous f ∧ Continuous g 
goal: Continuous (Sum.elim f g) ↔ Continuous f ∧ Continuous g

full_name: Continuous.sum_elim
code: @[continuity, fun_prop]
theorem Continuous.sum_elim {f : X → Z} {g : Y → Z} (hf : Continuous f) (hg : Continuous g) :
    Continuous (Sum.elim f g) 
goal: Continuous (Sum.elim f g)

full_name: continuous_isLeft
code: @[continuity, fun_prop]
theorem continuous_isLeft : Continuous (isLeft : X ⊕ Y → Bool) 
goal: Continuous Sum.isLeft

full_name: continuous_isRight
code: @[continuity, fun_prop]
theorem continuous_isRight : Continuous (isRight : X ⊕ Y → Bool) 
goal: Continuous Sum.isRight

full_name: continuous_inl
code: @[continuity, fun_prop]
-- Porting note: the proof was `continuous_sup_rng_left continuous_coinduced_rng`
theorem continuous_inl : Continuous (@inl X Y) 
goal: Continuous Sum.inl

full_name: continuous_inr
code: @[continuity, fun_prop]
-- Porting note: the proof was `continuous_sup_rng_right continuous_coinduced_rng`
theorem continuous_inr : Continuous (@inr X Y) 
goal: Continuous Sum.inr

full_name: isOpen_sum_iff
code: theorem isOpen_sum_iff {s : Set (X ⊕ Y)} : IsOpen s ↔ IsOpen (inl ⁻¹' s) ∧ IsOpen (inr ⁻¹' s) 
goal: IsOpen s ↔ IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s)

full_name: isClosed_sum_iff
code: theorem isClosed_sum_iff {s : Set (X ⊕ Y)} :
    IsClosed s ↔ IsClosed (inl ⁻¹' s) ∧ IsClosed (inr ⁻¹' s) 
goal: IsClosed s ↔ IsClosed (Sum.inl ⁻¹' s) ∧ IsClosed (Sum.inr ⁻¹' s)

full_name: isOpenMap_inl
code: theorem isOpenMap_inl : IsOpenMap (@inl X Y) 
goal: IsOpenMap Sum.inl

full_name: isOpenMap_inr
code: theorem isOpenMap_inr : IsOpenMap (@inr X Y) 
goal: IsOpenMap Sum.inr

full_name: openEmbedding_inl
code: theorem openEmbedding_inl : OpenEmbedding (@inl X Y) 
goal: OpenEmbedding Sum.inl

full_name: openEmbedding_inr
code: theorem openEmbedding_inr : OpenEmbedding (@inr X Y) 
goal: OpenEmbedding Sum.inr

full_name: embedding_inl
code: theorem embedding_inl : Embedding (@inl X Y) 
goal: Embedding Sum.inl

full_name: embedding_inr
code: theorem embedding_inr : Embedding (@inr X Y) 
goal: Embedding Sum.inr

full_name: isOpen_range_inl
code: theorem isOpen_range_inl : IsOpen (range (inl : X → X ⊕ Y)) 
goal: IsOpen (Set.range Sum.inl)

full_name: isOpen_range_inr
code: theorem isOpen_range_inr : IsOpen (range (inr : Y → X ⊕ Y)) 
goal: IsOpen (Set.range Sum.inr)

full_name: isClosed_range_inl
code: theorem isClosed_range_inl : IsClosed (range (inl : X → X ⊕ Y)) 
goal: IsClosed (Set.range Sum.inl)

full_name: isClosed_range_inr
code: theorem isClosed_range_inr : IsClosed (range (inr : Y → X ⊕ Y)) 
goal: IsClosed (Set.range Sum.inr)

full_name: closedEmbedding_inl
code: theorem closedEmbedding_inl : ClosedEmbedding (inl : X → X ⊕ Y) 
goal: ClosedEmbedding Sum.inl

full_name: closedEmbedding_inr
code: theorem closedEmbedding_inr : ClosedEmbedding (inr : Y → X ⊕ Y) 
goal: ClosedEmbedding Sum.inr

full_name: nhds_inl
code: theorem nhds_inl (x : X) : 𝓝 (inl x : X ⊕ Y) = map inl (𝓝 x) 
goal: 𝓝 (Sum.inl x) = Filter.map Sum.inl (𝓝 x)

full_name: nhds_inr
code: theorem nhds_inr (y : Y) : 𝓝 (inr y : X ⊕ Y) = map inr (𝓝 y) 
goal: 𝓝 (Sum.inr y) = Filter.map Sum.inr (𝓝 y)

full_name: continuous_sum_map
code: @[simp]
theorem continuous_sum_map {f : X → Y} {g : Z → W} :
    Continuous (Sum.map f g) ↔ Continuous f ∧ Continuous g 
goal: Continuous (Sum.map f g) ↔ Continuous f ∧ Continuous g

full_name: Continuous.sum_map
code: @[continuity, fun_prop]
theorem Continuous.sum_map {f : X → Y} {g : Z → W} (hf : Continuous f) (hg : Continuous g) :
    Continuous (Sum.map f g) 
goal: Continuous (Sum.map f g)

full_name: isOpenMap_sum
code: theorem isOpenMap_sum {f : X ⊕ Y → Z} :
    IsOpenMap f ↔ (IsOpenMap fun a => f (inl a)) ∧ IsOpenMap fun b => f (inr b) 
goal: IsOpenMap f ↔ (IsOpenMap fun a => f (Sum.inl a)) ∧ IsOpenMap fun b => f (Sum.inr b)

full_name: isOpenMap_sum_elim
code: @[simp]
theorem isOpenMap_sum_elim {f : X → Z} {g : Y → Z} :
    IsOpenMap (Sum.elim f g) ↔ IsOpenMap f ∧ IsOpenMap g 
goal: IsOpenMap (Sum.elim f g) ↔ IsOpenMap f ∧ IsOpenMap g

full_name: IsOpenMap.sum_elim
code: theorem IsOpenMap.sum_elim {f : X → Z} {g : Y → Z} (hf : IsOpenMap f) (hg : IsOpenMap g) :
    IsOpenMap (Sum.elim f g) 
goal: IsOpenMap (Sum.elim f g)

full_name: isClosedMap_sum
code: theorem isClosedMap_sum {f : X ⊕ Y → Z} :
    IsClosedMap f ↔ (IsClosedMap fun a => f (.inl a)) ∧ IsClosedMap fun b => f (.inr b) 
goal: IsClosedMap f ↔ (IsClosedMap fun a => f (Sum.inl a)) ∧ IsClosedMap fun b => f (Sum.inr b)

full_name: inducing_subtype_val
code: theorem inducing_subtype_val {t : Set Y} : Inducing ((↑) : t → Y) 
goal: Inducing Subtype.val

full_name: Inducing.of_codRestrict
code: theorem Inducing.of_codRestrict {f : X → Y} {t : Set Y} (ht : ∀ x, f x ∈ t)
    (h : Inducing (t.codRestrict f ht)) : Inducing f 
goal: Inducing f

full_name: embedding_subtype_val
code: theorem embedding_subtype_val : Embedding ((↑) : Subtype p → X) 
goal: Embedding Subtype.val

full_name: closedEmbedding_subtype_val
code: theorem closedEmbedding_subtype_val (h : IsClosed { a | p a }) :
    ClosedEmbedding ((↑) : Subtype p → X) 
goal: ClosedEmbedding Subtype.val

full_name: continuous_subtype_val
code: @[continuity, fun_prop]
theorem continuous_subtype_val : Continuous (@Subtype.val X p) 
goal: Continuous Subtype.val

full_name: Continuous.subtype_val
code: theorem Continuous.subtype_val {f : Y → Subtype p} (hf : Continuous f) :
    Continuous fun x => (f x : X) 
goal: Continuous fun x => ↑(f x)

full_name: IsOpen.openEmbedding_subtype_val
code: theorem IsOpen.openEmbedding_subtype_val {s : Set X} (hs : IsOpen s) :
    OpenEmbedding ((↑) : s → X) 
goal: OpenEmbedding Subtype.val

full_name: IsOpen.isOpenMap_subtype_val
code: theorem IsOpen.isOpenMap_subtype_val {s : Set X} (hs : IsOpen s) : IsOpenMap ((↑) : s → X) 
goal: IsOpenMap Subtype.val

full_name: IsOpenMap.restrict
code: theorem IsOpenMap.restrict {f : X → Y} (hf : IsOpenMap f) {s : Set X} (hs : IsOpen s) :
    IsOpenMap (s.restrict f) 
goal: IsOpenMap (s.restrict f)

full_name: IsClosed.closedEmbedding_subtype_val
code: nonrec theorem IsClosed.closedEmbedding_subtype_val {s : Set X} (hs : IsClosed s) :
    ClosedEmbedding ((↑) : s → X) 
goal: ClosedEmbedding Subtype.val

full_name: IsClosed.isClosedMap_subtype_val
code: theorem IsClosed.isClosedMap_subtype_val {s : Set X} (hs : IsClosed s) :
    IsClosedMap ((↑) : s → X) 
goal: IsClosedMap Subtype.val

full_name: Continuous.subtype_mk
code: @[continuity, fun_prop]
theorem Continuous.subtype_mk {f : Y → X} (h : Continuous f) (hp : ∀ x, p (f x)) :
    Continuous fun x => (⟨f x, hp x⟩ : Subtype p) 
goal: Continuous fun x => ⟨f x, ⋯⟩

full_name: Continuous.subtype_map
code: theorem Continuous.subtype_map {f : X → Y} (h : Continuous f) {q : Y → Prop}
    (hpq : ∀ x, p x → q (f x)) : Continuous (Subtype.map f hpq) 
goal: Continuous (Subtype.map f hpq)

full_name: continuous_inclusion
code: theorem continuous_inclusion {s t : Set X} (h : s ⊆ t) : Continuous (inclusion h) 
goal: Continuous (Set.inclusion h)

full_name: continuousAt_subtype_val
code: theorem continuousAt_subtype_val {p : X → Prop} {x : Subtype p} :
    ContinuousAt ((↑) : Subtype p → X) x 
goal: ContinuousAt Subtype.val x

full_name: Subtype.dense_iff
code: theorem Subtype.dense_iff {s : Set X} {t : Set s} : Dense t ↔ s ⊆ closure ((↑) '' t) 
goal: Dense t ↔ s ⊆ closure (Subtype.val '' t)

full_name: map_nhds_subtype_val
code: theorem map_nhds_subtype_val {s : Set X} (x : s) : map ((↑) : s → X) (𝓝 x) = 𝓝[s] ↑x 
goal: Filter.map Subtype.val (𝓝 x) = 𝓝[s] ↑x

full_name: map_nhds_subtype_coe_eq_nhds
code: theorem map_nhds_subtype_coe_eq_nhds {x : X} (hx : p x) (h : ∀ᶠ x in 𝓝 x, p x) :
    map ((↑) : Subtype p → X) (𝓝 ⟨x, hx⟩) = 𝓝 x 
goal: Filter.map Subtype.val (𝓝 ⟨x, hx⟩) = 𝓝 x

full_name: nhds_subtype_eq_comap
code: theorem nhds_subtype_eq_comap {x : X} {h : p x} : 𝓝 (⟨x, h⟩ : Subtype p) = comap (↑) (𝓝 x) 
goal: 𝓝 ⟨x, h⟩ = Filter.comap Subtype.val (𝓝 x)

full_name: tendsto_subtype_rng
code: theorem tendsto_subtype_rng {Y : Type*} {p : X → Prop} {l : Filter Y} {f : Y → Subtype p} :
    ∀ {x : Subtype p}, Tendsto f l (𝓝 x) ↔ Tendsto (fun x => (f x : X)) l (𝓝 (x : X))
  
goal: Filter.Tendsto f l (𝓝 x) ↔ Filter.Tendsto (fun x => ↑(f x)) l (𝓝 ↑x)

full_name: closure_subtype
code: theorem closure_subtype {x : { a // p a }} {s : Set { a // p a }} :
    x ∈ closure s ↔ (x : X) ∈ closure (((↑) : _ → X) '' s) 
goal: x ∈ closure s ↔ ↑x ∈ closure (Subtype.val '' s)

full_name: continuousAt_codRestrict_iff
code: @[simp]
theorem continuousAt_codRestrict_iff {f : X → Y} {t : Set Y} (h1 : ∀ x, f x ∈ t) {x : X} :
    ContinuousAt (codRestrict f t h1) x ↔ ContinuousAt f x 
goal: ContinuousAt (Set.codRestrict f t h1) x ↔ ContinuousAt f x

full_name: ContinuousAt.restrict
code: theorem ContinuousAt.restrict {f : X → Y} {s : Set X} {t : Set Y} (h1 : MapsTo f s t) {x : s}
    (h2 : ContinuousAt f x) : ContinuousAt (h1.restrict f s t) x 
goal: ContinuousAt (Set.MapsTo.restrict f s t h1) x

full_name: ContinuousAt.restrictPreimage
code: theorem ContinuousAt.restrictPreimage {f : X → Y} {s : Set Y} {x : f ⁻¹' s} (h : ContinuousAt f x) :
    ContinuousAt (s.restrictPreimage f) x 
goal: ContinuousAt (s.restrictPreimage f) x

full_name: Continuous.codRestrict
code: @[continuity, fun_prop]
theorem Continuous.codRestrict {f : X → Y} {s : Set Y} (hf : Continuous f) (hs : ∀ a, f a ∈ s) :
    Continuous (s.codRestrict f hs) 
goal: Continuous (Set.codRestrict f s hs)

full_name: Continuous.restrict
code: @[continuity, fun_prop]
theorem Continuous.restrict {f : X → Y} {s : Set X} {t : Set Y} (h1 : MapsTo f s t)
    (h2 : Continuous f) : Continuous (h1.restrict f s t) 
goal: Continuous (Set.MapsTo.restrict f s t h1)

full_name: Continuous.restrictPreimage
code: @[continuity, fun_prop]
theorem Continuous.restrictPreimage {f : X → Y} {s : Set Y} (h : Continuous f) :
    Continuous (s.restrictPreimage f) 
goal: Continuous (s.restrictPreimage f)

full_name: Inducing.codRestrict
code: theorem Inducing.codRestrict {e : X → Y} (he : Inducing e) {s : Set Y} (hs : ∀ x, e x ∈ s) :
    Inducing (codRestrict e s hs) 
goal: Inducing (Set.codRestrict e s hs)

full_name: Embedding.codRestrict
code: theorem Embedding.codRestrict {e : X → Y} (he : Embedding e) (s : Set Y) (hs : ∀ x, e x ∈ s) :
    Embedding (codRestrict e s hs) 
goal: Embedding (Set.codRestrict e s hs)

full_name: embedding_inclusion
code: theorem embedding_inclusion {s t : Set X} (h : s ⊆ t) : Embedding (inclusion h) 
goal: Embedding (Set.inclusion h)

full_name: DiscreteTopology.of_subset
code: /-- Let `s, t ⊆ X` be two subsets of a topological space `X`.  If `t ⊆ s` and the topology induced
by `X`on `s` is discrete, then also the topology induces on `t` is discrete.  -/
theorem DiscreteTopology.of_subset {X : Type*} [TopologicalSpace X] {s t : Set X}
    (_ : DiscreteTopology s) (ts : t ⊆ s) : DiscreteTopology t 
goal: DiscreteTopology ↑s → t ⊆ s → DiscreteTopology ↑t

full_name: DiscreteTopology.preimage_of_continuous_injective
code: /-- Let `s` be a discrete subset of a topological space. Then the preimage of `s` by
a continuous injective map is also discrete. -/
theorem DiscreteTopology.preimage_of_continuous_injective {X Y : Type*} [TopologicalSpace X]
    [TopologicalSpace Y] (s : Set Y) [DiscreteTopology s] {f : X → Y} (hc : Continuous f)
    (hinj : Function.Injective f) : DiscreteTopology (f ⁻¹' s) 
goal: DiscreteTopology ↑(f ⁻¹' s)

full_name: QuotientMap.restrictPreimage_isOpen
code: /-- If `f : X → Y` is a quotient map,
then its restriction to the preimage of an open set is a quotient map too. -/
theorem QuotientMap.restrictPreimage_isOpen {f : X → Y} (hf : QuotientMap f)
    {s : Set Y} (hs : IsOpen s) : QuotientMap (s.restrictPreimage f) 
goal: QuotientMap (s.restrictPreimage f)

full_name: isClosed_preimage_val
code: lemma isClosed_preimage_val {s t : Set X} : IsClosed (s ↓∩ t) ↔ s ∩ closure (s ∩ t) ⊆ t 
goal: IsClosed (Subtype.val ⁻¹' t) ↔ s ∩ closure (s ∩ t) ⊆ t

full_name: quotientMap_quot_mk
code: theorem quotientMap_quot_mk : QuotientMap (@Quot.mk X r) 
goal: QuotientMap (Quot.mk r)

full_name: continuous_quot_mk
code: @[continuity, fun_prop]
theorem continuous_quot_mk : Continuous (@Quot.mk X r) 
goal: Continuous (Quot.mk r)

full_name: continuous_quot_lift
code: @[continuity, fun_prop]
theorem continuous_quot_lift {f : X → Y} (hr : ∀ a b, r a b → f a = f b) (h : Continuous f) :
    Continuous (Quot.lift f hr : Quot r → Y) 
goal: Continuous (Quot.lift f hr)

full_name: quotientMap_quotient_mk'
code: theorem quotientMap_quotient_mk' : QuotientMap (@Quotient.mk' X s) 
goal: QuotientMap Quotient.mk'

full_name: continuous_quotient_mk'
code: theorem continuous_quotient_mk' : Continuous (@Quotient.mk' X s) 
goal: Continuous Quotient.mk'

full_name: Continuous.quotient_lift
code: theorem Continuous.quotient_lift {f : X → Y} (h : Continuous f) (hs : ∀ a b, a ≈ b → f a = f b) :
    Continuous (Quotient.lift f hs : Quotient s → Y) 
goal: Continuous (Quotient.lift f hs)

full_name: Continuous.quotient_liftOn'
code: theorem Continuous.quotient_liftOn' {f : X → Y} (h : Continuous f)
    (hs : ∀ a b, @Setoid.r _ s a b → f a = f b) :
    Continuous (fun x => Quotient.liftOn' x f hs : Quotient s → Y) 
goal: Continuous fun x => x.liftOn' f hs

full_name: Continuous.quotient_map'
code: @[continuity, fun_prop]
theorem Continuous.quotient_map' {t : Setoid Y} {f : X → Y} (hf : Continuous f)
    (H : (s.r ⇒ t.r) f f) : Continuous (Quotient.map' f H) 
goal: Continuous (Quotient.map' f H)

full_name: continuous_pi_iff
code: theorem continuous_pi_iff : Continuous f ↔ ∀ i, Continuous fun a => f a i 
goal: Continuous f ↔ ∀ (i : ι), Continuous fun a => f a i

full_name: continuous_pi
code: @[continuity, fun_prop]
theorem continuous_pi (h : ∀ i, Continuous fun a => f a i) : Continuous f 
goal: Continuous f

full_name: continuous_apply
code: @[continuity, fun_prop]
theorem continuous_apply (i : ι) : Continuous fun p : ∀ i, π i => p i 
goal: Continuous fun p => p i

full_name: continuous_apply_apply
code: @[continuity]
theorem continuous_apply_apply {ρ : κ → ι → Type*} [∀ j i, TopologicalSpace (ρ j i)] (j : κ)
    (i : ι) : Continuous fun p : ∀ j, ∀ i, ρ j i => p j i 
goal: Continuous fun p => p j i

full_name: continuousAt_apply
code: theorem continuousAt_apply (i : ι) (x : ∀ i, π i) : ContinuousAt (fun p : ∀ i, π i => p i) x 
goal: ContinuousAt (fun p => p i) x

full_name: Filter.Tendsto.apply_nhds
code: theorem Filter.Tendsto.apply_nhds {l : Filter Y} {f : Y → ∀ i, π i} {x : ∀ i, π i}
    (h : Tendsto f l (𝓝 x)) (i : ι) : Tendsto (fun a => f a i) l (𝓝 <| x i) 
goal: Filter.Tendsto (fun a => f a i) l (𝓝 (x i))

full_name: nhds_pi
code: theorem nhds_pi {a : ∀ i, π i} : 𝓝 a = pi fun i => 𝓝 (a i) 
goal: 𝓝 a = Filter.pi fun i => 𝓝 (a i)

full_name: tendsto_pi_nhds
code: theorem tendsto_pi_nhds {f : Y → ∀ i, π i} {g : ∀ i, π i} {u : Filter Y} :
    Tendsto f u (𝓝 g) ↔ ∀ x, Tendsto (fun i => f i x) u (𝓝 (g x)) 
goal: Filter.Tendsto f u (𝓝 g) ↔ ∀ (x : ι), Filter.Tendsto (fun i => f i x) u (𝓝 (g x))

full_name: continuousAt_pi
code: theorem continuousAt_pi {f : X → ∀ i, π i} {x : X} :
    ContinuousAt f x ↔ ∀ i, ContinuousAt (fun y => f y i) x 
goal: ContinuousAt f x ↔ ∀ (i : ι), ContinuousAt (fun y => f y i) x

full_name: continuousAt_pi'
code: @[fun_prop]
theorem continuousAt_pi' {f : X → ∀ i, π i} {x : X} (hf : ∀ i, ContinuousAt (fun y => f y i) x) :
    ContinuousAt f x 
goal: ContinuousAt f x

full_name: Pi.continuous_precomp'
code: theorem Pi.continuous_precomp' {ι' : Type*} (φ : ι' → ι) :
    Continuous (fun (f : (∀ i, π i)) (j : ι') ↦ f (φ j)) 
goal: Continuous fun f j => f (φ j)

full_name: Pi.continuous_precomp
code: theorem Pi.continuous_precomp {ι' : Type*} (φ : ι' → ι) :
    Continuous (· ∘ φ : (ι → X) → (ι' → X)) 
goal: Continuous fun x => x ∘ φ

full_name: Pi.continuous_postcomp'
code: theorem Pi.continuous_postcomp' {X : ι → Type*} [∀ i, TopologicalSpace (X i)]
    {g : ∀ i, π i → X i} (hg : ∀ i, Continuous (g i)) :
    Continuous (fun (f : (∀ i, π i)) (i : ι) ↦ g i (f i)) 
goal: Continuous fun f i => g i (f i)

full_name: Pi.continuous_postcomp
code: theorem Pi.continuous_postcomp [TopologicalSpace Y] {g : X → Y} (hg : Continuous g) :
    Continuous (g ∘ · : (ι → X) → (ι → Y)) 
goal: Continuous fun x => g ∘ x

full_name: Pi.induced_precomp'
code: lemma Pi.induced_precomp' {ι' : Type*} (φ : ι' → ι) :
    induced (fun (f : (∀ i, π i)) (j : ι') ↦ f (φ j)) Pi.topologicalSpace =
    ⨅ i', induced (eval (φ i')) (T (φ i')) 
goal: TopologicalSpace.induced (fun f j => f (φ j)) Pi.topologicalSpace =
  ⨅ i', TopologicalSpace.induced (Function.eval (φ i')) (T (φ i'))

full_name: Pi.induced_precomp
code: lemma Pi.induced_precomp [TopologicalSpace Y] {ι' : Type*} (φ : ι' → ι) :
    induced (· ∘ φ) Pi.topologicalSpace =
    ⨅ i', induced (eval (φ i')) ‹TopologicalSpace Y› 
goal: TopologicalSpace.induced (fun x => x ∘ φ) Pi.topologicalSpace =
  ⨅ i', TopologicalSpace.induced (Function.eval (φ i')) inst✝

full_name: Pi.continuous_restrict
code: lemma Pi.continuous_restrict (S : Set ι) :
    Continuous (S.restrict : (∀ i : ι, π i) → (∀ i : S, π i)) 
goal: Continuous S.restrict

full_name: Pi.induced_restrict
code: lemma Pi.induced_restrict (S : Set ι) :
    induced (S.restrict) Pi.topologicalSpace =
    ⨅ i ∈ S, induced (eval i) (T i) 
goal: TopologicalSpace.induced S.restrict Pi.topologicalSpace = ⨅ i ∈ S, TopologicalSpace.induced (Function.eval i) (T i)

full_name: Pi.induced_restrict_sUnion
code: lemma Pi.induced_restrict_sUnion (𝔖 : Set (Set ι)) :
    induced (⋃₀ 𝔖).restrict (Pi.topologicalSpace (Y := fun i : (⋃₀ 𝔖) ↦ π i)) =
    ⨅ S ∈ 𝔖, induced S.restrict Pi.topologicalSpace 
goal: TopologicalSpace.induced (⋃₀ 𝔖).restrict Pi.topologicalSpace =
  ⨅ S ∈ 𝔖, TopologicalSpace.induced S.restrict Pi.topologicalSpace

full_name: Filter.Tendsto.update
code: theorem Filter.Tendsto.update [DecidableEq ι] {l : Filter Y} {f : Y → ∀ i, π i} {x : ∀ i, π i}
    (hf : Tendsto f l (𝓝 x)) (i : ι) {g : Y → π i} {xi : π i} (hg : Tendsto g l (𝓝 xi)) :
    Tendsto (fun a => update (f a) i (g a)) l (𝓝 <| update x i xi) 
goal: Filter.Tendsto (fun a => Function.update (f a) i (g a)) l (𝓝 (Function.update x i xi))

full_name: ContinuousAt.update
code: theorem ContinuousAt.update [DecidableEq ι] {x : X} (hf : ContinuousAt f x) (i : ι) {g : X → π i}
    (hg : ContinuousAt g x) : ContinuousAt (fun a => update (f a) i (g a)) x 
goal: ContinuousAt (fun a => Function.update (f a) i (g a)) x

full_name: Continuous.update
code: theorem Continuous.update [DecidableEq ι] (hf : Continuous f) (i : ι) {g : X → π i}
    (hg : Continuous g) : Continuous fun a => update (f a) i (g a) 
goal: Continuous fun a => Function.update (f a) i (g a)

full_name: continuous_update
code: /-- `Function.update f i x` is continuous in `(f, x)`. -/
@[continuity, fun_prop]
theorem continuous_update [DecidableEq ι] (i : ι) :
    Continuous fun f : (∀ j, π j) × π i => update f.1 i f.2 
goal: Continuous fun f => Function.update f.1 i f.2

full_name: continuous_single
code: /-- `Pi.mulSingle i x` is continuous in `x`. -/
-- Porting note (#11215): TODO: restore @[continuity]
@[to_additive "`Pi.single i x` is continuous in `x`."]
theorem continuous_mulSingle [∀ i, One (π i)] [DecidableEq ι] (i : ι) :
    Continuous fun x => (Pi.mulSingle i x : ∀ i, π i) 
goal: Continuous fun x => Pi.single i x

full_name: continuous_mulSingle
code: /-- `Pi.mulSingle i x` is continuous in `x`. -/
-- Porting note (#11215): TODO: restore @[continuity]
@[to_additive "`Pi.single i x` is continuous in `x`."]
theorem continuous_mulSingle [∀ i, One (π i)] [DecidableEq ι] (i : ι) :
    Continuous fun x => (Pi.mulSingle i x : ∀ i, π i) 
goal: Continuous fun x => Pi.mulSingle i x

full_name: Filter.Tendsto.fin_insertNth
code: theorem Filter.Tendsto.fin_insertNth {n} {π : Fin (n + 1) → Type*} [∀ i, TopologicalSpace (π i)]
    (i : Fin (n + 1)) {f : Y → π i} {l : Filter Y} {x : π i} (hf : Tendsto f l (𝓝 x))
    {g : Y → ∀ j : Fin n, π (i.succAbove j)} {y : ∀ j, π (i.succAbove j)} (hg : Tendsto g l (𝓝 y)) :
    Tendsto (fun a => i.insertNth (f a) (g a)) l (𝓝 <| i.insertNth x y) 
goal: Filter.Tendsto (fun a => i.insertNth (f a) (g a)) l (𝓝 (i.insertNth x y))

full_name: ContinuousAt.fin_insertNth
code: theorem ContinuousAt.fin_insertNth {n} {π : Fin (n + 1) → Type*} [∀ i, TopologicalSpace (π i)]
    (i : Fin (n + 1)) {f : X → π i} {x : X} (hf : ContinuousAt f x)
    {g : X → ∀ j : Fin n, π (i.succAbove j)} (hg : ContinuousAt g x) :
    ContinuousAt (fun a => i.insertNth (f a) (g a)) x 
goal: ContinuousAt (fun a => i.insertNth (f a) (g a)) x

full_name: Continuous.fin_insertNth
code: theorem Continuous.fin_insertNth {n} {π : Fin (n + 1) → Type*} [∀ i, TopologicalSpace (π i)]
    (i : Fin (n + 1)) {f : X → π i} (hf : Continuous f) {g : X → ∀ j : Fin n, π (i.succAbove j)}
    (hg : Continuous g) : Continuous fun a => i.insertNth (f a) (g a) 
goal: Continuous fun a => i.insertNth (f a) (g a)

full_name: isOpen_set_pi
code: theorem isOpen_set_pi {i : Set ι} {s : ∀ a, Set (π a)} (hi : i.Finite)
    (hs : ∀ a ∈ i, IsOpen (s a)) : IsOpen (pi i s) 
goal: IsOpen (i.pi s)

full_name: isOpen_pi_iff
code: theorem isOpen_pi_iff {s : Set (∀ a, π a)} :
    IsOpen s ↔
      ∀ f, f ∈ s → ∃ (I : Finset ι) (u : ∀ a, Set (π a)),
        (∀ a, a ∈ I → IsOpen (u a) ∧ f a ∈ u a) ∧ (I : Set ι).pi u ⊆ s 
goal: IsOpen s ↔ ∀ f ∈ s, ∃ I u, (∀ a ∈ I, IsOpen (u a) ∧ f a ∈ u a) ∧ (↑I).pi u ⊆ s

full_name: isOpen_pi_iff'
code: theorem isOpen_pi_iff' [Finite ι] {s : Set (∀ a, π a)} :
    IsOpen s ↔
      ∀ f, f ∈ s → ∃ u : ∀ a, Set (π a), (∀ a, IsOpen (u a) ∧ f a ∈ u a) ∧ univ.pi u ⊆ s 
goal: IsOpen s ↔ ∀ f ∈ s, ∃ u, (∀ (a : ι), IsOpen (u a) ∧ f a ∈ u a) ∧ Set.univ.pi u ⊆ s

full_name: isClosed_set_pi
code: theorem isClosed_set_pi {i : Set ι} {s : ∀ a, Set (π a)} (hs : ∀ a ∈ i, IsClosed (s a)) :
    IsClosed (pi i s) 
goal: IsClosed (i.pi s)

full_name: mem_nhds_of_pi_mem_nhds
code: theorem mem_nhds_of_pi_mem_nhds {I : Set ι} {s : ∀ i, Set (π i)} (a : ∀ i, π i) (hs : I.pi s ∈ 𝓝 a)
    {i : ι} (hi : i ∈ I) : s i ∈ 𝓝 (a i) 
goal: s i ∈ 𝓝 (a i)

full_name: set_pi_mem_nhds
code: theorem set_pi_mem_nhds {i : Set ι} {s : ∀ a, Set (π a)} {x : ∀ a, π a} (hi : i.Finite)
    (hs : ∀ a ∈ i, s a ∈ 𝓝 (x a)) : pi i s ∈ 𝓝 x 
goal: i.pi s ∈ 𝓝 x

full_name: set_pi_mem_nhds_iff
code: theorem set_pi_mem_nhds_iff {I : Set ι} (hI : I.Finite) {s : ∀ i, Set (π i)} (a : ∀ i, π i) :
    I.pi s ∈ 𝓝 a ↔ ∀ i : ι, i ∈ I → s i ∈ 𝓝 (a i) 
goal: I.pi s ∈ 𝓝 a ↔ ∀ i ∈ I, s i ∈ 𝓝 (a i)

full_name: interior_pi_set
code: theorem interior_pi_set {I : Set ι} (hI : I.Finite) {s : ∀ i, Set (π i)} :
    interior (pi I s) = I.pi fun i => interior (s i) 
goal: interior (I.pi s) = I.pi fun i => interior (s i)

full_name: exists_finset_piecewise_mem_of_mem_nhds
code: theorem exists_finset_piecewise_mem_of_mem_nhds [DecidableEq ι] {s : Set (∀ a, π a)} {x : ∀ a, π a}
    (hs : s ∈ 𝓝 x) (y : ∀ a, π a) : ∃ I : Finset ι, I.piecewise x y ∈ s 
goal: ∃ I, I.piecewise x y ∈ s

full_name: pi_generateFrom_eq
code: theorem pi_generateFrom_eq {π : ι → Type*} {g : ∀ a, Set (Set (π a))} :
    (@Pi.topologicalSpace ι π fun a => generateFrom (g a)) =
      generateFrom
        { t | ∃ (s : ∀ a, Set (π a)) (i : Finset ι), (∀ a ∈ i, s a ∈ g a) ∧ t = pi (↑i) s } 
goal: Pi.topologicalSpace = TopologicalSpace.generateFrom {t | ∃ s i, (∀ a ∈ i, s a ∈ g a) ∧ t = (↑i).pi s}

full_name: pi_eq_generateFrom
code: theorem pi_eq_generateFrom :
    Pi.topologicalSpace =
      generateFrom
        { g | ∃ (s : ∀ a, Set (π a)) (i : Finset ι), (∀ a ∈ i, IsOpen (s a)) ∧ g = pi (↑i) s } 
goal: Pi.topologicalSpace = TopologicalSpace.generateFrom {g | ∃ s i, (∀ a ∈ i, IsOpen (s a)) ∧ g = (↑i).pi s}

full_name: pi_generateFrom_eq_finite
code: theorem pi_generateFrom_eq_finite {π : ι → Type*} {g : ∀ a, Set (Set (π a))} [Finite ι]
    (hg : ∀ a, ⋃₀ g a = univ) :
    (@Pi.topologicalSpace ι π fun a => generateFrom (g a)) =
      generateFrom { t | ∃ s : ∀ a, Set (π a), (∀ a, s a ∈ g a) ∧ t = pi univ s } 
goal: Pi.topologicalSpace = TopologicalSpace.generateFrom {t | ∃ s, (∀ (a : ι), s a ∈ g a) ∧ t = Set.univ.pi s}

full_name: induced_to_pi
code: theorem induced_to_pi {X : Type*} (f : X → ∀ i, π i) :
    induced f Pi.topologicalSpace = ⨅ i, induced (f · i) inferInstance 
goal: TopologicalSpace.induced f Pi.topologicalSpace = ⨅ i, TopologicalSpace.induced (fun x => f x i) inferInstance

full_name: inducing_iInf_to_pi
code: /-- Suppose `π i` is a family of topological spaces indexed by `i : ι`, and `X` is a type
endowed with a family of maps `f i : X → π i` for every `i : ι`, hence inducing a
map `g : X → Π i, π i`. This lemma shows that infimum of the topologies on `X` induced by
the `f i` as `i : ι` varies is simply the topology on `X` induced by `g : X → Π i, π i`
where `Π i, π i` is endowed with the usual product topology. -/
theorem inducing_iInf_to_pi {X : Type*} (f : ∀ i, X → π i) :
    @Inducing X (∀ i, π i) (⨅ i, induced (f i) inferInstance) _ fun x i => f i x 
goal: Inducing fun x i => f i x

full_name: Pi.discreteTopology
code: /-- A finite product of discrete spaces is discrete. -/
instance Pi.discreteTopology : DiscreteTopology (∀ i, π i) 
goal: DiscreteTopology ((i : ι) → π i)

full_name: continuous_sigmaMk
code: @[continuity, fun_prop]
theorem continuous_sigmaMk {i : ι} : Continuous (@Sigma.mk ι σ i) 
goal: Continuous (Sigma.mk i)

full_name: isOpen_sigma_iff
code: theorem isOpen_sigma_iff {s : Set (Sigma σ)} : IsOpen s ↔ ∀ i, IsOpen (Sigma.mk i ⁻¹' s) 
goal: IsOpen s ↔ ∀ (i : ι), IsOpen (Sigma.mk i ⁻¹' s)

full_name: isClosed_sigma_iff
code: theorem isClosed_sigma_iff {s : Set (Sigma σ)} : IsClosed s ↔ ∀ i, IsClosed (Sigma.mk i ⁻¹' s) 
goal: IsClosed s ↔ ∀ (i : ι), IsClosed (Sigma.mk i ⁻¹' s)

full_name: isOpenMap_sigmaMk
code: theorem isOpenMap_sigmaMk {i : ι} : IsOpenMap (@Sigma.mk ι σ i) 
goal: IsOpenMap (Sigma.mk i)

full_name: isOpen_range_sigmaMk
code: theorem isOpen_range_sigmaMk {i : ι} : IsOpen (range (@Sigma.mk ι σ i)) 
goal: IsOpen (Set.range (Sigma.mk i))

full_name: isClosedMap_sigmaMk
code: theorem isClosedMap_sigmaMk {i : ι} : IsClosedMap (@Sigma.mk ι σ i) 
goal: IsClosedMap (Sigma.mk i)

full_name: isClosed_range_sigmaMk
code: theorem isClosed_range_sigmaMk {i : ι} : IsClosed (range (@Sigma.mk ι σ i)) 
goal: IsClosed (Set.range (Sigma.mk i))

full_name: openEmbedding_sigmaMk
code: theorem openEmbedding_sigmaMk {i : ι} : OpenEmbedding (@Sigma.mk ι σ i) 
goal: OpenEmbedding (Sigma.mk i)

full_name: closedEmbedding_sigmaMk
code: theorem closedEmbedding_sigmaMk {i : ι} : ClosedEmbedding (@Sigma.mk ι σ i) 
goal: ClosedEmbedding (Sigma.mk i)

full_name: embedding_sigmaMk
code: theorem embedding_sigmaMk {i : ι} : Embedding (@Sigma.mk ι σ i) 
goal: Embedding (Sigma.mk i)

full_name: Sigma.nhds_mk
code: theorem Sigma.nhds_mk (i : ι) (x : σ i) : 𝓝 (⟨i, x⟩ : Sigma σ) = Filter.map (Sigma.mk i) (𝓝 x) 
goal: 𝓝 ⟨i, x⟩ = Filter.map (Sigma.mk i) (𝓝 x)

full_name: Sigma.nhds_eq
code: theorem Sigma.nhds_eq (x : Sigma σ) : 𝓝 x = Filter.map (Sigma.mk x.1) (𝓝 x.2) 
goal: 𝓝 x = Filter.map (Sigma.mk x.fst) (𝓝 x.snd)

full_name: comap_sigmaMk_nhds
code: theorem comap_sigmaMk_nhds (i : ι) (x : σ i) : comap (Sigma.mk i) (𝓝 ⟨i, x⟩) = 𝓝 x 
goal: Filter.comap (Sigma.mk i) (𝓝 ⟨i, x⟩) = 𝓝 x

full_name: isOpen_sigma_fst_preimage
code: theorem isOpen_sigma_fst_preimage (s : Set ι) : IsOpen (Sigma.fst ⁻¹' s : Set (Σ a, σ a)) 
goal: IsOpen (Sigma.fst ⁻¹' s)

full_name: continuous_sigma_iff
code: /-- A map out of a sum type is continuous iff its restriction to each summand is. -/
@[simp]
theorem continuous_sigma_iff {f : Sigma σ → X} :
    Continuous f ↔ ∀ i, Continuous fun a => f ⟨i, a⟩ 
goal: Continuous f ↔ ∀ (i : ι), Continuous fun a => f ⟨i, a⟩

full_name: continuous_sigma
code: /-- A map out of a sum type is continuous if its restriction to each summand is. -/
@[continuity, fun_prop]
theorem continuous_sigma {f : Sigma σ → X} (hf : ∀ i, Continuous fun a => f ⟨i, a⟩) :
    Continuous f 
goal: Continuous f

full_name: inducing_sigma
code: /-- A map defined on a sigma type (a.k.a. the disjoint union of an indexed family of topological
spaces) is inducing iff its restriction to each component is inducing and each the image of each
component under `f` can be separated from the images of all other components by an open set. -/
theorem inducing_sigma {f : Sigma σ → X} :
    Inducing f ↔ (∀ i, Inducing (f ∘ Sigma.mk i)) ∧
      (∀ i, ∃ U, IsOpen U ∧ ∀ x, f x ∈ U ↔ x.1 = i) 
goal: Inducing f ↔ (∀ (i : ι), Inducing (f ∘ Sigma.mk i)) ∧ ∀ (i : ι), ∃ U, IsOpen U ∧ ∀ (x : Sigma σ), f x ∈ U ↔ x.fst = i

full_name: continuous_sigma_map
code: @[simp 1100]
theorem continuous_sigma_map {f₁ : ι → κ} {f₂ : ∀ i, σ i → τ (f₁ i)} :
    Continuous (Sigma.map f₁ f₂) ↔ ∀ i, Continuous (f₂ i) 
goal: Continuous (Sigma.map f₁ f₂) ↔ ∀ (i : ι), Continuous (f₂ i)

full_name: Continuous.sigma_map
code: @[continuity, fun_prop]
theorem Continuous.sigma_map {f₁ : ι → κ} {f₂ : ∀ i, σ i → τ (f₁ i)} (hf : ∀ i, Continuous (f₂ i)) :
    Continuous (Sigma.map f₁ f₂) 
goal: Continuous (Sigma.map f₁ f₂)

full_name: isOpenMap_sigma
code: theorem isOpenMap_sigma {f : Sigma σ → X} : IsOpenMap f ↔ ∀ i, IsOpenMap fun a => f ⟨i, a⟩ 
goal: IsOpenMap f ↔ ∀ (i : ι), IsOpenMap fun a => f ⟨i, a⟩

full_name: isOpenMap_sigma_map
code: theorem isOpenMap_sigma_map {f₁ : ι → κ} {f₂ : ∀ i, σ i → τ (f₁ i)} :
    IsOpenMap (Sigma.map f₁ f₂) ↔ ∀ i, IsOpenMap (f₂ i) 
goal: IsOpenMap (Sigma.map f₁ f₂) ↔ ∀ (i : ι), IsOpenMap (f₂ i)

full_name: inducing_sigma_map
code: theorem inducing_sigma_map {f₁ : ι → κ} {f₂ : ∀ i, σ i → τ (f₁ i)} (h₁ : Injective f₁) :
    Inducing (Sigma.map f₁ f₂) ↔ ∀ i, Inducing (f₂ i) 
goal: Inducing (Sigma.map f₁ f₂) ↔ ∀ (i : ι), Inducing (f₂ i)

full_name: embedding_sigma_map
code: theorem embedding_sigma_map {f₁ : ι → κ} {f₂ : ∀ i, σ i → τ (f₁ i)} (h : Injective f₁) :
    Embedding (Sigma.map f₁ f₂) ↔ ∀ i, Embedding (f₂ i) 
goal: Embedding (Sigma.map f₁ f₂) ↔ ∀ (i : ι), Embedding (f₂ i)

full_name: openEmbedding_sigma_map
code: theorem openEmbedding_sigma_map {f₁ : ι → κ} {f₂ : ∀ i, σ i → τ (f₁ i)} (h : Injective f₁) :
    OpenEmbedding (Sigma.map f₁ f₂) ↔ ∀ i, OpenEmbedding (f₂ i) 
goal: OpenEmbedding (Sigma.map f₁ f₂) ↔ ∀ (i : ι), OpenEmbedding (f₂ i)

full_name: ULift.isOpen_iff
code: theorem ULift.isOpen_iff [TopologicalSpace X] {s : Set (ULift.{v} X)} :
    IsOpen s ↔ IsOpen (ULift.up ⁻¹' s) 
goal: IsOpen s ↔ IsOpen (ULift.up ⁻¹' s)

full_name: ULift.isClosed_iff
code: theorem ULift.isClosed_iff [TopologicalSpace X] {s : Set (ULift.{v} X)} :
    IsClosed s ↔ IsClosed (ULift.up ⁻¹' s) 
goal: IsClosed s ↔ IsClosed (ULift.up ⁻¹' s)

full_name: continuous_uLift_down
code: @[continuity]
theorem continuous_uLift_down [TopologicalSpace X] : Continuous (ULift.down : ULift.{v, u} X → X) 
goal: Continuous ULift.down

full_name: continuous_uLift_up
code: @[continuity]
theorem continuous_uLift_up [TopologicalSpace X] : Continuous (ULift.up : X → ULift.{v, u} X) 
goal: Continuous ULift.up

full_name: embedding_uLift_down
code: theorem embedding_uLift_down [TopologicalSpace X] : Embedding (ULift.down : ULift.{v, u} X → X) 
goal: Embedding ULift.down

full_name: ULift.closedEmbedding_down
code: theorem ULift.closedEmbedding_down [TopologicalSpace X] :
    ClosedEmbedding (ULift.down : ULift.{v, u} X → X) 
goal: ClosedEmbedding ULift.down

full_name: instDiscreteTopologyULift
code: instance [TopologicalSpace X] [DiscreteTopology X] : DiscreteTopology (ULift X) 
goal: DiscreteTopology (ULift.{u_5, u} X)

full_name: IsOpen.trans
code: theorem IsOpen.trans (ht : IsOpen t) (hs : IsOpen s) : IsOpen (t : Set X) 
goal: IsOpen (Subtype.val '' t)

full_name: IsClosed.trans
code: theorem IsClosed.trans (ht : IsClosed t) (hs : IsClosed s) : IsClosed (t : Set X) 
goal: IsClosed (Subtype.val '' t)

full_name: nhdsSet_prod_le
code: /-- The product of a neighborhood of `s` and a neighborhood of `t` is a neighborhood of `s ×ˢ t`,
formulated in terms of a filter inequality. -/
theorem nhdsSet_prod_le (s : Set X) (t : Set Y) : 𝓝ˢ (s ×ˢ t) ≤ 𝓝ˢ s ×ˢ 𝓝ˢ t 
goal: 𝓝ˢ (s ×ˢ t) ≤ 𝓝ˢ s ×ˢ 𝓝ˢ t

full_name: Filter.eventually_nhdsSet_prod_iff
code: theorem Filter.eventually_nhdsSet_prod_iff {p : X × Y → Prop} :
    (∀ᶠ q in 𝓝ˢ (s ×ˢ t), p q) ↔
      ∀ x ∈ s, ∀ y ∈ t,
          ∃ px : X → Prop, (∀ᶠ x' in 𝓝 x, px x') ∧ ∃ py : Y → Prop, (∀ᶠ y' in 𝓝 y, py y') ∧
            ∀ {x : X}, px x → ∀ {y : Y}, py y → p (x, y) 
goal: (∀ᶠ (q : X × Y) in 𝓝ˢ (s ×ˢ t), p q) ↔
  ∀ x ∈ s,
    ∀ y ∈ t,
      ∃ px,
        (∀ᶠ (x' : X) in 𝓝 x, px x') ∧ ∃ py, (∀ᶠ (y' : Y) in 𝓝 y, py y') ∧ ∀ {x : X}, px x → ∀ {y : Y}, py y → p (x, y)

full_name: Filter.Eventually.prod_nhdsSet
code: theorem Filter.Eventually.prod_nhdsSet {p : X × Y → Prop} {px : X → Prop} {py : Y → Prop}
    (hp : ∀ {x : X}, px x → ∀ {y : Y}, py y → p (x, y)) (hs : ∀ᶠ x in 𝓝ˢ s, px x)
    (ht : ∀ᶠ y in 𝓝ˢ t, py y) : ∀ᶠ q in 𝓝ˢ (s ×ˢ t), p q 
goal: ∀ᶠ (q : X × Y) in 𝓝ˢ (s ×ˢ t), p q