File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

full_name: PadicSeq
code: /-- The type of Cauchy sequences of rationals with respect to the `p`-adic norm. -/
abbrev PadicSeq (p : ℕ) 
goal: Type

full_name: PadicSeq.stationary
code: /-- The `p`-adic norm of the entries of a nonzero Cauchy sequence of rationals is eventually
constant. -/
theorem stationary {f : CauSeq ℚ (padicNorm p)} (hf : ¬f ≈ 0) :
    ∃ N, ∀ m n, N ≤ m → N ≤ n → padicNorm p (f n) = padicNorm p (f m) 
goal: ∃ N, ∀ (m n : ℕ), N ≤ m → N ≤ n → padicNorm p (↑f n) = padicNorm p (↑f m)

full_name: PadicSeq.stationaryPoint
code: /-- For all `n ≥ stationaryPoint f hf`, the `p`-adic norm of `f n` is the same. -/
def stationaryPoint {f : PadicSeq p} (hf : ¬f ≈ 0) : ℕ 
goal: ℕ

full_name: PadicSeq.stationaryPoint_spec
code: theorem stationaryPoint_spec {f : PadicSeq p} (hf : ¬f ≈ 0) :
    ∀ {m n},
      stationaryPoint hf ≤ m → stationaryPoint hf ≤ n → padicNorm p (f n) = padicNorm p (f m) 
goal: PadicSeq.stationaryPoint hf ≤ m → PadicSeq.stationaryPoint hf ≤ n → padicNorm p (↑f n) = padicNorm p (↑f m)

full_name: PadicSeq.norm
code: /-- Since the norm of the entries of a Cauchy sequence is eventually stationary,
we can lift the norm to sequences. -/
def norm (f : PadicSeq p) : ℚ 
goal: ℚ

full_name: PadicSeq.norm_zero_iff
code: theorem norm_zero_iff (f : PadicSeq p) : f.norm = 0 ↔ f ≈ 0 
goal: f.norm = 0 ↔ f ≈ 0

full_name: PadicSeq.equiv_zero_of_val_eq_of_equiv_zero
code: theorem equiv_zero_of_val_eq_of_equiv_zero {f g : PadicSeq p}
    (h : ∀ k, padicNorm p (f k) = padicNorm p (g k)) (hf : f ≈ 0) : g ≈ 0 
goal: g ≈ 0

full_name: PadicSeq.norm_nonzero_of_not_equiv_zero
code: theorem norm_nonzero_of_not_equiv_zero {f : PadicSeq p} (hf : ¬f ≈ 0) : f.norm ≠ 0 
goal: f.norm ≠ 0

full_name: PadicSeq.norm_eq_norm_app_of_nonzero
code: theorem norm_eq_norm_app_of_nonzero {f : PadicSeq p} (hf : ¬f ≈ 0) :
    ∃ k, f.norm = padicNorm p k ∧ k ≠ 0 
goal: ∃ k, f.norm = padicNorm p k ∧ k ≠ 0

full_name: PadicSeq.not_limZero_const_of_nonzero
code: theorem not_limZero_const_of_nonzero {q : ℚ} (hq : q ≠ 0) : ¬LimZero (const (padicNorm p) q) 
goal: ¬(CauSeq.const (padicNorm p) q).LimZero

full_name: PadicSeq.not_equiv_zero_const_of_nonzero
code: theorem not_equiv_zero_const_of_nonzero {q : ℚ} (hq : q ≠ 0) : ¬const (padicNorm p) q ≈ 0 
goal: ¬CauSeq.const (padicNorm p) q ≈ 0

full_name: PadicSeq.norm_nonneg
code: theorem norm_nonneg (f : PadicSeq p) : 0 ≤ f.norm 
goal: 0 ≤ f.norm

full_name: PadicSeq.lift_index_left_left
code: /-- An auxiliary lemma for manipulating sequence indices. -/
theorem lift_index_left_left {f : PadicSeq p} (hf : ¬f ≈ 0) (v2 v3 : ℕ) :
    padicNorm p (f (stationaryPoint hf)) =
    padicNorm p (f (max (stationaryPoint hf) (max v2 v3))) 
