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

tactic: by_contra hfg
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
⊢ MeasurablySeparable (range f) (range g)

tactic: have I : ∀ n x y, ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
    ∃ x' y', x' ∈ cylinder x n ∧ y' ∈ cylinder y n ∧
    ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1)) := by
  intro n x y
  contrapose!
  intro H
  rw [← iUnion_cylinder_update x n, ← iUnion_cylinder_update y n, image_iUnion, image_iUnion]
  refine' MeasurablySeparable.iUnion fun i j => _
  exact H _ _ (update_mem_cylinder _ _ _) (update_mem_cylinder _ _ _)
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
⊢ False

tactic: let A :=
  { p : ℕ × (ℕ → ℕ) × (ℕ → ℕ) //
    ¬MeasurablySeparable (f '' cylinder p.2.1 p.1) (g '' cylinder p.2.2 p.1) }
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
⊢ False

tactic: have : ∀ p : A, ∃ q : A,
    q.1.1 = p.1.1 + 1 ∧ q.1.2.1 ∈ cylinder p.1.2.1 p.1.1 ∧ q.1.2.2 ∈ cylinder p.1.2.2 p.1.1 := by
  rintro ⟨⟨n, x, y⟩, hp⟩
  rcases I n x y hp with ⟨x', y', hx', hy', h'⟩
  exact ⟨⟨⟨n + 1, x', y'⟩, h'⟩, rfl, hx', hy'⟩
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
⊢ False

tactic: choose F hFn hFx hFy using this
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
this :
  ∀ (p : A),
    ∃ q,
      (↑q).fst = (↑p).fst + 1 ∧
        (↑q).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst ∧ (↑q).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
⊢ False

tactic: let p0 : A := ⟨⟨0, fun _ => 0, fun _ => 0⟩, by simp [hfg]⟩
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
⊢ False

tactic: let p : ℕ → A := fun n => (F^[n]) p0
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
⊢ False

tactic: have prec : ∀ n, p (n + 1) = F (p n) := fun n => by simp only [iterate_succ', Function.comp]
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
⊢ False

tactic: set x : ℕ → ℕ := fun n => (p (n + 1)).1.2.1 n with hx
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
⊢ False

tactic: set y : ℕ → ℕ := fun n => (p (n + 1)).1.2.2 n with hy
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
⊢ False

tactic: obtain ⟨u, v, u_open, v_open, xu, yv, huv⟩ :
  ∃ u v : Set α, IsOpen u ∧ IsOpen v ∧ f x ∈ u ∧ g y ∈ v ∧ Disjoint u v := by
  apply t2_separation
  exact disjoint_iff_forall_ne.1 h (mem_range_self _) (mem_range_self _)
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
⊢ False

tactic: letI : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
⊢ False

tactic: obtain ⟨εx, εxpos, hεx⟩ : ∃ (εx : ℝ), εx > 0 ∧ Metric.ball x εx ⊆ f ⁻¹' u := by
  apply Metric.mem_nhds_iff.1
  exact hf.continuousAt.preimage_mem_nhds (u_open.mem_nhds xu)
state_before: case intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
⊢ False

tactic: obtain ⟨εy, εypos, hεy⟩ : ∃ (εy : ℝ), εy > 0 ∧ Metric.ball y εy ⊆ g ⁻¹' v := by
  apply Metric.mem_nhds_iff.1
  exact hg.continuousAt.preimage_mem_nhds (v_open.mem_nhds yv)
state_before: case intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
⊢ False

tactic: obtain ⟨n, hn⟩ : ∃ n : ℕ, (1 / 2 : ℝ) ^ n < min εx εy :=
  exists_pow_lt_of_lt_one (lt_min εxpos εypos) (by norm_num)
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
⊢ False

tactic: exact M n B
state_before: case intro.intro.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
B : MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
⊢ False

tactic: intro n x y
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
⊢ ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))

tactic: contrapose!
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
n : ℕ
x y : ℕ → ℕ
⊢ ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
    ∃ x' y',
      x' ∈ cylinder x n ∧ y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))

