l3lab/ntp-mathlib huggingface dataset:
theorem mem_filterAt_iff {x : α} {s : Set (Set α)} :
    s ∈ v.filterAt x ↔ ∃ ε > (0 : ℝ), ∀ a ∈ v.setsAt x, a ⊆ closedBall x ε → a ∈ s := by
  simp only [filterAt, exists_prop, gt_iff_lt]
  rw [mem_biInf_of_directed]
  · simp only [subset_def, and_imp, exists_prop, mem_sep_iff, mem_Ioi, mem_principal]
  · simp only [DirectedOn, exists_prop, ge_iff_le, le_principal_iff, mem_Ioi, Order.Preimage,
      mem_principal]
    

Proof state:
case h
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
s : Set (Set α)
⊢ ∀ (x_1 : ℝ),
    0 < x_1 →
      ∀ (y : ℝ),
        0 < y →
          ∃ z,
            0 < z ∧
              {a | a ∈ setsAt v x ∧ a ⊆ closedBall x z} ⊆ {a | a ∈ setsAt v x ∧ a ⊆ closedBall x x_1} ∧
                {a | a ∈ setsAt v x ∧ a ⊆ closedBall x z} ⊆ {a | a ∈ setsAt v x ∧ a ⊆ closedBall x y}

Next tactic:
intro x hx y hy
theorem mem_filterAt_iff {x : α} {s : Set (Set α)} :
    s ∈ v.filterAt x ↔ ∃ ε > (0 : ℝ), ∀ a ∈ v.setsAt x, a ⊆ closedBall x ε → a ∈ s := by
  simp only [filterAt, exists_prop, gt_iff_lt]
  rw [mem_biInf_of_directed]
  · simp only [subset_def, and_imp, exists_prop, mem_sep_iff, mem_Ioi, mem_principal]
  · simp only [DirectedOn, exists_prop, ge_iff_le, le_principal_iff, mem_Ioi, Order.Preimage,
      mem_principal]
    intro x hx y hy
    

Proof state:
case h
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x✝ : α
s : Set (Set α)
x : ℝ
hx : 0 < x
y : ℝ
hy : 0 < y
⊢ ∃ z,
    0 < z ∧
      {a | a ∈ setsAt v x✝ ∧ a ⊆ closedBall x✝ z} ⊆ {a | a ∈ setsAt v x✝ ∧ a ⊆ closedBall x✝ x} ∧
        {a | a ∈ setsAt v x✝ ∧ a ⊆ closedBall x✝ z} ⊆ {a | a ∈ setsAt v x✝ ∧ a ⊆ closedBall x✝ y}

Next tactic:
refine' ⟨min x y, lt_min hx hy,
      fun a ha => ⟨ha.1, ha.2.trans (closedBall_subset_closedBall (min_le_left _ _))⟩,
      fun a ha => ⟨ha.1, ha.2.trans (closedBall_subset_closedBall (min_le_right _ _))⟩⟩
theorem mem_filterAt_iff {x : α} {s : Set (Set α)} :
    s ∈ v.filterAt x ↔ ∃ ε > (0 : ℝ), ∀ a ∈ v.setsAt x, a ⊆ closedBall x ε → a ∈ s := by
  simp only [filterAt, exists_prop, gt_iff_lt]
  rw [mem_biInf_of_directed]
  · simp only [subset_def, and_imp, exists_prop, mem_sep_iff, mem_Ioi, mem_principal]
  · simp only [DirectedOn, exists_prop, ge_iff_le, le_principal_iff, mem_Ioi, Order.Preimage,
      mem_principal]
    intro x hx y hy
    refine' ⟨min x y, lt_min hx hy,
      fun a ha => ⟨ha.1, ha.2.trans (closedBall_subset_closedBall (min_le_left _ _))⟩,
      fun a ha => ⟨ha.1, ha.2.trans (closedBall_subset_closedBall (min_le_right _ _))⟩⟩
  · 

Proof state:
case ne
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
s : Set (Set α)
⊢ Set.Nonempty (Ioi 0)

