ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- inducing_const_prod
@[simp]
theorem inducing_const_prod {x : X} {f : Y → Z} : (Inducing fun x' => (x, f x')) ↔ Inducing f 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {x : X} {f : Y → Z}
Goal: (Inducing fun x' => (x, f x')) ↔ Inducing f
-- inducing_prod_const
@[simp]
theorem inducing_prod_const {y : Y} {f : X → Z} : (Inducing fun x => (f x, y)) ↔ Inducing f 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {y : Y} {f : X → Z}
Goal: (Inducing fun x => (f x, y)) ↔ Inducing f
-- Embedding.prod_map
theorem Embedding.prod_map {f : X → Y} {g : Z → W} (hf : Embedding f) (hg : Embedding g) :
    Embedding (Prod.map f g) 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} {W : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] [TopologicalSpace W] {f : X → Y} {g : Z → W} (hf : Embedding f) (hg : Embedding g)
Goal: Embedding (Prod.map f g)
-- IsOpenMap.prod
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) 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} {W : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] [TopologicalSpace W] {f : X → Y} {g : Z → W} (hf : IsOpenMap f) (hg : IsOpenMap g)
Goal: IsOpenMap fun p => (f p.1, g p.2)
-- OpenEmbedding.prod
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) 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} {W : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] [TopologicalSpace W] {f : X → Y} {g : Z → W} (hf : OpenEmbedding f) (hg : OpenEmbedding g)
Goal: OpenEmbedding fun x => (f x.1, g x.2)
-- embedding_graph
theorem embedding_graph {f : X → Y} (hf : Continuous f) : Embedding fun x => (x, f x) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} (hf : Continuous f)
Goal: Embedding fun x => (x, f x)
-- embedding_prod_mk
theorem embedding_prod_mk (x : X) : Embedding (Prod.mk x : Y → X × Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] (x : X)
Goal: Embedding (Prod.mk x)
-- continuous_bool_rng
lemma continuous_bool_rng [TopologicalSpace X] {f : X → Bool} (b : Bool) :
    Continuous f ↔ IsClopen (f ⁻¹' {b}) 
Arguments: {X : Type u} [TopologicalSpace X] {f : X → Bool} (b : Bool)
Goal: Continuous f ↔ IsClopen (f ⁻¹' {b})
-- continuous_sum_dom
theorem continuous_sum_dom {f : X ⊕ Y → Z} :
    Continuous f ↔ Continuous (f ∘ Sum.inl) ∧ Continuous (f ∘ Sum.inr) 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {f : X ⊕ Y → Z}
Goal: Continuous f ↔ Continuous (f ∘ Sum.inl) ∧ Continuous (f ∘ Sum.inr)
-- continuous_sum_elim
theorem continuous_sum_elim {f : X → Z} {g : Y → Z} :
    Continuous (Sum.elim f g) ↔ Continuous f ∧ Continuous g 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {f : X → Z} {g : Y → Z}
Goal: Continuous (Sum.elim f g) ↔ Continuous f ∧ Continuous g
-- Continuous.sum_elim
@[continuity, fun_prop]
theorem Continuous.sum_elim {f : X → Z} {g : Y → Z} (hf : Continuous f) (hg : Continuous g) :
    Continuous (Sum.elim f g) 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {f : X → Z} {g : Y → Z} (hf : Continuous f) (hg : Continuous g)
Goal: Continuous (Sum.elim f g)
-- continuous_isLeft
@[continuity, fun_prop]
theorem continuous_isLeft : Continuous (isLeft : X ⊕ Y → Bool) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: Continuous Sum.isLeft
-- continuous_isRight
@[continuity, fun_prop]
theorem continuous_isRight : Continuous (isRight : X ⊕ Y → Bool) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: Continuous Sum.isRight
-- continuous_inl
@[continuity, fun_prop]
-- Porting note: the proof was `continuous_sup_rng_left continuous_coinduced_rng`
theorem continuous_inl : Continuous (@inl X Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: Continuous Sum.inl
-- continuous_inr
@[continuity, fun_prop]
-- Porting note: the proof was `continuous_sup_rng_right continuous_coinduced_rng`
theorem continuous_inr : Continuous (@inr X Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: Continuous Sum.inr
-- isOpen_sum_iff
theorem isOpen_sum_iff {s : Set (X ⊕ Y)} : IsOpen s ↔ IsOpen (inl ⁻¹' s) ∧ IsOpen (inr ⁻¹' s) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {s : Set (X ⊕ Y)}
Goal: IsOpen s ↔ IsOpen (Sum.inl ⁻¹' s) ∧ IsOpen (Sum.inr ⁻¹' s)
-- isClosed_sum_iff
theorem isClosed_sum_iff {s : Set (X ⊕ Y)} :
    IsClosed s ↔ IsClosed (inl ⁻¹' s) ∧ IsClosed (inr ⁻¹' s) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {s : Set (X ⊕ Y)}
Goal: IsClosed s ↔ IsClosed (Sum.inl ⁻¹' s) ∧ IsClosed (Sum.inr ⁻¹' s)
-- isOpenMap_inl
theorem isOpenMap_inl : IsOpenMap (@inl X Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: IsOpenMap Sum.inl
-- isOpenMap_inr
theorem isOpenMap_inr : IsOpenMap (@inr X Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: IsOpenMap Sum.inr
-- openEmbedding_inl
theorem openEmbedding_inl : OpenEmbedding (@inl X Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: OpenEmbedding Sum.inl
-- openEmbedding_inr
theorem openEmbedding_inr : OpenEmbedding (@inr X Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: OpenEmbedding Sum.inr
-- embedding_inl
theorem embedding_inl : Embedding (@inl X Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: Embedding Sum.inl
-- embedding_inr
theorem embedding_inr : Embedding (@inr X Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: Embedding Sum.inr
-- isOpen_range_inl
theorem isOpen_range_inl : IsOpen (range (inl : X → X ⊕ Y)) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: IsOpen (Set.range Sum.inl)
-- isOpen_range_inr
theorem isOpen_range_inr : IsOpen (range (inr : Y → X ⊕ Y)) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: IsOpen (Set.range Sum.inr)
-- isClosed_range_inl
theorem isClosed_range_inl : IsClosed (range (inl : X → X ⊕ Y)) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: IsClosed (Set.range Sum.inl)
-- isClosed_range_inr
theorem isClosed_range_inr : IsClosed (range (inr : Y → X ⊕ Y)) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: IsClosed (Set.range Sum.inr)
-- closedEmbedding_inl
theorem closedEmbedding_inl : ClosedEmbedding (inl : X → X ⊕ Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: ClosedEmbedding Sum.inl
-- closedEmbedding_inr
theorem closedEmbedding_inr : ClosedEmbedding (inr : Y → X ⊕ Y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y]
Goal: ClosedEmbedding Sum.inr
-- nhds_inl
theorem nhds_inl (x : X) : 𝓝 (inl x : X ⊕ Y) = map inl (𝓝 x) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] (x : X)
Goal: 𝓝 (Sum.inl x) = Filter.map Sum.inl (𝓝 x)
-- nhds_inr
theorem nhds_inr (y : Y) : 𝓝 (inr y : X ⊕ Y) = map inr (𝓝 y) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] (y : Y)
Goal: 𝓝 (Sum.inr y) = Filter.map Sum.inr (𝓝 y)
-- continuous_sum_map
@[simp]
theorem continuous_sum_map {f : X → Y} {g : Z → W} :
    Continuous (Sum.map f g) ↔ Continuous f ∧ Continuous g 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} {W : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] [TopologicalSpace W] {f : X → Y} {g : Z → W}
Goal: Continuous (Sum.map f g) ↔ Continuous f ∧ Continuous g
-- Continuous.sum_map
@[continuity, fun_prop]
theorem Continuous.sum_map {f : X → Y} {g : Z → W} (hf : Continuous f) (hg : Continuous g) :
    Continuous (Sum.map f g) 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} {W : Type u_2} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] [TopologicalSpace W] {f : X → Y} {g : Z → W} (hf : Continuous f) (hg : Continuous g)
Goal: Continuous (Sum.map f g)
-- isOpenMap_sum
theorem isOpenMap_sum {f : X ⊕ Y → Z} :
    IsOpenMap f ↔ (IsOpenMap fun a => f (inl a)) ∧ IsOpenMap fun b => f (inr b) 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {f : X ⊕ Y → Z}
Goal: IsOpenMap f ↔ (IsOpenMap fun a => f (Sum.inl a)) ∧ IsOpenMap fun b => f (Sum.inr b)
-- isOpenMap_sum_elim
@[simp]
theorem isOpenMap_sum_elim {f : X → Z} {g : Y → Z} :
    IsOpenMap (Sum.elim f g) ↔ IsOpenMap f ∧ IsOpenMap g 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {f : X → Z} {g : Y → Z}
Goal: IsOpenMap (Sum.elim f g) ↔ IsOpenMap f ∧ IsOpenMap g
-- IsOpenMap.sum_elim
theorem IsOpenMap.sum_elim {f : X → Z} {g : Y → Z} (hf : IsOpenMap f) (hg : IsOpenMap g) :
    IsOpenMap (Sum.elim f g) 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {f : X → Z} {g : Y → Z} (hf : IsOpenMap f) (hg : IsOpenMap g)
Goal: IsOpenMap (Sum.elim f g)
-- isClosedMap_sum
theorem isClosedMap_sum {f : X ⊕ Y → Z} :
    IsClosedMap f ↔ (IsClosedMap fun a => f (.inl a)) ∧ IsClosedMap fun b => f (.inr b) 
Arguments: {X : Type u} {Y : Type v} {Z : Type u_1} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] {f : X ⊕ Y → Z}
Goal: IsClosedMap f ↔ (IsClosedMap fun a => f (Sum.inl a)) ∧ IsClosedMap fun b => f (Sum.inr b)
-- inducing_subtype_val
theorem inducing_subtype_val {t : Set Y} : Inducing ((↑) : t → Y) 
Arguments: {Y : Type v} [TopologicalSpace Y] {t : Set Y}
Goal: Inducing Subtype.val
-- Inducing.of_codRestrict
theorem Inducing.of_codRestrict {f : X → Y} {t : Set Y} (ht : ∀ x, f x ∈ t)
    (h : Inducing (t.codRestrict f ht)) : Inducing f 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} {t : Set Y} (ht : ∀ (x : X), f x ∈ t) (h : Inducing (Set.codRestrict f t ht))
Goal: Inducing f
-- embedding_subtype_val
theorem embedding_subtype_val : Embedding ((↑) : Subtype p → X) 
Arguments: {X : Type u} [TopologicalSpace X] {p : X → Prop}
Goal: Embedding Subtype.val
-- closedEmbedding_subtype_val
theorem closedEmbedding_subtype_val (h : IsClosed { a | p a }) :
    ClosedEmbedding ((↑) : Subtype p → X) 
Arguments: {X : Type u} [TopologicalSpace X] {p : X → Prop} (h : IsClosed {a | p a})
Goal: ClosedEmbedding Subtype.val
-- continuous_subtype_val
@[continuity, fun_prop]
theorem continuous_subtype_val : Continuous (@Subtype.val X p) 
Arguments: {X : Type u} [TopologicalSpace X] {p : X → Prop}
Goal: Continuous Subtype.val
-- Continuous.subtype_val
theorem Continuous.subtype_val {f : Y → Subtype p} (hf : Continuous f) :
    Continuous fun x => (f x : X) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {p : X → Prop} {f : Y → Subtype p} (hf : Continuous f)
Goal: Continuous fun x => ↑(f x)
-- IsOpen.openEmbedding_subtype_val
theorem IsOpen.openEmbedding_subtype_val {s : Set X} (hs : IsOpen s) :
    OpenEmbedding ((↑) : s → X) 
Arguments: {X : Type u} [TopologicalSpace X] {s : Set X} (hs : IsOpen s)
Goal: OpenEmbedding Subtype.val
-- IsOpen.isOpenMap_subtype_val
theorem IsOpen.isOpenMap_subtype_val {s : Set X} (hs : IsOpen s) : IsOpenMap ((↑) : s → X) 
Arguments: {X : Type u} [TopologicalSpace X] {s : Set X} (hs : IsOpen s)
Goal: IsOpenMap Subtype.val
-- IsOpenMap.restrict
theorem IsOpenMap.restrict {f : X → Y} (hf : IsOpenMap f) {s : Set X} (hs : IsOpen s) :
    IsOpenMap (s.restrict f) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} (hf : IsOpenMap f) {s : Set X} (hs : IsOpen s)
Goal: IsOpenMap (s.restrict f)
-- IsClosed.closedEmbedding_subtype_val
nonrec theorem IsClosed.closedEmbedding_subtype_val {s : Set X} (hs : IsClosed s) :
    ClosedEmbedding ((↑) : s → X) 
Arguments: {X : Type u} [TopologicalSpace X] {s : Set X} (hs : IsClosed s)
Goal: ClosedEmbedding Subtype.val
-- IsClosed.isClosedMap_subtype_val
theorem IsClosed.isClosedMap_subtype_val {s : Set X} (hs : IsClosed s) :
    IsClosedMap ((↑) : s → X) 
Arguments: {X : Type u} [TopologicalSpace X] {s : Set X} (hs : IsClosed s)
Goal: IsClosedMap Subtype.val
-- Continuous.subtype_mk
@[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) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {p : X → Prop} {f : Y → X} (h : Continuous f) (hp : ∀ (x : Y), p (f x))
Goal: Continuous fun x => ⟨f x, ⋯⟩
-- Continuous.subtype_map
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) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {p : X → Prop} {f : X → Y} (h : Continuous f) {q : Y → Prop} (hpq : ∀ (x : X), p x → q (f x))
Goal: Continuous (Subtype.map f hpq)
-- continuous_inclusion
theorem continuous_inclusion {s t : Set X} (h : s ⊆ t) : Continuous (inclusion h) 
Arguments: {X : Type u} [TopologicalSpace X] {s t : Set X} (h : s ⊆ t)
Goal: Continuous (Set.inclusion h)
-- continuousAt_subtype_val
theorem continuousAt_subtype_val {p : X → Prop} {x : Subtype p} :
    ContinuousAt ((↑) : Subtype p → X) x 
Arguments: {X : Type u} [TopologicalSpace X] {p : X → Prop} {x : Subtype p}
Goal: ContinuousAt Subtype.val x
-- Subtype.dense_iff
theorem Subtype.dense_iff {s : Set X} {t : Set s} : Dense t ↔ s ⊆ closure ((↑) '' t) 
Arguments: {X : Type u} [TopologicalSpace X] {s : Set X} {t : Set ↑s}
Goal: Dense t ↔ s ⊆ closure (Subtype.val '' t)
-- map_nhds_subtype_val
theorem map_nhds_subtype_val {s : Set X} (x : s) : map ((↑) : s → X) (𝓝 x) = 𝓝[s] ↑x 
Arguments: {X : Type u} [TopologicalSpace X] {s : Set X} (x : ↑s)
Goal: Filter.map Subtype.val (𝓝 x) = 𝓝[s] ↑x
-- map_nhds_subtype_coe_eq_nhds
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 
Arguments: {X : Type u} [TopologicalSpace X] {p : X → Prop} {x : X} (hx : p x) (h : ∀ᶠ (x : X) in 𝓝 x, p x)
Goal: Filter.map Subtype.val (𝓝 ⟨x, hx⟩) = 𝓝 x
-- nhds_subtype_eq_comap
theorem nhds_subtype_eq_comap {x : X} {h : p x} : 𝓝 (⟨x, h⟩ : Subtype p) = comap (↑) (𝓝 x) 
Arguments: {X : Type u} [TopologicalSpace X] {p : X → Prop} {x : X} {h : p x}
Goal: 𝓝 ⟨x, h⟩ = Filter.comap Subtype.val (𝓝 x)
-- tendsto_subtype_rng
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))
  
