Theorem: MeasureTheory.measurableSet_range_of_continuous_injective
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: letI := upgradePolishSpace γ
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
⊢ MeasurableSet (range f)

tactic: obtain ⟨b, b_count, b_nonempty, hb⟩ :
  ∃ b : Set (Set γ), b.Countable ∧ ∅ ∉ b ∧ IsTopologicalBasis b := exists_countable_basis γ
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this : UpgradedPolishSpace γ := upgradePolishSpace γ
⊢ MeasurableSet (range f)

tactic: haveI : Encodable b := b_count.toEncodable
state_before: case intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
⊢ MeasurableSet (range f)

tactic: let A := { p : b × b // Disjoint (p.1 : Set γ) p.2 }
state_before: case intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
⊢ MeasurableSet (range f)

tactic: have : ∀ p : A, ∃ q : Set β,
    f '' (p.1.1 : Set γ) ⊆ q ∧ Disjoint (f '' (p.1.2 : Set γ)) q ∧ MeasurableSet q := by
  intro p
  apply
    AnalyticSet.measurablySeparable ((hb.isOpen p.1.1.2).analyticSet_image f_cont)
      ((hb.isOpen p.1.2.2).analyticSet_image f_cont)
  exact Disjoint.image p.2 (f_inj.injOn univ) (subset_univ _) (subset_univ _)
state_before: case intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
⊢ MeasurableSet (range f)

tactic: choose q hq1 hq2 q_meas using this
state_before: case intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
this : ∀ (p : A), ∃ q, f '' ↑(↑p).fst ⊆ q ∧ Disjoint (f '' ↑(↑p).snd) q ∧ MeasurableSet q
⊢ MeasurableSet (range f)

tactic: let E : b → Set β := fun s =>
  closure (f '' s) ∩ ⋂ (t : b) (ht : Disjoint s.1 t.1), q ⟨(s, t), ht⟩ \ q ⟨(t, s), ht.symm⟩
state_before: case intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
⊢ MeasurableSet (range f)

tactic: obtain ⟨u, u_anti, u_pos, u_lim⟩ :
  ∃ u : ℕ → ℝ, StrictAnti u ∧ (∀ n : ℕ, 0 < u n) ∧ Tendsto u atTop (𝓝 0) :=
  exists_seq_strictAnti_tendsto (0 : ℝ)
state_before: case intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
⊢ MeasurableSet (range f)

tactic: let F : ℕ → Set β := fun n => ⋃ (s : b) (_ : Bounded s.1 ∧ diam s.1 ≤ u n), E s
state_before: case intro.intro.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
⊢ MeasurableSet (range f)

tactic: suffices range f = ⋂ n, F n by
  have E_meas : ∀ s : b, MeasurableSet (E s) := by
    intro b
    refine' isClosed_closure.measurableSet.inter _
    refine' MeasurableSet.iInter fun s => _
    exact MeasurableSet.iInter fun hs => (q_meas _).diff (q_meas _)
  have F_meas : ∀ n, MeasurableSet (F n) := by
    intro n
    refine' MeasurableSet.iUnion fun s => _
    exact MeasurableSet.iUnion fun _ => E_meas _
  rw [this]
  exact MeasurableSet.iInter fun n => F_meas n
state_before: case intro.intro.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
⊢ MeasurableSet (range f)

tactic: apply Subset.antisymm
state_before: case intro.intro.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
⊢ range f = ⋂ (n : ℕ), F n

tactic: intro p
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
⊢ ∀ (p : A), ∃ q, f '' ↑(↑p).fst ⊆ q ∧ Disjoint (f '' ↑(↑p).snd) q ∧ MeasurableSet q

tactic: apply
  AnalyticSet.measurablySeparable ((hb.isOpen p.1.1.2).analyticSet_image f_cont)
    ((hb.isOpen p.1.2.2).analyticSet_image f_cont)
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
p : A
⊢ ∃ q, f '' ↑(↑p).fst ⊆ q ∧ Disjoint (f '' ↑(↑p).snd) q ∧ MeasurableSet q

tactic: exact Disjoint.image p.2 (f_inj.injOn univ) (subset_univ _) (subset_univ _)
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
p : A
⊢ Disjoint (f '' ↑(↑p).fst) (f '' ↑(↑p).snd)

tactic: have E_meas : ∀ s : b, MeasurableSet (E s) := by
  intro b
  refine' isClosed_closure.measurableSet.inter _
  refine' MeasurableSet.iInter fun s => _
  exact MeasurableSet.iInter fun hs => (q_meas _).diff (q_meas _)
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
⊢ MeasurableSet (range f)

tactic: have F_meas : ∀ n, MeasurableSet (F n) := by
  intro n
  refine' MeasurableSet.iUnion fun s => _
  exact MeasurableSet.iUnion fun _ => E_meas _
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
E_meas : ∀ (s : ↑b), MeasurableSet (E s)
⊢ MeasurableSet (range f)

tactic: rw [this]
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
E_meas : ∀ (s : ↑b), MeasurableSet (E s)
F_meas : ∀ (n : ℕ), MeasurableSet (F n)
⊢ MeasurableSet (range f)

tactic: exact MeasurableSet.iInter fun n => F_meas n
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
E_meas : ∀ (s : ↑b), MeasurableSet (E s)
F_meas : ∀ (n : ℕ), MeasurableSet (F n)
⊢ MeasurableSet (⋂ (n : ℕ), F n)

tactic: intro b
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
⊢ ∀ (s : ↑b), MeasurableSet (E s)

tactic: refine' isClosed_closure.measurableSet.inter _
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b✝ : Set (Set γ)
b_count : Set.Countable b✝
b_nonempty : ¬∅ ∈ b✝
hb : IsTopologicalBasis b✝
this✝ : Encodable ↑b✝
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b✝ → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b✝) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b✝) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
b : ↑b✝
⊢ MeasurableSet (E b)