goal: padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑f (max (PadicSeq.stationaryPoint hf) (max v2 v3)))

full_name: PadicSeq.lift_index_left
code: /-- An auxiliary lemma for manipulating sequence indices. -/
theorem lift_index_left {f : PadicSeq p} (hf : ¬f ≈ 0) (v1 v3 : ℕ) :
    padicNorm p (f (stationaryPoint hf)) =
    padicNorm p (f (max v1 (max (stationaryPoint hf) v3))) 
goal: padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑f (max v1 (max (PadicSeq.stationaryPoint hf) v3)))

full_name: PadicSeq.lift_index_right
code: /-- An auxiliary lemma for manipulating sequence indices. -/
theorem lift_index_right {f : PadicSeq p} (hf : ¬f ≈ 0) (v1 v2 : ℕ) :
    padicNorm p (f (stationaryPoint hf)) =
    padicNorm p (f (max v1 (max v2 (stationaryPoint hf)))) 
goal: padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑f (max v1 (max v2 (PadicSeq.stationaryPoint hf))))

full_name: PadicSeq.valuation
code: /-- The `p`-adic valuation on `ℚ` lifts to `PadicSeq p`.
`Valuation f` is defined to be the valuation of the (`ℚ`-valued) stationary point of `f`. -/
def valuation (f : PadicSeq p) : ℤ 
goal: ℤ

full_name: PadicSeq.norm_eq_pow_val
code: theorem norm_eq_pow_val {f : PadicSeq p} (hf : ¬f ≈ 0) : f.norm = (p : ℚ) ^ (-f.valuation : ℤ) 
goal: f.norm = ↑p ^ (-f.valuation)

full_name: PadicSeq.val_eq_iff_norm_eq
code: theorem val_eq_iff_norm_eq {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0) :
    f.valuation = g.valuation ↔ f.norm = g.norm 
goal: f.valuation = g.valuation ↔ f.norm = g.norm

full_name: PadicSeq.norm_mul
code: theorem norm_mul (f g : PadicSeq p) : (f * g).norm = f.norm * g.norm 
goal: (f * g).norm = f.norm * g.norm

full_name: PadicSeq.eq_zero_iff_equiv_zero
code: theorem eq_zero_iff_equiv_zero (f : PadicSeq p) : mk f = 0 ↔ f ≈ 0 
goal: CauSeq.Completion.mk f = 0 ↔ f ≈ 0

full_name: PadicSeq.ne_zero_iff_nequiv_zero
code: theorem ne_zero_iff_nequiv_zero (f : PadicSeq p) : mk f ≠ 0 ↔ ¬f ≈ 0 
goal: CauSeq.Completion.mk f ≠ 0 ↔ ¬f ≈ 0

full_name: PadicSeq.norm_const
code: theorem norm_const (q : ℚ) : norm (const (padicNorm p) q) = padicNorm p q 
goal: PadicSeq.norm (CauSeq.const (padicNorm p) q) = padicNorm p q

full_name: PadicSeq.norm_values_discrete
code: theorem norm_values_discrete (a : PadicSeq p) (ha : ¬a ≈ 0) : ∃ z : ℤ, a.norm = (p : ℚ) ^ (-z) 
goal: ∃ z, a.norm = ↑p ^ (-z)

full_name: PadicSeq.norm_one
code: theorem norm_one : norm (1 : PadicSeq p) = 1 
goal: PadicSeq.norm 1 = 1

full_name: _private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.norm_eq_of_equiv_aux
code: private theorem norm_eq_of_equiv_aux {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0) (hfg : f ≈ g)
    (h : padicNorm p (f (stationaryPoint hf)) ≠ padicNorm p (g (stationaryPoint hg)))
    (hlt : padicNorm p (g (stationaryPoint hg)) < padicNorm p (f (stationaryPoint hf))) :
    False 
