[GOAL]
X : Compactum
x : X.A
⊢ str X (incl X x) = x
[PROOFSTEP]
change ((β).η.app _ ≫ X.a) _ = _
[GOAL]
X : Compactum
x : X.A
⊢ (NatTrans.app (Monad.η β) X.A ≫ X.a) x = x
[PROOFSTEP]
rw [Monad.Algebra.unit]
[GOAL]
X : Compactum
x : X.A
⊢ 𝟙 X.A x = x
[PROOFSTEP]
rfl
[GOAL]
X Y : Compactum
f : X ⟶ Y
xs : Ultrafilter X.A
⊢ Monad.Algebra.Hom.f f (str X xs) = str Y (Ultrafilter.map f.f xs)
[PROOFSTEP]
change (X.a ≫ f.f) _ = _
[GOAL]
X Y : Compactum
f : X ⟶ Y
xs : Ultrafilter X.A
⊢ (X.a ≫ f.f) xs = str Y (Ultrafilter.map f.f xs)
[PROOFSTEP]
rw [← f.h]
[GOAL]
X Y : Compactum
f : X ⟶ Y
xs : Ultrafilter X.A
⊢ (β.toFunctor.map f.f ≫ Y.a) xs = str Y (Ultrafilter.map f.f xs)
[PROOFSTEP]
rfl
[GOAL]
X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ str X (join X uux) = str X (Ultrafilter.map (str X) uux)
[PROOFSTEP]
change ((β).μ.app _ ≫ X.a) _ = _
[GOAL]
X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (NatTrans.app (Monad.μ β) X.A ≫ X.a) uux = str X (Ultrafilter.map (str X) uux)
[PROOFSTEP]
rw [Monad.Algebra.assoc]
[GOAL]
X : Compactum
uux : Ultrafilter (Ultrafilter X.A)
⊢ (β.toFunctor.map X.a ≫ X.a) uux = str X (Ultrafilter.map (str X) uux)
[PROOFSTEP]
rfl
[GOAL]
X : Compactum
S : Set X.A
⊢ IsClosed S ↔ ∀ (F : Ultrafilter X.A), S ∈ F → str X F ∈ S
[PROOFSTEP]
rw [← isOpen_compl_iff]
[GOAL]
X : Compactum
S : Set X.A
⊢ IsOpen Sᶜ ↔ ∀ (F : Ultrafilter X.A), S ∈ F → str X F ∈ S
[PROOFSTEP]
constructor
[GOAL]
case mp
X : Compactum
S : Set X.A
⊢ IsOpen Sᶜ → ∀ (F : Ultrafilter X.A), S ∈ F → str X F ∈ S
[PROOFSTEP]
intro cond F h
[GOAL]
case mp
X : Compactum
S : Set X.A
cond : IsOpen Sᶜ
F : Ultrafilter X.A
h : S ∈ F
⊢ str X F ∈ S
[PROOFSTEP]
by_contra c
[GOAL]
case mp
X : Compactum
S : Set X.A
cond : IsOpen Sᶜ
F : Ultrafilter X.A
h : S ∈ F
c : ¬str X F ∈ S
⊢ False
[PROOFSTEP]
specialize cond F c
[GOAL]
case mp
X : Compactum
S : Set X.A
F : Ultrafilter X.A
h : S ∈ F
c : ¬str X F ∈ S
cond : Sᶜ ∈ F
⊢ False
[PROOFSTEP]
rw [compl_mem_iff_not_mem] at cond
[GOAL]
case mp
X : Compactum
S : Set X.A
F : Ultrafilter X.A
h : S ∈ F
c : ¬str X F ∈ S
cond : ¬S ∈ F
⊢ False
[PROOFSTEP]
contradiction
[GOAL]
case mpr
X : Compactum
S : Set X.A
⊢ (∀ (F : Ultrafilter X.A), S ∈ F → str X F ∈ S) → IsOpen Sᶜ
[PROOFSTEP]
intro h1 F h2
[GOAL]
case mpr
X : Compactum
S : Set X.A
h1 : ∀ (F : Ultrafilter X.A), S ∈ F → str X F ∈ S
F : Ultrafilter X.A
h2 : str X F ∈ Sᶜ
⊢ Sᶜ ∈ F
[PROOFSTEP]
specialize h1 F
[GOAL]
case mpr
X : Compactum
S : Set X.A
F : Ultrafilter X.A
h2 : str X F ∈ Sᶜ
h1 : S ∈ F → str X F ∈ S
⊢ Sᶜ ∈ F
[PROOFSTEP]
cases' F.mem_or_compl_mem S with h h
[GOAL]
case mpr.inl
X : Compactum
S : Set X.A
F : Ultrafilter X.A
h2 : str X F ∈ Sᶜ
h1 : S ∈ F → str X F ∈ S
h : S ∈ F
⊢ Sᶜ ∈ F
case mpr.inr
X : Compactum
S : Set X.A
F : Ultrafilter X.A
h2 : str X F ∈ Sᶜ
h1 : S ∈ F → str X F ∈ S
h : Sᶜ ∈ F
⊢ Sᶜ ∈ F
[PROOFSTEP]
exacts [absurd (h1 h) h2, h]
[GOAL]
X : Compactum
⊢ CompactSpace X.A
[PROOFSTEP]
constructor
[GOAL]
case isCompact_univ
X : Compactum
⊢ IsCompact Set.univ
[PROOFSTEP]
rw [isCompact_iff_ultrafilter_le_nhds]
[GOAL]
case isCompact_univ
X : Compactum
⊢ ∀ (f : Ultrafilter X.A), ↑f ≤ 𝓟 Set.univ → ∃ a, a ∈ Set.univ ∧ ↑f ≤ 𝓝 a
[PROOFSTEP]
intro F _
[GOAL]
case isCompact_univ
X : Compactum
F : Ultrafilter X.A
a✝ : ↑F ≤ 𝓟 Set.univ
⊢ ∃ a, a ∈ Set.univ ∧ ↑F ≤ 𝓝 a
[PROOFSTEP]
refine' ⟨X.str F, by tauto, _⟩
[GOAL]
X : Compactum
F : Ultrafilter X.A
a✝ : ↑F ≤ 𝓟 Set.univ
⊢ str X F ∈ Set.univ
[PROOFSTEP]
tauto
[GOAL]
case isCompact_univ
X : Compactum
F : Ultrafilter X.A
a✝ : ↑F ≤ 𝓟 Set.univ
⊢ ↑F ≤ 𝓝 (str X F)
[PROOFSTEP]
rw [le_nhds_iff]
[GOAL]
case isCompact_univ
X : Compactum
F : Ultrafilter X.A
a✝ : ↑F ≤ 𝓟 Set.univ
⊢ ∀ (s : Set X.A), str X F ∈ s → IsOpen s → s ∈ ↑F
[PROOFSTEP]
intro S h1 h2
[GOAL]
case isCompact_univ
X : Compactum
F : Ultrafilter X.A
a✝ : ↑F ≤ 𝓟 Set.univ
S : Set X.A
h1 : str X F ∈ S
h2 : IsOpen S
⊢ S ∈ ↑F
[PROOFSTEP]
exact h2 F h1
[GOAL]
X : Compactum
A B : Set X.A
⊢ Compactum.basic (A ∩ B) = Compactum.basic A ∩ Compactum.basic B
[PROOFSTEP]
ext G
[GOAL]
case h
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
⊢ G ∈ Compactum.basic (A ∩ B) ↔ G ∈ Compactum.basic A ∩ Compactum.basic B
[PROOFSTEP]
constructor
[GOAL]
case h.mp
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
⊢ G ∈ Compactum.basic (A ∩ B) → G ∈ Compactum.basic A ∩ Compactum.basic B
[PROOFSTEP]
intro hG
[GOAL]
case h.mp
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
hG : G ∈ Compactum.basic (A ∩ B)
⊢ G ∈ Compactum.basic A ∩ Compactum.basic B
[PROOFSTEP]
constructor
[GOAL]
case h.mp.left
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
hG : G ∈ Compactum.basic (A ∩ B)
⊢ G ∈ Compactum.basic A
[PROOFSTEP]
filter_upwards [hG] with _
[GOAL]
case h.mp.right
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
hG : G ∈ Compactum.basic (A ∩ B)
⊢ G ∈ Compactum.basic B
[PROOFSTEP]
filter_upwards [hG] with _
[GOAL]
case h
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
hG : G ∈ Compactum.basic (A ∩ B)
a✝ : X.A
⊢ a✝ ∈ A ∩ B → a✝ ∈ A
case h X : Compactum A B : Set X.A G : Ultrafilter X.A hG : G ∈ Compactum.basic (A ∩ B) a✝ : X.A ⊢ a✝ ∈ A ∩ B → a✝ ∈ B
[PROOFSTEP]
exacts [And.left, And.right]
[GOAL]
case h.mpr
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
⊢ G ∈ Compactum.basic A ∩ Compactum.basic B → G ∈ Compactum.basic (A ∩ B)
[PROOFSTEP]
rintro ⟨h1, h2⟩
[GOAL]
case h.mpr.intro
X : Compactum
A B : Set X.A
G : Ultrafilter X.A
h1 : G ∈ Compactum.basic A
h2 : G ∈ Compactum.basic B
⊢ G ∈ Compactum.basic (A ∩ B)
[PROOFSTEP]
exact inter_mem h1 h2
[GOAL]
X : Compactum
A : Set X.A
a : X.A
ha : a ∈ A
⊢ str X (incl X a) = a
[PROOFSTEP]
simp
[GOAL]
X : Compactum
A : Set X.A
⊢ Compactum.cl (Compactum.cl A) ⊆ Compactum.cl A
[PROOFSTEP]
rintro _
  ⟨F, hF, rfl⟩
      -- Notation to be used in this proof.
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
let fsu := Finset (Set (Ultrafilter X))
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
let ssu := Set (Set (Ultrafilter X))
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
let ι : fsu → ssu := fun x ↦ ↑x
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
let C0 : ssu := {Z | ∃ B ∈ F, X.str ⁻¹' B = Z}
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
let AA := {G : Ultrafilter X | A ∈ G}
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
let C1 := insert AA C0
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
let C2 := finiteInterClosure C1
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
have claim1 : ∀ (B) (_ : B ∈ C0) (C) (_ : C ∈ C0), B ∩ C ∈ C0 :=
  by
  rintro B ⟨Q, hQ, rfl⟩ C ⟨R, hR, rfl⟩
  use Q ∩ R
  simp only [and_true_iff, eq_self_iff_true, Set.preimage_inter]
  exact inter_sets _ hQ hR
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
⊢ ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
[PROOFSTEP]
rintro B ⟨Q, hQ, rfl⟩ C ⟨R, hR, rfl⟩
[GOAL]
case intro.intro.intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
Q : Set X.A
hQ : Q ∈ F
R : Set X.A
hR : R ∈ F
⊢ str X ⁻¹' Q ∩ str X ⁻¹' R ∈ C0
[PROOFSTEP]
use Q ∩ R
[GOAL]
case h
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
Q : Set X.A
hQ : Q ∈ F
R : Set X.A
hR : R ∈ F
⊢ Q ∩ R ∈ F ∧ str X ⁻¹' (Q ∩ R) = str X ⁻¹' Q ∩ str X ⁻¹' R
[PROOFSTEP]
simp only [and_true_iff, eq_self_iff_true, Set.preimage_inter]
[GOAL]
case h
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
Q : Set X.A
hQ : Q ∈ F
R : Set X.A
hR : R ∈ F
⊢ Q ∩ R ∈ F
[PROOFSTEP]
exact inter_sets _ hQ hR
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
have claim2 : ∀ B ∈ C0, Set.Nonempty B := by
  rintro B ⟨Q, hQ, rfl⟩
  obtain ⟨q⟩ := Filter.nonempty_of_mem hQ
  use X.incl q
  simpa
    -- The intersection of AA with every set in C0 is nonempty.
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
⊢ ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
[PROOFSTEP]
rintro B ⟨Q, hQ, rfl⟩
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
Q : Set X.A
hQ : Q ∈ F
⊢ Set.Nonempty (str X ⁻¹' Q)
[PROOFSTEP]
obtain ⟨q⟩ := Filter.nonempty_of_mem hQ
[GOAL]
case intro.intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
Q : Set X.A
hQ : Q ∈ F
q : X.A
h✝ : q ∈ Q
⊢ Set.Nonempty (str X ⁻¹' Q)
[PROOFSTEP]
use X.incl q
[GOAL]
case h
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
Q : Set X.A
hQ : Q ∈ F
q : X.A
h✝ : q ∈ Q
⊢ incl X q ∈ str X ⁻¹' Q
[PROOFSTEP]
simpa
  -- The intersection of AA with every set in C0 is nonempty.
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
have claim3 : ∀ B ∈ C0, (AA ∩ B).Nonempty := by
  rintro B ⟨Q, hQ, rfl⟩
  have : (Q ∩ cl A).Nonempty := Filter.nonempty_of_mem (inter_mem hQ hF)
  rcases this with ⟨q, hq1, P, hq2, hq3⟩
  refine' ⟨P, hq2, _⟩
  rw [← hq3] at hq1
  simpa
    -- Suffices to show that the intersection of any finite subcollection of C1 is nonempty.
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
⊢ ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
[PROOFSTEP]
rintro B ⟨Q, hQ, rfl⟩
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
Q : Set X.A
hQ : Q ∈ F
⊢ Set.Nonempty (AA ∩ str X ⁻¹' Q)
[PROOFSTEP]
have : (Q ∩ cl A).Nonempty := Filter.nonempty_of_mem (inter_mem hQ hF)
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
Q : Set X.A
hQ : Q ∈ F
this : Set.Nonempty (Q ∩ Compactum.cl A)
⊢ Set.Nonempty (AA ∩ str X ⁻¹' Q)
[PROOFSTEP]
rcases this with ⟨q, hq1, P, hq2, hq3⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
Q : Set X.A
hQ : Q ∈ F
q : X.A
hq1 : q ∈ Q
P : Ultrafilter X.A
hq2 : P ∈ Compactum.basic A
hq3 : str X P = q
⊢ Set.Nonempty (AA ∩ str X ⁻¹' Q)
[PROOFSTEP]
refine' ⟨P, hq2, _⟩
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
Q : Set X.A
hQ : Q ∈ F
q : X.A
hq1 : q ∈ Q
P : Ultrafilter X.A
hq2 : P ∈ Compactum.basic A
hq3 : str X P = q
⊢ P ∈ str X ⁻¹' Q
[PROOFSTEP]
rw [← hq3] at hq1
[GOAL]
case intro.intro.intro.intro.intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
Q : Set X.A
hQ : Q ∈ F
q : X.A
P : Ultrafilter X.A
hq1 : str X P ∈ Q
hq2 : P ∈ Compactum.basic A
hq3 : str X P = q
⊢ P ∈ str X ⁻¹' Q
[PROOFSTEP]
simpa
  -- Suffices to show that the intersection of any finite subcollection of C1 is nonempty.
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
suffices ∀ T : fsu, ι T ⊆ C1 → (⋂₀ ι T).Nonempty
  by
  obtain ⟨G, h1⟩ := exists_ultrafilter_of_finite_inter_nonempty _ this
  use X.join G
  have : G.map X.str = F := Ultrafilter.coe_le_coe.1 fun S hS => h1 (Or.inr ⟨S, hS, rfl⟩)
  rw [join_distrib, this]
  exact
    ⟨h1 (Or.inl rfl), rfl⟩
      -- C2 is closed under finite intersections (by construction!).
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
this : ∀ (T : fsu), ι T ⊆ C1 → Set.Nonempty (⋂₀ ι T)
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
obtain ⟨G, h1⟩ := exists_ultrafilter_of_finite_inter_nonempty _ this
[GOAL]
case intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
this : ∀ (T : fsu), ι T ⊆ C1 → Set.Nonempty (⋂₀ ι T)
G : Ultrafilter (Ultrafilter X.A)
h1 : C1 ⊆ G.sets
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
use X.join G
[GOAL]
case h
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
this : ∀ (T : fsu), ι T ⊆ C1 → Set.Nonempty (⋂₀ ι T)
G : Ultrafilter (Ultrafilter X.A)
h1 : C1 ⊆ G.sets
⊢ join X G ∈ Compactum.basic A ∧ str X (join X G) = str X F
[PROOFSTEP]
have : G.map X.str = F := Ultrafilter.coe_le_coe.1 fun S hS => h1 (Or.inr ⟨S, hS, rfl⟩)
[GOAL]
case h
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
this✝ : ∀ (T : fsu), ι T ⊆ C1 → Set.Nonempty (⋂₀ ι T)
G : Ultrafilter (Ultrafilter X.A)
h1 : C1 ⊆ G.sets
this : Ultrafilter.map (str X) G = F
⊢ join X G ∈ Compactum.basic A ∧ str X (join X G) = str X F
[PROOFSTEP]
rw [join_distrib, this]
[GOAL]
case h
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
this✝ : ∀ (T : fsu), ι T ⊆ C1 → Set.Nonempty (⋂₀ ι T)
G : Ultrafilter (Ultrafilter X.A)
h1 : C1 ⊆ G.sets
this : Ultrafilter.map (str X) G = F
⊢ join X G ∈ Compactum.basic A ∧ str X F = str X F
[PROOFSTEP]
exact
  ⟨h1 (Or.inl rfl), rfl⟩
    -- C2 is closed under finite intersections (by construction!).
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
⊢ ∀ (T : fsu), ι T ⊆ C1 → Set.Nonempty (⋂₀ ι T)
[PROOFSTEP]
have claim4 := finiteInterClosure_finiteInter C1
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
⊢ ∀ (T : fsu), ι T ⊆ C1 → Set.Nonempty (⋂₀ ι T)
[PROOFSTEP]
have claim5 : FiniteInter C0 :=
  ⟨⟨_, univ_mem, Set.preimage_univ⟩, claim1⟩
    -- Every element of C2 is nonempty.
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
⊢ ∀ (T : fsu), ι T ⊆ C1 → Set.Nonempty (⋂₀ ι T)
[PROOFSTEP]
have claim6 : ∀ P ∈ C2, (P : Set (Ultrafilter X)).Nonempty :=
  by
  suffices ∀ P ∈ C2, P ∈ C0 ∨ ∃ Q ∈ C0, P = AA ∩ Q by
    intro P hP
    cases' this P hP with h h
    · exact claim2 _ h
    · rcases h with ⟨Q, hQ, rfl⟩
      exact claim3 _ hQ
  intro P hP
  exact claim5.finiteInterClosure_insert _ hP
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
⊢ ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → Set.Nonempty P
[PROOFSTEP]
suffices ∀ P ∈ C2, P ∈ C0 ∨ ∃ Q ∈ C0, P = AA ∩ Q by
  intro P hP
  cases' this P hP with h h
  · exact claim2 _ h
  · rcases h with ⟨Q, hQ, rfl⟩
    exact claim3 _ hQ
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
this : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → P ∈ C0 ∨ ∃ Q, Q ∈ C0 ∧ P = AA ∩ Q
⊢ ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → Set.Nonempty P
[PROOFSTEP]
intro P hP
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
this : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → P ∈ C0 ∨ ∃ Q, Q ∈ C0 ∧ P = AA ∩ Q
P : Set (Ultrafilter X.A)
hP : P ∈ C2
⊢ Set.Nonempty P
[PROOFSTEP]
cases' this P hP with h h
[GOAL]
case inl
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
this : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → P ∈ C0 ∨ ∃ Q, Q ∈ C0 ∧ P = AA ∩ Q
P : Set (Ultrafilter X.A)
hP : P ∈ C2
h : P ∈ C0
⊢ Set.Nonempty P
[PROOFSTEP]
exact claim2 _ h
[GOAL]
case inr
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
this : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → P ∈ C0 ∨ ∃ Q, Q ∈ C0 ∧ P = AA ∩ Q
P : Set (Ultrafilter X.A)
hP : P ∈ C2
h : ∃ Q, Q ∈ C0 ∧ P = AA ∩ Q
⊢ Set.Nonempty P
[PROOFSTEP]
rcases h with ⟨Q, hQ, rfl⟩
[GOAL]
case inr.intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
this : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → P ∈ C0 ∨ ∃ Q, Q ∈ C0 ∧ P = AA ∩ Q
Q : Set (Ultrafilter X.A)
hQ : Q ∈ C0
hP : AA ∩ Q ∈ C2
⊢ Set.Nonempty (AA ∩ Q)
[PROOFSTEP]
exact claim3 _ hQ
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
⊢ ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → P ∈ C0 ∨ ∃ Q, Q ∈ C0 ∧ P = AA ∩ Q
[PROOFSTEP]
intro P hP
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
P : Set (Ultrafilter X.A)
hP : P ∈ C2
⊢ P ∈ C0 ∨ ∃ Q, Q ∈ C0 ∧ P = AA ∩ Q
[PROOFSTEP]
exact claim5.finiteInterClosure_insert _ hP
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
claim6 : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → Set.Nonempty P
⊢ ∀ (T : fsu), ι T ⊆ C1 → Set.Nonempty (⋂₀ ι T)
[PROOFSTEP]
intro T hT
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
claim6 : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → Set.Nonempty P
T : fsu
hT : ι T ⊆ C1
⊢ Set.Nonempty (⋂₀ ι T)
[PROOFSTEP]
suffices ⋂₀ ι T ∈ C2 by exact claim6 _ this
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
claim6 : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → Set.Nonempty P
T : fsu
hT : ι T ⊆ C1
this : ⋂₀ ι T ∈ C2
⊢ Set.Nonempty (⋂₀ ι T)
[PROOFSTEP]
exact claim6 _ this
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
claim6 : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → Set.Nonempty P
T : fsu
hT : ι T ⊆ C1
⊢ ⋂₀ ι T ∈ C2
[PROOFSTEP]
apply claim4.finiteInter_mem T
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
claim6 : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → Set.Nonempty P
T : fsu
hT : ι T ⊆ C1
⊢ ↑T ⊆ finiteInterClosure C1
[PROOFSTEP]
intro t ht
[GOAL]
case intro.intro
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : F ∈ Compactum.basic (Compactum.cl A)
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
C0 : ssu := {Z | ∃ B, B ∈ F ∧ str X ⁻¹' B = Z}
AA : Set (Ultrafilter X.A) := {G | A ∈ G}
C1 : ssu := insert AA C0
C2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure C1
claim1 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → ∀ (C : Set (Ultrafilter X.A)), C ∈ C0 → B ∩ C ∈ C0
claim2 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty B
claim3 : ∀ (B : Set (Ultrafilter X.A)), B ∈ C0 → Set.Nonempty (AA ∩ B)
claim4 : FiniteInter (finiteInterClosure C1)
claim5 : FiniteInter C0
claim6 : ∀ (P : Set (Ultrafilter X.A)), P ∈ C2 → Set.Nonempty P
T : fsu
hT : ι T ⊆ C1
t : Set (Ultrafilter X.A)
ht : t ∈ ↑T
⊢ t ∈ finiteInterClosure C1
[PROOFSTEP]
refine' finiteInterClosure.basic (@hT t ht)
[GOAL]
X : Compactum
A : Set X.A
⊢ IsClosed (Compactum.cl A)
[PROOFSTEP]
rw [isClosed_iff]
[GOAL]
X : Compactum
A : Set X.A
⊢ ∀ (F : Ultrafilter X.A), Compactum.cl A ∈ F → str X F ∈ Compactum.cl A
[PROOFSTEP]
intro F hF
[GOAL]
X : Compactum
A : Set X.A
F : Ultrafilter X.A
hF : Compactum.cl A ∈ F
⊢ str X F ∈ Compactum.cl A
[PROOFSTEP]
exact cl_cl _ ⟨F, hF, rfl⟩
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
⊢ ↑F ≤ 𝓝 x → str X F = x
[PROOFSTEP]
let fsu := Finset (Set (Ultrafilter X))
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
⊢ ↑F ≤ 𝓝 x → str X F = x
[PROOFSTEP]
let ssu := Set (Set (Ultrafilter X))
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
⊢ ↑F ≤ 𝓝 x → str X F = x
[PROOFSTEP]
let ι : fsu → ssu := fun x ↦ ↑x
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
⊢ ↑F ≤ 𝓝 x → str X F = x
[PROOFSTEP]
let T0 : ssu := {S | ∃ A ∈ F, S = basic A}
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
⊢ ↑F ≤ 𝓝 x → str X F = x
[PROOFSTEP]
let AA := X.str ⁻¹' { x }
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
⊢ ↑F ≤ 𝓝 x → str X F = x
[PROOFSTEP]
let T1 := insert AA T0
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
⊢ ↑F ≤ 𝓝 x → str X F = x
[PROOFSTEP]
let T2 := finiteInterClosure T1
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
⊢ ↑F ≤ 𝓝 x → str X F = x
[PROOFSTEP]
intro cond
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
⊢ str X F = x
[PROOFSTEP]
have claim1 : ∀ A : Set X, IsClosed A → A ∈ F → x ∈ A :=
  by
  intro A hA h
  by_contra H
  rw [le_nhds_iff] at cond
  specialize cond Aᶜ H hA.isOpen_compl
  rw [Ultrafilter.mem_coe, Ultrafilter.compl_mem_iff_not_mem] at cond
  contradiction
    -- If A ∈ F, then x ∈ cl A.
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
⊢ ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
[PROOFSTEP]
intro A hA h
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
A : Set X.A
hA : IsClosed A
h : A ∈ F
⊢ x ∈ A
[PROOFSTEP]
by_contra H
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
A : Set X.A
hA : IsClosed A
h : A ∈ F
H : ¬x ∈ A
⊢ False
[PROOFSTEP]
rw [le_nhds_iff] at cond
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ∀ (s : Set X.A), x ∈ s → IsOpen s → s ∈ ↑F
A : Set X.A
hA : IsClosed A
h : A ∈ F
H : ¬x ∈ A
⊢ False
[PROOFSTEP]
specialize cond Aᶜ H hA.isOpen_compl
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
A : Set X.A
hA : IsClosed A
h : A ∈ F
H : ¬x ∈ A
cond : Aᶜ ∈ ↑F
⊢ False
[PROOFSTEP]
rw [Ultrafilter.mem_coe, Ultrafilter.compl_mem_iff_not_mem] at cond
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
A : Set X.A
hA : IsClosed A
h : A ∈ F
H : ¬x ∈ A
cond : ¬A ∈ F
⊢ False
[PROOFSTEP]
contradiction
  -- If A ∈ F, then x ∈ cl A.
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
⊢ str X F = x
[PROOFSTEP]
have claim2 : ∀ A : Set X, A ∈ F → x ∈ cl A := by
  intro A hA
  exact
    claim1 (cl A) (isClosed_cl A)
      (mem_of_superset hA (subset_cl A))
        -- T0 is closed under intersections.
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
⊢ ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
[PROOFSTEP]
intro A hA
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
A : Set X.A
hA : A ∈ F
⊢ x ∈ Compactum.cl A
[PROOFSTEP]
exact
  claim1 (cl A) (isClosed_cl A)
    (mem_of_superset hA (subset_cl A))
      -- T0 is closed under intersections.
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
⊢ str X F = x
[PROOFSTEP]
have claim3 : ∀ (S1) (_ : S1 ∈ T0) (S2) (_ : S2 ∈ T0), S1 ∩ S2 ∈ T0 :=
  by
  rintro S1 ⟨S1, hS1, rfl⟩ S2 ⟨S2, hS2, rfl⟩
  exact
    ⟨S1 ∩ S2, inter_mem hS1 hS2, by simp [basic_inter]⟩
      -- For every S ∈ T0, the intersection AA ∩ S is nonempty.
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
⊢ ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
[PROOFSTEP]
rintro S1 ⟨S1, hS1, rfl⟩ S2 ⟨S2, hS2, rfl⟩
[GOAL]
case intro.intro.intro.intro
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
S1 : Set X.A
hS1 : S1 ∈ F
S2 : Set X.A
hS2 : S2 ∈ F
⊢ Compactum.basic S1 ∩ Compactum.basic S2 ∈ T0
[PROOFSTEP]
exact
  ⟨S1 ∩ S2, inter_mem hS1 hS2, by simp [basic_inter]⟩
    -- For every S ∈ T0, the intersection AA ∩ S is nonempty.
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
S1 : Set X.A
hS1 : S1 ∈ F
S2 : Set X.A
hS2 : S2 ∈ F
⊢ Compactum.basic S1 ∩ Compactum.basic S2 = Compactum.basic (S1 ∩ S2)
[PROOFSTEP]
simp [basic_inter]
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
⊢ str X F = x
[PROOFSTEP]
have claim4 : ∀ S ∈ T0, (AA ∩ S).Nonempty := by
  rintro S ⟨S, hS, rfl⟩
  rcases claim2 _ hS with ⟨G, hG, hG2⟩
  exact
    ⟨G, hG2, hG⟩
      -- Every element of T0 is nonempty.
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
⊢ ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
[PROOFSTEP]
rintro S ⟨S, hS, rfl⟩
[GOAL]
case intro.intro
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
S : Set X.A
hS : S ∈ F
⊢ Set.Nonempty (AA ∩ Compactum.basic S)
[PROOFSTEP]
rcases claim2 _ hS with ⟨G, hG, hG2⟩
[GOAL]
case intro.intro.intro.intro
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
S : Set X.A
hS : S ∈ F
G : Ultrafilter X.A
hG : G ∈ Compactum.basic S
hG2 : str X G = x
⊢ Set.Nonempty (AA ∩ Compactum.basic S)
[PROOFSTEP]
exact
  ⟨G, hG2, hG⟩
    -- Every element of T0 is nonempty.
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
⊢ str X F = x
[PROOFSTEP]
have claim5 : ∀ S ∈ T0, Set.Nonempty S := by
  rintro S ⟨S, hS, rfl⟩
  exact
    ⟨F, hS⟩
      -- Every element of T2 is nonempty.
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
⊢ ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
[PROOFSTEP]
rintro S ⟨S, hS, rfl⟩
[GOAL]
case intro.intro
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
S : Set X.A
hS : S ∈ F
⊢ Set.Nonempty (Compactum.basic S)
[PROOFSTEP]
exact
  ⟨F, hS⟩
    -- Every element of T2 is nonempty.
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
⊢ str X F = x
[PROOFSTEP]
have claim6 : ∀ S ∈ T2, Set.Nonempty S :=
  by
  suffices ∀ S ∈ T2, S ∈ T0 ∨ ∃ Q ∈ T0, S = AA ∩ Q by
    intro S hS
    cases' this _ hS with h h
    · exact claim5 S h
    · rcases h with ⟨Q, hQ, rfl⟩
      exact claim4 Q hQ
  intro S hS
  apply finiteInterClosure_insert
  · constructor
    · use Set.univ
      refine' ⟨Filter.univ_sets _, _⟩
      ext
      refine' ⟨_, by tauto⟩
      · intro
        apply Filter.univ_sets
    · exact claim3
  · exact hS
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
⊢ ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
[PROOFSTEP]
suffices ∀ S ∈ T2, S ∈ T0 ∨ ∃ Q ∈ T0, S = AA ∩ Q by
  intro S hS
  cases' this _ hS with h h
  · exact claim5 S h
  · rcases h with ⟨Q, hQ, rfl⟩
    exact claim4 Q hQ
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
this : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → S ∈ T0 ∨ ∃ Q, Q ∈ T0 ∧ S = AA ∩ Q
⊢ ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
[PROOFSTEP]
intro S hS
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
this : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → S ∈ T0 ∨ ∃ Q, Q ∈ T0 ∧ S = AA ∩ Q
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ Set.Nonempty S
[PROOFSTEP]
cases' this _ hS with h h
[GOAL]
case inl
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
this : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → S ∈ T0 ∨ ∃ Q, Q ∈ T0 ∧ S = AA ∩ Q
S : Set (Ultrafilter X.A)
hS : S ∈ T2
h : S ∈ T0
⊢ Set.Nonempty S
[PROOFSTEP]
exact claim5 S h
[GOAL]
case inr
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
this : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → S ∈ T0 ∨ ∃ Q, Q ∈ T0 ∧ S = AA ∩ Q
S : Set (Ultrafilter X.A)
hS : S ∈ T2
h : ∃ Q, Q ∈ T0 ∧ S = AA ∩ Q
⊢ Set.Nonempty S
[PROOFSTEP]
rcases h with ⟨Q, hQ, rfl⟩
[GOAL]
case inr.intro.intro
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
this : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → S ∈ T0 ∨ ∃ Q, Q ∈ T0 ∧ S = AA ∩ Q
Q : Set (Ultrafilter X.A)
hQ : Q ∈ T0
hS : AA ∩ Q ∈ T2
⊢ Set.Nonempty (AA ∩ Q)
[PROOFSTEP]
exact claim4 Q hQ
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
⊢ ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → S ∈ T0 ∨ ∃ Q, Q ∈ T0 ∧ S = AA ∩ Q
[PROOFSTEP]
intro S hS
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ S ∈ T0 ∨ ∃ Q, Q ∈ T0 ∧ S = AA ∩ Q
[PROOFSTEP]
apply finiteInterClosure_insert
[GOAL]
case cond
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ FiniteInter T0
[PROOFSTEP]
constructor
[GOAL]
case cond.univ_mem
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ Set.univ ∈ T0
[PROOFSTEP]
use Set.univ
[GOAL]
case h
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ Set.univ ∈ F ∧ Set.univ = Compactum.basic Set.univ
[PROOFSTEP]
refine' ⟨Filter.univ_sets _, _⟩
[GOAL]
case h
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ Set.univ = Compactum.basic Set.univ
[PROOFSTEP]
ext
[GOAL]
case h.h
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
x✝ : Ultrafilter X.A
⊢ x✝ ∈ Set.univ ↔ x✝ ∈ Compactum.basic Set.univ
[PROOFSTEP]
refine' ⟨_, by tauto⟩
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
x✝ : Ultrafilter X.A
⊢ x✝ ∈ Compactum.basic Set.univ → x✝ ∈ Set.univ
[PROOFSTEP]
tauto
[GOAL]
case h.h
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
x✝ : Ultrafilter X.A
⊢ x✝ ∈ Set.univ → x✝ ∈ Compactum.basic Set.univ
[PROOFSTEP]
intro
[GOAL]
case h.h
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
x✝ : Ultrafilter X.A
a✝ : x✝ ∈ Set.univ
⊢ x✝ ∈ Compactum.basic Set.univ
[PROOFSTEP]
apply Filter.univ_sets
[GOAL]
case cond.inter_mem
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ ∀ ⦃s : Set (Ultrafilter X.A)⦄, s ∈ T0 → ∀ ⦃t : Set (Ultrafilter X.A)⦄, t ∈ T0 → s ∩ t ∈ T0
[PROOFSTEP]
exact claim3
[GOAL]
case H
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
S : Set (Ultrafilter X.A)
hS : S ∈ T2
⊢ S ∈ finiteInterClosure (insert AA T0)
[PROOFSTEP]
exact hS
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
⊢ str X F = x
[PROOFSTEP]
suffices ∀ F : fsu, ↑F ⊆ T1 → (⋂₀ ι F).Nonempty
  by
  obtain ⟨G, h1⟩ := Ultrafilter.exists_ultrafilter_of_finite_inter_nonempty _ this
  have c1 : X.join G = F := Ultrafilter.coe_le_coe.1 fun P hP => h1 (Or.inr ⟨P, hP, rfl⟩)
  have c2 : G.map X.str = X.incl x :=
    by
    refine' Ultrafilter.coe_le_coe.1 fun P hP => _
    apply mem_of_superset (h1 (Or.inl rfl))
    rintro x ⟨rfl⟩
    exact hP
  simp [← c1, c2]
    -- Finish...
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
this : ∀ (F : fsu), ↑F ⊆ T1 → Set.Nonempty (⋂₀ ι F)
⊢ str X F = x
[PROOFSTEP]
obtain ⟨G, h1⟩ := Ultrafilter.exists_ultrafilter_of_finite_inter_nonempty _ this
[GOAL]
case intro
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
this : ∀ (F : fsu), ↑F ⊆ T1 → Set.Nonempty (⋂₀ ι F)
G : Ultrafilter (Ultrafilter X.A)
h1 : T1 ⊆ G.sets
⊢ str X F = x
[PROOFSTEP]
have c1 : X.join G = F := Ultrafilter.coe_le_coe.1 fun P hP => h1 (Or.inr ⟨P, hP, rfl⟩)
[GOAL]
case intro
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
this : ∀ (F : fsu), ↑F ⊆ T1 → Set.Nonempty (⋂₀ ι F)
G : Ultrafilter (Ultrafilter X.A)
h1 : T1 ⊆ G.sets
c1 : join X G = F
⊢ str X F = x
[PROOFSTEP]
have c2 : G.map X.str = X.incl x := by
  refine' Ultrafilter.coe_le_coe.1 fun P hP => _
  apply mem_of_superset (h1 (Or.inl rfl))
  rintro x ⟨rfl⟩
  exact hP
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
this : ∀ (F : fsu), ↑F ⊆ T1 → Set.Nonempty (⋂₀ ι F)
G : Ultrafilter (Ultrafilter X.A)
h1 : T1 ⊆ G.sets
c1 : join X G = F
⊢ Ultrafilter.map (str X) G = incl X x
[PROOFSTEP]
refine' Ultrafilter.coe_le_coe.1 fun P hP => _
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
this : ∀ (F : fsu), ↑F ⊆ T1 → Set.Nonempty (⋂₀ ι F)
G : Ultrafilter (Ultrafilter X.A)
h1 : T1 ⊆ G.sets
c1 : join X G = F
P : Set X.A
hP : P ∈ ↑(incl X x)
⊢ P ∈ ↑(Ultrafilter.map (str X) G)
[PROOFSTEP]
apply mem_of_superset (h1 (Or.inl rfl))
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
this : ∀ (F : fsu), ↑F ⊆ T1 → Set.Nonempty (⋂₀ ι F)
G : Ultrafilter (Ultrafilter X.A)
h1 : T1 ⊆ G.sets
c1 : join X G = F
P : Set X.A
hP : P ∈ ↑(incl X x)
⊢ AA ⊆ str X ⁻¹' P
[PROOFSTEP]
rintro x ⟨rfl⟩
[GOAL]
case refl
X : Compactum
F : Ultrafilter X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
G : Ultrafilter (Ultrafilter X.A)
c1 : join X G = F
P : Set X.A
x : Ultrafilter X.A
AA : Set (Ultrafilter X.A) := str X ⁻¹' {str X x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 (str X x)
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → str X x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → str X x ∈ Compactum.cl A
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
this : ∀ (F : fsu), ↑F ⊆ T1 → Set.Nonempty (⋂₀ ι F)
h1 : T1 ⊆ G.sets
hP : P ∈ ↑(incl X (str X x))
⊢ x ∈ str X ⁻¹' P
[PROOFSTEP]
exact hP
[GOAL]
case intro
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
this : ∀ (F : fsu), ↑F ⊆ T1 → Set.Nonempty (⋂₀ ι F)
G : Ultrafilter (Ultrafilter X.A)
h1 : T1 ⊆ G.sets
c1 : join X G = F
c2 : Ultrafilter.map (str X) G = incl X x
⊢ str X F = x
[PROOFSTEP]
simp [← c1, c2]
  -- Finish...
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
⊢ ∀ (F : fsu), ↑F ⊆ T1 → Set.Nonempty (⋂₀ ι F)
[PROOFSTEP]
intro T hT
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
T : fsu
hT : ↑T ⊆ T1
⊢ Set.Nonempty (⋂₀ ι T)
[PROOFSTEP]
refine' claim6 _ (finiteInter_mem (.finiteInterClosure_finiteInter _) _ _)
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
T : fsu
hT : ↑T ⊆ T1
⊢ ↑T ⊆ finiteInterClosure T1
[PROOFSTEP]
intro t ht
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
ssu : Type u_1 := Set (Set (Ultrafilter X.A))
ι : fsu → ssu := fun x => ↑x
T0 : ssu := {S | ∃ A, A ∈ F ∧ S = Compactum.basic A}
AA : Set (Ultrafilter X.A) := str X ⁻¹' {x}
T1 : ssu := insert AA T0
T2 : Set (Set (Ultrafilter X.A)) := finiteInterClosure T1
cond : ↑F ≤ 𝓝 x
claim1 : ∀ (A : Set X.A), IsClosed A → A ∈ F → x ∈ A
claim2 : ∀ (A : Set X.A), A ∈ F → x ∈ Compactum.cl A
claim3 : ∀ (S1 : Set (Ultrafilter X.A)), S1 ∈ T0 → ∀ (S2 : Set (Ultrafilter X.A)), S2 ∈ T0 → S1 ∩ S2 ∈ T0
claim4 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty (AA ∩ S)
claim5 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T0 → Set.Nonempty S
claim6 : ∀ (S : Set (Ultrafilter X.A)), S ∈ T2 → Set.Nonempty S
T : fsu
hT : ↑T ⊆ T1
t : Set (Ultrafilter X.A)
ht : t ∈ ↑T
⊢ t ∈ finiteInterClosure T1
[PROOFSTEP]
exact finiteInterClosure.basic (@hT t ht)
[GOAL]
X : Compactum
F : Ultrafilter X.A
x : X.A
h : str X F = x
s : Set X.A
hx : x ∈ s
hs : IsOpen s
⊢ str X F ∈ s
[PROOFSTEP]
rwa [h]
[GOAL]
X : Compactum
⊢ T2Space X.A
[PROOFSTEP]
rw [t2_iff_ultrafilter]
[GOAL]
X : Compactum
⊢ ∀ {x y : X.A} (f : Ultrafilter X.A), ↑f ≤ 𝓝 x → ↑f ≤ 𝓝 y → x = y
[PROOFSTEP]
intro _ _ F hx hy
[GOAL]
X : Compactum
x✝ y✝ : X.A
F : Ultrafilter X.A
hx : ↑F ≤ 𝓝 x✝
hy : ↑F ≤ 𝓝 y✝
⊢ x✝ = y✝
[PROOFSTEP]
rw [← str_eq_of_le_nhds _ _ hx, ← str_eq_of_le_nhds _ _ hy]
[GOAL]
X : Compactum
F : Ultrafilter X.A
⊢ Ultrafilter.lim F = str X F
[PROOFSTEP]
rw [Ultrafilter.lim_eq_iff_le_nhds, le_nhds_iff]
[GOAL]
X : Compactum
F : Ultrafilter X.A
⊢ ∀ (s : Set X.A), str X F ∈ s → IsOpen s → s ∈ ↑F
[PROOFSTEP]
tauto
[GOAL]
X : Compactum
A : Set X.A
⊢ Compactum.cl A = closure A
[PROOFSTEP]
ext
[GOAL]
case h
X : Compactum
A : Set X.A
x✝ : X.A
⊢ x✝ ∈ Compactum.cl A ↔ x✝ ∈ closure A
[PROOFSTEP]
rw [mem_closure_iff_ultrafilter]
[GOAL]
case h
X : Compactum
A : Set X.A
x✝ : X.A
⊢ x✝ ∈ Compactum.cl A ↔ ∃ u, A ∈ u ∧ ↑u ≤ 𝓝 x✝
[PROOFSTEP]
constructor
[GOAL]
case h.mp
X : Compactum
A : Set X.A
x✝ : X.A
⊢ x✝ ∈ Compactum.cl A → ∃ u, A ∈ u ∧ ↑u ≤ 𝓝 x✝
[PROOFSTEP]
rintro ⟨F, h1, h2⟩
[GOAL]
case h.mp.intro.intro
X : Compactum
A : Set X.A
x✝ : X.A
F : Ultrafilter X.A
h1 : F ∈ Compactum.basic A
h2 : str X F = x✝
⊢ ∃ u, A ∈ u ∧ ↑u ≤ 𝓝 x✝
[PROOFSTEP]
exact ⟨F, h1, le_nhds_of_str_eq _ _ h2⟩
[GOAL]
case h.mpr
X : Compactum
A : Set X.A
x✝ : X.A
⊢ (∃ u, A ∈ u ∧ ↑u ≤ 𝓝 x✝) → x✝ ∈ Compactum.cl A
[PROOFSTEP]
rintro ⟨F, h1, h2⟩
[GOAL]
case h.mpr.intro.intro
X : Compactum
A : Set X.A
x✝ : X.A
F : Ultrafilter X.A
h1 : A ∈ F
h2 : ↑F ≤ 𝓝 x✝
⊢ x✝ ∈ Compactum.cl A
[PROOFSTEP]
exact ⟨F, h1, str_eq_of_le_nhds _ _ h2⟩
[GOAL]
X Y : Compactum
f : X ⟶ Y
⊢ Continuous f.f
[PROOFSTEP]
rw [continuous_iff_ultrafilter]
[GOAL]
X Y : Compactum
f : X ⟶ Y
⊢ ∀ (x : X.A) (g : Ultrafilter X.A), ↑g ≤ 𝓝 x → Tendsto f.f (↑g) (𝓝 (Monad.Algebra.Hom.f f x))
[PROOFSTEP]
intro x g h
[GOAL]
X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ Tendsto f.f (↑g) (𝓝 (Monad.Algebra.Hom.f f x))
[PROOFSTEP]
rw [Tendsto, ← coe_map]
[GOAL]
X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ ↑(Ultrafilter.map f.f g) ≤ 𝓝 (Monad.Algebra.Hom.f f x)
[PROOFSTEP]
apply le_nhds_of_str_eq
[GOAL]
case a
X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ str Y (Ultrafilter.map f.f g) = Monad.Algebra.Hom.f f x
[PROOFSTEP]
rw [← str_hom_commute, str_eq_of_le_nhds _ x _]
[GOAL]
X Y : Compactum
f : X ⟶ Y
x : X.A
g : Ultrafilter X.A
h : ↑g ≤ 𝓝 x
⊢ ↑g ≤ 𝓝 x
[PROOFSTEP]
apply h
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
⊢ NatTrans.app (Monad.η β) X ≫ Ultrafilter.lim = 𝟙 X
[PROOFSTEP]
ext x
[GOAL]
case h
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
x : (𝟭 (Type u_1)).obj X
⊢ (NatTrans.app (Monad.η β) X ≫ Ultrafilter.lim) x = 𝟙 X x
[PROOFSTEP]
exact lim_eq (pure_le_nhds _)
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
⊢ NatTrans.app (Monad.μ β) X ≫ Ultrafilter.lim = β.toFunctor.map Ultrafilter.lim ≫ Ultrafilter.lim
[PROOFSTEP]
ext FF
[GOAL]
case h
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : (β.toFunctor ⋙ β.toFunctor).obj X
⊢ (NatTrans.app (Monad.μ β) X ≫ Ultrafilter.lim) FF = (β.toFunctor.map Ultrafilter.lim ≫ Ultrafilter.lim) FF
[PROOFSTEP]
change Ultrafilter (Ultrafilter X) at FF
[GOAL]
case h
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
⊢ (NatTrans.app (Monad.μ β) X ≫ Ultrafilter.lim) FF = (β.toFunctor.map Ultrafilter.lim ≫ Ultrafilter.lim) FF
[PROOFSTEP]
set x := (Ultrafilter.map Ultrafilter.lim FF).lim with c1
[GOAL]
case h
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
⊢ (NatTrans.app (Monad.μ β) X ≫ Ultrafilter.lim) FF = (β.toFunctor.map Ultrafilter.lim ≫ Ultrafilter.lim) FF
[PROOFSTEP]
have c2 : ∀ (U : Set X) (F : Ultrafilter X), F.lim ∈ U → IsOpen U → U ∈ F :=
  by
  intro U F h1 hU
  exact isOpen_iff_ultrafilter.mp hU _ h1 _ (Ultrafilter.le_nhds_lim _)
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
⊢ ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
[PROOFSTEP]
intro U F h1 hU
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
U : Set X
F : Ultrafilter X
h1 : Ultrafilter.lim F ∈ U
hU : IsOpen U
⊢ U ∈ F
[PROOFSTEP]
exact isOpen_iff_ultrafilter.mp hU _ h1 _ (Ultrafilter.le_nhds_lim _)
[GOAL]
case h
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
⊢ (NatTrans.app (Monad.μ β) X ≫ Ultrafilter.lim) FF = (β.toFunctor.map Ultrafilter.lim ≫ Ultrafilter.lim) FF
[PROOFSTEP]
have c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x :=
  by
  rw [le_nhds_iff]
  intro U hx hU
  exact mem_coe.2 (c2 _ _ (by rwa [← c1]) hU)
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
⊢ ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
[PROOFSTEP]
rw [le_nhds_iff]
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
⊢ ∀ (s : Set X), x ∈ s → IsOpen s → s ∈ ↑(Ultrafilter.map Ultrafilter.lim FF)
[PROOFSTEP]
intro U hx hU
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
U : Set X
hx : x ∈ U
hU : IsOpen U
⊢ U ∈ ↑(Ultrafilter.map Ultrafilter.lim FF)
[PROOFSTEP]
exact mem_coe.2 (c2 _ _ (by rwa [← c1]) hU)
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
U : Set X
hx : x ∈ U
hU : IsOpen U
⊢ Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF) ∈ U
[PROOFSTEP]
rwa [← c1]
[GOAL]
case h
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
⊢ (NatTrans.app (Monad.μ β) X ≫ Ultrafilter.lim) FF = (β.toFunctor.map Ultrafilter.lim ≫ Ultrafilter.lim) FF
[PROOFSTEP]
have c4 : ∀ U : Set X, x ∈ U → IsOpen U → {G : Ultrafilter X | U ∈ G} ∈ FF :=
  by
  intro U hx hU
  suffices Ultrafilter.lim ⁻¹' U ∈ FF by
    apply mem_of_superset this
    intro P hP
    exact c2 U P hP hU
  exact @c3 U (IsOpen.mem_nhds hU hx)
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
⊢ ∀ (U : Set X), x ∈ U → IsOpen U → {G | U ∈ G} ∈ FF
[PROOFSTEP]
intro U hx hU
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
U : Set X
hx : x ∈ U
hU : IsOpen U
⊢ {G | U ∈ G} ∈ FF
[PROOFSTEP]
suffices Ultrafilter.lim ⁻¹' U ∈ FF by
  apply mem_of_superset this
  intro P hP
  exact c2 U P hP hU
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
U : Set X
hx : x ∈ U
hU : IsOpen U
this : Ultrafilter.lim ⁻¹' U ∈ FF
⊢ {G | U ∈ G} ∈ FF
[PROOFSTEP]
apply mem_of_superset this
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
U : Set X
hx : x ∈ U
hU : IsOpen U
this : Ultrafilter.lim ⁻¹' U ∈ FF
⊢ Ultrafilter.lim ⁻¹' U ⊆ {G | U ∈ G}
[PROOFSTEP]
intro P hP
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
U : Set X
hx : x ∈ U
hU : IsOpen U
this : Ultrafilter.lim ⁻¹' U ∈ FF
P : Ultrafilter X
hP : P ∈ Ultrafilter.lim ⁻¹' U
⊢ P ∈ {G | U ∈ G}
[PROOFSTEP]
exact c2 U P hP hU
[GOAL]
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
U : Set X
hx : x ∈ U
hU : IsOpen U
⊢ Ultrafilter.lim ⁻¹' U ∈ FF
[PROOFSTEP]
exact @c3 U (IsOpen.mem_nhds hU hx)
[GOAL]
case h
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
c4 : ∀ (U : Set X), x ∈ U → IsOpen U → {G | U ∈ G} ∈ FF
⊢ (NatTrans.app (Monad.μ β) X ≫ Ultrafilter.lim) FF = (β.toFunctor.map Ultrafilter.lim ≫ Ultrafilter.lim) FF
[PROOFSTEP]
apply lim_eq
[GOAL]
case h.h
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
c4 : ∀ (U : Set X), x ∈ U → IsOpen U → {G | U ∈ G} ∈ FF
⊢ ↑(NatTrans.app (Monad.μ β) X FF) ≤ 𝓝 ((β.toFunctor.map Ultrafilter.lim ≫ Ultrafilter.lim) FF)
[PROOFSTEP]
rw [le_nhds_iff]
[GOAL]
case h.h
X : Type u_1
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
FF : Ultrafilter (Ultrafilter X)
x : X := Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c1 : x = Ultrafilter.lim (Ultrafilter.map Ultrafilter.lim FF)
c2 : ∀ (U : Set X) (F : Ultrafilter X), Ultrafilter.lim F ∈ U → IsOpen U → U ∈ F
c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x
c4 : ∀ (U : Set X), x ∈ U → IsOpen U → {G | U ∈ G} ∈ FF
⊢ ∀ (s : Set X),
    (β.toFunctor.map Ultrafilter.lim ≫ Ultrafilter.lim) FF ∈ s → IsOpen s → s ∈ ↑(NatTrans.app (Monad.μ β) X FF)
[PROOFSTEP]
exact c4
[GOAL]
X Y : Compactum
f : X.A → Y.A
cont : Continuous f
⊢ β.toFunctor.map f ≫ Y.a = X.a ≫ f
[PROOFSTEP]
rw [continuous_iff_ultrafilter] at cont
[GOAL]
X Y : Compactum
f : X.A → Y.A
cont : ∀ (x : X.A) (g : Ultrafilter X.A), ↑g ≤ 𝓝 x → Tendsto f (↑g) (𝓝 (f x))
⊢ β.toFunctor.map f ≫ Y.a = X.a ≫ f
[PROOFSTEP]
ext (F : Ultrafilter X)
[GOAL]
case h
X Y : Compactum
f : X.A → Y.A
cont : ∀ (x : X.A) (g : Ultrafilter X.A), ↑g ≤ 𝓝 x → Tendsto f (↑g) (𝓝 (f x))
F : Ultrafilter X.A
⊢ (β.toFunctor.map f ≫ Y.a) F = (X.a ≫ f) F
[PROOFSTEP]
specialize cont (X.str F) F (le_nhds_of_str_eq F (X.str F) rfl)
[GOAL]
case h
X Y : Compactum
f : X.A → Y.A
F : Ultrafilter X.A
cont : Tendsto f (↑F) (𝓝 (f (str X F)))
⊢ (β.toFunctor.map f ≫ Y.a) F = (X.a ≫ f) F
[PROOFSTEP]
simp only [types_comp_apply, ofTypeFunctor_map]
[GOAL]
case h
X Y : Compactum
f : X.A → Y.A
F : Ultrafilter X.A
cont : Tendsto f (↑F) (𝓝 (f (str X F)))
⊢ Monad.Algebra.a Y (β.toFunctor.map f F) = f (Monad.Algebra.a X F)
[PROOFSTEP]
exact str_eq_of_le_nhds (Ultrafilter.map f F) _ cont
[GOAL]
⊢ ∀ {X Y : Compactum}, Function.Injective compactumToCompHaus.map
[PROOFSTEP]
intro _ _ _ _ h
[GOAL]
X✝ Y✝ : Compactum
a₁✝ a₂✝ : X✝ ⟶ Y✝
h : compactumToCompHaus.map a₁✝ = compactumToCompHaus.map a₂✝
⊢ a₁✝ = a₂✝
[PROOFSTEP]
apply Monad.Algebra.Hom.ext
[GOAL]
case f
X✝ Y✝ : Compactum
a₁✝ a₂✝ : X✝ ⟶ Y✝
h : compactumToCompHaus.map a₁✝ = compactumToCompHaus.map a₂✝
⊢ a₁✝.f = a₂✝.f
[PROOFSTEP]
apply congrArg (fun f => f.toFun) h
[GOAL]
D : CompHaus
x✝ : Set ↑D.toTop
h : IsOpen x✝
⊢ IsOpen (id ⁻¹' x✝)
[PROOFSTEP]
rw [isOpen_iff_ultrafilter'] at h
[GOAL]
D : CompHaus
x✝ : Set ↑D.toTop
h : ∀ (F : Ultrafilter ↑D.toTop), Ultrafilter.lim F ∈ x✝ → x✝ ∈ ↑F
⊢ IsOpen (id ⁻¹' x✝)
[PROOFSTEP]
exact h
[GOAL]
D : CompHaus
x✝ : Set ↑(compactumToCompHaus.obj (Compactum.ofTopologicalSpace ↑D.toTop)).toTop
h1 : IsOpen x✝
⊢ IsOpen (id ⁻¹' x✝)
[PROOFSTEP]
rw [isOpen_iff_ultrafilter']
[GOAL]
D : CompHaus
x✝ : Set ↑(compactumToCompHaus.obj (Compactum.ofTopologicalSpace ↑D.toTop)).toTop
h1 : IsOpen x✝
⊢ ∀ (F : Ultrafilter ↑D.toTop), Ultrafilter.lim F ∈ id ⁻¹' x✝ → id ⁻¹' x✝ ∈ ↑F
[PROOFSTEP]
intro _ h2
[GOAL]
D : CompHaus
x✝ : Set ↑(compactumToCompHaus.obj (Compactum.ofTopologicalSpace ↑D.toTop)).toTop
h1 : IsOpen x✝
F✝ : Ultrafilter ↑D.toTop
h2 : Ultrafilter.lim F✝ ∈ id ⁻¹' x✝
⊢ id ⁻¹' x✝ ∈ ↑F✝
[PROOFSTEP]
exact h1 _ h2
[GOAL]
⊢ IsEquivalence compactumToCompHaus
[PROOFSTEP]
have := compactumToCompHaus.full
[GOAL]
this : Full compactumToCompHaus
⊢ IsEquivalence compactumToCompHaus
[PROOFSTEP]
have := compactumToCompHaus.faithful
[GOAL]
this✝ : Full compactumToCompHaus
this : Faithful compactumToCompHaus
⊢ IsEquivalence compactumToCompHaus
[PROOFSTEP]
have := compactumToCompHaus.essSurj
[GOAL]
this✝¹ : Full compactumToCompHaus
this✝ : Faithful compactumToCompHaus
this : EssSurj compactumToCompHaus
⊢ IsEquivalence compactumToCompHaus
[PROOFSTEP]
apply Equivalence.ofFullyFaithfullyEssSurj _
[GOAL]
⊢ CreatesLimits (forget CompHaus)
[PROOFSTEP]
let e : forget CompHaus ≅ compactumToCompHaus.inv ⋙ Compactum.forget :=
  (((forget CompHaus).leftUnitor.symm ≪≫
        isoWhiskerRight compactumToCompHaus.asEquivalence.symm.unitIso (forget CompHaus)) ≪≫
      compactumToCompHaus.inv.associator compactumToCompHaus (forget CompHaus)) ≪≫
    isoWhiskerLeft _ compactumToCompHausCompForget
[GOAL]
e : forget CompHaus ≅ Functor.inv compactumToCompHaus ⋙ Compactum.forget :=
  (((Functor.leftUnitor (forget CompHaus)).symm ≪≫
        isoWhiskerRight (CategoryTheory.Equivalence.symm (Functor.asEquivalence compactumToCompHaus)).unitIso
          (forget CompHaus)) ≪≫
      Functor.associator (Functor.inv compactumToCompHaus) compactumToCompHaus (forget CompHaus)) ≪≫
    isoWhiskerLeft (Functor.inv compactumToCompHaus) compactumToCompHausCompForget
⊢ CreatesLimits (forget CompHaus)
[PROOFSTEP]
exact createsLimitsOfNatIso e.symm
[GOAL]
⊢ CreatesLimits (forget Profinite)
[PROOFSTEP]
change CreatesLimits (profiniteToCompHaus ⋙ forget _)
[GOAL]
⊢ CreatesLimits (profiniteToCompHaus ⋙ forget CompHaus)
[PROOFSTEP]
infer_instance