tactic: refine' MeasurableSet.iInter fun s => _
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b✝ : Set (Set γ)
b_count : Set.Countable b✝
b_nonempty : ¬∅ ∈ b✝
hb : IsTopologicalBasis b✝
this✝ : Encodable ↑b✝
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b✝ → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b✝) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b✝) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
b : ↑b✝
⊢ MeasurableSet
    (⋂ (t : ↑b✝) (ht : Disjoint ↑b ↑t),
      q { val := (b, t), property := ht } \ q { val := (t, b), property := (_ : Disjoint ↑t ↑b) })

tactic: exact MeasurableSet.iInter fun hs => (q_meas _).diff (q_meas _)
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b✝ : Set (Set γ)
b_count : Set.Countable b✝
b_nonempty : ¬∅ ∈ b✝
hb : IsTopologicalBasis b✝
this✝ : Encodable ↑b✝
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b✝ → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b✝) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b✝) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
b s : ↑b✝
⊢ MeasurableSet
    (⋂ (ht : Disjoint ↑b ↑s),
      q { val := (b, s), property := ht } \ q { val := (s, b), property := (_ : Disjoint ↑s ↑b) })

tactic: intro n
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
E_meas : ∀ (s : ↑b), MeasurableSet (E s)
⊢ ∀ (n : ℕ), MeasurableSet (F n)

tactic: refine' MeasurableSet.iUnion fun s => _
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
E_meas : ∀ (s : ↑b), MeasurableSet (E s)
n : ℕ
⊢ MeasurableSet (F n)

