Theorem: totallyBounded_iff_filter
File: Mathlib/Topology/UniformSpace/Cauchy.lean

tactic: constructor
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
⊢ TotallyBounded s ↔ ∀ (f : Filter α), NeBot f → f ≤ 𝓟 s → ∃ c, c ≤ f ∧ Cauchy c

tactic: exact fun H f hf hfs => ⟨Ultrafilter.of f, Ultrafilter.of_le f,
  (Ultrafilter.of f).cauchy_of_totallyBounded H ((Ultrafilter.of_le f).trans hfs)⟩
state_before: case mp
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
⊢ TotallyBounded s → ∀ (f : Filter α), NeBot f → f ≤ 𝓟 s → ∃ c, c ≤ f ∧ Cauchy c

tactic: intro H d hd
state_before: case mpr
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
⊢ (∀ (f : Filter α), NeBot f → f ≤ 𝓟 s → ∃ c, c ≤ f ∧ Cauchy c) → TotallyBounded s

tactic: contrapose! H with hd_cover
state_before: case mpr
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
H : ∀ (f : Filter α), NeBot f → f ≤ 𝓟 s → ∃ c, c ≤ f ∧ Cauchy c
d : Set (α × α)
hd : d ∈ 𝓤 α
⊢ ∃ t, Set.Finite t ∧ s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}

tactic: set f := ⨅ t : Finset α, 𝓟 (s \ ⋃ y ∈ t, { x | (x, y) ∈ d })
state_before: case mpr
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
⊢ ∃ f, NeBot f ∧ f ≤ 𝓟 s ∧ ∀ (c : Filter α), c ≤ f → ¬Cauchy c

tactic: have : f ≤ 𝓟 s := iInf_le_of_le ∅ (by simp)
state_before: case mpr
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this : NeBot f
⊢ ∃ f, NeBot f ∧ f ≤ 𝓟 s ∧ ∀ (c : Filter α), c ≤ f → ¬Cauchy c

tactic: refine' ⟨f, ‹_›, ‹_›, fun c hcf hc => _⟩
state_before: case mpr
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this✝ : NeBot f
this : f ≤ 𝓟 s
⊢ ∃ f, NeBot f ∧ f ≤ 𝓟 s ∧ ∀ (c : Filter α), c ≤ f → ¬Cauchy c

tactic: rcases mem_prod_same_iff.1 (hc.2 hd) with ⟨m, hm, hmd⟩
state_before: case mpr
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this✝ : NeBot f
this : f ≤ 𝓟 s
c : Filter α
hcf : c ≤ f
hc : Cauchy c
⊢ False

tactic: rcases hc.1.nonempty_of_mem hm with ⟨y, hym⟩
state_before: case mpr.intro.intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this✝ : NeBot f
this : f ≤ 𝓟 s
c : Filter α
hcf : c ≤ f
hc : Cauchy c
m : Set α
hm : m ∈ c
hmd : m ×ˢ m ⊆ d
⊢ False

tactic: set ys := ⋃ y' ∈ ({y} : Finset α), { x | (x, y') ∈ d }
state_before: case mpr.intro.intro.intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this✝ : NeBot f
this : f ≤ 𝓟 s
c : Filter α
hcf : c ≤ f
hc : Cauchy c
m : Set α
hm : m ∈ c
hmd : m ×ˢ m ⊆ d
y : α
hym : y ∈ m
⊢ False