tactic: intro H
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
n : ℕ
x y : ℕ → ℕ
⊢ (∀ (x' y' : ℕ → ℕ),
      x' ∈ cylinder x n →
        y' ∈ cylinder y n → MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))) →
    MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)

tactic: rw [← iUnion_cylinder_update x n, ← iUnion_cylinder_update y n, image_iUnion, image_iUnion]
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
n : ℕ
x y : ℕ → ℕ
H :
  ∀ (x' y' : ℕ → ℕ),
    x' ∈ cylinder x n → y' ∈ cylinder y n → MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
⊢ MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)

tactic: refine' MeasurablySeparable.iUnion fun i j => _
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
n : ℕ
x y : ℕ → ℕ
H :
  ∀ (x' y' : ℕ → ℕ),
    x' ∈ cylinder x n → y' ∈ cylinder y n → MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
⊢ MeasurablySeparable (⋃ (i : ℕ), f '' cylinder (update x n i) (n + 1))
    (⋃ (i : ℕ), g '' cylinder (update y n i) (n + 1))

tactic: exact H _ _ (update_mem_cylinder _ _ _) (update_mem_cylinder _ _ _)
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
n : ℕ
x y : ℕ → ℕ
H :
  ∀ (x' y' : ℕ → ℕ),
    x' ∈ cylinder x n → y' ∈ cylinder y n → MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
i j : ℕ
⊢ MeasurablySeparable (f '' cylinder (update x n i) (n + 1)) (g '' cylinder (update y n j) (n + 1))

tactic: rintro ⟨⟨n, x, y⟩, hp⟩
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
⊢ ∀ (p : A),
    ∃ q,
      (↑q).fst = (↑p).fst + 1 ∧
        (↑q).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst ∧ (↑q).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst

tactic: rcases I n x y hp with ⟨x', y', hx', hy', h'⟩
state_before: case mk.mk.mk
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
n : ℕ
x y : ℕ → ℕ
hp :
  ¬MeasurablySeparable (f '' cylinder (n, x, y).snd.fst (n, x, y).fst) (g '' cylinder (n, x, y).snd.snd (n, x, y).fst)
⊢ ∃ q,
    (↑q).fst = (↑{ val := (n, x, y), property := hp }).fst + 1 ∧
      (↑q).snd.fst ∈
          cylinder (↑{ val := (n, x, y), property := hp }).snd.fst (↑{ val := (n, x, y), property := hp }).fst ∧
        (↑q).snd.snd ∈
          cylinder (↑{ val := (n, x, y), property := hp }).snd.snd (↑{ val := (n, x, y), property := hp }).fst

tactic: exact ⟨⟨⟨n + 1, x', y'⟩, h'⟩, rfl, hx', hy'⟩
state_before: case mk.mk.mk.intro.intro.intro.intro
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
n : ℕ
x y : ℕ → ℕ
hp :
  ¬MeasurablySeparable (f '' cylinder (n, x, y).snd.fst (n, x, y).fst) (g '' cylinder (n, x, y).snd.snd (n, x, y).fst)
x' y' : ℕ → ℕ
hx' : x' ∈ cylinder x n
hy' : y' ∈ cylinder y n
h' : ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
⊢ ∃ q,
    (↑q).fst = (↑{ val := (n, x, y), property := hp }).fst + 1 ∧
      (↑q).snd.fst ∈
          cylinder (↑{ val := (n, x, y), property := hp }).snd.fst (↑{ val := (n, x, y), property := hp }).fst ∧
        (↑q).snd.snd ∈
          cylinder (↑{ val := (n, x, y), property := hp }).snd.snd (↑{ val := (n, x, y), property := hp }).fst

tactic: simp [hfg]
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
⊢ ¬MeasurablySeparable (f '' cylinder (0, fun x => 0, fun x => 0).snd.fst (0, fun x => 0, fun x => 0).fst)
      (g '' cylinder (0, fun x => 0, fun x => 0).snd.snd (0, fun x => 0, fun x => 0).fst)