tactic: exact MeasurableSet.iUnion fun _ => E_meas _
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
this : range f = ⋂ (n : ℕ), F n
E_meas : ∀ (s : ↑b), MeasurableSet (E s)
n : ℕ
s : ↑b
⊢ MeasurableSet (⋃ (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s)

tactic: rintro x ⟨y, rfl⟩
state_before: case intro.intro.intro.intro.intro.intro.h₁
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
⊢ range f ⊆ ⋂ (n : ℕ), F n

tactic: refine mem_iInter.2 fun n => ?_
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
⊢ f y ∈ ⋂ (n : ℕ), F n

tactic: obtain ⟨s, sb, ys, hs⟩ : ∃ (s : Set γ), s ∈ b ∧ y ∈ s ∧ s ⊆ ball y (u n / 2) := by
  apply hb.mem_nhds_iff.1
  exact ball_mem_nhds _ (half_pos (u_pos n))
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
⊢ f y ∈ F n

tactic: have diam_s : diam s ≤ u n := by
  apply (diam_mono hs bounded_ball).trans
  convert diam_ball (x := y) (half_pos (u_pos n)).le
  ring
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
⊢ f y ∈ F n

tactic: refine' mem_iUnion.2 ⟨⟨s, sb⟩, _⟩
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
diam_s : diam s ≤ u n
⊢ f y ∈ F n

tactic: refine' mem_iUnion.2 ⟨⟨Metric.Bounded.mono hs bounded_ball, diam_s⟩, _⟩
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
diam_s : diam s ≤ u n
⊢ f y ∈
    ⋃ (_ : Metric.Bounded ↑{ val := s, property := sb } ∧ diam ↑{ val := s, property := sb } ≤ u n),
      E { val := s, property := sb }

tactic: apply mem_inter (subset_closure (mem_image_of_mem _ ys))
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
diam_s : diam s ≤ u n
⊢ f y ∈ E { val := s, property := sb }

tactic: refine' mem_iInter.2 fun t => mem_iInter.2 fun ht => ⟨_, _⟩
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
diam_s : diam s ≤ u n
⊢ f y ∈
    ⋂ (t : ↑b) (ht : Disjoint ↑{ val := s, property := sb } ↑t),
      q { val := ({ val := s, property := sb }, t), property := ht } \
        q { val := (t, { val := s, property := sb }), property := (_ : Disjoint ↑t ↑{ val := s, property := sb }) }

tactic: apply hb.mem_nhds_iff.1
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
⊢ ∃ s, s ∈ b ∧ y ∈ s ∧ s ⊆ ball y (u n / 2)

tactic: exact ball_mem_nhds _ (half_pos (u_pos n))
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
⊢ ball y (u n / 2) ∈ 𝓝 y

tactic: apply (diam_mono hs bounded_ball).trans
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
⊢ diam s ≤ u n

tactic: convert diam_ball (x := y) (half_pos (u_pos n)).le
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
⊢ diam (ball y (u n / 2)) ≤ u n

tactic: ring
state_before: case h.e'_4
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
⊢ u n = 2 * (u n / 2)

tactic: apply hq1
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro.intro.intro.intro.refine'_1
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
diam_s : diam s ≤ u n
t : ↑b
ht : Disjoint ↑{ val := s, property := sb } ↑t
⊢ f y ∈ q { val := ({ val := s, property := sb }, t), property := ht }

tactic: exact mem_image_of_mem _ ys
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro.intro.intro.intro.refine'_1.a
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
diam_s : diam s ≤ u n
t : ↑b
ht : Disjoint ↑{ val := s, property := sb } ↑t
⊢ f y ∈ f '' ↑(↑{ val := ({ val := s, property := sb }, t), property := ht }).fst

tactic: apply disjoint_left.1 (hq2 ⟨(t, ⟨s, sb⟩), ht.symm⟩)
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro.intro.intro.intro.refine'_2
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
diam_s : diam s ≤ u n
t : ↑b
ht : Disjoint ↑{ val := s, property := sb } ↑t
⊢ ¬f y ∈ q { val := (t, { val := s, property := sb }), property := (_ : Disjoint ↑t ↑{ val := s, property := sb }) }

tactic: exact mem_image_of_mem _ ys
state_before: case intro.intro.intro.intro.intro.intro.h₁.intro.intro.intro.intro.refine'_2.a
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
y : γ
n : ℕ
s : Set γ
sb : s ∈ b
ys : y ∈ s
hs : s ⊆ ball y (u n / 2)
diam_s : diam s ≤ u n
t : ↑b
ht : Disjoint ↑{ val := s, property := sb } ↑t
⊢ f y ∈
    f ''
      ↑(↑{ val := (t, { val := s, property := sb }), property := (_ : Disjoint ↑t ↑{ val := s, property := sb }) }).snd

tactic: intro x hx
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
⊢ (⋂ (n : ℕ), F n) ⊆ range f

tactic: have C1 : ∀ n, ∃ (s : b) (_ : Bounded s.1 ∧ diam s.1 ≤ u n), x ∈ E s := fun n => by
  simpa only [mem_iUnion] using mem_iInter.1 hx n
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
⊢ x ∈ range f

tactic: choose s hs hxs using C1
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
C1 : ∀ (n : ℕ), ∃ s x_1, x ∈ E s
⊢ x ∈ range f

tactic: have C2 : ∀ n, (s n).1.Nonempty := by
  intro n
  rw [nonempty_iff_ne_empty]
  intro hn
  have := (s n).2
  rw [hn] at this
  exact b_nonempty this
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
⊢ x ∈ range f

tactic: choose y hy using C2
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
C2 : ∀ (n : ℕ), Set.Nonempty ↑(s n)
⊢ x ∈ range f

tactic: have I : ∀ m n, ((s m).1 ∩ (s n).1).Nonempty := by
  intro m n
  rw [← not_disjoint_iff_nonempty_inter]
  by_contra' h
  have A : x ∈ q ⟨(s m, s n), h⟩ \ q ⟨(s n, s m), h.symm⟩ :=
    haveI := mem_iInter.1 (hxs m).2 (s n)
    (mem_iInter.1 this h : _)
  have B : x ∈ q ⟨(s n, s m), h.symm⟩ \ q ⟨(s m, s n), h⟩ :=
    haveI := mem_iInter.1 (hxs n).2 (s m)
    (mem_iInter.1 this h.symm : _)
  exact A.2 B.1
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
⊢ x ∈ range f

tactic: have cauchy_y : CauchySeq y := by
  have : Tendsto (fun n => 2 * u n) atTop (𝓝 0) := by
    simpa only [MulZeroClass.mul_zero] using u_lim.const_mul 2
  refine cauchySeq_of_le_tendsto_0' (fun n => 2 * u n) (fun m n hmn => ?_) this
  rcases I m n with ⟨z, zsm, zsn⟩
  calc
    dist (y m) (y n) ≤ dist (y m) z + dist z (y n) := dist_triangle _ _ _
    _ ≤ u m + u n :=
      (add_le_add ((dist_le_diam_of_mem (hs m).1 (hy m) zsm).trans (hs m).2)
        ((dist_le_diam_of_mem (hs n).1 zsn (hy n)).trans (hs n).2))
    _ ≤ 2 * u m := by linarith [u_anti.antitone hmn]
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
⊢ x ∈ range f

tactic: haveI : Nonempty γ := ⟨y 0⟩
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
⊢ x ∈ range f

tactic: let z := limUnder atTop y
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
⊢ x ∈ range f

tactic: have y_lim : Tendsto y atTop (𝓝 z) := cauchy_y.tendsto_limUnder
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
⊢ x ∈ range f

tactic: suffices f z = x by
  rw [← this]
  exact mem_range_self _
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
⊢ x ∈ range f

tactic: by_contra' hne
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
⊢ f z = x

tactic: obtain ⟨v, w, v_open, w_open, fzv, xw, hvw⟩ := t2_separation hne
state_before: case intro.intro.intro.intro.intro.intro.h₂
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
⊢ False

tactic: obtain ⟨δ, δpos, hδ⟩ : ∃ δ > (0 : ℝ), ball z δ ⊆ f ⁻¹' v := by
  apply Metric.mem_nhds_iff.1
  exact f_cont.continuousAt.preimage_mem_nhds (v_open.mem_nhds fzv)
state_before: case intro.intro.intro.intro.intro.intro.h₂.intro.intro.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
⊢ False

tactic: obtain ⟨n, hn⟩ : ∃ n, u n + dist (y n) z < δ :=
  haveI : Tendsto (fun n => u n + dist (y n) z) atTop (𝓝 0) := by
    simpa only [add_zero] using u_lim.add (tendsto_iff_dist_tendsto_zero.1 y_lim)
  ((tendsto_order.1 this).2 _ δpos).exists
state_before: case intro.intro.intro.intro.intro.intro.h₂.intro.intro.intro.intro.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
δ : ℝ
δpos : δ > 0
hδ : ball z δ ⊆ f ⁻¹' v
⊢ False

tactic: have fsnv : f '' s n ⊆ v := by
  rw [image_subset_iff]
  apply Subset.trans _ hδ
  intro a ha
  calc
    dist a z ≤ dist a (y n) + dist (y n) z := dist_triangle _ _ _
    _ ≤ u n + dist (y n) z :=
      (add_le_add_right ((dist_le_diam_of_mem (hs n).1 ha (hy n)).trans (hs n).2) _)
    _ < δ := hn
state_before: case intro.intro.intro.intro.intro.intro.h₂.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
δ : ℝ
δpos : δ > 0
hδ : ball z δ ⊆ f ⁻¹' v
n : ℕ
hn : u n + dist (y n) z < δ
⊢ False

tactic: have : x ∈ closure v := closure_mono fsnv (hxs n).1
state_before: case intro.intro.intro.intro.intro.intro.h₂.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
δ : ℝ
δpos : δ > 0
hδ : ball z δ ⊆ f ⁻¹' v
n : ℕ
hn : u n + dist (y n) z < δ
fsnv : f '' ↑(s n) ⊆ v
⊢ False

tactic: exact disjoint_left.1 (hvw.closure_left w_open) this xw
state_before: case intro.intro.intro.intro.intro.intro.h₂.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝² : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝¹ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this✝ : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
δ : ℝ
δpos : δ > 0
hδ : ball z δ ⊆ f ⁻¹' v
n : ℕ
hn : u n + dist (y n) z < δ
fsnv : f '' ↑(s n) ⊆ v
this : x ∈ closure v
⊢ False

tactic: simpa only [mem_iUnion] using mem_iInter.1 hx n
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
n : ℕ
⊢ ∃ s x_1, x ∈ E s

tactic: intro n
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
⊢ ∀ (n : ℕ), Set.Nonempty ↑(s n)

tactic: rw [nonempty_iff_ne_empty]
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
n : ℕ
⊢ Set.Nonempty ↑(s n)

tactic: intro hn
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
n : ℕ
⊢ ↑(s n) ≠ ∅

tactic: have := (s n).2
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
n : ℕ
hn : ↑(s n) = ∅
⊢ False

tactic: rw [hn] at this
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
n : ℕ
hn : ↑(s n) = ∅
this : ↑(s n) ∈ b
⊢ False

tactic: exact b_nonempty this
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
n : ℕ
hn : ↑(s n) = ∅
this : ∅ ∈ b
⊢ False

tactic: intro m n
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
⊢ ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))