goal: False

full_name: _private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.norm_eq_of_equiv
code: private theorem norm_eq_of_equiv {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0) (hfg : f ≈ g) :
    padicNorm p (f (stationaryPoint hf)) = padicNorm p (g (stationaryPoint hg)) 
goal: padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑g (PadicSeq.stationaryPoint hg))

full_name: PadicSeq.norm_equiv
code: theorem norm_equiv {f g : PadicSeq p} (hfg : f ≈ g) : f.norm = g.norm 
goal: f.norm = g.norm

full_name: _private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.norm_nonarchimedean_aux
code: private theorem norm_nonarchimedean_aux {f g : PadicSeq p} (hfg : ¬f + g ≈ 0) (hf : ¬f ≈ 0)
    (hg : ¬g ≈ 0) : (f + g).norm ≤ max f.norm g.norm 
goal: (f + g).norm ≤ max f.norm g.norm

full_name: PadicSeq.norm_nonarchimedean
code: theorem norm_nonarchimedean (f g : PadicSeq p) : (f + g).norm ≤ max f.norm g.norm 
goal: (f + g).norm ≤ max f.norm g.norm

full_name: PadicSeq.norm_eq
code: theorem norm_eq {f g : PadicSeq p} (h : ∀ k, padicNorm p (f k) = padicNorm p (g k)) :
    f.norm = g.norm 
goal: f.norm = g.norm

full_name: PadicSeq.norm_neg
code: theorem norm_neg (a : PadicSeq p) : (-a).norm = a.norm 
goal: (-a).norm = a.norm

full_name: PadicSeq.norm_eq_of_add_equiv_zero
code: theorem norm_eq_of_add_equiv_zero {f g : PadicSeq p} (h : f + g ≈ 0) : f.norm = g.norm 
goal: f.norm = g.norm

full_name: PadicSeq.add_eq_max_of_ne
code: theorem add_eq_max_of_ne {f g : PadicSeq p} (hfgne : f.norm ≠ g.norm) :
    (f + g).norm = max f.norm g.norm 
goal: (f + g).norm = max f.norm g.norm

full_name: Padic
code: /-- The `p`-adic numbers `ℚ_[p]` are the Cauchy completion of `ℚ` with respect to the `p`-adic norm.
-/
def Padic (p : ℕ) [Fact p.Prime] 
goal: Type

full_name: «_aux_Mathlib_NumberTheory_Padics_PadicNumbers___macroRules_termℚ_[_]_1»
code: /-- notation for p-padic rationals -/
notation "ℚ_[" p "]" => Padic p
goal: Lean.Macro

full_name: _aux_Mathlib_NumberTheory_Padics_PadicNumbers___unexpand_Padic_1
code: /-- notation for p-padic rationals -/
notation "ℚ_[" p "]" => Padic p
goal: Lean.PrettyPrinter.Unexpander

full_name: Padic.field
code: instance field : Field ℚ_[p] 
goal: Field ℚ_[p]

full_name: Padic.instInhabited
code: instance : Inhabited ℚ_[p] 
goal: Inhabited ℚ_[p]

full_name: Padic.instCommRing
code: instance : CommRing ℚ_[p] 
goal: CommRing ℚ_[p]

full_name: Padic.instRing
code: instance : Ring ℚ_[p] 
goal: Ring ℚ_[p]

full_name: Padic.instZero
code: instance : Zero ℚ_[p] 
goal: Zero ℚ_[p]

full_name: Padic.instOne
code: instance : One ℚ_[p] 
goal: One ℚ_[p]

full_name: Padic.instAdd
code: instance : Add ℚ_[p] 
goal: Add ℚ_[p]

full_name: Padic.instMul
code: instance : Mul ℚ_[p] 
goal: Mul ℚ_[p]

full_name: Padic.instSub
code: instance : Sub ℚ_[p] 
goal: Sub ℚ_[p]