tactic: simp only [iterate_succ', Function.comp]
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
n : ℕ
⊢ p (n + 1) = F (p n)

tactic: intro n
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
⊢ ∀ (n : ℕ), (↑(p n)).fst = n

tactic: induction' n with n IH
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
n : ℕ
⊢ (↑(p n)).fst = n

tactic: rfl
state_before: case zero
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
⊢ (↑(p Nat.zero)).fst = Nat.zero

tactic: simp only [prec, hFn, IH]
state_before: case succ
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
n : ℕ
IH : (↑(p n)).fst = n
⊢ (↑(p (Nat.succ n))).fst = Nat.succ n

tactic: intro m
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
⊢ ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m

tactic: apply Nat.le_induction
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
m : ℕ
⊢ ∀ (n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m

tactic: intro n hmn IH
state_before: case succ
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
m : ℕ
⊢ ∀ (n : ℕ),
    m + 1 ≤ n →
      Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m →
        Prod.fst (↑(p (n + 1))).snd m = Prod.fst (↑(p (m + 1))).snd m

tactic: have I : (F (p n)).val.snd.fst m = (p n).val.snd.fst m := by
  apply hFx (p n) m
  rw [pn_fst]
  exact hmn
state_before: case succ
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
m n : ℕ
hmn : m + 1 ≤ n
IH : Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
⊢ Prod.fst (↑(p (n + 1))).snd m = Prod.fst (↑(p (m + 1))).snd m

tactic: rw [prec, I, IH]
state_before: case succ
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I✝ :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
m n : ℕ
hmn : m + 1 ≤ n
IH : Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
I : Prod.fst (↑(F (p n))).snd m = Prod.fst (↑(p n)).snd m
⊢ Prod.fst (↑(p (n + 1))).snd m = Prod.fst (↑(p (m + 1))).snd m

tactic: rfl
state_before: case base
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
m : ℕ
⊢ Prod.fst (↑(p (m + 1))).snd m = Prod.fst (↑(p (m + 1))).snd m

tactic: apply hFx (p n) m
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
m n : ℕ
hmn : m + 1 ≤ n
IH : Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
⊢ Prod.fst (↑(F (p n))).snd m = Prod.fst (↑(p n)).snd m

tactic: rw [pn_fst]
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
m n : ℕ
hmn : m + 1 ≤ n
IH : Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
⊢ m < (↑(p n)).fst

tactic: exact hmn
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
m n : ℕ
hmn : m + 1 ≤ n
IH : Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
⊢ m < n

tactic: intro m
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
⊢ ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m

tactic: apply Nat.le_induction
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
m : ℕ
⊢ ∀ (n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m

tactic: intro n hmn IH
state_before: case succ
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
m : ℕ
⊢ ∀ (n : ℕ),
    m + 1 ≤ n →
      Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m →
        Prod.snd (↑(p (n + 1))).snd m = Prod.snd (↑(p (m + 1))).snd m

tactic: have I : (F (p n)).val.snd.snd m = (p n).val.snd.snd m := by
  apply hFy (p n) m
  rw [pn_fst]
  exact hmn
state_before: case succ
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
m n : ℕ
hmn : m + 1 ≤ n
IH : Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
⊢ Prod.snd (↑(p (n + 1))).snd m = Prod.snd (↑(p (m + 1))).snd m

tactic: rw [prec, I, IH]
state_before: case succ
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I✝ :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
m n : ℕ
hmn : m + 1 ≤ n
IH : Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
I : Prod.snd (↑(F (p n))).snd m = Prod.snd (↑(p n)).snd m
⊢ Prod.snd (↑(p (n + 1))).snd m = Prod.snd (↑(p (m + 1))).snd m

tactic: rfl
state_before: case base
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
m : ℕ
⊢ Prod.snd (↑(p (m + 1))).snd m = Prod.snd (↑(p (m + 1))).snd m

tactic: apply hFy (p n) m
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
m n : ℕ
hmn : m + 1 ≤ n
IH : Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
⊢ Prod.snd (↑(F (p n))).snd m = Prod.snd (↑(p n)).snd m

tactic: rw [pn_fst]
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
m n : ℕ
hmn : m + 1 ≤ n
IH : Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
⊢ m < (↑(p n)).fst

tactic: exact hmn
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
m n : ℕ
hmn : m + 1 ≤ n
IH : Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
⊢ m < n

tactic: intro n
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
⊢ ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)

tactic: convert(p n).2 using 3
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
n : ℕ
⊢ ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)

tactic: rw [pn_fst, ← mem_cylinder_iff_eq, mem_cylinder_iff]
state_before: case h.e'_1.h.e'_3.h.e'_4
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
n : ℕ
⊢ cylinder x n = cylinder (↑(p n)).snd.fst (↑(p n)).fst

tactic: intro i hi
state_before: case h.e'_1.h.e'_3.h.e'_4
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
n : ℕ
⊢ ∀ (i : ℕ), i < n → x i = Prod.fst (↑(p n)).snd i

tactic: rw [hx]
state_before: case h.e'_1.h.e'_3.h.e'_4
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
n i : ℕ
hi : i < n
⊢ x i = Prod.fst (↑(p n)).snd i

tactic: exact (Ix i n hi).symm
state_before: case h.e'_1.h.e'_3.h.e'_4
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
n i : ℕ
hi : i < n
⊢ (fun n => Prod.fst (↑(p (n + 1))).snd n) i = Prod.fst (↑(p n)).snd i

tactic: rw [pn_fst, ← mem_cylinder_iff_eq, mem_cylinder_iff]
state_before: case h.e'_1.h.e'_4.h.e'_4
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
n : ℕ
⊢ cylinder y n = cylinder (↑(p n)).snd.snd (↑(p n)).fst

tactic: intro i hi
state_before: case h.e'_1.h.e'_4.h.e'_4
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
n : ℕ
⊢ ∀ (i : ℕ), i < n → y i = Prod.snd (↑(p n)).snd i

tactic: rw [hy]
state_before: case h.e'_1.h.e'_4.h.e'_4
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
n i : ℕ
hi : i < n
⊢ y i = Prod.snd (↑(p n)).snd i

tactic: exact (Iy i n hi).symm
state_before: case h.e'_1.h.e'_4.h.e'_4
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
n i : ℕ
hi : i < n
⊢ (fun n => Prod.snd (↑(p (n + 1))).snd n) i = Prod.snd (↑(p n)).snd i

tactic: apply t2_separation
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
⊢ ∃ u v, IsOpen u ∧ IsOpen v ∧ f x ∈ u ∧ g y ∈ v ∧ Disjoint u v

tactic: exact disjoint_iff_forall_ne.1 h (mem_range_self _) (mem_range_self _)
state_before: case h
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
⊢ f x ≠ g y

tactic: apply Metric.mem_nhds_iff.1
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
⊢ ∃ εx, εx > 0 ∧ ball x εx ⊆ f ⁻¹' u

tactic: exact hf.continuousAt.preimage_mem_nhds (u_open.mem_nhds xu)
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
⊢ f ⁻¹' u ∈ 𝓝 x

tactic: apply Metric.mem_nhds_iff.1
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
⊢ ∃ εy, εy > 0 ∧ ball y εy ⊆ g ⁻¹' v

tactic: exact hg.continuousAt.preimage_mem_nhds (v_open.mem_nhds yv)
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
⊢ g ⁻¹' v ∈ 𝓝 y

tactic: norm_num
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
⊢ 1 / 2 < 1

tactic: refine' ⟨u, _, _, u_open.measurableSet⟩
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
⊢ MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)

