[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
⊢ ↑v (x⁻¹ - y⁻¹) < ↑γ
[PROOFSTEP]
have hyp1 : v (x - y) < γ * (v y * v y) := lt_of_lt_of_le h (min_le_left _ _)
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
⊢ ↑v (x⁻¹ - y⁻¹) < ↑γ
[PROOFSTEP]
have hyp1' : v (x - y) * (v y * v y)⁻¹ < γ := mul_inv_lt_of_lt_mul₀ hyp1
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
⊢ ↑v (x⁻¹ - y⁻¹) < ↑γ
[PROOFSTEP]
have hyp2 : v (x - y) < v y := lt_of_lt_of_le h (min_le_right _ _)
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
⊢ ↑v (x⁻¹ - y⁻¹) < ↑γ
[PROOFSTEP]
have key : v x = v y := Valuation.map_eq_of_sub_lt v hyp2
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
⊢ ↑v (x⁻¹ - y⁻¹) < ↑γ
[PROOFSTEP]
have x_ne : x ≠ 0 := by
  intro h
  apply y_ne
  rw [h, v.map_zero] at key
  exact v.zero_iff.1 key.symm
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
⊢ x ≠ 0
[PROOFSTEP]
intro h
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h✝ : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
h : x = 0
⊢ False
[PROOFSTEP]
apply y_ne
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h✝ : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
h : x = 0
⊢ y = 0
[PROOFSTEP]
rw [h, v.map_zero] at key
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h✝ : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : 0 = ↑v y
h : x = 0
⊢ y = 0
[PROOFSTEP]
exact v.zero_iff.1 key.symm
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
x_ne : x ≠ 0
⊢ ↑v (x⁻¹ - y⁻¹) < ↑γ
[PROOFSTEP]
have decomp : x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹ := by
  rw [mul_sub_left_distrib, sub_mul, mul_assoc, show y * y⁻¹ = 1 from mul_inv_cancel y_ne,
    show x⁻¹ * x = 1 from inv_mul_cancel x_ne, mul_one, one_mul]
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
x_ne : x ≠ 0
⊢ x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹
[PROOFSTEP]
rw [mul_sub_left_distrib, sub_mul, mul_assoc, show y * y⁻¹ = 1 from mul_inv_cancel y_ne,
  show x⁻¹ * x = 1 from inv_mul_cancel x_ne, mul_one, one_mul]
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
x_ne : x ≠ 0
decomp : x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹
⊢ ↑v (x⁻¹ - y⁻¹) < ↑γ
[PROOFSTEP]
calc
  v (x⁻¹ - y⁻¹) = v (x⁻¹ * (y - x) * y⁻¹) := by rw [decomp]
  _ = v x⁻¹ * (v <| y - x) * v y⁻¹ := by repeat' rw [Valuation.map_mul]
  _ = (v x)⁻¹ * (v <| y - x) * (v y)⁻¹ := by rw [map_inv₀, map_inv₀]
  _ = (v <| y - x) * (v y * v y)⁻¹ := by rw [mul_assoc, mul_comm, key, mul_assoc, mul_inv_rev]
  _ = (v <| y - x) * (v y * v y)⁻¹ := rfl
  _ = (v <| x - y) * (v y * v y)⁻¹ := by rw [Valuation.map_sub_swap]
  _ < γ := hyp1'
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
x_ne : x ≠ 0
decomp : x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹
⊢ ↑v (x⁻¹ - y⁻¹) = ↑v (x⁻¹ * (y - x) * y⁻¹)
[PROOFSTEP]
rw [decomp]
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
x_ne : x ≠ 0
decomp : x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹
⊢ ↑v (x⁻¹ * (y - x) * y⁻¹) = ↑v x⁻¹ * ↑v (y - x) * ↑v y⁻¹
[PROOFSTEP]
repeat' rw [Valuation.map_mul]
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
x_ne : x ≠ 0
decomp : x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹
⊢ ↑v (x⁻¹ * (y - x) * y⁻¹) = ↑v x⁻¹ * ↑v (y - x) * ↑v y⁻¹
[PROOFSTEP]
rw [Valuation.map_mul]
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
x_ne : x ≠ 0
decomp : x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹
⊢ ↑v (x⁻¹ * (y - x)) * ↑v y⁻¹ = ↑v x⁻¹ * ↑v (y - x) * ↑v y⁻¹
[PROOFSTEP]
rw [Valuation.map_mul]
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
x_ne : x ≠ 0
decomp : x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹
⊢ ↑v x⁻¹ * ↑v (y - x) * ↑v y⁻¹ = (↑v x)⁻¹ * ↑v (y - x) * (↑v y)⁻¹
[PROOFSTEP]
rw [map_inv₀, map_inv₀]
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
x_ne : x ≠ 0
decomp : x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹
⊢ (↑v x)⁻¹ * ↑v (y - x) * (↑v y)⁻¹ = ↑v (y - x) * (↑v y * ↑v y)⁻¹
[PROOFSTEP]
rw [mul_assoc, mul_comm, key, mul_assoc, mul_inv_rev]
[GOAL]
K : Type u_1
inst✝¹ : DivisionRing K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation K Γ₀
x y : K
γ : Γ₀ˣ
y_ne : y ≠ 0
h : ↑v (x - y) < min (↑γ * (↑v y * ↑v y)) (↑v y)
hyp1 : ↑v (x - y) < ↑γ * (↑v y * ↑v y)
hyp1' : ↑v (x - y) * (↑v y * ↑v y)⁻¹ < ↑γ
hyp2 : ↑v (x - y) < ↑v y
key : ↑v x = ↑v y
x_ne : x ≠ 0
decomp : x⁻¹ - y⁻¹ = x⁻¹ * (y - x) * y⁻¹
⊢ ↑v (y - x) * (↑v y * ↑v y)⁻¹ = ↑v (x - y) * (↑v y * ↑v y)⁻¹
[PROOFSTEP]
rw [Valuation.map_sub_swap]
[GOAL]
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ TopologicalRing K
[PROOFSTEP]
infer_instance
[GOAL]
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
⊢ ∀ ⦃x : K⦄, x ≠ 0 → ContinuousAt Inv.inv x
[PROOFSTEP]
intro x x_ne s s_in
[GOAL]
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
s_in : s ∈ 𝓝 x⁻¹
⊢ s ∈ map Inv.inv (𝓝 x)
[PROOFSTEP]
cases' Valued.mem_nhds.mp s_in with γ hs
[GOAL]
case intro
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
s_in : s ∈ 𝓝 x⁻¹
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
⊢ s ∈ map Inv.inv (𝓝 x)
[PROOFSTEP]
clear s_in
[GOAL]
case intro
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
⊢ s ∈ map Inv.inv (𝓝 x)
[PROOFSTEP]
rw [mem_map, Valued.mem_nhds]
[GOAL]
case intro
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
⊢ ∃ γ, {y | ↑v (y - x) < ↑γ} ⊆ Inv.inv ⁻¹' s
[PROOFSTEP]
change ∃ γ : Γ₀ˣ, {y : K | (v (y - x) : Γ₀) < γ} ⊆ {x : K | x⁻¹ ∈ s}
[GOAL]
case intro
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
⊢ ∃ γ, {y | ↑v (y - x) < ↑γ} ⊆ {x | x⁻¹ ∈ s}
[PROOFSTEP]
have vx_ne := (Valuation.ne_zero_iff <| v).mpr x_ne
[GOAL]
case intro
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
vx_ne : ↑v x ≠ 0
⊢ ∃ γ, {y | ↑v (y - x) < ↑γ} ⊆ {x | x⁻¹ ∈ s}
[PROOFSTEP]
let γ' := Units.mk0 _ vx_ne
[GOAL]
case intro
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
vx_ne : ↑v x ≠ 0
γ' : ((fun x => Γ₀) x)ˣ := Units.mk0 (↑v x) vx_ne
⊢ ∃ γ, {y | ↑v (y - x) < ↑γ} ⊆ {x | x⁻¹ ∈ s}
[PROOFSTEP]
use min (γ * (γ' * γ')) γ'
[GOAL]
case h
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
vx_ne : ↑v x ≠ 0
γ' : ((fun x => Γ₀) x)ˣ := Units.mk0 (↑v x) vx_ne
⊢ {y | ↑v (y - x) < ↑(min (γ * (γ' * γ')) γ')} ⊆ {x | x⁻¹ ∈ s}
[PROOFSTEP]
intro y y_in
[GOAL]
case h
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
vx_ne : ↑v x ≠ 0
γ' : ((fun x => Γ₀) x)ˣ := Units.mk0 (↑v x) vx_ne
y : K
y_in : y ∈ {y | ↑v (y - x) < ↑(min (γ * (γ' * γ')) γ')}
⊢ y ∈ {x | x⁻¹ ∈ s}
[PROOFSTEP]
apply hs
[GOAL]
case h.a
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
vx_ne : ↑v x ≠ 0
γ' : ((fun x => Γ₀) x)ˣ := Units.mk0 (↑v x) vx_ne
y : K
y_in : y ∈ {y | ↑v (y - x) < ↑(min (γ * (γ' * γ')) γ')}
⊢ y⁻¹ ∈ {y | ↑v (y - x⁻¹) < ↑γ}
[PROOFSTEP]
simp only [mem_setOf_eq] at y_in
[GOAL]
case h.a
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
vx_ne : ↑v x ≠ 0
γ' : ((fun x => Γ₀) x)ˣ := Units.mk0 (↑v x) vx_ne
y : K
y_in : ↑v (y - x) < ↑(min (γ * (Units.mk0 (↑v x) vx_ne * Units.mk0 (↑v x) vx_ne)) (Units.mk0 (↑v x) vx_ne))
⊢ y⁻¹ ∈ {y | ↑v (y - x⁻¹) < ↑γ}
[PROOFSTEP]
rw [Units.min_val, Units.val_mul, Units.val_mul] at y_in
[GOAL]
case h.a
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
src✝ : TopologicalRing K := inferInstance
x : K
x_ne : x ≠ 0
s : Set K
γ : Γ₀ˣ
hs : {y | ↑v (y - x⁻¹) < ↑γ} ⊆ s
vx_ne : ↑v x ≠ 0
γ' : ((fun x => Γ₀) x)ˣ := Units.mk0 (↑v x) vx_ne
y : K
y_in : ↑v (y - x) < min (↑γ * (↑(Units.mk0 (↑v x) vx_ne) * ↑(Units.mk0 (↑v x) vx_ne))) ↑(Units.mk0 (↑v x) vx_ne)
⊢ y⁻¹ ∈ {y | ↑v (y - x⁻¹) < ↑γ}
[PROOFSTEP]
exact Valuation.inversion_estimate _ x_ne y_in
[GOAL]
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ SeparatedSpace K
[PROOFSTEP]
rw [separated_iff_t2]
[GOAL]
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ T2Space K
[PROOFSTEP]
apply TopologicalAddGroup.t2Space_of_zero_sep
[GOAL]
case H
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ ∀ (x : K), x ≠ 0 → ∃ U, U ∈ 𝓝 0 ∧ ¬x ∈ U
[PROOFSTEP]
intro x x_ne
[GOAL]
case H
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
x_ne : x ≠ 0
⊢ ∃ U, U ∈ 𝓝 0 ∧ ¬x ∈ U
[PROOFSTEP]
refine' ⟨{k | v k < v x}, _, fun h => lt_irrefl _ h⟩
[GOAL]
case H
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
x_ne : x ≠ 0
⊢ {k | ↑v k < ↑v x} ∈ 𝓝 0
[PROOFSTEP]
rw [Valued.mem_nhds]
[GOAL]
case H
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
x_ne : x ≠ 0
⊢ ∃ γ, {y | ↑v (y - 0) < ↑γ} ⊆ {k | ↑v k < ↑v x}
[PROOFSTEP]
have vx_ne := (Valuation.ne_zero_iff <| v).mpr x_ne
[GOAL]
case H
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
x_ne : x ≠ 0
vx_ne : ↑v x ≠ 0
⊢ ∃ γ, {y | ↑v (y - 0) < ↑γ} ⊆ {k | ↑v k < ↑v x}
[PROOFSTEP]
let γ' := Units.mk0 _ vx_ne
[GOAL]
case H
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
x_ne : x ≠ 0
vx_ne : ↑v x ≠ 0
γ' : ((fun x => Γ₀) x)ˣ := Units.mk0 (↑v x) vx_ne
⊢ ∃ γ, {y | ↑v (y - 0) < ↑γ} ⊆ {k | ↑v k < ↑v x}
[PROOFSTEP]
exact ⟨γ', fun y hy => by simpa using hy⟩
[GOAL]
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
x_ne : x ≠ 0
vx_ne : ↑v x ≠ 0
γ' : ((fun x => Γ₀) x)ˣ := Units.mk0 (↑v x) vx_ne
y : K
hy : y ∈ {y | ↑v (y - 0) < ↑γ'}
⊢ y ∈ {k | ↑v k < ↑v x}
[PROOFSTEP]
simpa using hy
[GOAL]
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ Continuous ↑v
[PROOFSTEP]
rw [continuous_iff_continuousAt]
[GOAL]
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ ∀ (x : K), ContinuousAt (↑v) x
[PROOFSTEP]
intro x
[GOAL]
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
⊢ ContinuousAt (↑v) x
[PROOFSTEP]
rcases eq_or_ne x 0 with (rfl | h)
[GOAL]
case inl
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ ContinuousAt (↑v) 0
[PROOFSTEP]
rw [ContinuousAt, map_zero, WithZeroTopology.tendsto_zero]
[GOAL]
case inl
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
⊢ ∀ (γ₀ : Γ₀), γ₀ ≠ 0 → ∀ᶠ (x : K) in 𝓝 0, ↑v x < γ₀
[PROOFSTEP]
intro γ hγ
[GOAL]
case inl
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
γ : Γ₀
hγ : γ ≠ 0
⊢ ∀ᶠ (x : K) in 𝓝 0, ↑v x < γ
[PROOFSTEP]
rw [Filter.Eventually, Valued.mem_nhds_zero]
[GOAL]
case inl
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
γ : Γ₀
hγ : γ ≠ 0
⊢ ∃ γ_1, {x | ↑v x < ↑γ_1} ⊆ {x | ↑v x < γ}
[PROOFSTEP]
use Units.mk0 γ hγ
[GOAL]
case h
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
γ : Γ₀
hγ : γ ≠ 0
⊢ {x | ↑v x < ↑(Units.mk0 γ hγ)} ⊆ {x | ↑v x < γ}
[PROOFSTEP]
rfl
[GOAL]
case inr
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
h : x ≠ 0
⊢ ContinuousAt (↑v) x
[PROOFSTEP]
have v_ne : (v x : Γ₀) ≠ 0 := (Valuation.ne_zero_iff _).mpr h
[GOAL]
case inr
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
h : x ≠ 0
v_ne : ↑v x ≠ 0
⊢ ContinuousAt (↑v) x
[PROOFSTEP]
rw [ContinuousAt, WithZeroTopology.tendsto_of_ne_zero v_ne]
[GOAL]
case inr
K : Type u_1
inst✝² : DivisionRing K
Γ₀ : Type u_2
inst✝¹ : LinearOrderedCommGroupWithZero Γ₀
inst✝ : Valued K Γ₀
x : K
h : x ≠ 0
v_ne : ↑v x ≠ 0
⊢ ∀ᶠ (x_1 : K) in 𝓝 x, ↑v x_1 = ↑v x
[PROOFSTEP]
apply Valued.loc_const v_ne
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
⊢ ∀ (F : Filter K), Cauchy F → 𝓝 0 ⊓ F = ⊥ → Cauchy (map (fun x => x⁻¹) F)
[PROOFSTEP]
rintro F hF h0
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
⊢ Cauchy (map (fun x => x⁻¹) F)
[PROOFSTEP]
have : ∃ γ₀ : Γ₀ˣ, ∃ M ∈ F, ∀ x ∈ M, (γ₀ : Γ₀) ≤ v x :=
  by
  rcases Filter.inf_eq_bot_iff.mp h0 with ⟨U, U_in, M, M_in, H⟩
  rcases Valued.mem_nhds_zero.mp U_in with ⟨γ₀, hU⟩
  exists γ₀, M, M_in
  intro x xM
  apply le_of_not_lt _
  intro hyp
  have : x ∈ U ∩ M := ⟨hU hyp, xM⟩
  rwa [H] at this
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
⊢ ∃ γ₀ M, M ∈ F ∧ ∀ (x : K), x ∈ M → ↑γ₀ ≤ ↑v x
[PROOFSTEP]
rcases Filter.inf_eq_bot_iff.mp h0 with ⟨U, U_in, M, M_in, H⟩
[GOAL]
case intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
U : Set K
U_in : U ∈ 𝓝 0
M : Set K
M_in : M ∈ F
H : U ∩ M = ∅
⊢ ∃ γ₀ M, M ∈ F ∧ ∀ (x : K), x ∈ M → ↑γ₀ ≤ ↑v x
[PROOFSTEP]
rcases Valued.mem_nhds_zero.mp U_in with ⟨γ₀, hU⟩
[GOAL]
case intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
U : Set K
U_in : U ∈ 𝓝 0
M : Set K
M_in : M ∈ F
H : U ∩ M = ∅
γ₀ : Γ₀ˣ
hU : {x | ↑v x < ↑γ₀} ⊆ U
⊢ ∃ γ₀ M, M ∈ F ∧ ∀ (x : K), x ∈ M → ↑γ₀ ≤ ↑v x
[PROOFSTEP]
exists γ₀, M, M_in
[GOAL]
case intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
U : Set K
U_in : U ∈ 𝓝 0
M : Set K
M_in : M ∈ F
H : U ∩ M = ∅
γ₀ : Γ₀ˣ
hU : {x | ↑v x < ↑γ₀} ⊆ U
⊢ ∀ (x : K), x ∈ M → ↑γ₀ ≤ ↑v x
[PROOFSTEP]
intro x xM
[GOAL]
case intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
U : Set K
U_in : U ∈ 𝓝 0
M : Set K
M_in : M ∈ F
H : U ∩ M = ∅
γ₀ : Γ₀ˣ
hU : {x | ↑v x < ↑γ₀} ⊆ U
x : K
xM : x ∈ M
⊢ ↑γ₀ ≤ ↑v x
[PROOFSTEP]
apply le_of_not_lt _
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
U : Set K
U_in : U ∈ 𝓝 0
M : Set K
M_in : M ∈ F
H : U ∩ M = ∅
γ₀ : Γ₀ˣ
hU : {x | ↑v x < ↑γ₀} ⊆ U
x : K
xM : x ∈ M
⊢ ¬↑v x < ↑γ₀
[PROOFSTEP]
intro hyp
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
U : Set K
U_in : U ∈ 𝓝 0
M : Set K
M_in : M ∈ F
H : U ∩ M = ∅
γ₀ : Γ₀ˣ
hU : {x | ↑v x < ↑γ₀} ⊆ U
x : K
xM : x ∈ M
hyp : ↑v x < ↑γ₀
⊢ False
[PROOFSTEP]
have : x ∈ U ∩ M := ⟨hU hyp, xM⟩
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
U : Set K
U_in : U ∈ 𝓝 0
M : Set K
M_in : M ∈ F
H : U ∩ M = ∅
γ₀ : Γ₀ˣ
hU : {x | ↑v x < ↑γ₀} ⊆ U
x : K
xM : x ∈ M
hyp : ↑v x < ↑γ₀
this : x ∈ U ∩ M
⊢ False
[PROOFSTEP]
rwa [H] at this
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
this : ∃ γ₀ M, M ∈ F ∧ ∀ (x : K), x ∈ M → ↑γ₀ ≤ ↑v x
⊢ Cauchy (map (fun x => x⁻¹) F)
[PROOFSTEP]
rcases this with ⟨γ₀, M₀, M₀_in, H₀⟩
[GOAL]
case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : Cauchy F
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
⊢ Cauchy (map (fun x => x⁻¹) F)
[PROOFSTEP]
rw [Valued.cauchy_iff] at hF ⊢
[GOAL]
case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : NeBot F ∧ ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
⊢ NeBot (map (fun x => x⁻¹) F) ∧
    ∀ (γ : Γ₀ˣ), ∃ M, M ∈ map (fun x => x⁻¹) F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
[PROOFSTEP]
refine' ⟨hF.1.map _, _⟩
[GOAL]
case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
hF : NeBot F ∧ ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
⊢ ∀ (γ : Γ₀ˣ), ∃ M, M ∈ map (fun x => x⁻¹) F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
[PROOFSTEP]
replace hF := hF.2
[GOAL]
case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
hF : ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
⊢ ∀ (γ : Γ₀ˣ), ∃ M, M ∈ map (fun x => x⁻¹) F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
[PROOFSTEP]
intro γ
[GOAL]
case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
hF : ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
γ : Γ₀ˣ
⊢ ∃ M, M ∈ map (fun x => x⁻¹) F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
[PROOFSTEP]
rcases hF (min (γ * γ₀ * γ₀) γ₀) with ⟨M₁, M₁_in, H₁⟩
[GOAL]
case intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
hF : ∀ (γ : Γ₀ˣ), ∃ M, M ∈ F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
H₁ : ∀ (x : K), x ∈ M₁ → ∀ (y : K), y ∈ M₁ → ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
⊢ ∃ M, M ∈ map (fun x => x⁻¹) F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
[PROOFSTEP]
clear hF
[GOAL]
case intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
H₁ : ∀ (x : K), x ∈ M₁ → ∀ (y : K), y ∈ M₁ → ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
⊢ ∃ M, M ∈ map (fun x => x⁻¹) F ∧ ∀ (x : K), x ∈ M → ∀ (y : K), y ∈ M → ↑v (y - x) < ↑γ
[PROOFSTEP]
use(fun x : K => x⁻¹) '' (M₀ ∩ M₁)
[GOAL]
case h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
H₁ : ∀ (x : K), x ∈ M₁ → ∀ (y : K), y ∈ M₁ → ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
⊢ (fun x => x⁻¹) '' (M₀ ∩ M₁) ∈ map (fun x => x⁻¹) F ∧
    ∀ (x : K), x ∈ (fun x => x⁻¹) '' (M₀ ∩ M₁) → ∀ (y : K), y ∈ (fun x => x⁻¹) '' (M₀ ∩ M₁) → ↑v (y - x) < ↑γ
[PROOFSTEP]
constructor
[GOAL]
case h.left
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
H₁ : ∀ (x : K), x ∈ M₁ → ∀ (y : K), y ∈ M₁ → ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
⊢ (fun x => x⁻¹) '' (M₀ ∩ M₁) ∈ map (fun x => x⁻¹) F
[PROOFSTEP]
rw [mem_map]
[GOAL]
case h.left
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
H₁ : ∀ (x : K), x ∈ M₁ → ∀ (y : K), y ∈ M₁ → ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
⊢ (fun x => x⁻¹) ⁻¹' ((fun x => x⁻¹) '' (M₀ ∩ M₁)) ∈ F
[PROOFSTEP]
apply mem_of_superset (Filter.inter_mem M₀_in M₁_in)
[GOAL]
case h.left
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
H₁ : ∀ (x : K), x ∈ M₁ → ∀ (y : K), y ∈ M₁ → ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
⊢ M₀ ∩ M₁ ⊆ (fun x => x⁻¹) ⁻¹' ((fun x => x⁻¹) '' (M₀ ∩ M₁))
[PROOFSTEP]
exact subset_preimage_image _ _
[GOAL]
case h.right
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
H₁ : ∀ (x : K), x ∈ M₁ → ∀ (y : K), y ∈ M₁ → ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
⊢ ∀ (x : K), x ∈ (fun x => x⁻¹) '' (M₀ ∩ M₁) → ∀ (y : K), y ∈ (fun x => x⁻¹) '' (M₀ ∩ M₁) → ↑v (y - x) < ↑γ
[PROOFSTEP]
rintro _ ⟨x, ⟨x_in₀, x_in₁⟩, rfl⟩ _ ⟨y, ⟨y_in₀, y_in₁⟩, rfl⟩
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
H₁ : ∀ (x : K), x ∈ M₁ → ∀ (y : K), y ∈ M₁ → ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x : K
x_in₀ : x ∈ M₀
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
⊢ ↑v ((fun x => x⁻¹) y - (fun x => x⁻¹) x) < ↑γ
[PROOFSTEP]
simp only [mem_setOf_eq]
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
H₁ : ∀ (x : K), x ∈ M₁ → ∀ (y : K), y ∈ M₁ → ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x : K
x_in₀ : x ∈ M₀
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
⊢ ↑v (y⁻¹ - x⁻¹) < ↑γ
[PROOFSTEP]
specialize H₁ x x_in₁ y y_in₁
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₀ : x ∈ M₀
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
⊢ ↑v (y⁻¹ - x⁻¹) < ↑γ
[PROOFSTEP]
replace x_in₀ := H₀ x x_in₀
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
⊢ ↑v (y⁻¹ - x⁻¹) < ↑γ
[PROOFSTEP]
replace := H₀ y y_in₀
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
H₀ : ∀ (x : K), x ∈ M₀ → ↑γ₀ ≤ ↑v x
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this : ↑γ₀ ≤ ↑v y
⊢ ↑v (y⁻¹ - x⁻¹) < ↑γ
[PROOFSTEP]
clear H₀
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this : ↑γ₀ ≤ ↑v y
⊢ ↑v (y⁻¹ - x⁻¹) < ↑γ
[PROOFSTEP]
apply Valuation.inversion_estimate
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro.y_ne
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this : ↑γ₀ ≤ ↑v y
⊢ x ≠ 0
[PROOFSTEP]
have : (v x : Γ₀) ≠ 0 := by
  intro h
  rw [h] at x_in₀
  simp at x_in₀
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this : ↑γ₀ ≤ ↑v y
⊢ ↑v x ≠ 0
[PROOFSTEP]
intro h
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this : ↑γ₀ ≤ ↑v y
h : ↑v x = 0
⊢ False
[PROOFSTEP]
rw [h] at x_in₀
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ 0
this : ↑γ₀ ≤ ↑v y
h : ↑v x = 0
⊢ False
[PROOFSTEP]
simp at x_in₀
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro.y_ne
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this✝ : ↑γ₀ ≤ ↑v y
this : ↑v x ≠ 0
⊢ x ≠ 0
[PROOFSTEP]
exact (Valuation.ne_zero_iff _).mp this
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro.h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this : ↑γ₀ ≤ ↑v y
⊢ ↑v (y - x) < min (↑γ * (↑v x * ↑v x)) (↑v x)
[PROOFSTEP]
refine' lt_of_lt_of_le H₁ _
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro.h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this : ↑γ₀ ≤ ↑v y
⊢ ↑(min (γ * γ₀ * γ₀) γ₀) ≤ min (↑γ * (↑v x * ↑v x)) (↑v x)
[PROOFSTEP]
rw [Units.min_val]
[GOAL]
case h.right.intro.intro.intro.intro.intro.intro.h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this : ↑γ₀ ≤ ↑v y
⊢ min ↑(γ * γ₀ * γ₀) ↑γ₀ ≤ min (↑γ * (↑v x * ↑v x)) (↑v x)
[PROOFSTEP]
apply min_le_min _ x_in₀
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this : ↑γ₀ ≤ ↑v y
⊢ ↑(γ * γ₀ * γ₀) ≤ ↑γ * (↑v x * ↑v x)
[PROOFSTEP]
rw [mul_assoc]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this : ↑γ₀ ≤ ↑v y
⊢ ↑(γ * (γ₀ * γ₀)) ≤ ↑γ * (↑v x * ↑v x)
[PROOFSTEP]
have : ((γ₀ * γ₀ : Γ₀ˣ) : Γ₀) ≤ v x * v x :=
  calc
    ↑γ₀ * ↑γ₀ ≤ ↑γ₀ * v x := mul_le_mul_left' x_in₀ ↑γ₀
    _ ≤ _ := mul_le_mul_right' x_in₀ (v x)
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this✝ : ↑γ₀ ≤ ↑v y
this : ↑(γ₀ * γ₀) ≤ ↑v x * ↑v x
⊢ ↑(γ * (γ₀ * γ₀)) ≤ ↑γ * (↑v x * ↑v x)
[PROOFSTEP]
rw [Units.val_mul]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
src✝ : SeparatedSpace K := ValuedRing.separated
F : Filter K
h0 : 𝓝 0 ⊓ F = ⊥
γ₀ : Γ₀ˣ
M₀ : Set K
M₀_in : M₀ ∈ F
γ : Γ₀ˣ
M₁ : Set K
M₁_in : M₁ ∈ F
x : K
x_in₁ : x ∈ M₁
y : K
y_in₀ : y ∈ M₀
y_in₁ : y ∈ M₁
H₁ : ↑v (y - x) < ↑(min (γ * γ₀ * γ₀) γ₀)
x_in₀ : ↑γ₀ ≤ ↑v x
this✝ : ↑γ₀ ≤ ↑v y
this : ↑(γ₀ * γ₀) ≤ ↑v x * ↑v x
⊢ ↑γ * ↑(γ₀ * γ₀) ≤ ↑γ * (↑v x * ↑v x)
[PROOFSTEP]
exact mul_le_mul_left' this γ
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
⊢ Continuous extension
[PROOFSTEP]
refine' Completion.denseInducing_coe.continuous_extend _
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
⊢ ∀ (b : hat K), ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 b)) (𝓝 c)
[PROOFSTEP]
intro x₀
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 c)
[PROOFSTEP]
rcases eq_or_ne x₀ 0 with (rfl | h)
[GOAL]
case inl
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 0)) (𝓝 c)
[PROOFSTEP]
refine' ⟨0, _⟩
[GOAL]
case inl
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
⊢ Tendsto (↑v) (Filter.comap (↑K) (𝓝 0)) (𝓝 0)
[PROOFSTEP]
erw [← Completion.denseInducing_coe.toInducing.nhds_eq_comap]
[GOAL]
case inl
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
⊢ Tendsto (↑v) (𝓝 0) (𝓝 0)
[PROOFSTEP]
exact Valued.continuous_valuation.tendsto' 0 0 (map_zero v)
[GOAL]
case inr
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 c)
[PROOFSTEP]
have preimage_one : v ⁻¹' {(1 : Γ₀)} ∈ 𝓝 (1 : K) :=
  by
  have : (v (1 : K) : Γ₀) ≠ 0 := by
    rw [Valuation.map_one]
    exact zero_ne_one.symm
  convert Valued.loc_const this
  ext x
  rw [Valuation.map_one, mem_preimage, mem_singleton_iff, mem_setOf_eq]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
⊢ ↑v ⁻¹' {1} ∈ 𝓝 1
[PROOFSTEP]
have : (v (1 : K) : Γ₀) ≠ 0 := by
  rw [Valuation.map_one]
  exact zero_ne_one.symm
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
⊢ ↑v 1 ≠ 0
[PROOFSTEP]
rw [Valuation.map_one]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
⊢ 1 ≠ 0
[PROOFSTEP]
exact zero_ne_one.symm
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
this : ↑v 1 ≠ 0
⊢ ↑v ⁻¹' {1} ∈ 𝓝 1
[PROOFSTEP]
convert Valued.loc_const this
[GOAL]
case h.e'_4
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
this : ↑v 1 ≠ 0
⊢ ↑v ⁻¹' {1} = {y | ↑v y = ↑v 1}
[PROOFSTEP]
ext x
[GOAL]
case h.e'_4.h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
this : ↑v 1 ≠ 0
x : K
⊢ x ∈ ↑v ⁻¹' {1} ↔ x ∈ {y | ↑v y = ↑v 1}
[PROOFSTEP]
rw [Valuation.map_one, mem_preimage, mem_singleton_iff, mem_setOf_eq]
[GOAL]
case inr
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 c)
[PROOFSTEP]
obtain ⟨V, V_in, hV⟩ : ∃ V ∈ 𝓝 (1 : hat K), ∀ x : K, (x : hat K) ∈ V → (v x : Γ₀) = 1 := by
  rwa [Completion.denseInducing_coe.nhds_eq_comap, mem_comap] at preimage_one
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
⊢ ∃ V, V ∈ 𝓝 1 ∧ ∀ (x : K), ↑K x ∈ V → ↑v x = 1
[PROOFSTEP]
rwa [Completion.denseInducing_coe.nhds_eq_comap, mem_comap] at preimage_one
[GOAL]
case inr.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 c)
[PROOFSTEP]
have : ∃ V' ∈ 𝓝 (1 : hat K), (0 : hat K) ∉ V' ∧ ∀ (x) (_ : x ∈ V') (y) (_ : y ∈ V'), x * y⁻¹ ∈ V :=
  by
  have : Tendsto (fun p : hat K × hat K => p.1 * p.2⁻¹) ((𝓝 1) ×ˢ (𝓝 1)) (𝓝 1) :=
    by
    rw [← nhds_prod_eq]
    conv =>
      congr
      rfl
      rfl
      rw [← one_mul (1 : hat K)]
    refine'
      Tendsto.mul continuous_fst.continuousAt
        (Tendsto.comp _ continuous_snd.continuousAt)
          -- Porting note: Added `ContinuousAt.tendsto`
    convert (continuousAt_inv₀ (zero_ne_one.symm : 1 ≠ (0 : hat K))).tendsto
    exact inv_one.symm
  rcases tendsto_prod_self_iff.mp this V V_in with ⟨U, U_in, hU⟩
  let hatKstar := ({0}ᶜ : Set <| hat K)
  have : hatKstar ∈ 𝓝 (1 : hat K) := compl_singleton_mem_nhds zero_ne_one.symm
  use U ∩ hatKstar, Filter.inter_mem U_in this
  constructor
  · rintro ⟨_, h'⟩
    rw [mem_compl_singleton_iff] at h'
    exact h' rfl
  · rintro x ⟨hx, _⟩ y ⟨hy, _⟩
    apply hU <;> assumption
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
⊢ ∃ V', V' ∈ 𝓝 1 ∧ ¬0 ∈ V' ∧ ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
[PROOFSTEP]
have : Tendsto (fun p : hat K × hat K => p.1 * p.2⁻¹) ((𝓝 1) ×ˢ (𝓝 1)) (𝓝 1) :=
  by
  rw [← nhds_prod_eq]
  conv =>
    congr
    rfl
    rfl
    rw [← one_mul (1 : hat K)]
  refine'
    Tendsto.mul continuous_fst.continuousAt
      (Tendsto.comp _ continuous_snd.continuousAt)
        -- Porting note: Added `ContinuousAt.tendsto`
  convert (continuousAt_inv₀ (zero_ne_one.symm : 1 ≠ (0 : hat K))).tendsto
  exact inv_one.symm
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
⊢ Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
[PROOFSTEP]
rw [← nhds_prod_eq]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
⊢ Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 (1, 1)) (𝓝 1)
[PROOFSTEP]
conv =>
  congr
  rfl
  rfl
  rw [← one_mul (1 : hat K)]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
| Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 (1, 1)) (𝓝 1)
[PROOFSTEP]
  congr
  rfl
  rfl
  rw [← one_mul (1 : hat K)]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
| Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 (1, 1)) (𝓝 1)
[PROOFSTEP]
  congr
  rfl
  rfl
  rw [← one_mul (1 : hat K)]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
| Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 (1, 1)) (𝓝 1)
[PROOFSTEP]
congr
[GOAL]
case f
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
| fun p => p.fst * p.snd⁻¹
case l₁
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
| 𝓝 (1, 1)
case l₂
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
| 𝓝 1
[PROOFSTEP]
rfl
[GOAL]
case l₁
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
| 𝓝 (1, 1)
case l₂
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
| 𝓝 1
[PROOFSTEP]
rfl
[GOAL]
case l₂
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
| 𝓝 1
[PROOFSTEP]
rw [← one_mul (1 : hat K)]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
⊢ Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 (1, 1)) (𝓝 (1 * 1))
[PROOFSTEP]
refine'
  Tendsto.mul continuous_fst.continuousAt
    (Tendsto.comp _ continuous_snd.continuousAt)
      -- Porting note: Added `ContinuousAt.tendsto`
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
⊢ Tendsto Inv.inv (𝓝 (1, 1).snd) (𝓝 1)
[PROOFSTEP]
convert (continuousAt_inv₀ (zero_ne_one.symm : 1 ≠ (0 : hat K))).tendsto
[GOAL]
case h.e'_5.h.e'_3
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
⊢ 1 = 1⁻¹
[PROOFSTEP]
exact inv_one.symm
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
⊢ ∃ V', V' ∈ 𝓝 1 ∧ ¬0 ∈ V' ∧ ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
[PROOFSTEP]
rcases tendsto_prod_self_iff.mp this V V_in with ⟨U, U_in, hU⟩
[GOAL]
case intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
⊢ ∃ V', V' ∈ 𝓝 1 ∧ ¬0 ∈ V' ∧ ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
[PROOFSTEP]
let hatKstar := ({0}ᶜ : Set <| hat K)
[GOAL]
case intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
hatKstar : Set (hat K) := {0}ᶜ
⊢ ∃ V', V' ∈ 𝓝 1 ∧ ¬0 ∈ V' ∧ ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
[PROOFSTEP]
have : hatKstar ∈ 𝓝 (1 : hat K) := compl_singleton_mem_nhds zero_ne_one.symm
[GOAL]
case intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this✝ : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
hatKstar : Set (hat K) := {0}ᶜ
this : hatKstar ∈ 𝓝 1
⊢ ∃ V', V' ∈ 𝓝 1 ∧ ¬0 ∈ V' ∧ ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
[PROOFSTEP]
use U ∩ hatKstar, Filter.inter_mem U_in this
[GOAL]
case right
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this✝ : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
hatKstar : Set (hat K) := {0}ᶜ
this : hatKstar ∈ 𝓝 1
⊢ ¬0 ∈ U ∩ hatKstar ∧ ∀ (x : hat K), x ∈ U ∩ hatKstar → ∀ (y : hat K), y ∈ U ∩ hatKstar → x * y⁻¹ ∈ V
[PROOFSTEP]
constructor
[GOAL]
case right.left
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this✝ : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
hatKstar : Set (hat K) := {0}ᶜ
this : hatKstar ∈ 𝓝 1
⊢ ¬0 ∈ U ∩ hatKstar
[PROOFSTEP]
rintro ⟨_, h'⟩
[GOAL]
case right.left.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this✝ : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
hatKstar : Set (hat K) := {0}ᶜ
this : hatKstar ∈ 𝓝 1
left✝ : 0 ∈ U
h' : 0 ∈ hatKstar
⊢ False
[PROOFSTEP]
rw [mem_compl_singleton_iff] at h'
[GOAL]
case right.left.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this✝ : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
hatKstar : Set (hat K) := {0}ᶜ
this : hatKstar ∈ 𝓝 1
left✝ : 0 ∈ U
h' : 0 ≠ 0
⊢ False
[PROOFSTEP]
exact h' rfl
[GOAL]
case right.right
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this✝ : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
hatKstar : Set (hat K) := {0}ᶜ
this : hatKstar ∈ 𝓝 1
⊢ ∀ (x : hat K), x ∈ U ∩ hatKstar → ∀ (y : hat K), y ∈ U ∩ hatKstar → x * y⁻¹ ∈ V
[PROOFSTEP]
rintro x ⟨hx, _⟩ y ⟨hy, _⟩
[GOAL]
case right.right.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this✝ : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
hatKstar : Set (hat K) := {0}ᶜ
this : hatKstar ∈ 𝓝 1
x : hat K
hx : x ∈ U
right✝¹ : x ∈ hatKstar
y : hat K
hy : y ∈ U
right✝ : y ∈ hatKstar
⊢ x * y⁻¹ ∈ V
[PROOFSTEP]
apply hU
[GOAL]
case right.right.intro.intro.a
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this✝ : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
hatKstar : Set (hat K) := {0}ᶜ
this : hatKstar ∈ 𝓝 1
x : hat K
hx : x ∈ U
right✝¹ : x ∈ hatKstar
y : hat K
hy : y ∈ U
right✝ : y ∈ hatKstar
⊢ x ∈ U
[PROOFSTEP]
assumption
[GOAL]
case right.right.intro.intro.a
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this✝ : Tendsto (fun p => p.fst * p.snd⁻¹) (𝓝 1 ×ˢ 𝓝 1) (𝓝 1)
U : Set (hat K)
U_in : U ∈ 𝓝 1
hU : ∀ (x x' : hat K), x ∈ U → x' ∈ U → (x, x').fst * (x, x').snd⁻¹ ∈ V
hatKstar : Set (hat K) := {0}ᶜ
this : hatKstar ∈ 𝓝 1
x : hat K
hx : x ∈ U
right✝¹ : x ∈ hatKstar
y : hat K
hy : y ∈ U
right✝ : y ∈ hatKstar
⊢ y ∈ U
[PROOFSTEP]
assumption
[GOAL]
case inr.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
this : ∃ V', V' ∈ 𝓝 1 ∧ ¬0 ∈ V' ∧ ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 c)
[PROOFSTEP]
rcases this with ⟨V', V'_in, zeroV', hV'⟩
[GOAL]
case inr.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 c)
[PROOFSTEP]
have nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀ :=
  by
  have l : Function.LeftInverse (fun x : hat K => x * x₀⁻¹) fun x : hat K => x * x₀ :=
    by
    intro x
    simp only [mul_assoc, mul_inv_cancel h, mul_one]
  have r : Function.RightInverse (fun x : hat K => x * x₀⁻¹) fun x : hat K => x * x₀ :=
    by
    intro x
    simp only [mul_assoc, inv_mul_cancel h, mul_one]
  have c : Continuous fun x : hat K => x * x₀⁻¹ := continuous_id.mul continuous_const
  rw [image_eq_preimage_of_inverse l r]
  rw [← mul_inv_cancel h] at V'_in
  exact c.continuousAt V'_in
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
⊢ (fun x => x * x₀) '' V' ∈ 𝓝 x₀
[PROOFSTEP]
have l : Function.LeftInverse (fun x : hat K => x * x₀⁻¹) fun x : hat K => x * x₀ :=
  by
  intro x
  simp only [mul_assoc, mul_inv_cancel h, mul_one]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