full_name: Padic.instNeg
code: instance : Neg ℚ_[p] 
goal: Neg ℚ_[p]

full_name: Padic.instDiv
code: instance : Div ℚ_[p] 
goal: Div ℚ_[p]

full_name: Padic.instAddCommGroup
code: instance : AddCommGroup ℚ_[p] 
goal: AddCommGroup ℚ_[p]

full_name: Padic.mk
code: /-- Builds the equivalence class of a Cauchy sequence of rationals. -/
def mk : PadicSeq p → ℚ_[p] 
goal: PadicSeq p → ℚ_[p]

full_name: Padic.zero_def
code: theorem zero_def : (0 : ℚ_[p]) = ⟦0⟧ 
goal: 0 = ⟦0⟧

full_name: Padic.mk_eq
code: theorem mk_eq {f g : PadicSeq p} : mk f = mk g ↔ f ≈ g 
goal: Padic.mk f = Padic.mk g ↔ f ≈ g

full_name: Padic.const_equiv
code: theorem const_equiv {q r : ℚ} : const (padicNorm p) q ≈ const (padicNorm p) r ↔ q = r 
goal: CauSeq.const (padicNorm p) q ≈ CauSeq.const (padicNorm p) r ↔ q = r

full_name: Padic.coe_inj
code: @[norm_cast]
theorem coe_inj {q r : ℚ} : (↑q : ℚ_[p]) = ↑r ↔ q = r 
goal: ↑q = ↑r ↔ q = r

full_name: Padic.instCharZero
code: instance : CharZero ℚ_[p] 
goal: CharZero ℚ_[p]

full_name: Padic.coe_add
code: @[norm_cast]
theorem coe_add : ∀ {x y : ℚ}, (↑(x + y) : ℚ_[p]) = ↑x + ↑y 
goal: ↑(x + y) = ↑x + ↑y

full_name: Padic.coe_neg
code: @[norm_cast]
theorem coe_neg : ∀ {x : ℚ}, (↑(-x) : ℚ_[p]) = -↑x 
goal: ↑(-x) = -↑x

full_name: Padic.coe_mul
code: @[norm_cast]
theorem coe_mul : ∀ {x y : ℚ}, (↑(x * y) : ℚ_[p]) = ↑x * ↑y 
goal: ↑(x * y) = ↑x * ↑y

full_name: Padic.coe_sub
code: @[norm_cast]
theorem coe_sub : ∀ {x y : ℚ}, (↑(x - y) : ℚ_[p]) = ↑x - ↑y 
goal: ↑(x - y) = ↑x - ↑y

full_name: Padic.coe_div
code: @[norm_cast]
theorem coe_div : ∀ {x y : ℚ}, (↑(x / y) : ℚ_[p]) = ↑x / ↑y 
goal: ↑(x / y) = ↑x / ↑y

full_name: Padic.coe_one
code: @[norm_cast]
theorem coe_one : (↑(1 : ℚ) : ℚ_[p]) = 1 
goal: ↑1 = 1

full_name: Padic.coe_zero
code: @[norm_cast]
theorem coe_zero : (↑(0 : ℚ) : ℚ_[p]) = 0 
goal: ↑0 = 0

full_name: padicNormE
code: /-- The rational-valued `p`-adic norm on `ℚ_[p]` is lifted from the norm on Cauchy sequences. The
canonical form of this function is the normed space instance, with notation `‖ ‖`. -/
def padicNormE {p : ℕ} [hp : Fact p.Prime] : AbsoluteValue ℚ_[p] ℚ 
goal: AbsoluteValue ℚ_[p] ℚ

full_name: padicNormE.defn
code: theorem defn (f : PadicSeq p) {ε : ℚ} (hε : 0 < ε) :
    ∃ N, ∀ i ≥ N, padicNormE (Padic.mk f - f i : ℚ_[p]) < ε 
goal: ∃ N, ∀ i ≥ N, padicNormE (Padic.mk f - ↑(↑f i)) < ε