Next tactic:
exact ⟨(1 : ℝ), mem_Ioi.2 zero_lt_one⟩
instance filterAt_neBot (x : α) : (v.filterAt x).NeBot := by
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
⊢ NeBot (filterAt v x)

Next tactic:
simp only [neBot_iff, ← empty_mem_iff_bot, mem_filterAt_iff, not_exists, exists_prop,
    mem_empty_iff_false, and_true_iff, gt_iff_lt, not_and, Ne.def, not_false_iff, not_forall]
instance filterAt_neBot (x : α) : (v.filterAt x).NeBot := by
  simp only [neBot_iff, ← empty_mem_iff_bot, mem_filterAt_iff, not_exists, exists_prop,
    mem_empty_iff_false, and_true_iff, gt_iff_lt, not_and, Ne.def, not_false_iff, not_forall]
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
⊢ ∀ (x_1 : ℝ), 0 < x_1 → ∃ x_2 ∈ setsAt v x, x_2 ⊆ closedBall x x_1

Next tactic:
intro ε εpos
instance filterAt_neBot (x : α) : (v.filterAt x).NeBot := by
  simp only [neBot_iff, ← empty_mem_iff_bot, mem_filterAt_iff, not_exists, exists_prop,
    mem_empty_iff_false, and_true_iff, gt_iff_lt, not_and, Ne.def, not_false_iff, not_forall]
  intro ε εpos
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
ε : ℝ
εpos : 0 < ε
⊢ ∃ x_1 ∈ setsAt v x, x_1 ⊆ closedBall x ε

Next tactic:
obtain ⟨w, w_sets, hw⟩ : ∃ w ∈ v.setsAt x, w ⊆ closedBall x ε := v.Nontrivial x ε εpos
instance filterAt_neBot (x : α) : (v.filterAt x).NeBot := by
  simp only [neBot_iff, ← empty_mem_iff_bot, mem_filterAt_iff, not_exists, exists_prop,
    mem_empty_iff_false, and_true_iff, gt_iff_lt, not_and, Ne.def, not_false_iff, not_forall]
  intro ε εpos
  obtain ⟨w, w_sets, hw⟩ : ∃ w ∈ v.setsAt x, w ⊆ closedBall x ε := v.Nontrivial x ε εpos
  

Proof state:
case intro.intro
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
ε : ℝ
εpos : 0 < ε
w : Set α
w_sets : w ∈ setsAt v x
hw : w ⊆ closedBall x ε
⊢ ∃ x_1 ∈ setsAt v x, x_1 ⊆ closedBall x ε

Next tactic:
exact ⟨w, w_sets, hw⟩
theorem eventually_filterAt_mem_sets (x : α) : ∀ᶠ a in v.filterAt x, a ∈ v.setsAt x := by
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
⊢ ∀ᶠ (a : Set α) in filterAt v x, a ∈ setsAt v x

Next tactic:
simp (config := { contextual := true }) only [eventually_filterAt_iff, exists_prop, and_true_iff,
    gt_iff_lt, imp_true_iff]
theorem eventually_filterAt_mem_sets (x : α) : ∀ᶠ a in v.filterAt x, a ∈ v.setsAt x := by
  simp (config := { contextual := true }) only [eventually_filterAt_iff, exists_prop, and_true_iff,
    gt_iff_lt, imp_true_iff]
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
⊢ ∃ ε, 0 < ε

Next tactic:
exact ⟨1, zero_lt_one⟩
theorem eventually_filterAt_subset_closedBall (x : α) {ε : ℝ} (hε : 0 < ε) :
    ∀ᶠ a : Set α in v.filterAt x, a ⊆ closedBall x ε := by
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
ε : ℝ
hε : 0 < ε
⊢ ∀ᶠ (a : Set α) in filterAt v x, a ⊆ closedBall x ε

Next tactic:
simp only [v.eventually_filterAt_iff]
theorem eventually_filterAt_subset_closedBall (x : α) {ε : ℝ} (hε : 0 < ε) :
    ∀ᶠ a : Set α in v.filterAt x, a ⊆ closedBall x ε := by
  simp only [v.eventually_filterAt_iff]
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
ε : ℝ
hε : 0 < ε
⊢ ∃ ε_1 > 0, ∀ a ∈ setsAt v x, a ⊆ closedBall x ε_1 → a ⊆ closedBall x ε

