File: Mathlib/Topology/Inseparable.lean

full_name: specializes_TFAE
code: /-- A collection of equivalent definitions of `x ⤳ y`. The public API is given by `iff` lemmas
below. -/
theorem specializes_TFAE (x y : X) :
    TFAE [x ⤳ y,
      pure x ≤ 𝓝 y,
      ∀ s : Set X , IsOpen s → y ∈ s → x ∈ s,
      ∀ s : Set X , IsClosed s → x ∈ s → y ∈ s,
      y ∈ closure ({ x } : Set X),
      closure ({ y } : Set X) ⊆ closure { x },
      ClusterPt y (pure x)] 
goal: [x ⤳ y, pure x ≤ 𝓝 y, ∀ (s : Set X), IsOpen s → y ∈ s → x ∈ s, ∀ (s : Set X), IsClosed s → x ∈ s → y ∈ s,
    y ∈ closure {x}, closure {y} ⊆ closure {x}, ClusterPt y (pure x)].TFAE

full_name: specializes_iff_nhds
code: theorem specializes_iff_nhds : x ⤳ y ↔ 𝓝 x ≤ 𝓝 y 
goal: x ⤳ y ↔ 𝓝 x ≤ 𝓝 y

full_name: Specializes.not_disjoint
code: theorem Specializes.not_disjoint (h : x ⤳ y) : ¬Disjoint (𝓝 x) (𝓝 y) 
goal: ¬Disjoint (𝓝 x) (𝓝 y)

full_name: specializes_iff_pure
code: theorem specializes_iff_pure : x ⤳ y ↔ pure x ≤ 𝓝 y 
goal: x ⤳ y ↔ pure x ≤ 𝓝 y

full_name: ker_nhds_eq_specializes
code: theorem ker_nhds_eq_specializes : (𝓝 x).ker = {y | y ⤳ x} 
goal: (𝓝 x).ker = {y | y ⤳ x}

full_name: specializes_iff_forall_open
code: theorem specializes_iff_forall_open : x ⤳ y ↔ ∀ s : Set X, IsOpen s → y ∈ s → x ∈ s 
goal: x ⤳ y ↔ ∀ (s : Set X), IsOpen s → y ∈ s → x ∈ s

full_name: Specializes.mem_open
code: theorem Specializes.mem_open (h : x ⤳ y) (hs : IsOpen s) (hy : y ∈ s) : x ∈ s 
goal: x ∈ s

full_name: IsOpen.not_specializes
code: theorem IsOpen.not_specializes (hs : IsOpen s) (hx : x ∉ s) (hy : y ∈ s) : ¬x ⤳ y 
goal: ¬x ⤳ y

full_name: specializes_iff_forall_closed
code: theorem specializes_iff_forall_closed : x ⤳ y ↔ ∀ s : Set X, IsClosed s → x ∈ s → y ∈ s 
goal: x ⤳ y ↔ ∀ (s : Set X), IsClosed s → x ∈ s → y ∈ s

full_name: Specializes.mem_closed
code: theorem Specializes.mem_closed (h : x ⤳ y) (hs : IsClosed s) (hx : x ∈ s) : y ∈ s 
goal: y ∈ s

full_name: IsClosed.not_specializes
code: theorem IsClosed.not_specializes (hs : IsClosed s) (hx : x ∈ s) (hy : y ∉ s) : ¬x ⤳ y 
goal: ¬x ⤳ y

full_name: specializes_iff_mem_closure
code: theorem specializes_iff_mem_closure : x ⤳ y ↔ y ∈ closure ({x} : Set X) 
goal: x ⤳ y ↔ y ∈ closure {x}

full_name: specializes_iff_closure_subset
code: theorem specializes_iff_closure_subset : x ⤳ y ↔ closure ({y} : Set X) ⊆ closure {x} 
goal: x ⤳ y ↔ closure {y} ⊆ closure {x}

full_name: specializes_iff_clusterPt
code: theorem specializes_iff_clusterPt : x ⤳ y ↔ ClusterPt y (pure x) 
goal: x ⤳ y ↔ ClusterPt y (pure x)

full_name: Filter.HasBasis.specializes_iff
code: theorem Filter.HasBasis.specializes_iff {ι} {p : ι → Prop} {s : ι → Set X}
    (h : (𝓝 y).HasBasis p s) : x ⤳ y ↔ ∀ i, p i → x ∈ s i 
goal: x ⤳ y ↔ ∀ (i : ι), p i → x ∈ s i

full_name: specializes_rfl
code: theorem specializes_rfl : x ⤳ x 
goal: x ⤳ x

full_name: specializes_refl
code: @[refl]
theorem specializes_refl (x : X) : x ⤳ x 
goal: x ⤳ x

full_name: Specializes.trans
code: @[trans]
theorem Specializes.trans : x ⤳ y → y ⤳ z → x ⤳ z 
goal: x ⤳ y → y ⤳ z → x ⤳ z

full_name: specializes_of_eq
code: theorem specializes_of_eq (e : x = y) : x ⤳ y 
goal: x ⤳ y

full_name: specializes_of_nhdsWithin
code: theorem specializes_of_nhdsWithin (h₁ : 𝓝[s] x ≤ 𝓝[s] y) (h₂ : x ∈ s) : x ⤳ y 
goal: x ⤳ y

full_name: Specializes.map_of_continuousAt
code: theorem Specializes.map_of_continuousAt (h : x ⤳ y) (hy : ContinuousAt f y) : f x ⤳ f y 
goal: f x ⤳ f y

full_name: Specializes.map
code: theorem Specializes.map (h : x ⤳ y) (hf : Continuous f) : f x ⤳ f y 
goal: f x ⤳ f y

