File: Mathlib/Topology/DenseEmbedding.lean

full_name: DenseInducing.dense
code: /-- `i : α → β` is "dense inducing" if it has dense range and the topology on `α`
  is the one induced by `i` from the topology on `β`. -/
structure DenseInducing [TopologicalSpace α] [TopologicalSpace β] (i : α → β)
    extends Inducing i : Prop where
  /-- The range of a dense inducing map is a dense set. -/
  protected dense : DenseRange i
goal: DenseRange i

full_name: DenseInducing
code: /-- `i : α → β` is "dense inducing" if it has dense range and the topology on `α`
  is the one induced by `i` from the topology on `β`. -/
structure DenseInducing [TopologicalSpace α] [TopologicalSpace β] (i : α → β)
    extends Inducing i : Prop where
  /-- The range of a dense inducing map is a dense set. -/
  protected dense : DenseRange i
goal: Prop

full_name: DenseInducing.nhds_eq_comap
code: theorem nhds_eq_comap (di : DenseInducing i) : ∀ a : α, 𝓝 a = comap i (𝓝 <| i a) 
goal: 𝓝 a = Filter.comap i (𝓝 (i a))

full_name: DenseInducing.continuous
code: protected theorem continuous (di : DenseInducing i) : Continuous i 
goal: Continuous i

full_name: DenseInducing.closure_range
code: theorem closure_range : closure (range i) = univ 
goal: closure (Set.range i) = Set.univ

full_name: DenseInducing.preconnectedSpace
code: protected theorem preconnectedSpace [PreconnectedSpace α] (di : DenseInducing i) :
    PreconnectedSpace β 
goal: PreconnectedSpace β

full_name: DenseInducing.closure_image_mem_nhds
code: theorem closure_image_mem_nhds {s : Set α} {a : α} (di : DenseInducing i) (hs : s ∈ 𝓝 a) :
    closure (i '' s) ∈ 𝓝 (i a) 
goal: closure (i '' s) ∈ 𝓝 (i a)

full_name: DenseInducing.dense_image
code: theorem dense_image (di : DenseInducing i) {s : Set α} : Dense (i '' s) ↔ Dense s 
goal: Dense (i '' s) ↔ Dense s

full_name: DenseInducing.interior_compact_eq_empty
code: /-- If `i : α → β` is a dense embedding with dense complement of the range, then any compact set in
`α` has empty interior. -/
theorem interior_compact_eq_empty [T2Space β] (di : DenseInducing i) (hd : Dense (range i)ᶜ)
    {s : Set α} (hs : IsCompact s) : interior s = ∅ 
goal: interior s = ∅

full_name: DenseInducing.prod
code: /-- The product of two dense inducings is a dense inducing -/
protected theorem prod [TopologicalSpace γ] [TopologicalSpace δ] {e₁ : α → β} {e₂ : γ → δ}
    (de₁ : DenseInducing e₁) (de₂ : DenseInducing e₂) :
    DenseInducing fun p : α × γ => (e₁ p.1, e₂ p.2) 
goal: DenseInducing fun p => (e₁ p.1, e₂ p.2)

full_name: DenseInducing.separableSpace
code: /-- If the domain of a `DenseInducing` map is a separable space, then so is the codomain. -/
protected theorem separableSpace [SeparableSpace α] : SeparableSpace β 
goal: TopologicalSpace.SeparableSpace β

full_name: DenseInducing.tendsto_comap_nhds_nhds
code: /--
```
 γ -f→ α
g↓     ↓e
 δ -h→ β
```
-/
theorem tendsto_comap_nhds_nhds {d : δ} {a : α} (di : DenseInducing i)
    (H : Tendsto h (𝓝 d) (𝓝 (i a))) (comm : h ∘ g = i ∘ f) : Tendsto f (comap g (𝓝 d)) (𝓝 a) 
goal: Filter.Tendsto f (Filter.comap g (𝓝 d)) (𝓝 a)