full_name: padicNormE.nonarchimedean'
code: /-- Theorems about `padicNormE` are named with a `'` so the names do not conflict with the
equivalent theorems about `norm` (`‖ ‖`). -/
theorem nonarchimedean' (q r : ℚ_[p]) :
    padicNormE (q + r : ℚ_[p]) ≤ max (padicNormE q) (padicNormE r) 
goal: padicNormE (q + r) ≤ max (padicNormE q) (padicNormE r)

full_name: padicNormE.add_eq_max_of_ne'
code: /-- Theorems about `padicNormE` are named with a `'` so the names do not conflict with the
equivalent theorems about `norm` (`‖ ‖`). -/
theorem add_eq_max_of_ne' {q r : ℚ_[p]} :
    padicNormE q ≠ padicNormE r → padicNormE (q + r : ℚ_[p]) = max (padicNormE q) (padicNormE r) 
goal: padicNormE q ≠ padicNormE r → padicNormE (q + r) = max (padicNormE q) (padicNormE r)

full_name: padicNormE.eq_padic_norm'
code: @[simp]
theorem eq_padic_norm' (q : ℚ) : padicNormE (q : ℚ_[p]) = padicNorm p q 
goal: padicNormE ↑q = padicNorm p q

full_name: padicNormE.image'
code: protected theorem image' {q : ℚ_[p]} : q ≠ 0 → ∃ n : ℤ, padicNormE q = (p : ℚ) ^ (-n) 
goal: q ≠ 0 → ∃ n, padicNormE q = ↑p ^ (-n)

full_name: Padic.rat_dense'
code: theorem rat_dense' (q : ℚ_[p]) {ε : ℚ} (hε : 0 < ε) : ∃ r : ℚ, padicNormE (q - r : ℚ_[p]) < ε 
goal: ∃ r, padicNormE (q - ↑r) < ε

full_name: _private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Padic.div_nat_pos
code: private theorem div_nat_pos (n : ℕ) : 0 < 1 / (n + 1 : ℚ) 
goal: 0 < 1 / (↑n + 1)

full_name: Padic.limSeq
code: /-- `limSeq f`, for `f` a Cauchy sequence of `p`-adic numbers, is a sequence of rationals with the
same limit point as `f`. -/
def limSeq : ℕ → ℚ 
goal: ℕ → ℚ

full_name: Padic.exi_rat_seq_conv
code: theorem exi_rat_seq_conv {ε : ℚ} (hε : 0 < ε) :
    ∃ N, ∀ i ≥ N, padicNormE (f i - (limSeq f i : ℚ_[p]) : ℚ_[p]) < ε 
goal: ∃ N, ∀ i ≥ N, padicNormE (↑f i - ↑(Padic.limSeq f i)) < ε

full_name: Padic.exi_rat_seq_conv_cauchy
code: theorem exi_rat_seq_conv_cauchy : IsCauSeq (padicNorm p) (limSeq f) 
goal: IsCauSeq (padicNorm p) (Padic.limSeq f)

full_name: _private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Padic.lim'
code: private def lim' : PadicSeq p 
goal: PadicSeq p

full_name: _private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Padic.lim
code: private def lim : ℚ_[p] 
goal: ℚ_[p]

full_name: Padic.complete'
code: theorem complete' : ∃ q : ℚ_[p], ∀ ε > 0, ∃ N, ∀ i ≥ N, padicNormE (q - f i : ℚ_[p]) < ε 
goal: ∃ q, ∀ ε > 0, ∃ N, ∀ i ≥ N, padicNormE (q - ↑f i) < ε

full_name: Padic.complete''
code: theorem complete'' : ∃ q : ℚ_[p], ∀ ε > 0, ∃ N, ∀ i ≥ N, padicNormE (f i - q : ℚ_[p]) < ε 
goal: ∃ q, ∀ ε > 0, ∃ N, ∀ i ≥ N, padicNormE (↑f i - q) < ε