Next tactic:
exact ⟨ε, hε, fun a _ ha' => ha'⟩
theorem tendsto_filterAt_iff {ι : Type*} {l : Filter ι} {f : ι → Set α} {x : α} :
    Tendsto f l (v.filterAt x) ↔
      (∀ᶠ i in l, f i ∈ v.setsAt x) ∧ ∀ ε > (0 : ℝ), ∀ᶠ i in l, f i ⊆ closedBall x ε := by
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
ι : Type u_2
l : Filter ι
f : ι → Set α
x : α
⊢ Tendsto f l (filterAt v x) ↔ (∀ᶠ (i : ι) in l, f i ∈ setsAt v x) ∧ ∀ ε > 0, ∀ᶠ (i : ι) in l, f i ⊆ closedBall x ε

Next tactic:
refine' ⟨fun H => ⟨H.eventually <| v.eventually_filterAt_mem_sets x,
    fun ε hε => H.eventually <| v.eventually_filterAt_subset_closedBall x hε⟩,
    fun H s hs => (_ : ∀ᶠ i in l, f i ∈ s)⟩
theorem tendsto_filterAt_iff {ι : Type*} {l : Filter ι} {f : ι → Set α} {x : α} :
    Tendsto f l (v.filterAt x) ↔
      (∀ᶠ i in l, f i ∈ v.setsAt x) ∧ ∀ ε > (0 : ℝ), ∀ᶠ i in l, f i ⊆ closedBall x ε := by
  refine' ⟨fun H => ⟨H.eventually <| v.eventually_filterAt_mem_sets x,
    fun ε hε => H.eventually <| v.eventually_filterAt_subset_closedBall x hε⟩,
    fun H s hs => (_ : ∀ᶠ i in l, f i ∈ s)⟩
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
ι : Type u_2
l : Filter ι
f : ι → Set α
x : α
H : (∀ᶠ (i : ι) in l, f i ∈ setsAt v x) ∧ ∀ ε > 0, ∀ᶠ (i : ι) in l, f i ⊆ closedBall x ε
s : Set (Set α)
hs : s ∈ filterAt v x
⊢ ∀ᶠ (i : ι) in l, f i ∈ s

Next tactic:
obtain ⟨ε, εpos, hε⟩ := v.mem_filterAt_iff.mp hs
theorem tendsto_filterAt_iff {ι : Type*} {l : Filter ι} {f : ι → Set α} {x : α} :
    Tendsto f l (v.filterAt x) ↔
      (∀ᶠ i in l, f i ∈ v.setsAt x) ∧ ∀ ε > (0 : ℝ), ∀ᶠ i in l, f i ⊆ closedBall x ε := by
  refine' ⟨fun H => ⟨H.eventually <| v.eventually_filterAt_mem_sets x,
    fun ε hε => H.eventually <| v.eventually_filterAt_subset_closedBall x hε⟩,
    fun H s hs => (_ : ∀ᶠ i in l, f i ∈ s)⟩
  obtain ⟨ε, εpos, hε⟩ := v.mem_filterAt_iff.mp hs
  

Proof state:
case intro.intro
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
ι : Type u_2
l : Filter ι
f : ι → Set α
x : α
H : (∀ᶠ (i : ι) in l, f i ∈ setsAt v x) ∧ ∀ ε > 0, ∀ᶠ (i : ι) in l, f i ⊆ closedBall x ε
s : Set (Set α)
hs : s ∈ filterAt v x
ε : ℝ
εpos : ε > 0
hε : ∀ a ∈ setsAt v x, a ⊆ closedBall x ε → a ∈ s
⊢ ∀ᶠ (i : ι) in l, f i ∈ s

Next tactic:
filter_upwards [H.1, H.2 ε εpos] with i hi hiε using hε _ hi hiε
theorem eventually_filterAt_measurableSet (x : α) : ∀ᶠ a in v.filterAt x, MeasurableSet a := by
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
⊢ ∀ᶠ (a : Set α) in filterAt v x, MeasurableSet a