full_name: DenseInducing.nhdsWithin_neBot
code: protected theorem nhdsWithin_neBot (di : DenseInducing i) (b : β) : NeBot (𝓝[range i] b) 
goal: (𝓝[Set.range i] b).NeBot

full_name: DenseInducing.comap_nhds_neBot
code: theorem comap_nhds_neBot (di : DenseInducing i) (b : β) : NeBot (comap i (𝓝 b)) 
goal: (Filter.comap i (𝓝 b)).NeBot

full_name: DenseInducing.extend
code: /-- If `i : α → β` is a dense inducing, then any function `f : α → γ` "extends" to a function `g =
  DenseInducing.extend di f : β → γ`. If `γ` is Hausdorff and `f` has a continuous extension, then
  `g` is the unique such extension. In general, `g` might not be continuous or even extend `f`. -/
def extend (di : DenseInducing i) (f : α → γ) (b : β) : γ 
goal: γ

full_name: DenseInducing.extend_eq_of_tendsto
code: theorem extend_eq_of_tendsto [T2Space γ] {b : β} {c : γ} {f : α → γ}
    (hf : Tendsto f (comap i (𝓝 b)) (𝓝 c)) : di.extend f b = c 
goal: di.extend f b = c

full_name: DenseInducing.extend_eq_at
code: theorem extend_eq_at [T2Space γ] {f : α → γ} {a : α} (hf : ContinuousAt f a) :
    di.extend f (i a) = f a 
goal: di.extend f (i a) = f a

full_name: DenseInducing.extend_eq_at'
code: theorem extend_eq_at' [T2Space γ] {f : α → γ} {a : α} (c : γ) (hf : Tendsto f (𝓝 a) (𝓝 c)) :
    di.extend f (i a) = f a 
goal: di.extend f (i a) = f a

full_name: DenseInducing.extend_eq
code: theorem extend_eq [T2Space γ] {f : α → γ} (hf : Continuous f) (a : α) : di.extend f (i a) = f a 
goal: di.extend f (i a) = f a

full_name: DenseInducing.extend_eq'
code: /-- Variation of `extend_eq` where we ask that `f` has a limit along `comap i (𝓝 b)` for each
`b : β`. This is a strictly stronger assumption than continuity of `f`, but in a lot of cases
you'd have to prove it anyway to use `continuous_extend`, so this avoids doing the work twice. -/
theorem extend_eq' [T2Space γ] {f : α → γ} (di : DenseInducing i)
    (hf : ∀ b, ∃ c, Tendsto f (comap i (𝓝 b)) (𝓝 c)) (a : α) : di.extend f (i a) = f a 
goal: di.extend f (i a) = f a

full_name: DenseInducing.extend_unique_at
code: theorem extend_unique_at [T2Space γ] {b : β} {f : α → γ} {g : β → γ} (di : DenseInducing i)
    (hf : ∀ᶠ x in comap i (𝓝 b), g (i x) = f x) (hg : ContinuousAt g b) : di.extend f b = g b 
goal: di.extend f b = g b

full_name: DenseInducing.extend_unique
code: theorem extend_unique [T2Space γ] {f : α → γ} {g : β → γ} (di : DenseInducing i)
    (hf : ∀ x, g (i x) = f x) (hg : Continuous g) : di.extend f = g 
goal: di.extend f = g

full_name: DenseInducing.continuousAt_extend
code: theorem continuousAt_extend [T3Space γ] {b : β} {f : α → γ} (di : DenseInducing i)
    (hf : ∀ᶠ x in 𝓝 b, ∃ c, Tendsto f (comap i <| 𝓝 x) (𝓝 c)) : ContinuousAt (di.extend f) b 
goal: ContinuousAt (di.extend f) b