full_name: Inducing.specializes_iff
code: theorem Inducing.specializes_iff (hf : Inducing f) : f x ⤳ f y ↔ x ⤳ y 
goal: f x ⤳ f y ↔ x ⤳ y

full_name: subtype_specializes_iff
code: theorem subtype_specializes_iff {p : X → Prop} (x y : Subtype p) : x ⤳ y ↔ (x : X) ⤳ y 
goal: x ⤳ y ↔ ↑x ⤳ ↑y

full_name: specializes_prod
code: @[simp]
theorem specializes_prod {x₁ x₂ : X} {y₁ y₂ : Y} : (x₁, y₁) ⤳ (x₂, y₂) ↔ x₁ ⤳ x₂ ∧ y₁ ⤳ y₂ 
goal: (x₁, y₁) ⤳ (x₂, y₂) ↔ x₁ ⤳ x₂ ∧ y₁ ⤳ y₂

full_name: Specializes.prod
code: theorem Specializes.prod {x₁ x₂ : X} {y₁ y₂ : Y} (hx : x₁ ⤳ x₂) (hy : y₁ ⤳ y₂) :
    (x₁, y₁) ⤳ (x₂, y₂) 
goal: (x₁, y₁) ⤳ (x₂, y₂)

full_name: Specializes.fst
code: theorem Specializes.fst {a b : X × Y} (h : a ⤳ b) : a.1 ⤳ b.1 
goal: a.1 ⤳ b.1

full_name: Specializes.snd
code: theorem Specializes.snd {a b : X × Y} (h : a ⤳ b) : a.2 ⤳ b.2 
goal: a.2 ⤳ b.2

full_name: specializes_pi
code: @[simp]
theorem specializes_pi {f g : ∀ i, π i} : f ⤳ g ↔ ∀ i, f i ⤳ g i 
goal: f ⤳ g ↔ ∀ (i : ι), f i ⤳ g i

full_name: not_specializes_iff_exists_open
code: theorem not_specializes_iff_exists_open : ¬x ⤳ y ↔ ∃ S : Set X, IsOpen S ∧ y ∈ S ∧ x ∉ S 
goal: ¬x ⤳ y ↔ ∃ S, IsOpen S ∧ y ∈ S ∧ x ∉ S

full_name: not_specializes_iff_exists_closed
code: theorem not_specializes_iff_exists_closed : ¬x ⤳ y ↔ ∃ S : Set X, IsClosed S ∧ x ∈ S ∧ y ∉ S 
goal: ¬x ⤳ y ↔ ∃ S, IsClosed S ∧ x ∈ S ∧ y ∉ S

full_name: IsOpen.continuous_piecewise_of_specializes
code: theorem IsOpen.continuous_piecewise_of_specializes [DecidablePred (· ∈ s)] (hs : IsOpen s)
    (hf : Continuous f) (hg : Continuous g) (hspec : ∀ x, f x ⤳ g x) :
    Continuous (s.piecewise f g) 
goal: Continuous (s.piecewise f g)

full_name: IsClosed.continuous_piecewise_of_specializes
code: theorem IsClosed.continuous_piecewise_of_specializes [DecidablePred (· ∈ s)] (hs : IsClosed s)
    (hf : Continuous f) (hg : Continuous g) (hspec : ∀ x, g x ⤳ f x) :
    Continuous (s.piecewise f g) 
goal: Continuous (s.piecewise f g)

full_name: Continuous.specialization_monotone
code: /-- A continuous function is monotone with respect to the specialization preorders on the domain and
the codomain. -/
theorem Continuous.specialization_monotone (hf : Continuous f) : Monotone f 
goal: Monotone f

full_name: closure_singleton_eq_Iic
code: lemma closure_singleton_eq_Iic (x : X) : closure {x} = Iic x 
goal: closure {x} = Set.Iic x

full_name: StableUnderSpecialization
code: /-- A subset `S` of a topological space is stable under specialization
if `x ∈ S → y ∈ S` for all `x ⤳ y`. -/
def StableUnderSpecialization (s : Set X) : Prop 
goal: Prop

full_name: StableUnderGeneralization
code: /-- A subset `S` of a topological space is stable under specialization
if `x ∈ S → y ∈ S` for all `y ⤳ x`. -/
def StableUnderGeneralization (s : Set X) : Prop 
goal: Prop

full_name: IsClosed.stableUnderSpecialization
code: lemma IsClosed.stableUnderSpecialization {s : Set X} (hs : IsClosed s) :
    StableUnderSpecialization s 
goal: StableUnderSpecialization s

full_name: IsOpen.stableUnderGeneralization
code: lemma IsOpen.stableUnderGeneralization {s : Set X} (hs : IsOpen s) :
    StableUnderGeneralization s 
goal: StableUnderGeneralization s

full_name: stableUnderSpecialization_compl_iff
code: @[simp]
lemma stableUnderSpecialization_compl_iff {s : Set X} :
    StableUnderSpecialization sᶜ ↔ StableUnderGeneralization s 
goal: StableUnderSpecialization sᶜ ↔ StableUnderGeneralization s

full_name: stableUnderGeneralization_compl_iff
code: @[simp]
lemma stableUnderGeneralization_compl_iff {s : Set X} :
    StableUnderGeneralization sᶜ ↔ StableUnderSpecialization s 
goal: StableUnderGeneralization sᶜ ↔ StableUnderSpecialization s

full_name: stableUnderSpecialization_univ
code: lemma stableUnderSpecialization_univ : StableUnderSpecialization (univ : Set X) 
goal: StableUnderSpecialization Set.univ