tactic: rw [image_subset_iff]
state_before: case refine'_1
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
⊢ f '' cylinder x n ⊆ u

tactic: apply Subset.trans _ hεx
state_before: case refine'_1
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
⊢ cylinder x n ⊆ f ⁻¹' u

tactic: intro z hz
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
⊢ cylinder x n ⊆ ball x εx

tactic: rw [mem_cylinder_iff_dist_le] at hz
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
z : ℕ → ℕ
hz : z ∈ cylinder x n
⊢ z ∈ ball x εx

tactic: exact hz.trans_lt (hn.trans_le (min_le_left _ _))
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
z : ℕ → ℕ
hz : dist z x ≤ (1 / 2) ^ n
⊢ z ∈ ball x εx

tactic: refine' Disjoint.mono_left _ huv.symm
state_before: case refine'_2
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
⊢ Disjoint (g '' cylinder y n) u

tactic: change g '' cylinder y n ⊆ v
state_before: case refine'_2
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
⊢ g '' cylinder y n ≤ v

tactic: rw [image_subset_iff]
state_before: case refine'_2
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
⊢ g '' cylinder y n ⊆ v

tactic: apply Subset.trans _ hεy
state_before: case refine'_2
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
⊢ cylinder y n ⊆ g ⁻¹' v