full_name: DenseInducing.continuous_extend
code: theorem continuous_extend [T3Space γ] {f : α → γ} (di : DenseInducing i)
    (hf : ∀ b, ∃ c, Tendsto f (comap i (𝓝 b)) (𝓝 c)) : Continuous (di.extend f) 
goal: Continuous (di.extend f)

full_name: DenseInducing.mk'
code: theorem mk' (i : α → β) (c : Continuous i) (dense : ∀ x, x ∈ closure (range i))
    (H : ∀ (a : α), ∀ s ∈ 𝓝 a, ∃ t ∈ 𝓝 (i a), ∀ b, i b ∈ t → b ∈ s) : DenseInducing i 
goal: DenseInducing i

full_name: DenseEmbedding
code: /-- A dense embedding is an embedding with dense image. -/
structure DenseEmbedding [TopologicalSpace α] [TopologicalSpace β] (e : α → β) extends
  DenseInducing e : Prop where
  /-- A dense embedding is injective. -/
  inj : Function.Injective e
goal: Prop

full_name: DenseEmbedding.inj
code: /-- A dense embedding is an embedding with dense image. -/
structure DenseEmbedding [TopologicalSpace α] [TopologicalSpace β] (e : α → β) extends
  DenseInducing e : Prop where
  /-- A dense embedding is injective. -/
  inj : Function.Injective e
goal: Function.Injective e

full_name: DenseEmbedding.mk'
code: theorem DenseEmbedding.mk' [TopologicalSpace α] [TopologicalSpace β] (e : α → β) (c : Continuous e)
    (dense : DenseRange e) (inj : Function.Injective e)
    (H : ∀ (a : α), ∀ s ∈ 𝓝 a, ∃ t ∈ 𝓝 (e a), ∀ b, e b ∈ t → b ∈ s) : DenseEmbedding e 
goal: DenseEmbedding e

full_name: DenseEmbedding.inj_iff
code: theorem inj_iff {x y} : e x = e y ↔ x = y 
goal: e x = e y ↔ x = y

full_name: DenseEmbedding.to_embedding
code: theorem to_embedding : Embedding e 
goal: Embedding e

full_name: DenseEmbedding.separableSpace
code: /-- If the domain of a `DenseEmbedding` is a separable space, then so is its codomain. -/
protected theorem separableSpace [SeparableSpace α] : SeparableSpace β 
goal: TopologicalSpace.SeparableSpace β

full_name: DenseEmbedding.prod
code: /-- The product of two dense embeddings is a dense embedding. -/
protected theorem prod {e₁ : α → β} {e₂ : γ → δ} (de₁ : DenseEmbedding e₁)
    (de₂ : DenseEmbedding e₂) : DenseEmbedding fun p : α × γ => (e₁ p.1, e₂ p.2) 
goal: DenseEmbedding fun p => (e₁ p.1, e₂ p.2)

