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

tactic: rintro _ ⟨F, hF, rfl⟩
state_before: X : Compactum
A : Set X.A
⊢ Compactum.cl (Compactum.cl A) ⊆ Compactum.cl A

tactic: let fsu := Finset (Set (Ultrafilter X))
state_before: 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

tactic: let ssu := Set (Set (Ultrafilter X))
state_before: 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

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

tactic: let C0 : ssu := { Z | ∃ B ∈ F, X.str ⁻¹' B = Z }
state_before: 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

tactic: let AA := { G : Ultrafilter X | A ∈ G }
state_before: 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

tactic: let C1 := insert AA C0
state_before: 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

tactic: let C2 := finiteInterClosure C1
state_before: 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

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

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

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

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

tactic: have claim4 := finiteInterClosure_finiteInter C1
state_before: 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)

tactic: have claim5 : FiniteInter C0 := ⟨⟨_, univ_mem, Set.preimage_univ⟩, claim1⟩
state_before: 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)

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

tactic: suffices ⋂₀ ι T ∈ C2 by exact claim6 _ this
state_before: 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)

tactic: apply claim4.finiteInter_mem T
state_before: 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

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

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

tactic: rintro B ⟨Q, hQ, rfl⟩ C ⟨R, hR, rfl⟩
state_before: 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

tactic: use Q ∩ R
state_before: 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

tactic: simp only [and_true_iff, eq_self_iff_true, Set.preimage_inter]
state_before: 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
⊢ Q ∩ R ∈ F ∧ str X ⁻¹' (Q ∩ R) = str X ⁻¹' Q ∩ str X ⁻¹' R

tactic: exact inter_sets _ hQ hR
state_before: 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
⊢ Q ∩ R ∈ F

tactic: rintro B ⟨Q, hQ, rfl⟩
state_before: 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

tactic: obtain ⟨q⟩ := Filter.nonempty_of_mem hQ
state_before: 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)

tactic: use X.incl q
state_before: 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)

tactic: simpa
state_before: 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
⊢ incl X q ∈ str X ⁻¹' Q

tactic: rintro B ⟨Q, hQ, rfl⟩
state_before: 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)

tactic: have : (Q ∩ cl A).Nonempty := Filter.nonempty_of_mem (inter_mem hQ hF)
state_before: 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)

tactic: rcases this with ⟨q, hq1, P, hq2, hq3⟩
state_before: 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)

tactic: refine' ⟨P, hq2, _⟩
state_before: 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)

tactic: rw [← hq3] at hq1
state_before: 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

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

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

tactic: use X.join G
state_before: 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

tactic: have : G.map X.str = F := Ultrafilter.coe_le_coe.1 fun S hS => h1 (Or.inr ⟨S, hS, rfl⟩)
state_before: 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
⊢ join X G ∈ Compactum.basic A ∧ str X (join X G) = str X F

tactic: rw [join_distrib, this]
state_before: 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
this : Ultrafilter.map (str X) G = F
⊢ join X G ∈ Compactum.basic A ∧ str X (join X G) = str X F

tactic: exact ⟨h1 (Or.inl rfl), rfl⟩
state_before: 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
this : Ultrafilter.map (str X) G = F
⊢ join X G ∈ Compactum.basic A ∧ str X F = str X F

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

tactic: exact claim5.finiteInterClosure_insert _ hP
state_before: 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

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

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

tactic: exact claim2 _ h
state_before: 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

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

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

tactic: exact claim6 _ this
state_before: 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)