tactic: intro z hz
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
⊢ cylinder y n ⊆ ball y εy

tactic: rw [mem_cylinder_iff_dist_le] at hz
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
z : ℕ → ℕ
hz : z ∈ cylinder y n
⊢ z ∈ ball y εy

tactic: exact hz.trans_lt (hn.trans_le (min_le_right _ _))
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.68523
inst✝² : T2Space α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
f g : (ℕ → ℕ) → α
hf : Continuous f
hg : Continuous g
h : Disjoint (range f) (range g)
hfg : ¬MeasurablySeparable (range f) (range g)
I :
  ∀ (n : ℕ) (x y : ℕ → ℕ),
    ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n) →
      ∃ x' y',
        x' ∈ cylinder x n ∧
          y' ∈ cylinder y n ∧ ¬MeasurablySeparable (f '' cylinder x' (n + 1)) (g '' cylinder y' (n + 1))
A : Type := { p // ¬MeasurablySeparable (f '' cylinder p.snd.fst p.fst) (g '' cylinder p.snd.snd p.fst) }
F : A → A
hFn : ∀ (p : A), (↑(F p)).fst = (↑p).fst + 1
hFx : ∀ (p : A), (↑(F p)).snd.fst ∈ cylinder (↑p).snd.fst (↑p).fst
hFy : ∀ (p : A), (↑(F p)).snd.snd ∈ cylinder (↑p).snd.snd (↑p).fst
p0 : A :=
  { val := (0, fun x => 0, fun x => 0),
    property := (_ : ¬MeasurablySeparable (f '' cylinder (fun x => 0) 0) (g '' cylinder (fun x => 0) 0)) }
p : ℕ → A := fun n => (F^[n]) p0
prec : ∀ (n : ℕ), p (n + 1) = F (p n)
pn_fst : ∀ (n : ℕ), (↑(p n)).fst = n
Ix : ∀ (m n : ℕ), m + 1 ≤ n → Prod.fst (↑(p n)).snd m = Prod.fst (↑(p (m + 1))).snd m
Iy : ∀ (m n : ℕ), m + 1 ≤ n → Prod.snd (↑(p n)).snd m = Prod.snd (↑(p (m + 1))).snd m
x : ℕ → ℕ := fun n => Prod.fst (↑(p (n + 1))).snd n
hx : x = fun n => Prod.fst (↑(p (n + 1))).snd n
y : ℕ → ℕ := fun n => Prod.snd (↑(p (n + 1))).snd n
hy : y = fun n => Prod.snd (↑(p (n + 1))).snd n
M : ∀ (n : ℕ), ¬MeasurablySeparable (f '' cylinder x n) (g '' cylinder y n)
u v : Set α
u_open : IsOpen u
v_open : IsOpen v
xu : f x ∈ u
yv : g y ∈ v
huv : Disjoint u v
this : MetricSpace (ℕ → ℕ) := metricSpaceNatNat
εx : ℝ
εxpos : εx > 0
hεx : ball x εx ⊆ f ⁻¹' u
εy : ℝ
εypos : εy > 0
hεy : ball y εy ⊆ g ⁻¹' v
n : ℕ
hn : (1 / 2) ^ n < min εx εy
z : ℕ → ℕ
hz : dist z y ≤ (1 / 2) ^ n
⊢ z ∈ ball y εy