full_name: stableUnderSpecialization_empty
code: lemma stableUnderSpecialization_empty : StableUnderSpecialization (∅ : Set X) 
goal: StableUnderSpecialization ∅

full_name: stableUnderGeneralization_univ
code: lemma stableUnderGeneralization_univ : StableUnderGeneralization (univ : Set X) 
goal: StableUnderGeneralization Set.univ

full_name: stableUnderGeneralization_empty
code: lemma stableUnderGeneralization_empty : StableUnderGeneralization (∅ : Set X) 
goal: StableUnderGeneralization ∅

full_name: stableUnderSpecialization_sUnion
code: lemma stableUnderSpecialization_sUnion (S : Set (Set X))
    (H : ∀ s ∈ S, StableUnderSpecialization s) : StableUnderSpecialization (⋃₀ S) 
goal: StableUnderSpecialization (⋃₀ S)

full_name: stableUnderSpecialization_sInter
code: lemma stableUnderSpecialization_sInter (S : Set (Set X))
    (H : ∀ s ∈ S, StableUnderSpecialization s) : StableUnderSpecialization (⋂₀ S) 
goal: StableUnderSpecialization (⋂₀ S)

full_name: stableUnderGeneralization_sUnion
code: lemma stableUnderGeneralization_sUnion (S : Set (Set X))
    (H : ∀ s ∈ S, StableUnderGeneralization s) : StableUnderGeneralization (⋃₀ S) 
goal: StableUnderGeneralization (⋃₀ S)

full_name: stableUnderGeneralization_sInter
code: lemma stableUnderGeneralization_sInter (S : Set (Set X))
    (H : ∀ s ∈ S, StableUnderGeneralization s) : StableUnderGeneralization (⋂₀ S) 
goal: StableUnderGeneralization (⋂₀ S)

full_name: stableUnderSpecialization_iUnion
code: lemma stableUnderSpecialization_iUnion {ι : Sort*} (S : ι → Set X)
    (H : ∀ i, StableUnderSpecialization (S i)) : StableUnderSpecialization (⋃ i, S i) 
goal: StableUnderSpecialization (⋃ i, S i)

full_name: stableUnderSpecialization_iInter
code: lemma stableUnderSpecialization_iInter {ι : Sort*} (S : ι → Set X)
    (H : ∀ i, StableUnderSpecialization (S i)) : StableUnderSpecialization (⋂ i, S i) 
goal: StableUnderSpecialization (⋂ i, S i)

full_name: stableUnderGeneralization_iUnion
code: lemma stableUnderGeneralization_iUnion {ι : Sort*} (S : ι → Set X)
    (H : ∀ i, StableUnderGeneralization (S i)) : StableUnderGeneralization (⋃ i, S i) 
goal: StableUnderGeneralization (⋃ i, S i)

full_name: stableUnderGeneralization_iInter
code: lemma stableUnderGeneralization_iInter {ι : Sort*} (S : ι → Set X)
    (H : ∀ i, StableUnderGeneralization (S i)) : StableUnderGeneralization (⋂ i, S i) 
goal: StableUnderGeneralization (⋂ i, S i)

full_name: Union_closure_singleton_eq_iff
code: lemma Union_closure_singleton_eq_iff {s : Set X} :
    (⋃ x ∈ s, closure {x}) = s ↔ StableUnderSpecialization s 
goal: ⋃ x ∈ s, closure {x} = s ↔ StableUnderSpecialization s

full_name: stableUnderSpecialization_iff_Union_eq
code: lemma stableUnderSpecialization_iff_Union_eq {s : Set X} :
    StableUnderSpecialization s ↔ (⋃ x ∈ s, closure {x}) = s 
goal: StableUnderSpecialization s ↔ ⋃ x ∈ s, closure {x} = s

full_name: stableUnderSpecialization_iff_exists_sUnion_eq
code: /-- A set is stable under specialization iff it is a union of closed sets. -/
lemma stableUnderSpecialization_iff_exists_sUnion_eq {s : Set X} :
    StableUnderSpecialization s ↔ ∃ (S : Set (Set X)), (∀ s ∈ S, IsClosed s) ∧ ⋃₀ S = s 
goal: StableUnderSpecialization s ↔ ∃ S, (∀ s ∈ S, IsClosed s) ∧ ⋃₀ S = s

full_name: stableUnderGeneralization_iff_exists_sInter_eq
code: /-- A set is stable under generalization iff it is an intersection of open sets. -/
lemma stableUnderGeneralization_iff_exists_sInter_eq {s : Set X} :
    StableUnderGeneralization s ↔ ∃ (S : Set (Set X)), (∀ s ∈ S, IsOpen s) ∧ ⋂₀ S = s 
goal: StableUnderGeneralization s ↔ ∃ S, (∀ s ∈ S, IsOpen s) ∧ ⋂₀ S = s

