File: Mathlib/Topology/SeparatedMap.lean

full_name: embedding_toPullbackDiag
code: theorem embedding_toPullbackDiag (f : X → Y) : Embedding (toPullbackDiag f) 
goal: Embedding (toPullbackDiag f)

full_name: Continuous.mapPullback
code: lemma Continuous.mapPullback {X₁ X₂ Y₁ Y₂ Z₁ Z₂}
    [TopologicalSpace X₁] [TopologicalSpace X₂] [TopologicalSpace Z₁] [TopologicalSpace Z₂]
    {f₁ : X₁ → Y₁} {g₁ : Z₁ → Y₁} {f₂ : X₂ → Y₂} {g₂ : Z₂ → Y₂}
    {mapX : X₁ → X₂} (contX : Continuous mapX) {mapY : Y₁ → Y₂}
    {mapZ : Z₁ → Z₂} (contZ : Continuous mapZ)
    {commX : f₂ ∘ mapX = mapY ∘ f₁} {commZ : g₂ ∘ mapZ = mapY ∘ g₁} :
    Continuous (Function.mapPullback mapX mapY mapZ commX commZ) 
goal: Continuous (Function.mapPullback mapX mapY mapZ commX commZ)

full_name: IsSeparatedMap
code: /-- A function from a topological space `X` to a type `Y` is a separated map if any two distinct
  points in `X` with the same image in `Y` can be separated by open neighborhoods. -/
def IsSeparatedMap (f : X → Y) : Prop 
goal: Prop

full_name: t2space_iff_isSeparatedMap
code: lemma t2space_iff_isSeparatedMap (y : Y) : T2Space X ↔ IsSeparatedMap fun _ : X ↦ y 
goal: T2Space X ↔ IsSeparatedMap fun x => y

full_name: T2Space.isSeparatedMap
code: lemma T2Space.isSeparatedMap [T2Space X] (f : X → Y) : IsSeparatedMap f 
goal: IsSeparatedMap f

full_name: Function.Injective.isSeparatedMap
code: lemma Function.Injective.isSeparatedMap {f : X → Y} (inj : f.Injective) : IsSeparatedMap f 
goal: IsSeparatedMap f

full_name: isSeparatedMap_iff_disjoint_nhds
code: lemma isSeparatedMap_iff_disjoint_nhds {f : X → Y} : IsSeparatedMap f ↔
    ∀ x₁ x₂, f x₁ = f x₂ → x₁ ≠ x₂ → Disjoint (𝓝 x₁) (𝓝 x₂) 
goal: IsSeparatedMap f ↔ ∀ (x₁ x₂ : X), f x₁ = f x₂ → x₁ ≠ x₂ → Disjoint (𝓝 x₁) (𝓝 x₂)

full_name: isSeparatedMap_iff_nhds
code: lemma isSeparatedMap_iff_nhds {f : X → Y} : IsSeparatedMap f ↔
    ∀ x₁ x₂, f x₁ = f x₂ → x₁ ≠ x₂ → ∃ s₁ ∈ 𝓝 x₁, ∃ s₂ ∈ 𝓝 x₂, Disjoint s₁ s₂ 
goal: IsSeparatedMap f ↔ ∀ (x₁ x₂ : X), f x₁ = f x₂ → x₁ ≠ x₂ → ∃ s₁ ∈ 𝓝 x₁, ∃ s₂ ∈ 𝓝 x₂, Disjoint s₁ s₂

full_name: isSeparatedMap_iff_isClosed_diagonal
code: theorem isSeparatedMap_iff_isClosed_diagonal {f : X → Y} :
    IsSeparatedMap f ↔ IsClosed f.pullbackDiagonal 
goal: IsSeparatedMap f ↔ IsClosed (Function.pullbackDiagonal f)

full_name: isSeparatedMap_iff_closedEmbedding
code: theorem isSeparatedMap_iff_closedEmbedding {f : X → Y} :
    IsSeparatedMap f ↔ ClosedEmbedding (toPullbackDiag f) 
goal: IsSeparatedMap f ↔ ClosedEmbedding (toPullbackDiag f)

full_name: isSeparatedMap_iff_isClosedMap
code: theorem isSeparatedMap_iff_isClosedMap {f : X → Y} :
    IsSeparatedMap f ↔ IsClosedMap (toPullbackDiag f) 
goal: IsSeparatedMap f ↔ IsClosedMap (toPullbackDiag f)

full_name: IsSeparatedMap.pullback
code: theorem IsSeparatedMap.pullback {f : X → Y} (sep : IsSeparatedMap f) (g : A → Y) :
    IsSeparatedMap (@snd X Y A f g) 
goal: IsSeparatedMap Function.Pullback.snd

full_name: IsSeparatedMap.comp_left
code: theorem IsSeparatedMap.comp_left {f : X → Y} (sep : IsSeparatedMap f) {g : Y → A}
    (inj : g.Injective) : IsSeparatedMap (g ∘ f) 
goal: IsSeparatedMap (g ∘ f)

full_name: IsSeparatedMap.comp_right
code: theorem IsSeparatedMap.comp_right {f : X → Y} (sep : IsSeparatedMap f) {g : A → X}
    (cont : Continuous g) (inj : g.Injective) : IsSeparatedMap (f ∘ g) 