Next tactic:
filter_upwards [v.eventually_filterAt_mem_sets x] with _ ha using v.MeasurableSet' _ _ ha
theorem frequently_filterAt_iff {x : α} {P : Set α → Prop} :
    (∃ᶠ a in v.filterAt x, P a) ↔ ∀ ε > (0 : ℝ), ∃ a ∈ v.setsAt x, a ⊆ closedBall x ε ∧ P a := by
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
P : Set α → Prop
⊢ (∃ᶠ (a : Set α) in filterAt v x, P a) ↔ ∀ ε > 0, ∃ a ∈ setsAt v x, a ⊆ closedBall x ε ∧ P a

Next tactic:
simp only [Filter.Frequently, eventually_filterAt_iff, not_exists, exists_prop, not_and,
    Classical.not_not, not_forall]
theorem eventually_filterAt_subset_of_nhds {x : α} {o : Set α} (hx : o ∈ 𝓝 x) :
    ∀ᶠ a in v.filterAt x, a ⊆ o := by
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
o : Set α
hx : o ∈ 𝓝 x
⊢ ∀ᶠ (a : Set α) in filterAt v x, a ⊆ o

Next tactic:
rw [eventually_filterAt_iff]
theorem eventually_filterAt_subset_of_nhds {x : α} {o : Set α} (hx : o ∈ 𝓝 x) :
    ∀ᶠ a in v.filterAt x, a ⊆ o := by
  rw [eventually_filterAt_iff]
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
o : Set α
hx : o ∈ 𝓝 x
⊢ ∃ ε > 0, ∀ a ∈ setsAt v x, a ⊆ closedBall x ε → a ⊆ o

Next tactic:
rcases Metric.mem_nhds_iff.1 hx with ⟨ε, εpos, hε⟩
theorem eventually_filterAt_subset_of_nhds {x : α} {o : Set α} (hx : o ∈ 𝓝 x) :
    ∀ᶠ a in v.filterAt x, a ⊆ o := by
  rw [eventually_filterAt_iff]
  rcases Metric.mem_nhds_iff.1 hx with ⟨ε, εpos, hε⟩
  

Proof state:
case intro.intro
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
x : α
o : Set α
hx : o ∈ 𝓝 x
ε : ℝ
εpos : ε > 0
hε : ball x ε ⊆ o
⊢ ∃ ε > 0, ∀ a ∈ setsAt v x, a ⊆ closedBall x ε → a ⊆ o

Next tactic:
exact ⟨ε / 2, half_pos εpos,
    fun a _ ha => ha.trans ((closedBall_subset_ball (half_lt_self εpos)).trans hε)⟩
theorem fineSubfamilyOn_of_frequently (v : VitaliFamily μ) (f : α → Set (Set α)) (s : Set α)
    (h : ∀ x ∈ s, ∃ᶠ a in v.filterAt x, a ∈ f x) : v.FineSubfamilyOn f s := by
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ x ∈ s, ∃ᶠ (a : Set α) in filterAt v x, a ∈ f x
⊢ FineSubfamilyOn v f s

Next tactic:
intro x hx ε εpos
theorem fineSubfamilyOn_of_frequently (v : VitaliFamily μ) (f : α → Set (Set α)) (s : Set α)
    (h : ∀ x ∈ s, ∃ᶠ a in v.filterAt x, a ∈ f x) : v.FineSubfamilyOn f s := by
  intro x hx ε εpos
  

Proof state:
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ x ∈ s, ∃ᶠ (a : Set α) in filterAt v x, a ∈ f x
x : α
hx : x ∈ s
ε : ℝ
εpos : ε > 0
⊢ ∃ a ∈ setsAt v x ∩ f x, a ⊆ closedBall x ε

Next tactic:
obtain ⟨a, av, ha, af⟩ : ∃ (a : Set α) , a ∈ v.setsAt x ∧ a ⊆ closedBall x ε ∧ a ∈ f x :=
    v.frequently_filterAt_iff.1 (h x hx) ε εpos