full_name: Padic.instDist
code: instance : Dist ℚ_[p] 
goal: Dist ℚ_[p]

full_name: Padic.metricSpace
code: instance metricSpace : MetricSpace ℚ_[p] 
goal: MetricSpace ℚ_[p]

full_name: Padic.instNorm
code: instance : Norm ℚ_[p] 
goal: Norm ℚ_[p]

full_name: Padic.normedField
code: instance normedField : NormedField ℚ_[p] 
goal: NormedField ℚ_[p]

full_name: Padic.isAbsoluteValue
code: instance isAbsoluteValue : IsAbsoluteValue fun a : ℚ_[p] ↦ ‖a‖ 
goal: IsAbsoluteValue fun a => ‖a‖

full_name: Padic.rat_dense
code: theorem rat_dense (q : ℚ_[p]) {ε : ℝ} (hε : 0 < ε) : ∃ r : ℚ, ‖q - r‖ < ε 
goal: ∃ r, ‖q - ↑r‖ < ε

full_name: padicNormE.mul
code: @[simp (high)]
protected theorem mul (q r : ℚ_[p]) : ‖q * r‖ = ‖q‖ * ‖r‖ 
goal: ‖q * r‖ = ‖q‖ * ‖r‖

full_name: padicNormE.is_norm
code: protected theorem is_norm (q : ℚ_[p]) : ↑(padicNormE q) = ‖q‖ 
goal: ↑(padicNormE q) = ‖q‖

full_name: padicNormE.nonarchimedean
code: theorem nonarchimedean (q r : ℚ_[p]) : ‖q + r‖ ≤ max ‖q‖ ‖r‖ 
goal: ‖q + r‖ ≤ max ‖q‖ ‖r‖

full_name: padicNormE.add_eq_max_of_ne
code: theorem add_eq_max_of_ne {q r : ℚ_[p]} (h : ‖q‖ ≠ ‖r‖) : ‖q + r‖ = max ‖q‖ ‖r‖ 
goal: ‖q + r‖ = max ‖q‖ ‖r‖

full_name: padicNormE.eq_padicNorm
code: @[simp]
theorem eq_padicNorm (q : ℚ) : ‖(q : ℚ_[p])‖ = padicNorm p q 
goal: ‖↑q‖ = ↑(padicNorm p q)

full_name: padicNormE.norm_p
code: @[simp]
theorem norm_p : ‖(p : ℚ_[p])‖ = (p : ℝ)⁻¹ 
goal: ‖↑p‖ = (↑p)⁻¹

full_name: padicNormE.norm_p_lt_one
code: theorem norm_p_lt_one : ‖(p : ℚ_[p])‖ < 1 
goal: ‖↑p‖ < 1

full_name: padicNormE.norm_p_zpow
code: @[simp (high)]
theorem norm_p_zpow (n : ℤ) : ‖(p : ℚ_[p]) ^ n‖ = (p : ℝ) ^ (-n) 
goal: ‖↑p ^ n‖ = ↑p ^ (-n)

full_name: padicNormE.norm_p_pow
code: @[simp (high)]
theorem norm_p_pow (n : ℕ) : ‖(p : ℚ_[p]) ^ n‖ = (p : ℝ) ^ (-n : ℤ) 
goal: ‖↑p ^ n‖ = ↑p ^ (-↑n)

full_name: padicNormE.instNontriviallyNormedFieldPadic
code: instance : NontriviallyNormedField ℚ_[p] 
goal: NontriviallyNormedField ℚ_[p]

full_name: padicNormE.image
code: protected theorem image {q : ℚ_[p]} : q ≠ 0 → ∃ n : ℤ, ‖q‖ = ↑((p : ℚ) ^ (-n)) 
goal: q ≠ 0 → ∃ n, ‖q‖ = ↑(↑p ^ (-n))

full_name: padicNormE.is_rat
code: protected theorem is_rat (q : ℚ_[p]) : ∃ q' : ℚ, ‖q‖ = q' 
goal: ∃ q', ‖q‖ = ↑q'