full_name: DenseEmbedding.subtypeEmb
code: /-- The dense embedding of a subtype inside its closure. -/
@[simps]
def subtypeEmb {α : Type*} (p : α → Prop) (e : α → β) (x : { x // p x }) :
    { x // x ∈ closure (e '' { x | p x }) } 
goal: { x // x ∈ closure (e '' {x | p x}) }

full_name: DenseEmbedding.subtypeEmb_coe
code: /-- The dense embedding of a subtype inside its closure. -/
@[simps]
def subtypeEmb {α : Type*} (p : α → Prop) (e : α → β) (x : { x // p x }) :
    { x // x ∈ closure (e '' { x | p x }) } 
goal: ↑(DenseEmbedding.subtypeEmb p e x) = e ↑x

full_name: DenseEmbedding.subtype
code: protected theorem subtype (p : α → Prop) : DenseEmbedding (subtypeEmb p e) 
goal: DenseEmbedding (DenseEmbedding.subtypeEmb p e)

full_name: DenseEmbedding.dense_image
code: theorem dense_image {s : Set α} : Dense (e '' s) ↔ Dense s 
goal: Dense (e '' s) ↔ Dense s

full_name: denseEmbedding_id
code: theorem denseEmbedding_id {α : Type*} [TopologicalSpace α] : DenseEmbedding (id : α → α) 
goal: DenseEmbedding id

full_name: Dense.denseEmbedding_val
code: theorem Dense.denseEmbedding_val [TopologicalSpace α] {s : Set α} (hs : Dense s) :
    DenseEmbedding ((↑) : s → α) 
goal: DenseEmbedding Subtype.val

full_name: isClosed_property
code: theorem isClosed_property [TopologicalSpace β] {e : α → β} {p : β → Prop} (he : DenseRange e)
    (hp : IsClosed { x | p x }) (h : ∀ a, p (e a)) : ∀ b, p b 
goal: p b

full_name: isClosed_property2
code: theorem isClosed_property2 [TopologicalSpace β] {e : α → β} {p : β → β → Prop} (he : DenseRange e)
    (hp : IsClosed { q : β × β | p q.1 q.2 }) (h : ∀ a₁ a₂, p (e a₁) (e a₂)) : ∀ b₁ b₂, p b₁ b₂ 
goal: p b₁ b₂

full_name: isClosed_property3
code: theorem isClosed_property3 [TopologicalSpace β] {e : α → β} {p : β → β → β → Prop}
    (he : DenseRange e) (hp : IsClosed { q : β × β × β | p q.1 q.2.1 q.2.2 })
    (h : ∀ a₁ a₂ a₃, p (e a₁) (e a₂) (e a₃)) : ∀ b₁ b₂ b₃, p b₁ b₂ b₃ 
goal: p b₁ b₂ b₃

full_name: DenseRange.induction_on
code: @[elab_as_elim]
theorem DenseRange.induction_on [TopologicalSpace β] {e : α → β} (he : DenseRange e) {p : β → Prop}
    (b₀ : β) (hp : IsClosed { b | p b }) (ih : ∀ a : α, p <| e a) : p b₀ 
goal: p b₀

full_name: DenseRange.induction_on₂
code: @[elab_as_elim]
theorem DenseRange.induction_on₂ [TopologicalSpace β] {e : α → β} {p : β → β → Prop}
    (he : DenseRange e) (hp : IsClosed { q : β × β | p q.1 q.2 }) (h : ∀ a₁ a₂, p (e a₁) (e a₂))
    (b₁ b₂ : β) : p b₁ b₂ 
goal: p b₁ b₂

full_name: DenseRange.induction_on₃
code: @[elab_as_elim]
theorem DenseRange.induction_on₃ [TopologicalSpace β] {e : α → β} {p : β → β → β → Prop}
    (he : DenseRange e) (hp : IsClosed { q : β × β × β | p q.1 q.2.1 q.2.2 })
    (h : ∀ a₁ a₂ a₃, p (e a₁) (e a₂) (e a₃)) (b₁ b₂ b₃ : β) : p b₁ b₂ b₃ 
goal: p b₁ b₂ b₃

full_name: DenseRange.equalizer
code: /-- Two continuous functions to a t2-space that agree on the dense range of a function are equal. -/
theorem DenseRange.equalizer (hfd : DenseRange f) {g h : β → γ} (hg : Continuous g)
    (hh : Continuous h) (H : g ∘ f = h ∘ f) : g = h 
goal: g = h

full_name: Filter.HasBasis.hasBasis_of_denseInducing
code: theorem Filter.HasBasis.hasBasis_of_denseInducing [TopologicalSpace α] [TopologicalSpace β]
    [T3Space β] {ι : Type*} {s : ι → Set α} {p : ι → Prop} {x : α} (h : (𝓝 x).HasBasis p s)
    {f : α → β} (hf : DenseInducing f) : (𝓝 (f x)).HasBasis p fun i => closure <| f '' s i 
goal: (𝓝 (f x)).HasBasis p fun i => closure (f '' s i)