theorem fineSubfamilyOn_of_frequently (v : VitaliFamily μ) (f : α → Set (Set α)) (s : Set α)
    (h : ∀ x ∈ s, ∃ᶠ a in v.filterAt x, a ∈ f x) : v.FineSubfamilyOn f s := by
  intro x hx ε εpos
  obtain ⟨a, av, ha, af⟩ : ∃ (a : Set α) , a ∈ v.setsAt x ∧ a ⊆ closedBall x ε ∧ a ∈ f x :=
    v.frequently_filterAt_iff.1 (h x hx) ε εpos
  

Proof state:
case intro.intro.intro
α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v✝ v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : ∀ x ∈ s, ∃ᶠ (a : Set α) in filterAt v x, a ∈ f x
x : α
hx : x ∈ s
ε : ℝ
εpos : ε > 0
a : Set α
av : a ∈ setsAt v x
ha : a ⊆ closedBall x ε
af : a ∈ f x
⊢ ∃ a ∈ setsAt v x ∩ f x, a ⊆ closedBall x ε

Next tactic:
exact ⟨a, ⟨av, af⟩, ha⟩
instance {E : Type*} [TopologicalSpace E] [AddCommGroup E] [TopologicalAddGroup E]
    [Module ℝ E] [ContinuousSMul ℝ E] [LocallyConvexSpace ℝ E] [T1Space E] : SeparatingDual ℝ E :=
  ⟨fun x hx ↦ by
    

Proof state:
E : Type u_1
inst✝⁶ : TopologicalSpace E
inst✝⁵ : AddCommGroup E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : Module ℝ E
inst✝² : ContinuousSMul ℝ E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : T1Space E
x : E
hx : x ≠ 0
⊢ ∃ f, f x ≠ 0

Next tactic:
rcases geometric_hahn_banach_point_point hx.symm with ⟨f, hf⟩
instance {E : Type*} [TopologicalSpace E] [AddCommGroup E] [TopologicalAddGroup E]
    [Module ℝ E] [ContinuousSMul ℝ E] [LocallyConvexSpace ℝ E] [T1Space E] : SeparatingDual ℝ E :=
  ⟨fun x hx ↦ by
    rcases geometric_hahn_banach_point_point hx.symm with ⟨f, hf⟩
    

Proof state:
case intro
E : Type u_1
inst✝⁶ : TopologicalSpace E
inst✝⁵ : AddCommGroup E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : Module ℝ E
inst✝² : ContinuousSMul ℝ E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : T1Space E
x : E
hx : x ≠ 0
f : E →L[ℝ] ℝ
hf : f 0 < f x
⊢ ∃ f, f x ≠ 0

Next tactic:
simp only [map_zero] at hf
instance {E : Type*} [TopologicalSpace E] [AddCommGroup E] [TopologicalAddGroup E]
    [Module ℝ E] [ContinuousSMul ℝ E] [LocallyConvexSpace ℝ E] [T1Space E] : SeparatingDual ℝ E :=
  ⟨fun x hx ↦ by
    rcases geometric_hahn_banach_point_point hx.symm with ⟨f, hf⟩
    simp only [map_zero] at hf
    

Proof state:
case intro
E : Type u_1
inst✝⁶ : TopologicalSpace E
inst✝⁵ : AddCommGroup E
inst✝⁴ : TopologicalAddGroup E
inst✝³ : Module ℝ E
inst✝² : ContinuousSMul ℝ E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : T1Space E
x : E
hx : x ≠ 0
f : E →L[ℝ] ℝ
hf : 0 < f x
⊢ ∃ f, f x ≠ 0

Next tactic:
exact ⟨f, hf.ne'⟩
instance {E 𝕜 : Type*} [IsROrC 𝕜] [NormedAddCommGroup E] [NormedSpace 𝕜 E] : SeparatingDual 𝕜 E :=
  ⟨fun x hx ↦ by
    

Proof state:
E : Type u_1
𝕜 : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x ≠ 0
⊢ ∃ f, f x ≠ 0