goal: IsSeparatedMap (f ∘ g)

full_name: IsLocallyInjective
code: /-- A function from a topological space `X` is locally injective if every point of `X`
  has a neighborhood on which `f` is injective. -/
def IsLocallyInjective (f : X → Y) : Prop 
goal: Prop

full_name: Function.Injective.IsLocallyInjective
code: lemma Function.Injective.IsLocallyInjective {f : X → Y} (inj : f.Injective) :
    IsLocallyInjective f 
goal: IsLocallyInjective f

full_name: isLocallyInjective_iff_nhds
code: lemma isLocallyInjective_iff_nhds {f : X → Y} :
    IsLocallyInjective f ↔ ∀ x : X, ∃ U ∈ 𝓝 x, U.InjOn f 
goal: IsLocallyInjective f ↔ ∀ (x : X), ∃ U ∈ 𝓝 x, Set.InjOn f U

full_name: isLocallyInjective_iff_isOpen_diagonal
code: theorem isLocallyInjective_iff_isOpen_diagonal {f : X → Y} :
    IsLocallyInjective f ↔ IsOpen f.pullbackDiagonal 
goal: IsLocallyInjective f ↔ IsOpen (Function.pullbackDiagonal f)

full_name: IsLocallyInjective_iff_openEmbedding
code: theorem IsLocallyInjective_iff_openEmbedding {f : X → Y} :
    IsLocallyInjective f ↔ OpenEmbedding (toPullbackDiag f) 
goal: IsLocallyInjective f ↔ OpenEmbedding (toPullbackDiag f)

full_name: isLocallyInjective_iff_isOpenMap
code: theorem isLocallyInjective_iff_isOpenMap {f : X → Y} :
    IsLocallyInjective f ↔ IsOpenMap (toPullbackDiag f) 
goal: IsLocallyInjective f ↔ IsOpenMap (toPullbackDiag f)

full_name: discreteTopology_iff_locallyInjective
code: theorem discreteTopology_iff_locallyInjective (y : Y) :
    DiscreteTopology X ↔ IsLocallyInjective fun _ : X ↦ y 
goal: DiscreteTopology X ↔ IsLocallyInjective fun x => y

full_name: IsLocallyInjective.comp_left
code: theorem IsLocallyInjective.comp_left {f : X → Y} (hf : IsLocallyInjective f) {g : Y → A}
    (hg : g.Injective) : IsLocallyInjective (g ∘ f) 
goal: IsLocallyInjective (g ∘ f)

full_name: IsLocallyInjective.comp_right
code: theorem IsLocallyInjective.comp_right {f : X → Y} (hf : IsLocallyInjective f) {g : A → X}
    (cont : Continuous g) (hg : g.Injective) : IsLocallyInjective (f ∘ g) 
goal: IsLocallyInjective (f ∘ g)

full_name: IsSeparatedMap.isClosed_eqLocus
code: theorem IsSeparatedMap.isClosed_eqLocus (he : f ∘ g₁ = f ∘ g₂) : IsClosed {a | g₁ a = g₂ a} 
goal: IsClosed {a | g₁ a = g₂ a}

full_name: IsLocallyInjective.isOpen_eqLocus
code: theorem IsLocallyInjective.isOpen_eqLocus (he : f ∘ g₁ = f ∘ g₂) : IsOpen {a | g₁ a = g₂ a} 
goal: IsOpen {a | g₁ a = g₂ a}

full_name: IsSeparatedMap.eq_of_comp_eq
code: /-- If `p` is a locally injective separated map, and `A` is a connected space,
  then two lifts `g₁, g₂ : A → E` of a map `f : A → X` are equal if they agree at one point. -/
theorem eq_of_comp_eq [PreconnectedSpace A] (h₁ : Continuous g₁) (h₂ : Continuous g₂)
    (he : p ∘ g₁ = p ∘ g₂) (a : A) (ha : g₁ a = g₂ a) : g₁ = g₂ 
goal: g₁ = g₂

full_name: IsSeparatedMap.eqOn_of_comp_eqOn
code: theorem eqOn_of_comp_eqOn (h₁ : ContinuousOn g₁ s) (h₂ : ContinuousOn g₂ s)
    (he : s.EqOn (p ∘ g₁) (p ∘ g₂)) {a : A} (has : a ∈ s) (ha : g₁ a = g₂ a) : s.EqOn g₁ g₂ 
goal: Set.EqOn g₁ g₂ s

full_name: IsSeparatedMap.const_of_comp
code: theorem const_of_comp [PreconnectedSpace A] (cont : Continuous g)
    (he : ∀ a a', p (g a) = p (g a')) (a a') : g a = g a' 
goal: g a = g a'

full_name: IsSeparatedMap.constOn_of_comp
code: theorem constOn_of_comp (cont : ContinuousOn g s)
    (he : ∀ a ∈ s, ∀ a' ∈ s, p (g a) = p (g a'))
    {a a'} (ha : a ∈ s) (ha' : a' ∈ s) : g a = g a' 
goal: g a = g a'