tactic: rw [← not_disjoint_iff_nonempty_inter]
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
m n : ℕ
⊢ Set.Nonempty (↑(s m) ∩ ↑(s n))

tactic: by_contra' h
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
m n : ℕ
⊢ ¬Disjoint ↑(s m) ↑(s n)

tactic: have A : x ∈ q ⟨(s m, s n), h⟩ \ q ⟨(s n, s m), h.symm⟩ :=
  haveI := mem_iInter.1 (hxs m).2 (s n)
  (mem_iInter.1 this h : _)
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
m n : ℕ
h : Disjoint ↑(s m) ↑(s n)
⊢ False

tactic: have B : x ∈ q ⟨(s n, s m), h.symm⟩ \ q ⟨(s m, s n), h⟩ :=
  haveI := mem_iInter.1 (hxs n).2 (s m)
  (mem_iInter.1 this h.symm : _)
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A✝ : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A✝ → Set β
hq1 : ∀ (p : A✝), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A✝), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A✝), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
m n : ℕ
h : Disjoint ↑(s m) ↑(s n)
A : x ∈ q { val := (s m, s n), property := h } \ q { val := (s n, s m), property := (_ : Disjoint ↑(s n) ↑(s m)) }
⊢ False

tactic: exact A.2 B.1
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A✝ : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A✝ → Set β
hq1 : ∀ (p : A✝), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A✝), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A✝), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
m n : ℕ
h : Disjoint ↑(s m) ↑(s n)
A : x ∈ q { val := (s m, s n), property := h } \ q { val := (s n, s m), property := (_ : Disjoint ↑(s n) ↑(s m)) }
B : x ∈ q { val := (s n, s m), property := (_ : Disjoint ↑(s n) ↑(s m)) } \ q { val := (s m, s n), property := h }
⊢ False

