Theorem: ContinuousMap.sublattice_closure_eq_top
File: Mathlib/Topology/ContinuousFunction/StoneWeierstrass.lean

tactic: apply eq_top_iff.mpr
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : Set.SeparatesPointsStrongly L
⊢ closure L = ⊤

tactic: rintro f -
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : Set.SeparatesPointsStrongly L
⊢ ⊤ ≤ closure L

tactic: refine'
  Filter.Frequently.mem_closure
    ((Filter.HasBasis.frequently_iff Metric.nhds_basis_ball).mpr fun ε pos => _)
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : Set.SeparatesPointsStrongly L
f : C(X, ℝ)
⊢ f ∈ closure L

tactic: simp only [exists_prop, Metric.mem_ball]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : Set.SeparatesPointsStrongly L
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
⊢ ∃ x, x ∈ Metric.ball f ε ∧ x ∈ L

tactic: by_cases nX : Nonempty X
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : Set.SeparatesPointsStrongly L
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: swap
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : Set.SeparatesPointsStrongly L
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
⊢ ∃ x, dist x f < ε ∧ x ∈ L

case neg
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : Set.SeparatesPointsStrongly L
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : ¬Nonempty X
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: exact ⟨nA.some, (dist_lt_iff pos).mpr fun x => False.elim (nX ⟨x⟩), nA.choose_spec⟩
state_before: case neg
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : Set.SeparatesPointsStrongly L
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : ¬Nonempty X
⊢ ∃ x, dist x f < ε ∧ x ∈ L

case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : Set.SeparatesPointsStrongly L
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: dsimp only [Set.SeparatesPointsStrongly] at sep
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : Set.SeparatesPointsStrongly L
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: choose g hg w₁ w₂ using sep f
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: let U : X → X → Set X := fun x y => {z | f z - ε < g x y z}
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: let ys : ∀ _, Finset X := fun x => (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x)).choose
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: let ys_w : ∀ x, (⋃ y ∈ ys x, U x y) = ⊤ := fun x =>
  (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x)).choose_spec
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: have ys_nonempty : ∀ x, (ys x).Nonempty := fun x =>
  Set.nonempty_of_union_eq_top_of_nonempty _ _ nX (ys_w x)
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: let h : ∀ _, L := fun x =>
  ⟨(ys x).sup' (ys_nonempty x) fun y => (g x y : C(X, ℝ)),
    Finset.sup'_mem _ sup_mem _ _ _ fun y _ => hg x y⟩
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: have lt_h : ∀ x z, f z - ε < (h x : X → ℝ) z := by
  intro x z
  obtain ⟨y, ym, zm⟩ := Set.exists_set_mem_of_union_eq_top _ _ (ys_w x) z
  dsimp
  simp only [Subtype.coe_mk, sup'_coe, Finset.sup'_apply, Finset.lt_sup'_iff]
  exact ⟨y, ym, zm⟩
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: have h_eq : ∀ x, (h x : X → ℝ) x = f x := by intro x; simp [w₁]
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: let W : ∀ _, Set X := fun x => {z | (h x : X → ℝ) z < f z + ε}
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: let xs : Finset X := (CompactSpace.elim_nhds_subcover W W_nhd).choose
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: let xs_w : (⋃ x ∈ xs, W x) = ⊤ := (CompactSpace.elim_nhds_subcover W W_nhd).choose_spec
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: have xs_nonempty : xs.Nonempty := Set.nonempty_of_union_eq_top_of_nonempty _ _ nX xs_w
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: let k : (L : Type _) :=
  ⟨xs.inf' xs_nonempty fun x => (h x : C(X, ℝ)),
    Finset.inf'_mem _ inf_mem _ _ _ fun x _ => (h x).2⟩
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: refine' ⟨k.1, _, k.2⟩
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
⊢ ∃ x, dist x f < ε ∧ x ∈ L

tactic: rw [dist_lt_iff pos]
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
⊢ dist (↑k) f < ε

tactic: intro z
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
⊢ ∀ (x : X), dist (↑↑k x) (↑f x) < ε

tactic: rw [show ∀ a b ε : ℝ, dist a b < ε ↔ a < b + ε ∧ b - ε < a by
      intros; simp only [← Metric.mem_ball, Real.ball_eq_Ioo, Set.mem_Ioo, and_comm]]
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z : X
⊢ dist (↑↑k z) (↑f z) < ε

tactic: fconstructor
state_before: case pos
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z : X
⊢ ↑↑k z < ↑f z + ε ∧ ↑f z - ε < ↑↑k z

tactic: intro x y
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
⊢ ∀ (x y : X), U x y ∈ 𝓝 y

tactic: refine' IsOpen.mem_nhds _ _
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
x y : X
⊢ U x y ∈ 𝓝 y

tactic: apply isOpen_lt <;> continuity
state_before: case refine'_1
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
x y : X
⊢ IsOpen (U x y)

tactic: rw [Set.mem_setOf_eq, w₂]
state_before: case refine'_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
x y : X
⊢ y ∈ U x y

tactic: exact sub_lt_self _ pos
state_before: case refine'_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
x y : X
⊢ ↑f y - ε < ↑f y

tactic: intro x z
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
⊢ ∀ (x z : X), ↑f z - ε < ↑↑(h x) z

tactic: obtain ⟨y, ym, zm⟩ := Set.exists_set_mem_of_union_eq_top _ _ (ys_w x) z
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
x z : X
⊢ ↑f z - ε < ↑↑(h x) z

tactic: dsimp
state_before: case intro.intro
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
x z y : X
ym : y ∈ fun i => i ∈ (ys x).val
zm : z ∈ U x y
⊢ ↑f z - ε < ↑↑(h x) z

tactic: simp only [Subtype.coe_mk, sup'_coe, Finset.sup'_apply, Finset.lt_sup'_iff]
state_before: case intro.intro
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
x z y : X
ym : y ∈ fun i => i ∈ (ys x).val
zm : z ∈ U x y
⊢ ↑f z - ε <
    ↑(Finset.sup' (Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), {z | ↑f z - ε < ↑(g x x_1) z}) = ⊤))
          (_ : Finset.Nonempty (ys x)) fun y => g x y)
      z

tactic: exact ⟨y, ym, zm⟩
state_before: case intro.intro
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
x z y : X
ym : y ∈ fun i => i ∈ (ys x).val
zm : z ∈ U x y
⊢ ∃ b,
    b ∈ Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), {z | ↑f z - ε < ↑(g x x_1) z}) = ⊤) ∧ ↑f z - ε < ↑(g x b) z