⊢ Function.LeftInverse (fun x => x * x₀⁻¹) fun x => x * x₀
[PROOFSTEP]
intro x
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
x : hat K
⊢ (fun x => x * x₀⁻¹) ((fun x => x * x₀) x) = x
[PROOFSTEP]
simp only [mul_assoc, mul_inv_cancel h, mul_one]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
l : Function.LeftInverse (fun x => x * x₀⁻¹) fun x => x * x₀
⊢ (fun x => x * x₀) '' V' ∈ 𝓝 x₀
[PROOFSTEP]
have r : Function.RightInverse (fun x : hat K => x * x₀⁻¹) fun x : hat K => x * x₀ :=
  by
  intro x
  simp only [mul_assoc, inv_mul_cancel h, mul_one]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
l : Function.LeftInverse (fun x => x * x₀⁻¹) fun x => x * x₀
⊢ Function.RightInverse (fun x => x * x₀⁻¹) fun x => x * x₀
[PROOFSTEP]
intro x
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
l : Function.LeftInverse (fun x => x * x₀⁻¹) fun x => x * x₀
x : hat K
⊢ (fun x => x * x₀) ((fun x => x * x₀⁻¹) x) = x
[PROOFSTEP]
simp only [mul_assoc, inv_mul_cancel h, mul_one]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
l : Function.LeftInverse (fun x => x * x₀⁻¹) fun x => x * x₀
r : Function.RightInverse (fun x => x * x₀⁻¹) fun x => x * x₀
⊢ (fun x => x * x₀) '' V' ∈ 𝓝 x₀
[PROOFSTEP]
have c : Continuous fun x : hat K => x * x₀⁻¹ := continuous_id.mul continuous_const
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
l : Function.LeftInverse (fun x => x * x₀⁻¹) fun x => x * x₀
r : Function.RightInverse (fun x => x * x₀⁻¹) fun x => x * x₀
c : Continuous fun x => x * x₀⁻¹
⊢ (fun x => x * x₀) '' V' ∈ 𝓝 x₀
[PROOFSTEP]
rw [image_eq_preimage_of_inverse l r]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
l : Function.LeftInverse (fun x => x * x₀⁻¹) fun x => x * x₀
r : Function.RightInverse (fun x => x * x₀⁻¹) fun x => x * x₀
c : Continuous fun x => x * x₀⁻¹
⊢ (fun x => x * x₀⁻¹) ⁻¹' V' ∈ 𝓝 x₀
[PROOFSTEP]
rw [← mul_inv_cancel h] at V'_in
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 (x₀ * x₀⁻¹)
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
l : Function.LeftInverse (fun x => x * x₀⁻¹) fun x => x * x₀
r : Function.RightInverse (fun x => x * x₀⁻¹) fun x => x * x₀
c : Continuous fun x => x * x₀⁻¹
⊢ (fun x => x * x₀⁻¹) ⁻¹' V' ∈ 𝓝 x₀
[PROOFSTEP]
exact c.continuousAt V'_in
[GOAL]
case inr.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 c)
[PROOFSTEP]
have : ∃ z₀ : K, ∃ y₀ ∈ V', ↑z₀ = y₀ * x₀ ∧ z₀ ≠ 0 :=
  by
  rcases Completion.denseRange_coe.mem_nhds nhds_right with ⟨z₀, y₀, y₀_in, H : y₀ * x₀ = z₀⟩
  refine' ⟨z₀, y₀, y₀_in, ⟨H.symm, _⟩⟩
  rintro rfl
  exact mul_ne_zero (ne_of_mem_of_not_mem y₀_in zeroV') h H
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
⊢ ∃ z₀ y₀, y₀ ∈ V' ∧ ↑K z₀ = y₀ * x₀ ∧ z₀ ≠ 0
[PROOFSTEP]
rcases Completion.denseRange_coe.mem_nhds nhds_right with ⟨z₀, y₀, y₀_in, H : y₀ * x₀ = z₀⟩
[GOAL]
case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
H : y₀ * x₀ = ↑K z₀
⊢ ∃ z₀ y₀, y₀ ∈ V' ∧ ↑K z₀ = y₀ * x₀ ∧ z₀ ≠ 0
[PROOFSTEP]
refine' ⟨z₀, y₀, y₀_in, ⟨H.symm, _⟩⟩
[GOAL]
case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
H : y₀ * x₀ = ↑K z₀
⊢ z₀ ≠ 0
[PROOFSTEP]
rintro rfl
[GOAL]
case intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
y₀ : hat K
y₀_in : y₀ ∈ V'
H : y₀ * x₀ = ↑K 0
⊢ False
[PROOFSTEP]
exact mul_ne_zero (ne_of_mem_of_not_mem y₀_in zeroV') h H
[GOAL]
case inr.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
this : ∃ z₀ y₀, y₀ ∈ V' ∧ ↑K z₀ = y₀ * x₀ ∧ z₀ ≠ 0
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 c)
[PROOFSTEP]
rcases this with ⟨z₀, y₀, y₀_in, hz₀, z₀_ne⟩
[GOAL]
case inr.intro.intro.intro.intro.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 c)
[PROOFSTEP]
have vz₀_ne : (v z₀ : Γ₀) ≠ 0 := by rwa [Valuation.ne_zero_iff]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
⊢ ↑v z₀ ≠ 0
[PROOFSTEP]
rwa [Valuation.ne_zero_iff]
[GOAL]
case inr.intro.intro.intro.intro.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
⊢ ∃ c, Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 c)
[PROOFSTEP]
refine' ⟨v z₀, _⟩
[GOAL]
case inr.intro.intro.intro.intro.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
⊢ Tendsto (↑v) (Filter.comap (↑K) (𝓝 x₀)) (𝓝 (↑v z₀))
[PROOFSTEP]
rw [WithZeroTopology.tendsto_of_ne_zero vz₀_ne, eventually_comap]
[GOAL]
case inr.intro.intro.intro.intro.intro.intro.intro.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
⊢ ∀ᶠ (b : hat K) in 𝓝 x₀, ∀ (a : K), ↑K a = b → ↑v a = ↑v z₀
[PROOFSTEP]
filter_upwards [nhds_right] with x x_in a ha
[GOAL]
case h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
x : hat K
x_in : x ∈ (fun x => x * x₀) '' V'
a : K
ha : ↑K a = x
⊢ ↑v a = ↑v z₀
[PROOFSTEP]
rcases x_in with ⟨y, y_in, rfl⟩
[GOAL]
case h.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
a : K
y : hat K
y_in : y ∈ V'
ha : ↑K a = (fun x => x * x₀) y
⊢ ↑v a = ↑v z₀
[PROOFSTEP]
have : (v (a * z₀⁻¹) : Γ₀) = 1 := by
  apply hV
  have : (z₀⁻¹ : K) = (z₀ : hat K)⁻¹ := map_inv₀ (Completion.coeRingHom : K →+* hat K) z₀
  rw [Completion.coe_mul, this, ha, hz₀, mul_inv, mul_comm y₀⁻¹, ← mul_assoc, mul_assoc y, mul_inv_cancel h, mul_one]
  solve_by_elim
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
a : K
y : hat K
y_in : y ∈ V'
ha : ↑K a = (fun x => x * x₀) y
⊢ ↑v (a * z₀⁻¹) = 1
[PROOFSTEP]
apply hV
[GOAL]
case a
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
a : K
y : hat K
y_in : y ∈ V'
ha : ↑K a = (fun x => x * x₀) y
⊢ ↑K (a * z₀⁻¹) ∈ V
[PROOFSTEP]
have : (z₀⁻¹ : K) = (z₀ : hat K)⁻¹ := map_inv₀ (Completion.coeRingHom : K →+* hat K) z₀
[GOAL]
case a
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
a : K
y : hat K
y_in : y ∈ V'
ha : ↑K a = (fun x => x * x₀) y
this : ↑K z₀⁻¹ = (↑K z₀)⁻¹
⊢ ↑K (a * z₀⁻¹) ∈ V
[PROOFSTEP]
rw [Completion.coe_mul, this, ha, hz₀, mul_inv, mul_comm y₀⁻¹, ← mul_assoc, mul_assoc y, mul_inv_cancel h, mul_one]
[GOAL]
case a
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
a : K
y : hat K
y_in : y ∈ V'
ha : ↑K a = (fun x => x * x₀) y
this : ↑K z₀⁻¹ = (↑K z₀)⁻¹
⊢ y * y₀⁻¹ ∈ V
[PROOFSTEP]
solve_by_elim
[GOAL]
case h.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
a : K
y : hat K
y_in : y ∈ V'
ha : ↑K a = (fun x => x * x₀) y
this : ↑v (a * z₀⁻¹) = 1
⊢ ↑v a = ↑v z₀
[PROOFSTEP]
calc
  v a = v (a * z₀⁻¹ * z₀) := by rw [mul_assoc, inv_mul_cancel z₀_ne, mul_one]
  _ = v (a * z₀⁻¹) * v z₀ := (Valuation.map_mul _ _ _)
  _ = v z₀ := by rw [this, one_mul]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