full_name: StableUnderSpecialization.preimage
code: lemma StableUnderSpecialization.preimage {s : Set Y}
    (hs : StableUnderSpecialization s) (hf : Continuous f) :
    StableUnderSpecialization (f ⁻¹' s) 
goal: StableUnderSpecialization (f ⁻¹' s)

full_name: StableUnderGeneralization.preimage
code: lemma StableUnderGeneralization.preimage {s : Set Y}
    (hs : StableUnderGeneralization s) (hf : Continuous f) :
    StableUnderGeneralization (f ⁻¹' s) 
goal: StableUnderGeneralization (f ⁻¹' s)

full_name: SpecializingMap
code: /-- A map `f` between topological spaces is specializing if specializations lifts along `f`,
i.e. for each `f x' ⤳ y` there is some `x` with `x' ⤳ x` whose image is `y`. -/
def SpecializingMap (f : X → Y) : Prop 
goal: Prop

full_name: GeneralizingMap
code: /-- A map `f` between topological spaces is generalizing if generalizations lifts along `f`,
i.e. for each `y ⤳ f x'` there is some `x ⤳ x'` whose image is `y`. -/
def GeneralizingMap (f : X → Y) : Prop 
goal: Prop

full_name: specializingMap_iff_closure_singleton_subset
code: lemma specializingMap_iff_closure_singleton_subset :
    SpecializingMap f ↔ ∀ x, closure {f x} ⊆ f '' closure {x} 
goal: SpecializingMap f ↔ ∀ (x : X), closure {f x} ⊆ f '' closure {x}

full_name: SpecializingMap.stableUnderSpecialization_image
code: lemma SpecializingMap.stableUnderSpecialization_image (hf : SpecializingMap f)
    {s : Set X} (hs : StableUnderSpecialization s) : StableUnderSpecialization (f '' s) 
goal: StableUnderSpecialization (f '' s)

full_name: specializingMap_iff_stableUnderSpecialization_image_singleton
code: lemma specializingMap_iff_stableUnderSpecialization_image_singleton :
    SpecializingMap f ↔ ∀ x, StableUnderSpecialization (f '' closure {x}) 
goal: SpecializingMap f ↔ ∀ (x : X), StableUnderSpecialization (f '' closure {x})

full_name: specializingMap_iff_stableUnderSpecialization_image
code: lemma specializingMap_iff_stableUnderSpecialization_image :
    SpecializingMap f ↔ ∀ s, StableUnderSpecialization s → StableUnderSpecialization (f '' s) 
goal: SpecializingMap f ↔ ∀ (s : Set X), StableUnderSpecialization s → StableUnderSpecialization (f '' s)

full_name: specializingMap_iff_closure_singleton
code: lemma specializingMap_iff_closure_singleton (hf : Continuous f) :
    SpecializingMap f ↔ ∀ x, f '' closure {x} = closure {f x} 
goal: SpecializingMap f ↔ ∀ (x : X), f '' closure {x} = closure {f x}

full_name: specializingMap_iff_isClosed_image_closure_singleton
code: lemma specializingMap_iff_isClosed_image_closure_singleton (hf : Continuous f) :
    SpecializingMap f ↔ ∀ x, IsClosed (f '' closure {x}) 
goal: SpecializingMap f ↔ ∀ (x : X), IsClosed (f '' closure {x})

full_name: IsClosedMap.specializingMap
code: lemma IsClosedMap.specializingMap (hf : IsClosedMap f) : SpecializingMap f 
goal: SpecializingMap f

full_name: Inducing.specializingMap
code: lemma Inducing.specializingMap (hf : Inducing f) (h : StableUnderSpecialization (range f)) :
    SpecializingMap f 
goal: SpecializingMap f

full_name: Inducing.generalizingMap
code: lemma Inducing.generalizingMap (hf : Inducing f) (h : StableUnderGeneralization (range f)) :
    GeneralizingMap f 
goal: GeneralizingMap f

full_name: OpenEmbedding.generalizingMap
code: lemma OpenEmbedding.generalizingMap (hf : OpenEmbedding f) : GeneralizingMap f 
goal: GeneralizingMap f

full_name: SpecializingMap.stableUnderSpecialization_range
code: lemma SpecializingMap.stableUnderSpecialization_range (h : SpecializingMap f) :
    StableUnderSpecialization (range f) 
goal: StableUnderSpecialization (Set.range f)

full_name: GeneralizingMap.stableUnderGeneralization_image
code: lemma GeneralizingMap.stableUnderGeneralization_image (hf : GeneralizingMap f) {s : Set X}
    (hs : StableUnderGeneralization s) : StableUnderGeneralization (f '' s) 
goal: StableUnderGeneralization (f '' s)

full_name: GeneralizingMap_iff_stableUnderGeneralization_image
code: lemma GeneralizingMap_iff_stableUnderGeneralization_image :
    GeneralizingMap f ↔ ∀ s, StableUnderGeneralization s → StableUnderGeneralization (f '' s) 
goal: GeneralizingMap f ↔ ∀ (s : Set X), StableUnderGeneralization s → StableUnderGeneralization (f '' s)

full_name: GeneralizingMap.stableUnderGeneralization_range
code: lemma GeneralizingMap.stableUnderGeneralization_range (h : GeneralizingMap f) :
    StableUnderGeneralization (range f) 
goal: StableUnderGeneralization (Set.range f)

full_name: «_aux_Mathlib_Topology_Inseparable___macroRules_term_~ᵢ__1»
code: local infixl:0 " ~ᵢ " => Inseparable
goal: Lean.Macro

full_name: _aux_Mathlib_Topology_Inseparable___unexpand_Inseparable_1
code: local infixl:0 " ~ᵢ " => Inseparable
goal: Lean.PrettyPrinter.Unexpander

full_name: inseparable_def
code: theorem inseparable_def : (x ~ᵢ y) ↔ 𝓝 x = 𝓝 y 
goal: (x ~ᵢ y) ↔ 𝓝 x = 𝓝 y

full_name: inseparable_iff_specializes_and
code: theorem inseparable_iff_specializes_and : (x ~ᵢ y) ↔ x ⤳ y ∧ y ⤳ x 
goal: (x ~ᵢ y) ↔ x ⤳ y ∧ y ⤳ x

full_name: Inseparable.specializes
code: theorem Inseparable.specializes (h : x ~ᵢ y) : x ⤳ y 
goal: x ⤳ y

full_name: Inseparable.specializes'
code: theorem Inseparable.specializes' (h : x ~ᵢ y) : y ⤳ x 
goal: y ⤳ x

full_name: Specializes.antisymm
code: theorem Specializes.antisymm (h₁ : x ⤳ y) (h₂ : y ⤳ x) : x ~ᵢ y 
goal: x ~ᵢ y

full_name: inseparable_iff_forall_open
code: theorem inseparable_iff_forall_open : (x ~ᵢ y) ↔ ∀ s : Set X, IsOpen s → (x ∈ s ↔ y ∈ s) 
goal: (x ~ᵢ y) ↔ ∀ (s : Set X), IsOpen s → (x ∈ s ↔ y ∈ s)

full_name: not_inseparable_iff_exists_open
code: theorem not_inseparable_iff_exists_open :
    ¬(x ~ᵢ y) ↔ ∃ s : Set X, IsOpen s ∧ Xor' (x ∈ s) (y ∈ s) 
goal: ¬(x ~ᵢ y) ↔ ∃ s, IsOpen s ∧ Xor' (x ∈ s) (y ∈ s)

full_name: inseparable_iff_forall_closed
code: theorem inseparable_iff_forall_closed : (x ~ᵢ y) ↔ ∀ s : Set X, IsClosed s → (x ∈ s ↔ y ∈ s) 
goal: (x ~ᵢ y) ↔ ∀ (s : Set X), IsClosed s → (x ∈ s ↔ y ∈ s)

full_name: inseparable_iff_mem_closure
code: theorem inseparable_iff_mem_closure :
    (x ~ᵢ y) ↔ x ∈ closure ({y} : Set X) ∧ y ∈ closure ({x} : Set X) 
goal: (x ~ᵢ y) ↔ x ∈ closure {y} ∧ y ∈ closure {x}

full_name: inseparable_iff_closure_eq
code: theorem inseparable_iff_closure_eq : (x ~ᵢ y) ↔ closure ({x} : Set X) = closure {y} 
goal: (x ~ᵢ y) ↔ closure {x} = closure {y}

full_name: inseparable_of_nhdsWithin_eq
code: theorem inseparable_of_nhdsWithin_eq (hx : x ∈ s) (hy : y ∈ s) (h : 𝓝[s] x = 𝓝[s] y) : x ~ᵢ y 
goal: x ~ᵢ y

full_name: Inducing.inseparable_iff
code: theorem Inducing.inseparable_iff (hf : Inducing f) : (f x ~ᵢ f y) ↔ (x ~ᵢ y) 
goal: (f x ~ᵢ f y) ↔ (x ~ᵢ y)

full_name: subtype_inseparable_iff
code: theorem subtype_inseparable_iff {p : X → Prop} (x y : Subtype p) : (x ~ᵢ y) ↔ ((x : X) ~ᵢ y) 
goal: (x ~ᵢ y) ↔ (↑x ~ᵢ ↑y)

full_name: inseparable_prod
code: @[simp] theorem inseparable_prod {x₁ x₂ : X} {y₁ y₂ : Y} :
    ((x₁, y₁) ~ᵢ (x₂, y₂)) ↔ (x₁ ~ᵢ x₂) ∧ (y₁ ~ᵢ y₂) 
goal: ((x₁, y₁) ~ᵢ (x₂, y₂)) ↔ (x₁ ~ᵢ x₂) ∧ (y₁ ~ᵢ y₂)

full_name: Inseparable.prod
code: theorem Inseparable.prod {x₁ x₂ : X} {y₁ y₂ : Y} (hx : x₁ ~ᵢ x₂) (hy : y₁ ~ᵢ y₂) :
    (x₁, y₁) ~ᵢ (x₂, y₂) 
goal: (x₁, y₁) ~ᵢ (x₂, y₂)

full_name: inseparable_pi
code: @[simp]
theorem inseparable_pi {f g : ∀ i, π i} : (f ~ᵢ g) ↔ ∀ i, f i ~ᵢ g i 
goal: (f ~ᵢ g) ↔ ∀ (i : ι), f i ~ᵢ g i

full_name: Inseparable.refl
code: @[refl]
theorem refl (x : X) : x ~ᵢ x 
goal: x ~ᵢ x

full_name: Inseparable.rfl
code: theorem rfl : x ~ᵢ x 
goal: x ~ᵢ x

full_name: Inseparable.of_eq
code: theorem of_eq (e : x = y) : Inseparable x y 
goal: x ~ᵢ y

full_name: Inseparable.symm
code: @[symm]
nonrec theorem symm (h : x ~ᵢ y) : y ~ᵢ x 
goal: y ~ᵢ x

full_name: Inseparable.trans
code: @[trans]
nonrec theorem trans (h₁ : x ~ᵢ y) (h₂ : y ~ᵢ z) : x ~ᵢ z 
goal: x ~ᵢ z

full_name: Inseparable.nhds_eq
code: theorem nhds_eq (h : x ~ᵢ y) : 𝓝 x = 𝓝 y 
goal: 𝓝 x = 𝓝 y

full_name: Inseparable.mem_open_iff
code: theorem mem_open_iff (h : x ~ᵢ y) (hs : IsOpen s) : x ∈ s ↔ y ∈ s 
goal: x ∈ s ↔ y ∈ s

full_name: Inseparable.mem_closed_iff
code: theorem mem_closed_iff (h : x ~ᵢ y) (hs : IsClosed s) : x ∈ s ↔ y ∈ s 
goal: x ∈ s ↔ y ∈ s

full_name: Inseparable.map_of_continuousAt
code: theorem map_of_continuousAt (h : x ~ᵢ y) (hx : ContinuousAt f x) (hy : ContinuousAt f y) :
    f x ~ᵢ f y 
goal: f x ~ᵢ f y

full_name: Inseparable.map
code: theorem map (h : x ~ᵢ y) (hf : Continuous f) : f x ~ᵢ f y 
goal: f x ~ᵢ f y

full_name: IsClosed.not_inseparable
code: theorem IsClosed.not_inseparable (hs : IsClosed s) (hx : x ∈ s) (hy : y ∉ s) : ¬(x ~ᵢ y) 
goal: ¬(x ~ᵢ y)

full_name: IsOpen.not_inseparable
code: theorem IsOpen.not_inseparable (hs : IsOpen s) (hx : x ∈ s) (hy : y ∉ s) : ¬(x ~ᵢ y) 
goal: ¬(x ~ᵢ y)

full_name: instTopologicalSpaceSeparationQuotient
code: instance : TopologicalSpace (SeparationQuotient X) 
goal: TopologicalSpace (SeparationQuotient X)

full_name: SeparationQuotient.mk
code: /-- The natural map from a topological space to its separation quotient. -/
def mk : X → SeparationQuotient X 
goal: X → SeparationQuotient X

full_name: SeparationQuotient.quotientMap_mk
code: theorem quotientMap_mk : QuotientMap (mk : X → SeparationQuotient X) 
goal: QuotientMap SeparationQuotient.mk

full_name: SeparationQuotient.continuous_mk
code: @[fun_prop, continuity]
theorem continuous_mk : Continuous (mk : X → SeparationQuotient X) 
goal: Continuous SeparationQuotient.mk

full_name: SeparationQuotient.mk_eq_mk
code: @[simp]
theorem mk_eq_mk : mk x = mk y ↔ (x ~ᵢ y) 
goal: SeparationQuotient.mk x = SeparationQuotient.mk y ↔ (x ~ᵢ y)

full_name: SeparationQuotient.surjective_mk
code: theorem surjective_mk : Surjective (mk : X → SeparationQuotient X) 
goal: Function.Surjective SeparationQuotient.mk

full_name: SeparationQuotient.range_mk
code: @[simp]
theorem range_mk : range (mk : X → SeparationQuotient X) = univ 
goal: Set.range SeparationQuotient.mk = Set.univ

full_name: SeparationQuotient.instNonempty
code: instance [Nonempty X] : Nonempty (SeparationQuotient X) 
goal: Nonempty (SeparationQuotient X)

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

full_name: SeparationQuotient.instSubsingleton
code: instance [Subsingleton X] : Subsingleton (SeparationQuotient X) 
goal: Subsingleton (SeparationQuotient X)

full_name: SeparationQuotient.preimage_image_mk_open
code: theorem preimage_image_mk_open (hs : IsOpen s) : mk ⁻¹' (mk '' s) = s 
goal: SeparationQuotient.mk ⁻¹' (SeparationQuotient.mk '' s) = s

full_name: SeparationQuotient.isOpenMap_mk
code: theorem isOpenMap_mk : IsOpenMap (mk : X → SeparationQuotient X) 
goal: IsOpenMap SeparationQuotient.mk

full_name: SeparationQuotient.preimage_image_mk_closed
code: theorem preimage_image_mk_closed (hs : IsClosed s) : mk ⁻¹' (mk '' s) = s 
goal: SeparationQuotient.mk ⁻¹' (SeparationQuotient.mk '' s) = s

full_name: SeparationQuotient.inducing_mk
code: theorem inducing_mk : Inducing (mk : X → SeparationQuotient X) 
goal: Inducing SeparationQuotient.mk

full_name: SeparationQuotient.isClosedMap_mk
code: theorem isClosedMap_mk : IsClosedMap (mk : X → SeparationQuotient X) 
goal: IsClosedMap SeparationQuotient.mk

full_name: SeparationQuotient.comap_mk_nhds_mk
code: @[simp]
theorem comap_mk_nhds_mk : comap mk (𝓝 (mk x)) = 𝓝 x 
goal: Filter.comap SeparationQuotient.mk (𝓝 (SeparationQuotient.mk x)) = 𝓝 x

full_name: SeparationQuotient.comap_mk_nhdsSet_image
code: @[simp]
theorem comap_mk_nhdsSet_image : comap mk (𝓝ˢ (mk '' s)) = 𝓝ˢ s 
goal: Filter.comap SeparationQuotient.mk (𝓝ˢ (SeparationQuotient.mk '' s)) = 𝓝ˢ s

full_name: SeparationQuotient.map_mk_nhds
code: theorem map_mk_nhds : map mk (𝓝 x) = 𝓝 (mk x) 
goal: Filter.map SeparationQuotient.mk (𝓝 x) = 𝓝 (SeparationQuotient.mk x)

full_name: SeparationQuotient.map_mk_nhdsSet
code: theorem map_mk_nhdsSet : map mk (𝓝ˢ s) = 𝓝ˢ (mk '' s) 
goal: Filter.map SeparationQuotient.mk (𝓝ˢ s) = 𝓝ˢ (SeparationQuotient.mk '' s)

full_name: SeparationQuotient.comap_mk_nhdsSet
code: theorem comap_mk_nhdsSet : comap mk (𝓝ˢ t) = 𝓝ˢ (mk ⁻¹' t) 
goal: Filter.comap SeparationQuotient.mk (𝓝ˢ t) = 𝓝ˢ (SeparationQuotient.mk ⁻¹' t)

full_name: SeparationQuotient.preimage_mk_closure
code: theorem preimage_mk_closure : mk ⁻¹' closure t = closure (mk ⁻¹' t) 
goal: SeparationQuotient.mk ⁻¹' closure t = closure (SeparationQuotient.mk ⁻¹' t)

full_name: SeparationQuotient.preimage_mk_interior
code: theorem preimage_mk_interior : mk ⁻¹' interior t = interior (mk ⁻¹' t) 
goal: SeparationQuotient.mk ⁻¹' interior t = interior (SeparationQuotient.mk ⁻¹' t)

full_name: SeparationQuotient.preimage_mk_frontier
code: theorem preimage_mk_frontier : mk ⁻¹' frontier t = frontier (mk ⁻¹' t) 
goal: SeparationQuotient.mk ⁻¹' frontier t = frontier (SeparationQuotient.mk ⁻¹' t)

