File: Mathlib/Topology/Sequences.lean

full_name: subset_seqClosure
code: theorem subset_seqClosure {s : Set X} : s ⊆ seqClosure s 
goal: s ⊆ seqClosure s

full_name: seqClosure_subset_closure
code: /-- The sequential closure of a set is contained in the closure of that set.
The converse is not true. -/
theorem seqClosure_subset_closure {s : Set X} : seqClosure s ⊆ closure s 
goal: seqClosure s ⊆ closure s

full_name: IsSeqClosed.seqClosure_eq
code: /-- The sequential closure of a sequentially closed set is the set itself. -/
theorem IsSeqClosed.seqClosure_eq {s : Set X} (hs : IsSeqClosed s) : seqClosure s = s 
goal: seqClosure s = s

full_name: isSeqClosed_of_seqClosure_eq
code: /-- If a set is equal to its sequential closure, then it is sequentially closed. -/
theorem isSeqClosed_of_seqClosure_eq {s : Set X} (hs : seqClosure s = s) : IsSeqClosed s 
goal: IsSeqClosed s

full_name: isSeqClosed_iff
code: /-- A set is sequentially closed iff it is equal to its sequential closure. -/
theorem isSeqClosed_iff {s : Set X} : IsSeqClosed s ↔ seqClosure s = s 
goal: IsSeqClosed s ↔ seqClosure s = s

full_name: IsClosed.isSeqClosed
code: /-- A set is sequentially closed if it is closed. -/
protected theorem IsClosed.isSeqClosed {s : Set X} (hc : IsClosed s) : IsSeqClosed s 
goal: IsSeqClosed s

full_name: seqClosure_eq_closure
code: theorem seqClosure_eq_closure [FrechetUrysohnSpace X] (s : Set X) : seqClosure s = closure s 
goal: seqClosure s = closure s

full_name: mem_closure_iff_seq_limit
code: /-- In a Fréchet-Urysohn space, a point belongs to the closure of a set iff it is a limit
of a sequence taking values in this set. -/
theorem mem_closure_iff_seq_limit [FrechetUrysohnSpace X] {s : Set X} {a : X} :
    a ∈ closure s ↔ ∃ x : ℕ → X, (∀ n : ℕ, x n ∈ s) ∧ Tendsto x atTop (𝓝 a) 
goal: a ∈ closure s ↔ ∃ x, (∀ (n : ℕ), x n ∈ s) ∧ Filter.Tendsto x Filter.atTop (𝓝 a)

full_name: tendsto_nhds_iff_seq_tendsto
code: /-- If the domain of a function `f : α → β` is a Fréchet-Urysohn space, then convergence
is equivalent to sequential convergence. See also `Filter.tendsto_iff_seq_tendsto` for a version
that works for any pair of filters assuming that the filter in the domain is countably generated.

This property is equivalent to the definition of `FrechetUrysohnSpace`, see
`FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto`. -/
theorem tendsto_nhds_iff_seq_tendsto [FrechetUrysohnSpace X] {f : X → Y} {a : X} {b : Y} :
    Tendsto f (𝓝 a) (𝓝 b) ↔ ∀ u : ℕ → X, Tendsto u atTop (𝓝 a) → Tendsto (f ∘ u) atTop (𝓝 b) 
goal: Filter.Tendsto f (𝓝 a) (𝓝 b) ↔
  ∀ (u : ℕ → X), Filter.Tendsto u Filter.atTop (𝓝 a) → Filter.Tendsto (f ∘ u) Filter.atTop (𝓝 b)

full_name: FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
code: /-- An alternative construction for `FrechetUrysohnSpace`: if sequential convergence implies
convergence, then the space is a Fréchet-Urysohn space. -/
theorem FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto
    (h : ∀ (f : X → Prop) (a : X),
      (∀ u : ℕ → X, Tendsto u atTop (𝓝 a) → Tendsto (f ∘ u) atTop (𝓝 (f a))) → ContinuousAt f a) :
    FrechetUrysohnSpace X 
goal: FrechetUrysohnSpace X

full_name: FirstCountableTopology.frechetUrysohnSpace
code: /-- Every first-countable space is a Fréchet-Urysohn space. -/
instance (priority := 100) FirstCountableTopology.frechetUrysohnSpace
    [FirstCountableTopology X] : FrechetUrysohnSpace X 
goal: FrechetUrysohnSpace X

full_name: FrechetUrysohnSpace.to_sequentialSpace
code: /-- Every Fréchet-Urysohn space is a sequential space. -/
instance (priority := 100) FrechetUrysohnSpace.to_sequentialSpace [FrechetUrysohnSpace X] :
    SequentialSpace X 
goal: SequentialSpace X

full_name: Inducing.frechetUrysohnSpace
code: theorem Inducing.frechetUrysohnSpace [FrechetUrysohnSpace Y] {f : X → Y} (hf : Inducing f) :
    FrechetUrysohnSpace X 
