Theorem: Compactum.str_eq_of_le_nhds
File: Mathlib/Topology/Category/Compactum.lean

tactic: let fsu := Finset (Set (Ultrafilter X))
state_before: X : Compactum
F : Ultrafilter X.A
x : X.A
⊢ ↑F ≤ 𝓝 x → str X F = x

tactic: let ssu := Set (Set (Ultrafilter X))
state_before: X : Compactum
F : Ultrafilter X.A
x : X.A
fsu : Type u_1 := Finset (Set (Ultrafilter X.A))
⊢ ↑F ≤ 𝓝 x → str X F = x

tactic: let ι : fsu → ssu := fun x ↦ ↑x
state_before: 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

tactic: let T0 : ssu := { S | ∃ A ∈ F, S = basic A }
state_before: 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

tactic: let AA := X.str ⁻¹' {x}
state_before: 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

tactic: let T1 := insert AA T0
state_before: 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

tactic: let T2 := finiteInterClosure T1
state_before: 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

tactic: intro cond
state_before: 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

tactic: 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
state_before: 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

tactic: 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))
state_before: 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

tactic: 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]⟩
state_before: 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

tactic: have claim4 : ∀ S ∈ T0, (AA ∩ S).Nonempty := by
  rintro S ⟨S, hS, rfl⟩
  rcases claim2 _ hS with ⟨G, hG, hG2⟩
  exact ⟨G, hG2, hG⟩
state_before: 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

tactic: have claim5 : ∀ S ∈ T0, Set.Nonempty S := by
  rintro S ⟨S, hS, rfl⟩
  exact ⟨F, hS⟩
state_before: 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

tactic: 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]
state_before: 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

tactic: intro T hT
state_before: 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)

tactic: refine' claim6 _ (finiteInter_mem (.finiteInterClosure_finiteInter _) _ _)
state_before: 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)

tactic: intro t ht
state_before: 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

tactic: exact finiteInterClosure.basic (@hT t ht)
state_before: 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

tactic: intro A hA h
state_before: 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

tactic: by_contra H
state_before: 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

tactic: rw [le_nhds_iff] at cond
state_before: 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

tactic: specialize cond (Aᶜ) H hA.isOpen_compl
state_before: 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

tactic: rw [Ultrafilter.mem_coe, Ultrafilter.compl_mem_iff_not_mem] at cond
state_before: 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

tactic: contradiction
state_before: 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

tactic: intro A hA
state_before: 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

tactic: exact claim1 (cl A) (isClosed_cl A) (mem_of_superset hA (subset_cl A))
state_before: 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

tactic: rintro S1 ⟨S1, hS1, rfl⟩ S2 ⟨S2, hS2, rfl⟩
state_before: 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

tactic: exact ⟨S1 ∩ S2, inter_mem hS1 hS2, by simp [basic_inter]⟩
state_before: 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

tactic: simp [basic_inter]
state_before: 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)

tactic: rintro S ⟨S, hS, rfl⟩
state_before: 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)

tactic: rcases claim2 _ hS with ⟨G, hG, hG2⟩
state_before: 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)

tactic: exact ⟨G, hG2, hG⟩
state_before: 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)

tactic: rintro S ⟨S, hS, rfl⟩
state_before: 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

tactic: exact ⟨F, hS⟩
state_before: 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)

tactic: intro S hS
state_before: 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

tactic: apply finiteInterClosure_insert
state_before: 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

tactic: intro S hS
state_before: 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

tactic: cases' this _ hS with h h
state_before: 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

tactic: exact claim5 S h
state_before: 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

tactic: rcases h with ⟨Q, hQ, rfl⟩
state_before: 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

tactic: exact claim4 Q hQ
state_before: 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)

tactic: constructor
state_before: 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

tactic: use Set.univ
state_before: 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

tactic: refine' ⟨Filter.univ_sets _, _⟩
state_before: 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 ∈ F ∧ Set.univ = Compactum.basic Set.univ

tactic: ext
state_before: 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 = Compactum.basic Set.univ

tactic: refine' ⟨_, by tauto⟩
state_before: case cond.univ_mem.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

tactic: tauto
state_before: 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

tactic: intro
state_before: case cond.univ_mem.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

tactic: apply Filter.univ_sets
state_before: case cond.univ_mem.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

tactic: exact claim3
state_before: 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

tactic: exact hS
state_before: 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)

tactic: obtain ⟨G, h1⟩ := Ultrafilter.exists_ultrafilter_of_finite_inter_nonempty _ this
state_before: 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

tactic: have c1 : X.join G = F := Ultrafilter.coe_le_coe.1 fun P hP => h1 (Or.inr ⟨P, hP, rfl⟩)
state_before: 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

tactic: 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
state_before: 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

tactic: simp [← c1, c2]
state_before: 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

tactic: refine' Ultrafilter.coe_le_coe.1 fun P hP => _
state_before: 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

tactic: apply mem_of_superset (h1 (Or.inl rfl))
state_before: 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)

tactic: rintro x ⟨rfl⟩
state_before: 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

tactic: exact hP
state_before: 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