full_name: SeparationQuotient.image_mk_closure
code: theorem image_mk_closure : mk '' closure s = closure (mk '' s) 
goal: SeparationQuotient.mk '' closure s = closure (SeparationQuotient.mk '' s)

full_name: SeparationQuotient.map_prod_map_mk_nhds
code: theorem map_prod_map_mk_nhds (x : X) (y : Y) :
    map (Prod.map mk mk) (𝓝 (x, y)) = 𝓝 (mk x, mk y) 
goal: Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (𝓝 (x, y)) =
  𝓝 (SeparationQuotient.mk x, SeparationQuotient.mk y)

full_name: SeparationQuotient.map_mk_nhdsWithin_preimage
code: theorem map_mk_nhdsWithin_preimage (s : Set (SeparationQuotient X)) (x : X) :
    map mk (𝓝[mk ⁻¹' s] x) = 𝓝[s] mk x 
goal: Filter.map SeparationQuotient.mk (𝓝[SeparationQuotient.mk ⁻¹' s] x) = 𝓝[s] SeparationQuotient.mk x

full_name: SeparationQuotient.quotientMap_prodMap_mk
code: /-- The map `(x, y) ↦ (mk x, mk y)` is a quotient map. -/
theorem quotientMap_prodMap_mk : QuotientMap (Prod.map mk mk : X × Y → _) 
goal: QuotientMap (Prod.map SeparationQuotient.mk SeparationQuotient.mk)

full_name: SeparationQuotient.lift
code: /-- Lift a map `f : X → α` such that `Inseparable x y → f x = f y` to a map
`SeparationQuotient X → α`. -/
def lift (f : X → α) (hf : ∀ x y, (x ~ᵢ y) → f x = f y) : SeparationQuotient X → α 
goal: SeparationQuotient X → α

full_name: SeparationQuotient.lift_mk
code: @[simp]
theorem lift_mk {f : X → α} (hf : ∀ x y, (x ~ᵢ y) → f x = f y) (x : X) : lift f hf (mk x) = f x 
goal: SeparationQuotient.lift f hf (SeparationQuotient.mk x) = f x

full_name: SeparationQuotient.lift_comp_mk
code: @[simp]
theorem lift_comp_mk {f : X → α} (hf : ∀ x y, (x ~ᵢ y) → f x = f y) : lift f hf ∘ mk = f 
goal: SeparationQuotient.lift f hf ∘ SeparationQuotient.mk = f

full_name: SeparationQuotient.tendsto_lift_nhds_mk
code: @[simp]
theorem tendsto_lift_nhds_mk {f : X → α} {hf : ∀ x y, (x ~ᵢ y) → f x = f y} {l : Filter α} :
    Tendsto (lift f hf) (𝓝 <| mk x) l ↔ Tendsto f (𝓝 x) l 
goal: Filter.Tendsto (SeparationQuotient.lift f hf) (𝓝 (SeparationQuotient.mk x)) l ↔ Filter.Tendsto f (𝓝 x) l

full_name: SeparationQuotient.tendsto_lift_nhdsWithin_mk
code: @[simp]
theorem tendsto_lift_nhdsWithin_mk {f : X → α} {hf : ∀ x y, (x ~ᵢ y) → f x = f y}
    {s : Set (SeparationQuotient X)} {l : Filter α} :
    Tendsto (lift f hf) (𝓝[s] mk x) l ↔ Tendsto f (𝓝[mk ⁻¹' s] x) l 
goal: Filter.Tendsto (SeparationQuotient.lift f hf) (𝓝[s] SeparationQuotient.mk x) l ↔
  Filter.Tendsto f (𝓝[SeparationQuotient.mk ⁻¹' s] x) l

full_name: SeparationQuotient.continuousAt_lift
code: @[simp]
theorem continuousAt_lift {hf : ∀ x y, (x ~ᵢ y) → f x = f y} :
    ContinuousAt (lift f hf) (mk x) ↔ ContinuousAt f x 
goal: ContinuousAt (SeparationQuotient.lift f hf) (SeparationQuotient.mk x) ↔ ContinuousAt f x

full_name: SeparationQuotient.continuousWithinAt_lift
code: @[simp]
theorem continuousWithinAt_lift {hf : ∀ x y, (x ~ᵢ y) → f x = f y}
    {s : Set (SeparationQuotient X)} :
    ContinuousWithinAt (lift f hf) s (mk x) ↔ ContinuousWithinAt f (mk ⁻¹' s) x 
goal: ContinuousWithinAt (SeparationQuotient.lift f hf) s (SeparationQuotient.mk x) ↔
  ContinuousWithinAt f (SeparationQuotient.mk ⁻¹' s) x

full_name: SeparationQuotient.continuousOn_lift
code: @[simp]
theorem continuousOn_lift {hf : ∀ x y, (x ~ᵢ y) → f x = f y} {s : Set (SeparationQuotient X)} :
    ContinuousOn (lift f hf) s ↔ ContinuousOn f (mk ⁻¹' s) 
goal: ContinuousOn (SeparationQuotient.lift f hf) s ↔ ContinuousOn f (SeparationQuotient.mk ⁻¹' s)

full_name: SeparationQuotient.continuous_lift
code: @[simp]
theorem continuous_lift {hf : ∀ x y, (x ~ᵢ y) → f x = f y} :
    Continuous (lift f hf) ↔ Continuous f 
goal: Continuous (SeparationQuotient.lift f hf) ↔ Continuous f

full_name: SeparationQuotient.lift₂
code: /-- Lift a map `f : X → Y → α` such that `Inseparable a b → Inseparable c d → f a c = f b d` to a
map `SeparationQuotient X → SeparationQuotient Y → α`. -/
def lift₂ (f : X → Y → α) (hf : ∀ a b c d, (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d) :
    SeparationQuotient X → SeparationQuotient Y → α 
goal: SeparationQuotient X → SeparationQuotient Y → α

full_name: SeparationQuotient.lift₂_mk
code: @[simp]
theorem lift₂_mk {f : X → Y → α} (hf : ∀ a b c d, (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d) (x : X)
    (y : Y) : lift₂ f hf (mk x) (mk y) = f x y 
goal: SeparationQuotient.lift₂ f hf (SeparationQuotient.mk x) (SeparationQuotient.mk y) = f x y

full_name: SeparationQuotient.tendsto_lift₂_nhds
code: @[simp]
theorem tendsto_lift₂_nhds {f : X → Y → α} {hf : ∀ a b c d, (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d}
    {x : X} {y : Y} {l : Filter α} :
    Tendsto (uncurry <| lift₂ f hf) (𝓝 (mk x, mk y)) l ↔ Tendsto (uncurry f) (𝓝 (x, y)) l 
goal: Filter.Tendsto (Function.uncurry (SeparationQuotient.lift₂ f hf)) (𝓝 (SeparationQuotient.mk x, SeparationQuotient.mk y))
    l ↔
  Filter.Tendsto (Function.uncurry f) (𝓝 (x, y)) l

full_name: SeparationQuotient.tendsto_lift₂_nhdsWithin
code: @[simp] theorem tendsto_lift₂_nhdsWithin {f : X → Y → α}
    {hf : ∀ a b c d, (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d} {x : X} {y : Y}
    {s : Set (SeparationQuotient X × SeparationQuotient Y)} {l : Filter α} :
    Tendsto (uncurry <| lift₂ f hf) (𝓝[s] (mk x, mk y)) l ↔
      Tendsto (uncurry f) (𝓝[Prod.map mk mk ⁻¹' s] (x, y)) l 
goal: Filter.Tendsto (Function.uncurry (SeparationQuotient.lift₂ f hf))
    (𝓝[s] (SeparationQuotient.mk x, SeparationQuotient.mk y)) l ↔
  Filter.Tendsto (Function.uncurry f) (𝓝[Prod.map SeparationQuotient.mk SeparationQuotient.mk ⁻¹' s] (x, y)) l

full_name: SeparationQuotient.continuousAt_lift₂
code: @[simp]
theorem continuousAt_lift₂ {f : X → Y → Z} {hf : ∀ a b c d, (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d}
    {x : X} {y : Y} :
    ContinuousAt (uncurry <| lift₂ f hf) (mk x, mk y) ↔ ContinuousAt (uncurry f) (x, y) 
goal: ContinuousAt (Function.uncurry (SeparationQuotient.lift₂ f hf)) (SeparationQuotient.mk x, SeparationQuotient.mk y) ↔
  ContinuousAt (Function.uncurry f) (x, y)

full_name: SeparationQuotient.continuousWithinAt_lift₂
code: @[simp] theorem continuousWithinAt_lift₂ {f : X → Y → Z}
    {hf : ∀ a b c d, (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d}
    {s : Set (SeparationQuotient X × SeparationQuotient Y)} {x : X} {y : Y} :
    ContinuousWithinAt (uncurry <| lift₂ f hf) s (mk x, mk y) ↔
      ContinuousWithinAt (uncurry f) (Prod.map mk mk ⁻¹' s) (x, y) 
goal: ContinuousWithinAt (Function.uncurry (SeparationQuotient.lift₂ f hf)) s
    (SeparationQuotient.mk x, SeparationQuotient.mk y) ↔
  ContinuousWithinAt (Function.uncurry f) (Prod.map SeparationQuotient.mk SeparationQuotient.mk ⁻¹' s) (x, y)

full_name: SeparationQuotient.continuousOn_lift₂
code: @[simp]
theorem continuousOn_lift₂ {f : X → Y → Z} {hf : ∀ a b c d, (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d}
    {s : Set (SeparationQuotient X × SeparationQuotient Y)} :
    ContinuousOn (uncurry <| lift₂ f hf) s ↔ ContinuousOn (uncurry f) (Prod.map mk mk ⁻¹' s) 
goal: ContinuousOn (Function.uncurry (SeparationQuotient.lift₂ f hf)) s ↔
  ContinuousOn (Function.uncurry f) (Prod.map SeparationQuotient.mk SeparationQuotient.mk ⁻¹' s)

full_name: SeparationQuotient.continuous_lift₂
code: @[simp]
theorem continuous_lift₂ {f : X → Y → Z} {hf : ∀ a b c d, (a ~ᵢ c) → (b ~ᵢ d) → f a b = f c d} :
    Continuous (uncurry <| lift₂ f hf) ↔ Continuous (uncurry f) 
goal: Continuous (Function.uncurry (SeparationQuotient.lift₂ f hf)) ↔ Continuous (Function.uncurry f)

full_name: continuous_congr_of_inseparable
code: theorem continuous_congr_of_inseparable (h : ∀ x, f x ~ᵢ g x) :
    Continuous f ↔ Continuous g 
goal: Continuous f ↔ Continuous g