goal: FrechetUrysohnSpace X

full_name: Subtype.instFrechetUrysohnSpace
code: /-- Subtype of a Fréchet-Urysohn space is a Fréchet-Urysohn space. -/
instance Subtype.instFrechetUrysohnSpace [FrechetUrysohnSpace X] {p : X → Prop} :
    FrechetUrysohnSpace (Subtype p) 
goal: FrechetUrysohnSpace (Subtype p)

full_name: isSeqClosed_iff_isClosed
code: /-- In a sequential space, a set is closed iff it's sequentially closed. -/
theorem isSeqClosed_iff_isClosed [SequentialSpace X] {M : Set X} : IsSeqClosed M ↔ IsClosed M 
goal: IsSeqClosed M ↔ IsClosed M

full_name: IsSeqClosed.preimage
code: /-- The preimage of a sequentially closed set under a sequentially continuous map is sequentially
closed. -/
theorem IsSeqClosed.preimage {f : X → Y} {s : Set Y} (hs : IsSeqClosed s) (hf : SeqContinuous f) :
    IsSeqClosed (f ⁻¹' s) 
goal: IsSeqClosed (f ⁻¹' s)

full_name: Continuous.seqContinuous
code: protected theorem Continuous.seqContinuous {f : X → Y} (hf : Continuous f) : SeqContinuous f 
goal: SeqContinuous f

full_name: SeqContinuous.continuous
code: /-- A sequentially continuous function defined on a sequential space is continuous. -/
protected theorem SeqContinuous.continuous [SequentialSpace X] {f : X → Y} (hf : SeqContinuous f) :
    Continuous f 
goal: Continuous f

full_name: continuous_iff_seqContinuous
code: /-- If the domain of a function is a sequential space, then continuity of this function is
equivalent to its sequential continuity. -/
theorem continuous_iff_seqContinuous [SequentialSpace X] {f : X → Y} :
    Continuous f ↔ SeqContinuous f 
goal: Continuous f ↔ SeqContinuous f

full_name: SequentialSpace.coinduced
code: theorem SequentialSpace.coinduced [SequentialSpace X] (f : X → Y) :
    @SequentialSpace Y (.coinduced f ‹_›) 
goal: SequentialSpace Y

full_name: SequentialSpace.iSup
code: protected theorem SequentialSpace.iSup {ι : Sort*} {t : ι → TopologicalSpace X}
    (h : ∀ i, @SequentialSpace X (t i)) : @SequentialSpace X (⨆ i, t i) 
goal: SequentialSpace X

full_name: SequentialSpace.sup
code: protected theorem SequentialSpace.sup {t₁ t₂ : TopologicalSpace X}
    (h₁ : @SequentialSpace X t₁) (h₂ : @SequentialSpace X t₂) :
    @SequentialSpace X (t₁ ⊔ t₂) 
goal: SequentialSpace X

full_name: QuotientMap.sequentialSpace
code: theorem QuotientMap.sequentialSpace [SequentialSpace X] {f : X → Y} (hf : QuotientMap f) :
    SequentialSpace Y 
goal: SequentialSpace Y

full_name: Quotient.instSequentialSpace
code: /-- The quotient of a sequential space is a sequential space. -/
instance Quotient.instSequentialSpace [SequentialSpace X] {s : Setoid X} :
    SequentialSpace (Quotient s) 
goal: SequentialSpace (Quotient s)

full_name: Sum.instSequentialSpace
code: /-- The sum (disjoint union) of two sequential spaces is a sequential space. -/
instance Sum.instSequentialSpace [SequentialSpace X] [SequentialSpace Y] :
    SequentialSpace (X ⊕ Y) 
goal: SequentialSpace (X ⊕ Y)

full_name: Sigma.instSequentialSpace
code: /-- The disjoint union of an indexed family of sequential spaces is a sequential space. -/
instance Sigma.instSequentialSpace {ι : Type*} {X : ι → Type*}
    [∀ i, TopologicalSpace (X i)] [∀ i, SequentialSpace (X i)] : SequentialSpace (Σ i, X i) 
goal: SequentialSpace ((i : ι) × X i)

full_name: IsSeqCompact.subseq_of_frequently_in
code: theorem IsSeqCompact.subseq_of_frequently_in {s : Set X} (hs : IsSeqCompact s) {x : ℕ → X}
    (hx : ∃ᶠ n in atTop, x n ∈ s) :
    ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) 
goal: ∃ a ∈ s, ∃ φ, StrictMono φ ∧ Filter.Tendsto (x ∘ φ) Filter.atTop (𝓝 a)

full_name: SeqCompactSpace.tendsto_subseq
code: theorem SeqCompactSpace.tendsto_subseq [SeqCompactSpace X] (x : ℕ → X) :
    ∃ (a : X) (φ : ℕ → ℕ), StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) 