full_name: padicNormE.ratNorm
code: /-- `ratNorm q`, for a `p`-adic number `q` is the `p`-adic norm of `q`, as rational number.

The lemma `padicNormE.eq_ratNorm` asserts `‖q‖ = ratNorm q`. -/
def ratNorm (q : ℚ_[p]) : ℚ 
goal: ℚ

full_name: padicNormE.eq_ratNorm
code: theorem eq_ratNorm (q : ℚ_[p]) : ‖q‖ = ratNorm q 
goal: ‖q‖ = ↑(padicNormE.ratNorm q)

full_name: padicNormE.norm_rat_le_one
code: theorem norm_rat_le_one : ∀ {q : ℚ} (_ : ¬p ∣ q.den), ‖(q : ℚ_[p])‖ ≤ 1
  
goal: ¬p ∣ q.den → ‖↑q‖ ≤ 1

full_name: padicNormE.norm_int_le_one
code: theorem norm_int_le_one (z : ℤ) : ‖(z : ℚ_[p])‖ ≤ 1 
goal: ‖↑z‖ ≤ 1

full_name: padicNormE.norm_int_lt_one_iff_dvd
code: theorem norm_int_lt_one_iff_dvd (k : ℤ) : ‖(k : ℚ_[p])‖ < 1 ↔ ↑p ∣ k 
goal: ‖↑k‖ < 1 ↔ ↑p ∣ k

full_name: padicNormE.norm_int_le_pow_iff_dvd
code: theorem norm_int_le_pow_iff_dvd (k : ℤ) (n : ℕ) :
    ‖(k : ℚ_[p])‖ ≤ (p : ℝ) ^ (-n : ℤ) ↔ (p ^ n : ℤ) ∣ k 
goal: ‖↑k‖ ≤ ↑p ^ (-↑n) ↔ ↑p ^ n ∣ k

full_name: padicNormE.eq_of_norm_add_lt_right
code: theorem eq_of_norm_add_lt_right {z1 z2 : ℚ_[p]} (h : ‖z1 + z2‖ < ‖z2‖) : ‖z1‖ = ‖z2‖ 
goal: ‖z1‖ = ‖z2‖

full_name: padicNormE.eq_of_norm_add_lt_left
code: theorem eq_of_norm_add_lt_left {z1 z2 : ℚ_[p]} (h : ‖z1 + z2‖ < ‖z1‖) : ‖z1‖ = ‖z2‖ 
goal: ‖z1‖ = ‖z2‖

full_name: Padic.complete
code: instance complete : CauSeq.IsComplete ℚ_[p] norm 
goal: CauSeq.IsComplete ℚ_[p] norm

full_name: Padic.padicNormE_lim_le
code: theorem padicNormE_lim_le {f : CauSeq ℚ_[p] norm} {a : ℝ} (ha : 0 < a) (hf : ∀ i, ‖f i‖ ≤ a) :
    ‖f.lim‖ ≤ a 
goal: ‖f.lim‖ ≤ a

full_name: Padic.instCompleteSpace
code: instance : CompleteSpace ℚ_[p] 
goal: CompleteSpace ℚ_[p]

full_name: Padic.valuation
code: /-- `Padic.valuation` lifts the `p`-adic valuation on rationals to `ℚ_[p]`. -/
def valuation : ℚ_[p] → ℤ 
goal: ℚ_[p] → ℤ

full_name: Padic.valuation_zero
code: @[simp]
theorem valuation_zero : valuation (0 : ℚ_[p]) = 0 
goal: Padic.valuation 0 = 0

full_name: Padic.valuation_one
code: @[simp]
theorem valuation_one : valuation (1 : ℚ_[p]) = 0 
goal: Padic.valuation 1 = 0

full_name: Padic.norm_eq_pow_val
code: theorem norm_eq_pow_val {x : ℚ_[p]} : x ≠ 0 → ‖x‖ = (p : ℝ) ^ (-x.valuation) 
goal: x ≠ 0 → ‖x‖ = ↑p ^ (-x.valuation)