tactic: have : Tendsto (fun n => 2 * u n) atTop (𝓝 0) := by
  simpa only [MulZeroClass.mul_zero] using u_lim.const_mul 2
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
⊢ CauchySeq y

tactic: refine cauchySeq_of_le_tendsto_0' (fun n => 2 * u n) (fun m n hmn => ?_) this
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
this : Tendsto (fun n => 2 * u n) atTop (𝓝 0)
⊢ CauchySeq y

tactic: rcases I m n with ⟨z, zsm, zsn⟩
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
this : Tendsto (fun n => 2 * u n) atTop (𝓝 0)
m n : ℕ
hmn : m ≤ n
⊢ dist (y m) (y n) ≤ (fun n => 2 * u n) m

tactic: calc
  dist (y m) (y n) ≤ dist (y m) z + dist z (y n) := dist_triangle _ _ _
  _ ≤ u m + u n :=
    (add_le_add ((dist_le_diam_of_mem (hs m).1 (hy m) zsm).trans (hs m).2)
      ((dist_le_diam_of_mem (hs n).1 zsn (hy n)).trans (hs n).2))
  _ ≤ 2 * u m := by linarith [u_anti.antitone hmn]
state_before: case intro.intro
α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
this : Tendsto (fun n => 2 * u n) atTop (𝓝 0)
m n : ℕ
hmn : m ≤ n
z : γ
zsm : z ∈ ↑(s m)
zsn : z ∈ ↑(s n)
⊢ dist (y m) (y n) ≤ (fun n => 2 * u n) m