Next tactic:
rcases exists_dual_vector 𝕜 x hx with ⟨f, -, hf⟩
instance {E 𝕜 : Type*} [IsROrC 𝕜] [NormedAddCommGroup E] [NormedSpace 𝕜 E] : SeparatingDual 𝕜 E :=
  ⟨fun x hx ↦ by
    rcases exists_dual_vector 𝕜 x hx with ⟨f, -, hf⟩
    

Proof state:
case intro.intro
E : Type u_1
𝕜 : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x ≠ 0
f : E →L[𝕜] 𝕜
hf : f x = ↑‖x‖
⊢ ∃ f, f x ≠ 0

Next tactic:
refine ⟨f, ?_⟩
instance {E 𝕜 : Type*} [IsROrC 𝕜] [NormedAddCommGroup E] [NormedSpace 𝕜 E] : SeparatingDual 𝕜 E :=
  ⟨fun x hx ↦ by
    rcases exists_dual_vector 𝕜 x hx with ⟨f, -, hf⟩
    refine ⟨f, ?_⟩
    

Proof state:
case intro.intro
E : Type u_1
𝕜 : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x ≠ 0
f : E →L[𝕜] 𝕜
hf : f x = ↑‖x‖
⊢ f x ≠ 0

Next tactic:
simpa [hf] using hx
theorem exists_separating_of_ne {x y : V} (h : x ≠ y) :
    ∃ f : V →L[R] R, f x ≠ f y := by
  

Proof state:
R : Type u_1
V : Type u_2
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup V
inst✝³ : TopologicalSpace V
inst✝² : TopologicalSpace R
inst✝¹ : Module R V
inst✝ : SeparatingDual R V
x y : V
h : x ≠ y
⊢ ∃ f, f x ≠ f y

Next tactic:
rcases exists_ne_zero (R := R) (sub_ne_zero_of_ne h) with ⟨f, hf⟩
theorem exists_separating_of_ne {x y : V} (h : x ≠ y) :
    ∃ f : V →L[R] R, f x ≠ f y := by
  rcases exists_ne_zero (R := R) (sub_ne_zero_of_ne h) with ⟨f, hf⟩
  

Proof state:
case intro
R : Type u_1
V : Type u_2
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup V
inst✝³ : TopologicalSpace V
inst✝² : TopologicalSpace R
inst✝¹ : Module R V
inst✝ : SeparatingDual R V
x y : V
h : x ≠ y
f : V →L[R] R
hf : f (x - y) ≠ 0
⊢ ∃ f, f x ≠ f y

Next tactic:
exact ⟨f, by simpa [sub_ne_zero] using hf⟩
theorem exists_separating_of_ne {x y : V} (h : x ≠ y) :
    ∃ f : V →L[R] R, f x ≠ f y := by
  rcases exists_ne_zero (R := R) (sub_ne_zero_of_ne h) with ⟨f, hf⟩
  exact ⟨f, by 

Proof state:
R : Type u_1
V : Type u_2
inst✝⁵ : Ring R
inst✝⁴ : AddCommGroup V
inst✝³ : TopologicalSpace V
inst✝² : TopologicalSpace R
inst✝¹ : Module R V
inst✝ : SeparatingDual R V
x y : V
h : x ≠ y
f : V →L[R] R
hf : f (x - y) ≠ 0
⊢ f x ≠ f y

Next tactic:
simpa [sub_ne_zero] using hf
protected theorem t1Space [T1Space R] : T1Space V := by
  

Proof state:
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T1Space R
⊢ T1Space V

Next tactic:
apply t1Space_iff_exists_open.2 (fun x y hxy ↦ ?_)
protected theorem t1Space [T1Space R] : T1Space V := by
  apply t1Space_iff_exists_open.2 (fun x y hxy ↦ ?_)
  

Proof state:
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T1Space R
x y : V
hxy : x ≠ y
⊢ ∃ U, IsOpen U ∧ x ∈ U ∧ y ∉ U

Next tactic:
rcases exists_separating_of_ne (R := R) hxy with ⟨f, hf⟩
protected theorem t1Space [T1Space R] : T1Space V := by
  apply t1Space_iff_exists_open.2 (fun x y hxy ↦ ?_)
  rcases exists_separating_of_ne (R := R) hxy with ⟨f, hf⟩
  