Arguments: {X : Type u} [TopologicalSpace X] {Y : Type u_5} {p : X → Prop} {l : Filter Y} {f : Y → Subtype p} {x : Subtype p}
Goal: Filter.Tendsto f l (𝓝 x) ↔ Filter.Tendsto (fun x => ↑(f x)) l (𝓝 ↑x)
-- closure_subtype
theorem closure_subtype {x : { a // p a }} {s : Set { a // p a }} :
    x ∈ closure s ↔ (x : X) ∈ closure (((↑) : _ → X) '' s) 
Arguments: {X : Type u} [TopologicalSpace X] {p : X → Prop} {x : { a // p a }} {s : Set { a // p a }}
Goal: x ∈ closure s ↔ ↑x ∈ closure (Subtype.val '' s)
-- continuousAt_codRestrict_iff
@[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 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} {t : Set Y} (h1 : ∀ (x : X), f x ∈ t) {x : X}
Goal: ContinuousAt (Set.codRestrict f t h1) x ↔ ContinuousAt f x
-- ContinuousAt.restrict
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 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} {s : Set X} {t : Set Y} (h1 : Set.MapsTo f s t) {x : ↑s} (h2 : ContinuousAt f ↑x)
Goal: ContinuousAt (Set.MapsTo.restrict f s t h1) x
-- ContinuousAt.restrictPreimage
theorem ContinuousAt.restrictPreimage {f : X → Y} {s : Set Y} {x : f ⁻¹' s} (h : ContinuousAt f x) :
    ContinuousAt (s.restrictPreimage f) x 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} {s : Set Y} {x : ↑(f ⁻¹' s)} (h : ContinuousAt f ↑x)
Goal: ContinuousAt (s.restrictPreimage f) x
-- Continuous.codRestrict
@[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) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} {s : Set Y} (hf : Continuous f) (hs : ∀ (a : X), f a ∈ s)
Goal: Continuous (Set.codRestrict f s hs)
-- Continuous.restrict
@[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) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} {s : Set X} {t : Set Y} (h1 : Set.MapsTo f s t) (h2 : Continuous f)
Goal: Continuous (Set.MapsTo.restrict f s t h1)
-- Continuous.restrictPreimage
@[continuity, fun_prop]
theorem Continuous.restrictPreimage {f : X → Y} {s : Set Y} (h : Continuous f) :
    Continuous (s.restrictPreimage f) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} {s : Set Y} (h : Continuous f)
Goal: Continuous (s.restrictPreimage f)
-- Inducing.codRestrict
theorem Inducing.codRestrict {e : X → Y} (he : Inducing e) {s : Set Y} (hs : ∀ x, e x ∈ s) :
    Inducing (codRestrict e s hs) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {e : X → Y} (he : Inducing e) {s : Set Y} (hs : ∀ (x : X), e x ∈ s)
Goal: Inducing (Set.codRestrict e s hs)
-- Embedding.codRestrict
theorem Embedding.codRestrict {e : X → Y} (he : Embedding e) (s : Set Y) (hs : ∀ x, e x ∈ s) :
    Embedding (codRestrict e s hs) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {e : X → Y} (he : Embedding e) (s : Set Y) (hs : ∀ (x : X), e x ∈ s)
Goal: Embedding (Set.codRestrict e s hs)
-- embedding_inclusion
theorem embedding_inclusion {s t : Set X} (h : s ⊆ t) : Embedding (inclusion h) 
Arguments: {X : Type u} [TopologicalSpace X] {s t : Set X} (h : s ⊆ t)
Goal: Embedding (Set.inclusion h)
-- DiscreteTopology.of_subset
theorem DiscreteTopology.of_subset {X : Type*} [TopologicalSpace X] {s t : Set X}
    (_ : DiscreteTopology s) (ts : t ⊆ s) : DiscreteTopology t 
Arguments: {X : Type u_5} [TopologicalSpace X] {s t : Set X}
Goal: DiscreteTopology ↑s → t ⊆ s → DiscreteTopology ↑t
-- DiscreteTopology.preimage_of_continuous_injective
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) 
Arguments: {X : Type u_5} {Y : Type u_6} [TopologicalSpace X] [TopologicalSpace Y] (s : Set Y) [DiscreteTopology ↑s] {f : X → Y} (hc : Continuous f) (hinj : Function.Injective f)
Goal: DiscreteTopology ↑(f ⁻¹' s)
-- QuotientMap.restrictPreimage_isOpen
theorem QuotientMap.restrictPreimage_isOpen {f : X → Y} (hf : QuotientMap f)
    {s : Set Y} (hs : IsOpen s) : QuotientMap (s.restrictPreimage f) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {f : X → Y} (hf : QuotientMap f) {s : Set Y} (hs : IsOpen s)
Goal: QuotientMap (s.restrictPreimage f)
-- isClosed_preimage_val
lemma isClosed_preimage_val {s t : Set X} : IsClosed (s ↓∩ t) ↔ s ∩ closure (s ∩ t) ⊆ t 
Arguments: {X : Type u} [TopologicalSpace X] {s t : Set X}
Goal: IsClosed (Subtype.val ⁻¹' t) ↔ s ∩ closure (s ∩ t) ⊆ t
-- quotientMap_quot_mk
theorem quotientMap_quot_mk : QuotientMap (@Quot.mk X r) 
Arguments: {X : Type u} [TopologicalSpace X] {r : X → X → Prop}
Goal: QuotientMap (Quot.mk r)
-- continuous_quot_mk
@[continuity, fun_prop]
theorem continuous_quot_mk : Continuous (@Quot.mk X r) 
Arguments: {X : Type u} [TopologicalSpace X] {r : X → X → Prop}
Goal: Continuous (Quot.mk r)
-- continuous_quot_lift
@[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) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {r : X → X → Prop} {f : X → Y} (hr : ∀ (a b : X), r a b → f a = f b) (h : Continuous f)
Goal: Continuous (Quot.lift f hr)
-- quotientMap_quotient_mk'
theorem quotientMap_quotient_mk' : QuotientMap (@Quotient.mk' X s) 
Arguments: {X : Type u} [TopologicalSpace X] {s : Setoid X}
Goal: QuotientMap Quotient.mk'
-- continuous_quotient_mk'
theorem continuous_quotient_mk' : Continuous (@Quotient.mk' X s) 
Arguments: {X : Type u} [TopologicalSpace X] {s : Setoid X}
Goal: Continuous Quotient.mk'
-- Continuous.quotient_lift
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) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {s : Setoid X} {f : X → Y} (h : Continuous f) (hs : ∀ (a b : X), a ≈ b → f a = f b)
Goal: Continuous (Quotient.lift f hs)
-- Continuous.quotient_liftOn'
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) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {s : Setoid X} {f : X → Y} (h : Continuous f) (hs : ∀ (a b : X), Setoid.r a b → f a = f b)
Goal: Continuous fun x => x.liftOn' f hs
-- Continuous.quotient_map'
@[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) 
Arguments: {X : Type u} {Y : Type v} [TopologicalSpace X] [TopologicalSpace Y] {s : Setoid X} {t : Setoid Y} {f : X → Y} (hf : Continuous f) (H : (Setoid.r ⇒ Setoid.r) f f)
Goal: Continuous (Quotient.map' f H)
-- continuous_pi_iff
theorem continuous_pi_iff : Continuous f ↔ ∀ i, Continuous fun a => f a i 
Arguments: {X : Type u} {ι : Type u_5} {π : ι → Type u_6} [TopologicalSpace X] [T : (i : ι) → TopologicalSpace (π i)] {f : X → (i : ι) → π i}
Goal: Continuous f ↔ ∀ (i : ι), Continuous fun a => f a i
-- continuous_pi
@[continuity, fun_prop]
theorem continuous_pi (h : ∀ i, Continuous fun a => f a i) : Continuous f 
Arguments: {X : Type u} {ι : Type u_5} {π : ι → Type u_6} [TopologicalSpace X] [T : (i : ι) → TopologicalSpace (π i)] {f : X → (i : ι) → π i} (h : ∀ (i : ι), Continuous fun a => f a i)
Goal: Continuous f
-- continuous_apply
@[continuity, fun_prop]
theorem continuous_apply (i : ι) : Continuous fun p : ∀ i, π i => p i 
Arguments: {ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] (i : ι)
Goal: Continuous fun p => p i
-- continuous_apply_apply
@[continuity]
theorem continuous_apply_apply {ρ : κ → ι → Type*} [∀ j i, TopologicalSpace (ρ j i)] (j : κ)
    (i : ι) : Continuous fun p : ∀ j, ∀ i, ρ j i => p j i 
Arguments: {ι : Type u_5} {κ : Type u_7} {ρ : κ → ι → Type u_8} [(j : κ) → (i : ι) → TopologicalSpace (ρ j i)] (j : κ) (i : ι)
Goal: Continuous fun p => p j i
-- continuousAt_apply
theorem continuousAt_apply (i : ι) (x : ∀ i, π i) : ContinuousAt (fun p : ∀ i, π i => p i) x 
Arguments: {ι : Type u_5} {π : ι → Type u_6} [T : (i : ι) → TopologicalSpace (π i)] (i : ι) (x : (i : ι) → π i)
Goal: ContinuousAt (fun p => p i) x