tactic: simpa only [MulZeroClass.mul_zero] using u_lim.const_mul 2
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
⊢ Tendsto (fun n => 2 * u n) atTop (𝓝 0)

tactic: linarith [u_anti.antitone hmn]
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
this : Tendsto (fun n => 2 * u n) atTop (𝓝 0)
m n : ℕ
hmn : m ≤ n
z : γ
zsm : z ∈ ↑(s m)
zsn : z ∈ ↑(s n)
⊢ u m + u n ≤ 2 * u m

tactic: rw [← this]
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝² : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝¹ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this✝ : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
this : f z = x
⊢ x ∈ range f

tactic: exact mem_range_self _
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝² : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝¹ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this✝ : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
this : f z = x
⊢ f z ∈ range f

tactic: apply Metric.mem_nhds_iff.1
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
⊢ ∃ δ, δ > 0 ∧ ball z δ ⊆ f ⁻¹' v

tactic: exact f_cont.continuousAt.preimage_mem_nhds (v_open.mem_nhds fzv)
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
⊢ f ⁻¹' v ∈ 𝓝 z

tactic: simpa only [add_zero] using u_lim.add (tendsto_iff_dist_tendsto_zero.1 y_lim)
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
δ : ℝ
δpos : δ > 0
hδ : ball z δ ⊆ f ⁻¹' v
⊢ Tendsto (fun n => u n + dist (y n) z) atTop (𝓝 0)