Proof state:
case intro
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T1Space R
x y : V
hxy : x ≠ y
f : V →L[R] R
hf : f x ≠ f y
⊢ ∃ U, IsOpen U ∧ x ∈ U ∧ y ∉ U

Next tactic:
exact ⟨f ⁻¹' {f y}ᶜ, isOpen_compl_singleton.preimage f.continuous, hf, by simp⟩
protected theorem t1Space [T1Space R] : T1Space V := by
  apply t1Space_iff_exists_open.2 (fun x y hxy ↦ ?_)
  rcases exists_separating_of_ne (R := R) hxy with ⟨f, hf⟩
  exact ⟨f ⁻¹' {f y}ᶜ, isOpen_compl_singleton.preimage f.continuous, hf, by 

Proof state:
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T1Space R
x y : V
hxy : x ≠ y
f : V →L[R] R
hf : f x ≠ f y
⊢ y ∉ ⇑f ⁻¹' {f y}ᶜ

Next tactic:
simp
protected theorem t2Space [T2Space R] : T2Space V := by
  

Proof state:
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T2Space R
⊢ T2Space V

Next tactic:
apply (t2Space_iff _).2 (fun {x} {y} hxy ↦ ?_)
protected theorem t2Space [T2Space R] : T2Space V := by
  apply (t2Space_iff _).2 (fun {x} {y} hxy ↦ ?_)
  

Proof state:
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T2Space R
x y : V
hxy : x ≠ y
⊢ ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v

Next tactic:
rcases exists_separating_of_ne (R := R) hxy with ⟨f, hf⟩
protected theorem t2Space [T2Space R] : T2Space V := by
  apply (t2Space_iff _).2 (fun {x} {y} hxy ↦ ?_)
  rcases exists_separating_of_ne (R := R) hxy with ⟨f, hf⟩
  

Proof state:
case intro
R : Type u_1
V : Type u_2
inst✝⁶ : Ring R
inst✝⁵ : AddCommGroup V
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalSpace R
inst✝² : Module R V
inst✝¹ : SeparatingDual R V
inst✝ : T2Space R
x y : V
hxy : x ≠ y
f : V →L[R] R
hf : f x ≠ f y
⊢ ∃ u v, IsOpen u ∧ IsOpen v ∧ x ∈ u ∧ y ∈ v ∧ Disjoint u v

Next tactic:
exact separated_by_continuous f.continuous hf
theorem _root_.separatingDual_iff_injective : SeparatingDual R V ↔
    Function.Injective (ContinuousLinearMap.coeLM (R := R) R (M := V) (N₃ := R)).flip := by
  

Proof state:
R : Type u_1
V : Type u_2
inst✝⁷ : Field R
inst✝⁶ : AddCommGroup V
inst✝⁵ : TopologicalSpace R
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalRing R
inst✝² : TopologicalAddGroup V
inst✝¹ : Module R V
inst✝ : SeparatingDual R V
⊢ SeparatingDual R V ↔ Function.Injective ⇑(LinearMap.flip (ContinuousLinearMap.coeLM R))

Next tactic:
simp_rw [separatingDual_def, Ne, injective_iff_map_eq_zero]
theorem _root_.separatingDual_iff_injective : SeparatingDual R V ↔
    Function.Injective (ContinuousLinearMap.coeLM (R := R) R (M := V) (N₃ := R)).flip := by
  simp_rw [separatingDual_def, Ne, injective_iff_map_eq_zero]
  

Proof state:
R : Type u_1
V : Type u_2
inst✝⁷ : Field R
inst✝⁶ : AddCommGroup V
inst✝⁵ : TopologicalSpace R
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalRing R
inst✝² : TopologicalAddGroup V
inst✝¹ : Module R V
inst✝ : SeparatingDual R V
⊢ (∀ (x : V), ¬x = 0 → ∃ f, ¬f x = 0) ↔ ∀ (a : V), (LinearMap.flip (ContinuousLinearMap.coeLM R)) a = 0 → a = 0