full_name: Padic.valuation_p
code: @[simp]
theorem valuation_p : valuation (p : ℚ_[p]) = 1 
goal: (↑p).valuation = 1

full_name: Padic.valuation_map_add
code: theorem valuation_map_add {x y : ℚ_[p]} (hxy : x + y ≠ 0) :
    min (valuation x) (valuation y) ≤ valuation (x + y : ℚ_[p]) 
goal: min x.valuation y.valuation ≤ (x + y).valuation

full_name: Padic.valuation_map_mul
code: @[simp]
theorem valuation_map_mul {x y : ℚ_[p]} (hx : x ≠ 0) (hy : y ≠ 0) :
    valuation (x * y : ℚ_[p]) = valuation x + valuation y 
goal: (x * y).valuation = x.valuation + y.valuation

full_name: Padic.addValuationDef
code: /-- The additive `p`-adic valuation on `ℚ_[p]`, with values in `WithTop ℤ`. -/
def addValuationDef : ℚ_[p] → WithTop ℤ 
goal: ℚ_[p] → WithTop ℤ

full_name: Padic.AddValuation.map_zero
code: @[simp]
theorem AddValuation.map_zero : addValuationDef (0 : ℚ_[p]) = ⊤ 
goal: Padic.addValuationDef 0 = ⊤

full_name: Padic.AddValuation.map_one
code: @[simp]
theorem AddValuation.map_one : addValuationDef (1 : ℚ_[p]) = 0 
goal: Padic.addValuationDef 1 = 0

full_name: Padic.AddValuation.map_mul
code: theorem AddValuation.map_mul (x y : ℚ_[p]) :
    addValuationDef (x * y : ℚ_[p]) = addValuationDef x + addValuationDef y 
goal: (x * y).addValuationDef = x.addValuationDef + y.addValuationDef

full_name: Padic.AddValuation.map_add
code: theorem AddValuation.map_add (x y : ℚ_[p]) :
    min (addValuationDef x) (addValuationDef y) ≤ addValuationDef (x + y : ℚ_[p]) 
goal: min x.addValuationDef y.addValuationDef ≤ (x + y).addValuationDef

full_name: Padic.addValuation
code: /-- The additive `p`-adic valuation on `ℚ_[p]`, as an `addValuation`. -/
def addValuation : AddValuation ℚ_[p] (WithTop ℤ) 
goal: AddValuation ℚ_[p] (WithTop ℤ)

full_name: Padic.addValuation.apply
code: @[simp]
theorem addValuation.apply {x : ℚ_[p]} (hx : x ≠ 0) :
    Padic.addValuation x = (x.valuation : WithTop ℤ) 
goal: Padic.addValuation x = ↑x.valuation

full_name: Padic.norm_le_pow_iff_norm_lt_pow_add_one
code: theorem norm_le_pow_iff_norm_lt_pow_add_one (x : ℚ_[p]) (n : ℤ) :
    ‖x‖ ≤ (p : ℝ) ^ n ↔ ‖x‖ < (p : ℝ) ^ (n + 1) 
goal: ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)

full_name: Padic.norm_lt_pow_iff_norm_le_pow_sub_one
code: theorem norm_lt_pow_iff_norm_le_pow_sub_one (x : ℚ_[p]) (n : ℤ) :
    ‖x‖ < (p : ℝ) ^ n ↔ ‖x‖ ≤ (p : ℝ) ^ (n - 1) 
goal: ‖x‖ < ↑p ^ n ↔ ‖x‖ ≤ ↑p ^ (n - 1)

full_name: Padic.norm_le_one_iff_val_nonneg
code: theorem norm_le_one_iff_val_nonneg (x : ℚ_[p]) : ‖x‖ ≤ 1 ↔ 0 ≤ x.valuation 
goal: ‖x‖ ≤ 1 ↔ 0 ≤ x.valuation