tactic: have : c ≤ 𝓟 (s \ ys) := hcf.trans (iInf_le_of_le {y} le_rfl)
state_before: case mpr.intro.intro.intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this✝ : NeBot f
this : f ≤ 𝓟 s
c : Filter α
hcf : c ≤ f
hc : Cauchy c
m : Set α
hm : m ∈ c
hmd : m ×ˢ m ⊆ d
y : α
hym : y ∈ m
ys : Set α := ⋃ (y' : α) (_ : y' ∈ {y}), {x | (x, y') ∈ d}
⊢ False

tactic: refine' hc.1.ne (empty_mem_iff_bot.mp _)
state_before: case mpr.intro.intro.intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this✝¹ : NeBot f
this✝ : f ≤ 𝓟 s
c : Filter α
hcf : c ≤ f
hc : Cauchy c
m : Set α
hm : m ∈ c
hmd : m ×ˢ m ⊆ d
y : α
hym : y ∈ m
ys : Set α := ⋃ (y' : α) (_ : y' ∈ {y}), {x | (x, y') ∈ d}
this : c ≤ 𝓟 (s \ ys)
⊢ False

tactic: filter_upwards [le_principal_iff.1 this, hm]
state_before: case mpr.intro.intro.intro
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this✝¹ : NeBot f
this✝ : f ≤ 𝓟 s
c : Filter α
hcf : c ≤ f
hc : Cauchy c
m : Set α
hm : m ∈ c
hmd : m ×ˢ m ⊆ d
y : α
hym : y ∈ m
ys : Set α := ⋃ (y' : α) (_ : y' ∈ {y}), {x | (x, y') ∈ d}
this : c ≤ 𝓟 (s \ ys)
⊢ ∅ ∈ c

tactic: refine' fun x hx hxm => hx.2 _
state_before: case h
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this✝¹ : NeBot f
this✝ : f ≤ 𝓟 s
c : Filter α
hcf : c ≤ f
hc : Cauchy c
m : Set α
hm : m ∈ c
hmd : m ×ˢ m ⊆ d
y : α
hym : y ∈ m
ys : Set α := ⋃ (y' : α) (_ : y' ∈ {y}), {x | (x, y') ∈ d}
this : c ≤ 𝓟 (s \ ys)
⊢ ∀ (a : α), (a ∈ s \ ⋃ (y' : α) (_ : y' ∈ {y}), {x | (x, y') ∈ d}) → a ∈ m → a ∈ ∅

tactic: simpa using hmd (mk_mem_prod hxm hym)
state_before: case h
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this✝¹ : NeBot f
this✝ : f ≤ 𝓟 s
c : Filter α
hcf : c ≤ f
hc : Cauchy c
m : Set α
hm : m ∈ c
hmd : m ×ˢ m ⊆ d
y : α
hym : y ∈ m
ys : Set α := ⋃ (y' : α) (_ : y' ∈ {y}), {x | (x, y') ∈ d}
this : c ≤ 𝓟 (s \ ys)
x : α
hx : x ∈ s \ ⋃ (y' : α) (_ : y' ∈ {y}), {x | (x, y') ∈ d}
hxm : x ∈ m
⊢ x ∈ ⋃ (y' : α) (_ : y' ∈ {y}), {x | (x, y') ∈ d}

tactic: refine' iInf_neBot_of_directed' (directed_of_sup _) _
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
⊢ NeBot f

tactic: intro t₁ t₂ h
state_before: case refine'_1
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
⊢ ∀ ⦃i j : Finset α⦄,
    i ≤ j → 𝓟 (s \ ⋃ (y : α) (_ : y ∈ i), {x | (x, y) ∈ d}) ≥ 𝓟 (s \ ⋃ (y : α) (_ : y ∈ j), {x | (x, y) ∈ d})

tactic: exact principal_mono.2 (diff_subset_diff_right <| biUnion_subset_biUnion_left h)
state_before: case refine'_1
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
t₁ t₂ : Finset α
h : t₁ ≤ t₂
⊢ 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t₁), {x | (x, y) ∈ d}) ≥ 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t₂), {x | (x, y) ∈ d})

tactic: intro t
state_before: case refine'_2
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
⊢ ∀ (i : Finset α), NeBot (𝓟 (s \ ⋃ (y : α) (_ : y ∈ i), {x | (x, y) ∈ d}))

tactic: simpa [nonempty_diff] using hd_cover t t.finite_toSet
state_before: case refine'_2
α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
t : Finset α
⊢ NeBot (𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}))

tactic: simp
state_before: α : Type u
β : Type v
inst✝ : UniformSpace α
s : Set α
d : Set (α × α)
hd : d ∈ 𝓤 α
hd_cover : ∀ (t : Set α), Set.Finite t → ¬s ⊆ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d}
f : Filter α := ⨅ (t : Finset α), 𝓟 (s \ ⋃ (y : α) (_ : y ∈ t), {x | (x, y) ∈ d})
this : NeBot f
⊢ 𝓟 (s \ ⋃ (y : α) (_ : y ∈ ∅), {x | (x, y) ∈ d}) ≤ 𝓟 s