tactic: intro x
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
⊢ ∀ (x : X), ↑↑(h x) x = ↑f x

tactic: simp [w₁]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
x : X
⊢ ↑↑(h x) x = ↑f x

tactic: intro x
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
⊢ ∀ (x : X), W x ∈ 𝓝 x

tactic: refine' IsOpen.mem_nhds _ _
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
x : X
⊢ W x ∈ 𝓝 x

tactic: apply isOpen_lt (continuous_set_coe _ _)
state_before: case refine'_1
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
x : X
⊢ IsOpen (W x)

tactic: continuity
state_before: case refine'_1
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
x : X
⊢ Continuous fun b => ↑f b + ε

tactic: dsimp only [Set.mem_setOf_eq]
state_before: case refine'_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
x : X
⊢ x ∈ W x

tactic: rw [h_eq]
state_before: case refine'_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
x : X
⊢ ↑(Finset.sup' (Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), {z | ↑f z - ε < ↑(g x x_1) z}) = ⊤))
          (_ : Finset.Nonempty (ys x)) fun y => g x y)
      x <
    ↑f x + ε

tactic: exact lt_add_of_pos_right _ pos
state_before: case refine'_2
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
x : X
⊢ ↑f x < ↑f x + ε

tactic: intros
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z : X
⊢ ∀ (a b ε : ℝ), dist a b < ε ↔ a < b + ε ∧ b - ε < a

tactic: simp only [← Metric.mem_ball, Real.ball_eq_Ioo, Set.mem_Ioo, and_comm]
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z : X
a✝ b✝ ε✝ : ℝ
⊢ dist a✝ b✝ < ε✝ ↔ a✝ < b✝ + ε✝ ∧ b✝ - ε✝ < a✝

tactic: dsimp
state_before: case pos.left
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z : X
⊢ ↑↑k z < ↑f z + ε

tactic: simp only [Finset.inf'_lt_iff, ContinuousMap.inf'_apply]
state_before: case pos.left
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z : X
⊢ ↑(Finset.inf'
          (Exists.choose
            (_ :
              ∃ t,
                (⋃ (x : X) (_ : x ∈ t),
                    {z |
                      ↑(Finset.sup'
                              (Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), {z | ↑f z - ε < ↑(g x x_1) z}) = ⊤))
                              (_ : Finset.Nonempty (ys x)) fun y => g x y)
                          z <
                        ↑f z + ε}) =
                  ⊤))
          xs_nonempty fun x =>
          Finset.sup' (Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), {z | ↑f z - ε < ↑(g x x_1) z}) = ⊤))
            (_ : Finset.Nonempty (ys x)) fun y => g x y)
      z <
    ↑f z + ε

tactic: exact Set.exists_set_mem_of_union_eq_top _ _ xs_w z
state_before: case pos.left
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z : X
⊢ ∃ i,
    i ∈
        Exists.choose
          (_ :
            ∃ t,
              (⋃ (x : X) (_ : x ∈ t),
                  {z |
                    ↑(Finset.sup'
                            (Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), {z | ↑f z - ε < ↑(g x x_1) z}) = ⊤))
                            (_ : Finset.Nonempty (ys x)) fun y => g x y)
                        z <
                      ↑f z + ε}) =
                ⊤) ∧
      ↑(Finset.sup' (Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), {z | ↑f z - ε < ↑(g i x) z}) = ⊤))
              (_ : Finset.Nonempty (ys i)) fun y => g i y)
          z <
        ↑f z + ε