a : K
y : hat K
y_in : y ∈ V'
ha : ↑K a = (fun x => x * x₀) y
this : ↑v (a * z₀⁻¹) = 1
⊢ ↑v a = ↑v (a * z₀⁻¹ * z₀)
[PROOFSTEP]
rw [mul_assoc, inv_mul_cancel z₀_ne, mul_one]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x₀ : hat K
h : x₀ ≠ 0
preimage_one : ↑v ⁻¹' {1} ∈ 𝓝 1
V : Set (hat K)
V_in : V ∈ 𝓝 1
hV : ∀ (x : K), ↑K x ∈ V → ↑v x = 1
V' : Set (hat K)
V'_in : V' ∈ 𝓝 1
zeroV' : ¬0 ∈ V'
hV' : ∀ (x : hat K), x ∈ V' → ∀ (y : hat K), y ∈ V' → x * y⁻¹ ∈ V
nhds_right : (fun x => x * x₀) '' V' ∈ 𝓝 x₀
z₀ : K
y₀ : hat K
y₀_in : y₀ ∈ V'
hz₀ : ↑K z₀ = y₀ * x₀
z₀_ne : z₀ ≠ 0
vz₀_ne : ↑v z₀ ≠ 0
a : K
y : hat K
y_in : y ∈ V'
ha : ↑K a = (fun x => x * x₀) y
this : ↑v (a * z₀⁻¹) = 1
⊢ ↑v (a * z₀⁻¹) * ↑v z₀ = ↑v z₀
[PROOFSTEP]
rw [this, one_mul]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x : K
⊢ extension (↑K x) = ↑v x
[PROOFSTEP]
refine' Completion.denseInducing_coe.extend_eq_of_tendsto _
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x : K
⊢ Tendsto (↑v) (Filter.comap (↑K) (𝓝 (↑K x))) (𝓝 (↑v x))
[PROOFSTEP]
rw [← Completion.denseInducing_coe.nhds_eq_comap]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x : K
⊢ Tendsto (↑v) (𝓝 x) (𝓝 (↑v x))
[PROOFSTEP]
exact Valued.continuous_valuation.continuousAt
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
⊢ extension 0 = 0
[PROOFSTEP]
rw [← v.map_zero (R := K), ← Valued.extension_extends (0 : K)]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
⊢ extension 0 = extension (↑K 0)
[PROOFSTEP]
rfl
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
⊢ ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } 1 = 1
[PROOFSTEP]
simp
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
⊢ extension 1 = 1
[PROOFSTEP]
rw [← Completion.coe_one, Valued.extension_extends (1 : K)]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
⊢ ↑v 1 = 1
[PROOFSTEP]
exact Valuation.map_one _
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x y : hat K
⊢ ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } (x * y) =
    ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } x *
      ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } y