goal: ∃ a φ, StrictMono φ ∧ Filter.Tendsto (x ∘ φ) Filter.atTop (𝓝 a)

full_name: IsCompact.isSeqCompact
code: protected theorem IsCompact.isSeqCompact {s : Set X} (hs : IsCompact s) : IsSeqCompact s 
goal: IsSeqCompact s

full_name: IsCompact.tendsto_subseq'
code: theorem IsCompact.tendsto_subseq' {s : Set X} {x : ℕ → X} (hs : IsCompact s)
    (hx : ∃ᶠ n in atTop, x n ∈ s) :
    ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) 
goal: ∃ a ∈ s, ∃ φ, StrictMono φ ∧ Filter.Tendsto (x ∘ φ) Filter.atTop (𝓝 a)

full_name: IsCompact.tendsto_subseq
code: theorem IsCompact.tendsto_subseq {s : Set X} {x : ℕ → X} (hs : IsCompact s) (hx : ∀ n, x n ∈ s) :
    ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) 
goal: ∃ a ∈ s, ∃ φ, StrictMono φ ∧ Filter.Tendsto (x ∘ φ) Filter.atTop (𝓝 a)

full_name: FirstCountableTopology.seq_compact_of_compact
code: instance (priority := 100) FirstCountableTopology.seq_compact_of_compact [CompactSpace X] :
    SeqCompactSpace X 
goal: SeqCompactSpace X

full_name: CompactSpace.tendsto_subseq
code: theorem CompactSpace.tendsto_subseq [CompactSpace X] (x : ℕ → X) :
    ∃ (a : _) (φ : ℕ → ℕ), StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a) 
goal: ∃ a φ, StrictMono φ ∧ Filter.Tendsto (x ∘ φ) Filter.atTop (𝓝 a)

full_name: IsSeqCompact.image
code: /-- Sequential compactness of sets is preserved under sequentially continuous functions. -/
theorem IsSeqCompact.image (f_cont : SeqContinuous f) {K : Set X} (K_cpt : IsSeqCompact K) :
    IsSeqCompact (f '' K) 
goal: IsSeqCompact (f '' K)

full_name: IsSeqCompact.range
code: /-- The range of sequentially continuous function on a sequentially compact space is sequentially
compact. -/
theorem IsSeqCompact.range [SeqCompactSpace X] (f_cont : SeqContinuous f) :
    IsSeqCompact (Set.range f) 
goal: IsSeqCompact (Set.range f)

full_name: IsSeqCompact.exists_tendsto_of_frequently_mem
code: theorem IsSeqCompact.exists_tendsto_of_frequently_mem (hs : IsSeqCompact s) {u : ℕ → X}
    (hu : ∃ᶠ n in atTop, u n ∈ s) (huc : CauchySeq u) : ∃ x ∈ s, Tendsto u atTop (𝓝 x) 
goal: ∃ x ∈ s, Filter.Tendsto u Filter.atTop (𝓝 x)

full_name: IsSeqCompact.exists_tendsto
code: theorem IsSeqCompact.exists_tendsto (hs : IsSeqCompact s) {u : ℕ → X} (hu : ∀ n, u n ∈ s)
    (huc : CauchySeq u) : ∃ x ∈ s, Tendsto u atTop (𝓝 x) 
goal: ∃ x ∈ s, Filter.Tendsto u Filter.atTop (𝓝 x)

full_name: IsSeqCompact.totallyBounded
code: /-- A sequentially compact set in a uniform space is totally bounded. -/
protected theorem IsSeqCompact.totallyBounded (h : IsSeqCompact s) : TotallyBounded s 
goal: TotallyBounded s

full_name: IsSeqCompact.isComplete
code: /-- A sequentially compact set in a uniform set with countably generated uniformity filter
is complete. -/
protected theorem IsSeqCompact.isComplete (hs : IsSeqCompact s) : IsComplete s 
goal: IsComplete s

full_name: IsSeqCompact.isCompact
code: /-- If `𝓤 β` is countably generated, then any sequentially compact set is compact. -/
protected theorem IsSeqCompact.isCompact (hs : IsSeqCompact s) : IsCompact s 
goal: IsCompact s

full_name: UniformSpace.isCompact_iff_isSeqCompact
code: /-- A version of Bolzano-Weierstrass: in a uniform space with countably generated uniformity filter
(e.g., in a metric space), a set is compact if and only if it is sequentially compact. -/
protected theorem UniformSpace.isCompact_iff_isSeqCompact : IsCompact s ↔ IsSeqCompact s 
goal: IsCompact s ↔ IsSeqCompact s

full_name: UniformSpace.compactSpace_iff_seqCompactSpace
code: theorem UniformSpace.compactSpace_iff_seqCompactSpace : CompactSpace X ↔ SeqCompactSpace X 
goal: CompactSpace X ↔ SeqCompactSpace X