tactic: rw [image_subset_iff]
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
δ : ℝ
δpos : δ > 0
hδ : ball z δ ⊆ f ⁻¹' v
n : ℕ
hn : u n + dist (y n) z < δ
⊢ f '' ↑(s n) ⊆ v

tactic: apply Subset.trans _ hδ
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
δ : ℝ
δpos : δ > 0
hδ : ball z δ ⊆ f ⁻¹' v
n : ℕ
hn : u n + dist (y n) z < δ
⊢ ↑(s n) ⊆ f ⁻¹' v

tactic: intro a ha
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
δ : ℝ
δpos : δ > 0
hδ : ball z δ ⊆ f ⁻¹' v
n : ℕ
hn : u n + dist (y n) z < δ
⊢ ↑(s n) ⊆ ball z δ

tactic: calc
  dist a z ≤ dist a (y n) + dist (y n) z := dist_triangle _ _ _
  _ ≤ u n + dist (y n) z :=
    (add_le_add_right ((dist_le_diam_of_mem (hs n).1 ha (hy n)).trans (hs n).2) _)
  _ < δ := hn
state_before: α : Type ?u.87426
inst✝⁵ : TopologicalSpace α
ι : Type ?u.87432
γ : Type u_2
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
β : Type u_1
inst✝³ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
f : γ → β
f_cont : Continuous f
f_inj : Injective f
this✝¹ : UpgradedPolishSpace γ := upgradePolishSpace γ
b : Set (Set γ)
b_count : Set.Countable b
b_nonempty : ¬∅ ∈ b
hb : IsTopologicalBasis b
this✝ : Encodable ↑b
A : Type u_2 := { p // Disjoint ↑p.fst ↑p.snd }
q : A → Set β
hq1 : ∀ (p : A), f '' ↑(↑p).fst ⊆ q p
hq2 : ∀ (p : A), Disjoint (f '' ↑(↑p).snd) (q p)
q_meas : ∀ (p : A), MeasurableSet (q p)
E : ↑b → Set β :=
  fun s =>
    closure (f '' ↑s) ∩
      ⋂ (t : ↑b) (ht : Disjoint ↑s ↑t),
        q { val := (s, t), property := ht } \ q { val := (t, s), property := (_ : Disjoint ↑t ↑s) }
u : ℕ → ℝ
u_anti : StrictAnti u
u_pos : ∀ (n : ℕ), 0 < u n
u_lim : Tendsto u atTop (𝓝 0)
F : ℕ → Set β := fun n => ⋃ (s : ↑b) (_ : Metric.Bounded ↑s ∧ diam ↑s ≤ u n), E s
x : β
hx : x ∈ ⋂ (n : ℕ), F n
s : ℕ → ↑b
hs : ∀ (n : ℕ), Metric.Bounded ↑(s n) ∧ diam ↑(s n) ≤ u n
hxs : ∀ (n : ℕ), x ∈ E (s n)
y : ℕ → γ
hy : ∀ (n : ℕ), y n ∈ ↑(s n)
I : ∀ (m n : ℕ), Set.Nonempty (↑(s m) ∩ ↑(s n))
cauchy_y : CauchySeq y
this : Nonempty γ
z : γ := limUnder atTop y
y_lim : Tendsto y atTop (𝓝 z)
hne : f (limUnder atTop y) ≠ x
v w : Set β
v_open : IsOpen v
w_open : IsOpen w
fzv : f (limUnder atTop y) ∈ v
xw : x ∈ w
hvw : Disjoint v w
δ : ℝ
δpos : δ > 0
hδ : ball z δ ⊆ f ⁻¹' v
n : ℕ
hn : u n + dist (y n) z < δ
a : γ
ha : a ∈ ↑(s n)
⊢ a ∈ ball z δ