[PROOFSTEP]
apply Completion.induction_on₂ x y (p := fun x y => extension (x * y) = extension x * extension y)
[GOAL]
case hp
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x y : hat K
⊢ IsClosed {x | extension (x.fst * x.snd) = extension x.fst * extension x.snd}
[PROOFSTEP]
have c1 : Continuous fun x : hat K × hat K => Valued.extension (x.1 * x.2) :=
  Valued.continuous_extension.comp (continuous_fst.mul continuous_snd)
[GOAL]
case hp
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x y : hat K
c1 : Continuous fun x => extension (x.fst * x.snd)
⊢ IsClosed {x | extension (x.fst * x.snd) = extension x.fst * extension x.snd}
[PROOFSTEP]
have c2 : Continuous fun x : hat K × hat K => Valued.extension x.1 * Valued.extension x.2 :=
  (Valued.continuous_extension.comp continuous_fst).mul (Valued.continuous_extension.comp continuous_snd)
[GOAL]
case hp
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x y : hat K
c1 : Continuous fun x => extension (x.fst * x.snd)
c2 : Continuous fun x => extension x.fst * extension x.snd
⊢ IsClosed {x | extension (x.fst * x.snd) = extension x.fst * extension x.snd}
[PROOFSTEP]
exact isClosed_eq c1 c2
[GOAL]
case ih
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x y : hat K
⊢ ∀ (a b : K), extension (↑K a * ↑K b) = extension (↑K a) * extension (↑K b)
[PROOFSTEP]
intro x y
[GOAL]
case ih
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x✝ y✝ : hat K
x y : K
⊢ extension (↑K x * ↑K y) = extension (↑K x) * extension (↑K y)
[PROOFSTEP]
norm_cast
[GOAL]
case ih
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x✝ y✝ : hat K
x y : K
⊢ ↑v (x * y) = ↑v x * ↑v y
[PROOFSTEP]
exact Valuation.map_mul _ _ _
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x y : hat K
⊢ ZeroHom.toFun
      (↑{ toZeroHom := { toFun := extension, map_zero' := (_ : extension 0 = 0) },
          map_one' := (_ : ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } 1 = 1),
          map_mul' := (_ : ∀ (x y : hat K), extension (x * y) = extension x * extension y) })
      (x + y) ≤
    max
      (ZeroHom.toFun
        (↑{ toZeroHom := { toFun := extension, map_zero' := (_ : extension 0 = 0) },
            map_one' := (_ : ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } 1 = 1),
            map_mul' := (_ : ∀ (x y : hat K), extension (x * y) = extension x * extension y) })
        x)
      (ZeroHom.toFun
        (↑{ toZeroHom := { toFun := extension, map_zero' := (_ : extension 0 = 0) },
            map_one' := (_ : ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } 1 = 1),
            map_mul' := (_ : ∀ (x y : hat K), extension (x * y) = extension x * extension y) })
        y)
[PROOFSTEP]
rw [le_max_iff]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x y : hat K
⊢ ZeroHom.toFun
        (↑{ toZeroHom := { toFun := extension, map_zero' := (_ : extension 0 = 0) },
            map_one' := (_ : ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } 1 = 1),
            map_mul' := (_ : ∀ (x y : hat K), extension (x * y) = extension x * extension y) })
        (x + y) ≤
      ZeroHom.toFun
        (↑{ toZeroHom := { toFun := extension, map_zero' := (_ : extension 0 = 0) },
            map_one' := (_ : ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } 1 = 1),
            map_mul' := (_ : ∀ (x y : hat K), extension (x * y) = extension x * extension y) })
        x ∨
    ZeroHom.toFun
        (↑{ toZeroHom := { toFun := extension, map_zero' := (_ : extension 0 = 0) },
            map_one' := (_ : ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } 1 = 1),
            map_mul' := (_ : ∀ (x y : hat K), extension (x * y) = extension x * extension y) })
        (x + y) ≤
      ZeroHom.toFun
        (↑{ toZeroHom := { toFun := extension, map_zero' := (_ : extension 0 = 0) },
            map_one' := (_ : ZeroHom.toFun { toFun := extension, map_zero' := (_ : extension 0 = 0) } 1 = 1),
            map_mul' := (_ : ∀ (x y : hat K), extension (x * y) = extension x * extension y) })
        y
[PROOFSTEP]
apply Completion.induction_on₂ x y (p := fun x y => extension (x + y) ≤ extension x ∨ extension (x + y) ≤ extension y)
[GOAL]
case hp
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x y : hat K
⊢ IsClosed {x | extension (x.fst + x.snd) ≤ extension x.fst ∨ extension (x.fst + x.snd) ≤ extension x.snd}
[PROOFSTEP]
have cont : Continuous (Valued.extension : hat K → Γ₀) := Valued.continuous_extension
[GOAL]
case hp
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x y : hat K
cont : Continuous extension
⊢ IsClosed {x | extension (x.fst + x.snd) ≤ extension x.fst ∨ extension (x.fst + x.snd) ≤ extension x.snd}
[PROOFSTEP]
exact
  (isClosed_le (cont.comp continuous_add) <| cont.comp continuous_fst).union
    (isClosed_le (cont.comp continuous_add) <| cont.comp continuous_snd)
[GOAL]
case ih
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x y : hat K
⊢ ∀ (a b : K), extension (↑K a + ↑K b) ≤ extension (↑K a) ∨ extension (↑K a + ↑K b) ≤ extension (↑K b)
[PROOFSTEP]
intro x y
[GOAL]
case ih
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x✝ y✝ : hat K
x y : K
⊢ extension (↑K x + ↑K y) ≤ extension (↑K x) ∨ extension (↑K x + ↑K y) ≤ extension (↑K y)
[PROOFSTEP]
norm_cast
[GOAL]
case ih
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x✝ y✝ : hat K
x y : K
⊢ ↑v (x + y) ≤ ↑v x ∨ ↑v (x + y) ≤ ↑v y
[PROOFSTEP]
rw [← le_max_iff]
[GOAL]
case ih
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
x✝ y✝ : hat K
x y : K
⊢ ↑v (x + y) ≤ max (↑v x) (↑v y)
[PROOFSTEP]
exact v.map_add x y
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
⊢ closure (↑K '' {x | ↑v x < ↑γ}) = {x | ↑extensionValuation x < ↑γ}
[PROOFSTEP]
ext x
[GOAL]
case h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
⊢ x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ x ∈ {x | ↑extensionValuation x < ↑γ}
[PROOFSTEP]
let γ₀ := extensionValuation x
[GOAL]
case h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
⊢ x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ x ∈ {x | ↑extensionValuation x < ↑γ}
[PROOFSTEP]
suffices γ₀ ≠ 0 → (x ∈ closure ((↑) '' {x : K | v x < (γ : Γ₀)}) ↔ γ₀ < (γ : Γ₀))
  by
  cases' eq_or_ne γ₀ 0 with h h
  · simp only [h, (Valuation.zero_iff _).mp h, mem_setOf_eq, Valuation.map_zero, Units.zero_lt, iff_true_iff]
    apply subset_closure
    exact ⟨0, by simp only [mem_setOf_eq, Valuation.map_zero, Units.zero_lt, true_and_iff]; rfl⟩
  · exact this h
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
this : γ₀ ≠ 0 → (x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ γ₀ < ↑γ)
⊢ x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ x ∈ {x | ↑extensionValuation x < ↑γ}
[PROOFSTEP]
cases' eq_or_ne γ₀ 0 with h h
[GOAL]
case inl
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
this : γ₀ ≠ 0 → (x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ γ₀ < ↑γ)
h : γ₀ = 0
⊢ x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ x ∈ {x | ↑extensionValuation x < ↑γ}
[PROOFSTEP]
simp only [h, (Valuation.zero_iff _).mp h, mem_setOf_eq, Valuation.map_zero, Units.zero_lt, iff_true_iff]
[GOAL]
case inl
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
this : γ₀ ≠ 0 → (x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ γ₀ < ↑γ)
h : γ₀ = 0
⊢ 0 ∈ closure (↑K '' {x | ↑v x < ↑γ})
[PROOFSTEP]
apply subset_closure
[GOAL]
case inl.a
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
this : γ₀ ≠ 0 → (x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ γ₀ < ↑γ)
h : γ₀ = 0
⊢ 0 ∈ ↑K '' {x | ↑v x < ↑γ}
[PROOFSTEP]
exact ⟨0, by simp only [mem_setOf_eq, Valuation.map_zero, Units.zero_lt, true_and_iff]; rfl⟩
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
this : γ₀ ≠ 0 → (x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ γ₀ < ↑γ)
h : γ₀ = 0
⊢ 0 ∈ {x | ↑v x < ↑γ} ∧ ↑K 0 = 0
[PROOFSTEP]
simp only [mem_setOf_eq, Valuation.map_zero, Units.zero_lt, true_and_iff]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
this : γ₀ ≠ 0 → (x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ γ₀ < ↑γ)
h : γ₀ = 0
⊢ ↑K 0 = 0
[PROOFSTEP]
rfl
[GOAL]
case inr
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
this : γ₀ ≠ 0 → (x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ γ₀ < ↑γ)
h : γ₀ ≠ 0
⊢ x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ x ∈ {x | ↑extensionValuation x < ↑γ}
[PROOFSTEP]
exact this h
[GOAL]
case h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
⊢ γ₀ ≠ 0 → (x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ γ₀ < ↑γ)
[PROOFSTEP]
intro h
[GOAL]
case h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
⊢ x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ γ₀ < ↑γ
[PROOFSTEP]
have hγ₀ : extension ⁻¹' { γ₀ } ∈ 𝓝 x :=
  continuous_extension.continuousAt.preimage_mem_nhds (WithZeroTopology.singleton_mem_nhds_of_ne_zero h)
[GOAL]
case h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
⊢ x ∈ closure (↑K '' {x | ↑v x < ↑γ}) ↔ γ₀ < ↑γ
[PROOFSTEP]
rw [mem_closure_iff_nhds']
[GOAL]
case h
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
⊢ (∀ (t : Set (hat K)), t ∈ 𝓝 x → ∃ y, ↑y ∈ t) ↔ γ₀ < ↑γ
[PROOFSTEP]
refine' ⟨fun hx => _, fun hx s hs => _⟩
[GOAL]
case h.refine'_1
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
hx : ∀ (t : Set (hat K)), t ∈ 𝓝 x → ∃ y, ↑y ∈ t
⊢ γ₀ < ↑γ
[PROOFSTEP]
obtain ⟨⟨-, y, hy₁ : v y < (γ : Γ₀), rfl⟩, hy₂⟩ := hx _ hγ₀
[GOAL]
case h.refine'_1.intro.mk.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
hx : ∀ (t : Set (hat K)), t ∈ 𝓝 x → ∃ y, ↑y ∈ t
y : K
hy₁ : ↑v y < ↑γ
hy₂ : ↑{ val := ↑K y, property := (_ : ∃ a, a ∈ {x | ↑v x < ↑γ} ∧ ↑K a = ↑K y) } ∈ extension ⁻¹' {γ₀}
⊢ γ₀ < ↑γ
[PROOFSTEP]
replace hy₂ : v y = γ₀
[GOAL]
case hy₂
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
hx : ∀ (t : Set (hat K)), t ∈ 𝓝 x → ∃ y, ↑y ∈ t
y : K
hy₁ : ↑v y < ↑γ
hy₂ : ↑{ val := ↑K y, property := (_ : ∃ a, a ∈ {x | ↑v x < ↑γ} ∧ ↑K a = ↑K y) } ∈ extension ⁻¹' {γ₀}
⊢ ↑v y = γ₀
[PROOFSTEP]
simpa using hy₂
[GOAL]
case h.refine'_1.intro.mk.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
hx : ∀ (t : Set (hat K)), t ∈ 𝓝 x → ∃ y, ↑y ∈ t
y : K
hy₁ : ↑v y < ↑γ
hy₂ : ↑v y = γ₀
⊢ γ₀ < ↑γ
[PROOFSTEP]
rwa [← hy₂]
[GOAL]
case h.refine'_2
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
hx : γ₀ < ↑γ
s : Set (hat K)
hs : s ∈ 𝓝 x
⊢ ∃ y, ↑y ∈ s
[PROOFSTEP]
obtain ⟨y, hy₁, hy₂⟩ := Completion.denseRange_coe.mem_nhds (inter_mem hγ₀ hs)
[GOAL]
case h.refine'_2.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
hx : γ₀ < ↑γ
s : Set (hat K)
hs : s ∈ 𝓝 x
y : K
hy₁ : ↑K y ∈ extension ⁻¹' {γ₀}
hy₂ : ↑K y ∈ s
⊢ ∃ y, ↑y ∈ s
[PROOFSTEP]
replace hy₁ : v y = γ₀
[GOAL]
case hy₁
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
hx : γ₀ < ↑γ
s : Set (hat K)
hs : s ∈ 𝓝 x
y : K
hy₁ : ↑K y ∈ extension ⁻¹' {γ₀}
hy₂ : ↑K y ∈ s
⊢ ↑v y = γ₀
[PROOFSTEP]
simpa using hy₁
[GOAL]
case h.refine'_2.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
hx : γ₀ < ↑γ
s : Set (hat K)
hs : s ∈ 𝓝 x
y : K
hy₂ : ↑K y ∈ s
hy₁ : ↑v y = γ₀
⊢ ∃ y, ↑y ∈ s
[PROOFSTEP]
rw [← hy₁] at hx
[GOAL]
case h.refine'_2.intro.intro
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
γ : Γ₀ˣ
x : hat K
γ₀ : (fun x => Γ₀) x := ↑extensionValuation x
h : γ₀ ≠ 0
hγ₀ : extension ⁻¹' {γ₀} ∈ 𝓝 x
s : Set (hat K)
hs : s ∈ 𝓝 x
y : K
hx : ↑v y < ↑γ
hy₂ : ↑K y ∈ s
hy₁ : ↑v y = γ₀
⊢ ∃ y, ↑y ∈ s
[PROOFSTEP]
exact ⟨⟨y, ⟨y, hx, rfl⟩⟩, hy₂⟩
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
s : Set (hat K)
⊢ s ∈ 𝓝 0 ↔ ∃ γ, {x | ↑extensionValuation x < ↑γ} ⊆ s
[PROOFSTEP]
suffices HasBasis (𝓝 (0 : hat K)) (fun _ => True) fun γ : Γ₀ˣ => {x | extensionValuation x < γ}
  by
  rw [this.mem_iff]
  exact exists_congr fun γ => by simp
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
s : Set (hat K)
this : HasBasis (𝓝 0) (fun x => True) fun γ => {x | ↑extensionValuation x < ↑γ}
⊢ s ∈ 𝓝 0 ↔ ∃ γ, {x | ↑extensionValuation x < ↑γ} ⊆ s
[PROOFSTEP]
rw [this.mem_iff]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
s : Set (hat K)
this : HasBasis (𝓝 0) (fun x => True) fun γ => {x | ↑extensionValuation x < ↑γ}
⊢ (∃ i, True ∧ {x | ↑extensionValuation x < ↑i} ⊆ s) ↔ ∃ γ, {x | ↑extensionValuation x < ↑γ} ⊆ s
[PROOFSTEP]
exact exists_congr fun γ => by simp
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
s : Set (hat K)
this : HasBasis (𝓝 0) (fun x => True) fun γ => {x | ↑extensionValuation x < ↑γ}
γ : Γ₀ˣ
⊢ True ∧ {x | ↑extensionValuation x < ↑γ} ⊆ s ↔ {x | ↑extensionValuation x < ↑γ} ⊆ s
[PROOFSTEP]
simp
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
s : Set (hat K)
⊢ HasBasis (𝓝 0) (fun x => True) fun γ => {x | ↑extensionValuation x < ↑γ}
[PROOFSTEP]
simp_rw [← closure_coe_completion_v_lt]
[GOAL]
K : Type u_1
inst✝¹ : Field K
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
hv : Valued K Γ₀
s : Set (hat K)
⊢ HasBasis (𝓝 0) (fun x => True) fun γ => closure (↑K '' {x | ↑v x < ↑γ})
[PROOFSTEP]
exact (hasBasis_nhds_zero K Γ₀).hasBasis_of_denseInducing Completion.denseInducing_coe


[GOAL]
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
P : Matrix (Fin (m + 1)) (Fin n) α → Prop
⊢ Forall P ↔ ∀ (x : Matrix (Fin (m + 1)) (Fin n) α), P x
[PROOFSTEP]
simp only [Forall, FinVec.forall_iff, forall_iff]
[GOAL]
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
P : Matrix (Fin (m + 1)) (Fin n) α → Prop
⊢ (∀ (x : Fin n → α) (x_1 : Matrix (Fin (Nat.add m 0)) (Fin n) α), P (↑of (vecCons x x_1))) ↔
    ∀ (x : Matrix (Fin (m + 1)) (Fin n) α), P x
[PROOFSTEP]
exact Iff.symm Fin.forall_fin_succ_pi
[GOAL]
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
P : Matrix (Fin (m + 1)) (Fin n) α → Prop
⊢ Exists P ↔ ∃ x, P x
[PROOFSTEP]
simp only [Exists, FinVec.exists_iff, exists_iff]
[GOAL]
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
P : Matrix (Fin (m + 1)) (Fin n) α → Prop
⊢ (∃ x x_1, P (↑of (vecCons x x_1))) ↔ ∃ x, P x
[PROOFSTEP]
exact Iff.symm Fin.exists_fin_succ_pi
[GOAL]
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ transposeᵣ A i j = Aᵀ i j
[PROOFSTEP]
simp_rw [transposeᵣ, transposeᵣ_eq]
[GOAL]
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ ↑of (vecCons (FinVec.map (fun v => v 0) A) (submatrix A id Fin.succ)ᵀ) i j = Aᵀ i j
[PROOFSTEP]
refine' i.cases _ fun i => _
[GOAL]
case refine'_1
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ ↑of (vecCons (FinVec.map (fun v => v 0) A) (submatrix A id Fin.succ)ᵀ) 0 j = Aᵀ 0 j
[PROOFSTEP]
dsimp
[GOAL]
case refine'_1
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i : Fin (n + 1)
j : Fin m
⊢ FinVec.map (fun v => v 0) A j = A j 0
[PROOFSTEP]
rw [FinVec.map_eq, Function.comp_apply]
[GOAL]
case refine'_2
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i✝ : Fin (n + 1)
j : Fin m
i : Fin n
⊢ ↑of (vecCons (FinVec.map (fun v => v 0) A) (submatrix A id Fin.succ)ᵀ) (Fin.succ i) j = Aᵀ (Fin.succ i) j
[PROOFSTEP]
simp only [of_apply, Matrix.cons_val_succ]
[GOAL]
case refine'_2
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin (n + 1)) α
i✝ : Fin (n + 1)
j : Fin m
i : Fin n
⊢ (submatrix A id Fin.succ)ᵀ i j = Aᵀ (Fin.succ i) j
[PROOFSTEP]
rfl
[GOAL]
l m✝ n : ℕ
α : Type u_1
β : Type u_2
inst✝¹ : Mul α
inst✝ : AddCommMonoid α
m : ℕ
a b : Fin m → α
⊢ dotProductᵣ a b = a ⬝ᵥ b
[PROOFSTEP]
simp_rw [dotProductᵣ, dotProduct, FinVec.sum_eq, FinVec.seq_eq, FinVec.map_eq, Function.comp_apply]
[GOAL]
l m n : ℕ
α : Type u_1
β : Type u_2
inst✝¹ : Mul α
inst✝ : AddCommMonoid α
A : Matrix (Fin l) (Fin m) α
B : Matrix (Fin m) (Fin n) α
⊢ mulᵣ A B = A * B
[PROOFSTEP]
simp [mulᵣ, Function.comp, Matrix.transpose]
[GOAL]
l m n : ℕ
α : Type u_1
β : Type u_2
inst✝¹ : Mul α
inst✝ : AddCommMonoid α
A : Matrix (Fin l) (Fin m) α
B : Matrix (Fin m) (Fin n) α
⊢ (↑of fun x x_1 => A x ⬝ᵥ ↑of (fun x y => B y x) x_1) = A * B
[PROOFSTEP]
rfl
[GOAL]
l m n : ℕ
α : Type u_1
β : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix (Fin l) (Fin m) α
v : Fin m → α
⊢ mulVecᵣ A v = mulVec A v
[PROOFSTEP]
simp [mulVecᵣ, Function.comp]
[GOAL]
l m n : ℕ
α : Type u_1
β : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
A : Matrix (Fin l) (Fin m) α
v : Fin m → α
⊢ (fun x => A x ⬝ᵥ v) = mulVec A v
[PROOFSTEP]
rfl
[GOAL]
l m n : ℕ
α : Type u_1
β : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
v : Fin l → α
A : Matrix (Fin l) (Fin m) α
⊢ vecMulᵣ v A = vecMul v A
[PROOFSTEP]
simp [vecMulᵣ, Function.comp]
[GOAL]
l m n : ℕ
α : Type u_1
β : Type u_2
inst✝ : NonUnitalNonAssocSemiring α
v : Fin l → α
A : Matrix (Fin l) (Fin m) α
⊢ (fun x => v ⬝ᵥ Aᵀ x) = vecMul v A
[PROOFSTEP]
rfl
[GOAL]
l m✝ n✝ : ℕ
α : Type u_1
β : Type u_2
m n : ℕ
A : Matrix (Fin m) (Fin n) α
⊢ etaExpand A = A
[PROOFSTEP]
simp_rw [etaExpand, FinVec.etaExpand_eq, Matrix.of, Equiv.refl_apply]