Next tactic:
congrm ∀ v, ?_
theorem _root_.separatingDual_iff_injective : SeparatingDual R V ↔
    Function.Injective (ContinuousLinearMap.coeLM (R := R) R (M := V) (N₃ := R)).flip := by
  simp_rw [separatingDual_def, Ne, injective_iff_map_eq_zero]
  congrm ∀ v, ?_
  

Proof state:
case a
R : Type u_1
V : Type u_2
inst✝⁷ : Field R
inst✝⁶ : AddCommGroup V
inst✝⁵ : TopologicalSpace R
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalRing R
inst✝² : TopologicalAddGroup V
inst✝¹ : Module R V
inst✝ : SeparatingDual R V
v : V
⊢ (¬v = 0 → ∃ f, ¬f v = 0) ↔ (LinearMap.flip (ContinuousLinearMap.coeLM R)) v = 0 → v = 0

Next tactic:
rw [not_imp_comm, LinearMap.ext_iff]
theorem _root_.separatingDual_iff_injective : SeparatingDual R V ↔
    Function.Injective (ContinuousLinearMap.coeLM (R := R) R (M := V) (N₃ := R)).flip := by
  simp_rw [separatingDual_def, Ne, injective_iff_map_eq_zero]
  congrm ∀ v, ?_
  rw [not_imp_comm, LinearMap.ext_iff]
  

Proof state:
case a
R : Type u_1
V : Type u_2
inst✝⁷ : Field R
inst✝⁶ : AddCommGroup V
inst✝⁵ : TopologicalSpace R
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalRing R
inst✝² : TopologicalAddGroup V
inst✝¹ : Module R V
inst✝ : SeparatingDual R V
v : V
⊢ (¬∃ f, ¬f v = 0) → v = 0 ↔ (∀ (x : V →L[R] R), ((LinearMap.flip (ContinuousLinearMap.coeLM R)) v) x = 0 x) → v = 0

Next tactic:
push_neg
theorem _root_.separatingDual_iff_injective : SeparatingDual R V ↔
    Function.Injective (ContinuousLinearMap.coeLM (R := R) R (M := V) (N₃ := R)).flip := by
  simp_rw [separatingDual_def, Ne, injective_iff_map_eq_zero]
  congrm ∀ v, ?_
  rw [not_imp_comm, LinearMap.ext_iff]
  push_neg; 

Proof state:
case a
R : Type u_1
V : Type u_2
inst✝⁷ : Field R
inst✝⁶ : AddCommGroup V
inst✝⁵ : TopologicalSpace R
inst✝⁴ : TopologicalSpace V
inst✝³ : TopologicalRing R
inst✝² : TopologicalAddGroup V
inst✝¹ : Module R V
inst✝ : SeparatingDual R V
v : V
⊢ (∀ (f : V →L[R] R), f v = 0) → v = 0 ↔
    (∀ (x : V →L[R] R), ((LinearMap.flip (ContinuousLinearMap.coeLM R)) v) x = 0 x) → v = 0

Next tactic:
rfl
open Function in
/-- Given a finite-dimensional subspace `W` of a space `V` with separating dual, any
  linear functional on `W` extends to a continuous linear functional on `V`.
  This is stated more generally for an injective linear map from `W` to `V`. -/
theorem dualMap_surjective_iff {W} [AddCommGroup W] [Module R W] [FiniteDimensional R W]
    {f : W →ₗ[R] V} : Surjective (f.dualMap ∘ ContinuousLinearMap.toLinearMap) ↔ Injective f := by
  

Proof state:
R : Type u_1
V : Type u_2
inst✝¹⁰ : Field R
inst✝⁹ : AddCommGroup V
inst✝⁸ : TopologicalSpace R
inst✝⁷ : TopologicalSpace V
inst✝⁶ : TopologicalRing R
inst✝⁵ : TopologicalAddGroup V
inst✝⁴ : Module R V
inst✝³ : SeparatingDual R V
W : Type u_3
inst✝² : AddCommGroup W
inst✝¹ : Module R W
inst✝ : FiniteDimensional R W
f : W →ₗ[R] V
⊢ Surjective (⇑(LinearMap.dualMap f) ∘ ContinuousLinearMap.toLinearMap) ↔ Injective ⇑f

Next tactic:
constructor