tactic: dsimp
state_before: case pos.right
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z : X
⊢ ↑f z - ε < ↑↑k z

tactic: simp only [Finset.lt_inf'_iff, ContinuousMap.inf'_apply]
state_before: case pos.right
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z : X
⊢ ↑f z - ε <
    ↑(Finset.inf'
          (Exists.choose
            (_ :
              ∃ t,
                (⋃ (x : X) (_ : x ∈ t),
                    {z |
                      ↑(Finset.sup'
                              (Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), {z | ↑f z - ε < ↑(g x x_1) z}) = ⊤))
                              (_ : Finset.Nonempty (ys x)) fun y => g x y)
                          z <
                        ↑f z + ε}) =
                  ⊤))
          xs_nonempty fun x =>
          Finset.sup' (Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), {z | ↑f z - ε < ↑(g x x_1) z}) = ⊤))
            (_ : Finset.Nonempty (ys x)) fun y => g x y)
      z

tactic: rintro x -
state_before: case pos.right
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z : X
⊢ ∀ (i : X),
    i ∈
        Exists.choose
          (_ :
            ∃ t,
              (⋃ (x : X) (_ : x ∈ t),
                  {z |
                    ↑(Finset.sup'
                            (Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), {z | ↑f z - ε < ↑(g x x_1) z}) = ⊤))
                            (_ : Finset.Nonempty (ys x)) fun y => g x y)
                        z <
                      ↑f z + ε}) =
                ⊤) →
      ↑f z - ε <
        ↑(Finset.sup' (Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), {z | ↑f z - ε < ↑(g i x) z}) = ⊤))
              (_ : Finset.Nonempty (ys i)) fun y => g i y)
          z

tactic: apply lt_h
state_before: case pos.right
X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : CompactSpace X
L : Set C(X, ℝ)
nA : Set.Nonempty L
inf_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊓ g ∈ L
sup_mem : ∀ (f : C(X, ℝ)), f ∈ L → ∀ (g : C(X, ℝ)), g ∈ L → f ⊔ g ∈ L
sep : ∀ (v : X → ℝ) (x y : X), ∃ f, f ∈ L ∧ ↑f x = v x ∧ ↑f y = v y
f : C(X, ℝ)
ε : ℝ
pos : 0 < ε
nX : Nonempty X
g : X → X → C(X, ℝ)
hg : ∀ (x y : X), g x y ∈ L
w₁ : ∀ (x y : X), ↑(g x y) x = ↑f x
w₂ : ∀ (x y : X), ↑(g x y) y = ↑f y
U : X → X → Set X := fun x y => {z | ↑f z - ε < ↑(g x y) z}
U_nhd_y : ∀ (x y : X), U x y ∈ 𝓝 y
ys : X → Finset X := fun x => Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), U x x_1) = ⊤)
ys_w : ∀ (x : X), (⋃ (y : X) (_ : y ∈ ys x), U x y) = ⊤ :=
  fun x => Exists.choose_spec (CompactSpace.elim_nhds_subcover (U x) (U_nhd_y x))
ys_nonempty : ∀ (x : X), Finset.Nonempty (ys x)
h : X → ↑L :=
  fun x =>
    { val := Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y,
      property := (_ : (Finset.sup' (ys x) (_ : Finset.Nonempty (ys x)) fun y => g x y) ∈ L) }
lt_h : ∀ (x z : X), ↑f z - ε < ↑↑(h x) z
h_eq : ∀ (x : X), ↑↑(h x) x = ↑f x
W : X → Set X := fun x => {z | ↑↑(h x) z < ↑f z + ε}
W_nhd : ∀ (x : X), W x ∈ 𝓝 x
xs : Finset X := Exists.choose (_ : ∃ t, (⋃ (x : X) (_ : x ∈ t), W x) = ⊤)
xs_w : (⋃ (x : X) (_ : x ∈ xs), W x) = ⊤ := Exists.choose_spec (CompactSpace.elim_nhds_subcover W W_nhd)
xs_nonempty : Finset.Nonempty xs
k : ↑L :=
  { val := Finset.inf' xs xs_nonempty fun x => ↑(h x),
    property := (_ : (Finset.inf' xs xs_nonempty fun x => ↑(h x)) ∈ L) }
z x : X
⊢ ↑f z - ε <
    ↑(Finset.sup' (Exists.choose (_ : ∃ t, (⋃ (x_1 : X) (_ : x_1 ∈ t), {z | ↑f z - ε < ↑(g x x_1) z}) = ⊤))
          (_ : Finset.Nonempty (ys x)) fun y => g x y)
      z