ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_succ_dist_weak
private theorem newton_seq_succ_dist_weak (n : ℕ) :
    ‖newton_seq (n + 2) - newton_seq (n + 1)‖ < ‖F.eval a‖ / ‖F.derivative.eval a‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) (hnsol : Polynomial.eval a F ≠ 0) (n : ℕ)
Goal: ‖newton_seq_gen hnorm (n + 2) - newton_seq_gen hnorm (n + 1)‖ <
  ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_dist_aux
private theorem newton_seq_dist_aux (n : ℕ) :
    ∀ k : ℕ, ‖newton_seq (n + k) - newton_seq n‖ ≤ ‖F.derivative.eval a‖ * T ^ 2 ^ n
  
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) (n k : ℕ)
Goal: ‖newton_seq_gen hnorm (n + k) - newton_seq_gen hnorm n‖ ≤
  ‖Polynomial.eval a (Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_dist
private theorem newton_seq_dist {n k : ℕ} (hnk : n ≤ k) :
    ‖newton_seq k - newton_seq n‖ ≤ ‖F.derivative.eval a‖ * T ^ 2 ^ n 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) {n k : ℕ} (hnk : n ≤ k)
Goal: ‖newton_seq_gen hnorm k - newton_seq_gen hnorm n‖ ≤ ‖Polynomial.eval a (Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_dist_to_a
private theorem newton_seq_dist_to_a :
    ∀ n : ℕ, 0 < n → ‖newton_seq n - a‖ = ‖F.eval a‖ / ‖F.derivative.eval a‖
  
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) (hnsol : Polynomial.eval a F ≠ 0) (n : ℕ)
Goal: 0 < n → ‖newton_seq_gen hnorm n - a‖ = ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.bound'
private theorem bound' : Tendsto (fun n : ℕ => ‖F.derivative.eval a‖ * T ^ 2 ^ n) atTop (𝓝 0) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2)
Goal: Filter.Tendsto (fun n => ‖Polynomial.eval a (Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n) Filter.atTop (𝓝 0)
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.bound
private theorem bound :
    ∀ {ε}, ε > 0 → ∃ N : ℕ, ∀ {n}, n ≥ N → ‖F.derivative.eval a‖ * T ^ 2 ^ n < ε 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) {ε : ℝ}
Goal: ε > 0 → ∃ N, ∀ {n : ℕ}, n ≥ N → ‖Polynomial.eval a (Polynomial.derivative F)‖ * T_gen p F a ^ 2 ^ n < ε
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.bound'_sq
private theorem bound'_sq :
    Tendsto (fun n : ℕ => ‖F.derivative.eval a‖ ^ 2 * T ^ 2 ^ n) atTop (𝓝 0) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2)
Goal: Filter.Tendsto (fun n => ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2 * T_gen p F a ^ 2 ^ n) Filter.atTop (𝓝 0)
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_is_cauchy
private theorem newton_seq_is_cauchy : IsCauSeq norm newton_seq 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2)
Goal: IsCauSeq norm (newton_seq_gen hnorm)
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.soln_spec
private theorem soln_spec {ε : ℝ} (hε : ε > 0) :
    ∃ N : ℕ, ∀ {i : ℕ}, i ≥ N → ‖soln - newton_cau_seq hnorm i‖ < ε 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) {ε : ℝ} (hε : ε > 0)
Goal: ∃ N, ∀ {i : ℕ}, i ≥ N → ‖soln_gen hnorm - ↑(newton_cau_seq hnorm) i‖ < ε
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.soln_deriv_norm
private theorem soln_deriv_norm : ‖F.derivative.eval soln‖ = ‖F.derivative.eval a‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2)
Goal: ‖Polynomial.eval (soln_gen hnorm) (Polynomial.derivative F)‖ = ‖Polynomial.eval a (Polynomial.derivative F)‖
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_norm_tendsto_zero
private theorem newton_seq_norm_tendsto_zero :
    Tendsto (fun i => ‖F.eval (newton_cau_seq hnorm i)‖) atTop (𝓝 0) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2)
Goal: Filter.Tendsto (fun i => ‖Polynomial.eval (↑(newton_cau_seq hnorm) i) F‖) Filter.atTop (𝓝 0)
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_dist_tendsto
private theorem newton_seq_dist_tendsto :
    Tendsto (fun n => ‖newton_cau_seq hnorm n - a‖)
    atTop (𝓝 (‖F.eval a‖ / ‖F.derivative.eval a‖)) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) (hnsol : Polynomial.eval a F ≠ 0)
Goal: Filter.Tendsto (fun n => ‖↑(newton_cau_seq hnorm) n - a‖) Filter.atTop
  (𝓝 (‖Polynomial.eval a F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖))
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_dist_tendsto'
private theorem newton_seq_dist_tendsto' :
    Tendsto (fun n => ‖newton_cau_seq hnorm n - a‖) atTop (𝓝 ‖soln - a‖) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2)
Goal: Filter.Tendsto (fun n => ‖↑(newton_cau_seq hnorm) n - a‖) Filter.atTop (𝓝 ‖soln_gen hnorm - a‖)
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.soln_dist_to_a
private theorem soln_dist_to_a : ‖soln - a‖ = ‖F.eval a‖ / ‖F.derivative.eval a‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) (hnsol : Polynomial.eval a F ≠ 0)
Goal: ‖soln_gen hnorm - a‖ = ‖Polynomial.eval a F‖ / ‖Polynomial.eval a (Polynomial.derivative F)‖
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.soln_dist_to_a_lt_deriv
private theorem soln_dist_to_a_lt_deriv : ‖soln - a‖ < ‖F.derivative.eval a‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) (hnsol : Polynomial.eval a F ≠ 0)
Goal: ‖soln_gen hnorm - a‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.eval_soln
private theorem eval_soln : F.eval soln = 0 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2)
Goal: Polynomial.eval (soln_gen hnorm) F = 0
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.soln_unique
private theorem soln_unique (z : ℤ_[p]) (hev : F.eval z = 0)
    (hnlt : ‖z - a‖ < ‖F.derivative.eval a‖) : z = soln 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) (hnsol : Polynomial.eval a F ≠ 0) (z : ℤ_[p]) (hev : Polynomial.eval z F = 0) (hnlt : ‖z - a‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖)
Goal: z = soln_gen hnorm
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.a_soln_is_unique
private theorem a_soln_is_unique (ha : F.eval a = 0) (z' : ℤ_[p]) (hz' : F.eval z' = 0)
    (hnormz' : ‖z' - a‖ < ‖F.derivative.eval a‖) : z' = a 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (ha : Polynomial.eval a F = 0) (z' : ℤ_[p]) (hz' : Polynomial.eval z' F = 0) (hnormz' : ‖z' - a‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖)
Goal: z' = a
-- _private.Mathlib.NumberTheory.Padics.Hensel.0.a_is_soln
private theorem a_is_soln (ha : F.eval a = 0) :
    F.eval a = 0 ∧
      ‖a - a‖ < ‖F.derivative.eval a‖ ∧
        ‖F.derivative.eval a‖ = ‖F.derivative.eval a‖ ∧
          ∀ z', F.eval z' = 0 → ‖z' - a‖ < ‖F.derivative.eval a‖ → z' = a 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2) (ha : Polynomial.eval a F = 0)
Goal: Polynomial.eval a F = 0 ∧
  ‖a - a‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ∧
    ‖Polynomial.eval a (Polynomial.derivative F)‖ = ‖Polynomial.eval a (Polynomial.derivative F)‖ ∧
      ∀ (z' : ℤ_[p]), Polynomial.eval z' F = 0 → ‖z' - a‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ → z' = a
-- hensels_lemma
theorem hensels_lemma :
    ∃ z : ℤ_[p],
      F.eval z = 0 ∧
        ‖z - a‖ < ‖F.derivative.eval a‖ ∧
          ‖F.derivative.eval z‖ = ‖F.derivative.eval a‖ ∧
            ∀ z', F.eval z' = 0 → ‖z' - a‖ < ‖F.derivative.eval a‖ → z' = z 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {F : Polynomial ℤ_[p]} {a : ℤ_[p]} (hnorm : ‖Polynomial.eval a F‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ^ 2)
Goal: ∃ z,
  Polynomial.eval z F = 0 ∧
    ‖z - a‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ ∧
      ‖Polynomial.eval z (Polynomial.derivative F)‖ = ‖Polynomial.eval a (Polynomial.derivative F)‖ ∧
        ∀ (z' : ℤ_[p]), Polynomial.eval z' F = 0 → ‖z' - a‖ < ‖Polynomial.eval a (Polynomial.derivative F)‖ → z' = z
-- Action.ofMulAction_apply
@[simp]
theorem ofMulAction_apply {G H : Type u} [Monoid G] [MulAction G H] (g : G) (x : H) :
    (ofMulAction G H).ρ g x = (g • x : H) 
Arguments: {G H : Type u} [Monoid G] [MulAction G H] (g : G) (x : H)
Goal: (Action.ofMulAction G H).ρ g x = g • x
-- Action.leftRegular_V
@[simps!]
def leftRegular (G : Type u) [Monoid G] : Action (Type u) (MonCat.of G) 
Arguments: (G : Type u) [Monoid G]
Goal: (Action.leftRegular G).V = G
-- Action.leftRegular_ρ_apply
@[simps!]
def leftRegular (G : Type u) [Monoid G] : Action (Type u) (MonCat.of G) 
Arguments: (G : Type u) [Monoid G]
Goal: ∀ (x : ↑(MonCat.of G)) (x_1 : G), (Action.leftRegular G).ρ x x_1 = x * x_1
-- Action.diagonal_ρ_apply
@[simps!]
def diagonal (G : Type u) [Monoid G] (n : ℕ) : Action (Type u) (MonCat.of G) 
Arguments: (G : Type u) [Monoid G] (n : ℕ)
Goal: ∀ (x : ↑(MonCat.of G)) (x_1 : Fin n → G) (a : Fin n), (Action.diagonal G n).ρ x x_1 a = (x • x_1) a
-- Action.diagonal_V
@[simps!]
def diagonal (G : Type u) [Monoid G] (n : ℕ) : Action (Type u) (MonCat.of G) 
Arguments: (G : Type u) [Monoid G] (n : ℕ)
Goal: (Action.diagonal G n).V = (Fin n → G)
-- Action.FintypeCat.ofMulAction_apply
@[simp]
theorem ofMulAction_apply {G : Type u} {H : FintypeCat.{u}} [Monoid G] [MulAction G H]
    (g : G) (x : H) : (FintypeCat.ofMulAction G H).ρ g x = (g • x : H) 
Arguments: {G : Type u} {H : FintypeCat} [Monoid G] [MulAction G ↑H] (g : G) (x : ↑H)
Goal: (Action.FintypeCat.ofMulAction G H).ρ g x = g • x
-- ZetaAsymptotics.term_nonneg
lemma term_nonneg (n : ℕ) (s : ℝ) : 0 ≤ term n s 
Arguments: (n : ℕ) (s : ℝ)
Goal: 0 ≤ ZetaAsymptotics.term n s
-- ZetaAsymptotics.term_welldef
lemma term_welldef {n : ℕ} (hn : 0 < n) {s : ℝ} (hs : 0 < s) :
    IntervalIntegrable (fun x : ℝ ↦ (x - n) / x ^ (s + 1)) volume n (n + 1) 
Arguments: {n : ℕ} (hn : 0 < n) {s : ℝ} (hs : 0 < s)
Goal: IntervalIntegrable (fun x => (x - ↑n) / x ^ (s + 1)) MeasureTheory.volume (↑n) (↑n + 1)
-- ZetaAsymptotics.term_one
lemma term_one {n : ℕ} (hn : 0 < n) :
    term n 1 = (log (n + 1) - log n) -  1 / (n + 1) 
Arguments: {n : ℕ} (hn : 0 < n)
Goal: ZetaAsymptotics.term n 1 = Real.log (↑n + 1) - Real.log ↑n - 1 / (↑n + 1)
-- ZetaAsymptotics.term_sum_one
lemma term_sum_one (N : ℕ) : term_sum 1 N = log (N + 1) - harmonic (N + 1) + 1 
Arguments: (N : ℕ)
Goal: ZetaAsymptotics.term_sum 1 N = Real.log (↑N + 1) - ↑(harmonic (N + 1)) + 1
-- ZetaAsymptotics.term_tsum_one
lemma term_tsum_one : HasSum (fun n ↦ term (n + 1) 1) (1 - γ) 
Goal: HasSum (fun n => ZetaAsymptotics.term (n + 1) 1) (1 - γ)
-- ZetaAsymptotics.term_of_lt
lemma term_of_lt {n : ℕ} (hn : 0 < n) {s : ℝ} (hs : 1 < s) :
    term n s = 1 / (s - 1) * (1 / n ^ (s - 1) - 1 / (n + 1) ^ (s - 1))
    - n / s * (1 / n ^ s - 1 / (n + 1) ^ s) 
Arguments: {n : ℕ} (hn : 0 < n) {s : ℝ} (hs : 1 < s)
Goal: ZetaAsymptotics.term n s =
  1 / (s - 1) * (1 / ↑n ^ (s - 1) - 1 / (↑n + 1) ^ (s - 1)) - ↑n / s * (1 / ↑n ^ s - 1 / (↑n + 1) ^ s)
-- ZetaAsymptotics.term_sum_of_lt
lemma term_sum_of_lt (N : ℕ) {s : ℝ} (hs : 1 < s) :
    term_sum s N = 1 / (s - 1) * (1 - 1 / (N + 1) ^ (s - 1))
    - 1 / s * ((∑ n ∈ Finset.range N, 1 / (n + 1 : ℝ) ^ s) - N / (N + 1) ^ s) 
Arguments: (N : ℕ) {s : ℝ} (hs : 1 < s)
Goal: ZetaAsymptotics.term_sum s N =
  1 / (s - 1) * (1 - 1 / (↑N + 1) ^ (s - 1)) - 1 / s * (∑ n ∈ Finset.range N, 1 / (↑n + 1) ^ s - ↑N / (↑N + 1) ^ s)
-- ZetaAsymptotics.term_tsum_of_lt
lemma term_tsum_of_lt {s : ℝ} (hs : 1 < s) :
    term_tsum s = (1 / (s - 1) - 1 / s * ∑' n : ℕ, 1 / (n + 1 : ℝ) ^ s) 
Arguments: {s : ℝ} (hs : 1 < s)
Goal: ZetaAsymptotics.term_tsum s = 1 / (s - 1) - 1 / s * ∑' (n : ℕ), 1 / (↑n + 1) ^ s
-- ZetaAsymptotics.zeta_limit_aux1
lemma zeta_limit_aux1 {s : ℝ} (hs : 1 < s) :
    (∑' n : ℕ, 1 / (n + 1 : ℝ) ^ s) - 1 / (s - 1) = 1 - s * term_tsum s 
Arguments: {s : ℝ} (hs : 1 < s)
Goal: ∑' (n : ℕ), 1 / (↑n + 1) ^ s - 1 / (s - 1) = 1 - s * ZetaAsymptotics.term_tsum s
-- ZetaAsymptotics.continuousOn_term
lemma continuousOn_term (n : ℕ) :
    ContinuousOn (fun x ↦ term (n + 1) x) (Ici 1) 
Arguments: (n : ℕ)
Goal: ContinuousOn (fun x => ZetaAsymptotics.term (n + 1) x) (Set.Ici 1)
-- ZetaAsymptotics.continuousOn_term_tsum
lemma continuousOn_term_tsum : ContinuousOn term_tsum (Ici 1) 
Goal: ContinuousOn ZetaAsymptotics.term_tsum (Set.Ici 1)
-- ZetaAsymptotics.tendsto_riemannZeta_sub_one_div_nhds_right
lemma tendsto_riemannZeta_sub_one_div_nhds_right :
    Tendsto (fun s : ℝ ↦ riemannZeta s - 1 / (s - 1)) (𝓝[>] 1) (𝓝 γ) 
Goal: Filter.Tendsto (fun s => riemannZeta ↑s - 1 / (↑s - 1)) (𝓝[>] 1) (𝓝 ↑γ)
-- tendsto_riemannZeta_sub_one_div
theorem _root_.tendsto_riemannZeta_sub_one_div :
    Tendsto (fun s : ℂ ↦ riemannZeta s - 1 / (s - 1)) (𝓝[≠] 1) (𝓝 γ) 
Goal: Filter.Tendsto (fun s => riemannZeta s - 1 / (s - 1)) (𝓝[≠] 1) (𝓝 ↑γ)
-- isBigO_riemannZeta_sub_one_div
lemma _root_.isBigO_riemannZeta_sub_one_div {F : Type*} [Norm F] [One F] [NormOneClass F] :
    (fun s : ℂ ↦ riemannZeta s - 1 / (s - 1)) =O[𝓝 1] (fun _ ↦ 1 : ℂ → F) 
Arguments: {F : Type u_1} [Norm F] [One F] [NormOneClass F]
Goal: (fun s => riemannZeta s - 1 / (s - 1)) =O[𝓝 1] fun x => 1
-- ZetaAsymptotics.tendsto_Gamma_term_aux
lemma tendsto_Gamma_term_aux : Tendsto (fun s ↦ 1 / (s - 1) - 1 / Gammaℝ s / (s - 1)) (𝓝[≠] 1)
    (𝓝 (-(γ + Complex.log (4 * ↑π)) / 2)) 
Goal: Filter.Tendsto (fun s => 1 / (s - 1) - 1 / s.Gammaℝ / (s - 1)) (𝓝[≠] 1) (𝓝 (-(↑γ + Complex.log (4 * ↑π)) / 2))
-- ZetaAsymptotics.tendsto_riemannZeta_sub_one_div_Gammaℝ
lemma tendsto_riemannZeta_sub_one_div_Gammaℝ :
    Tendsto (fun s ↦ riemannZeta s - 1 / Gammaℝ s / (s - 1)) (𝓝[≠] 1)
    (𝓝 ((γ - Complex.log (4 * ↑π)) / 2)) 
Goal: Filter.Tendsto (fun s => riemannZeta s - 1 / s.Gammaℝ / (s - 1)) (𝓝[≠] 1) (𝓝 ((↑γ - Complex.log (4 * ↑π)) / 2))
-- riemannZeta_one
lemma _root_.riemannZeta_one : riemannZeta 1 = (γ - Complex.log (4 * ↑π)) / 2 
Goal: riemannZeta 1 = (↑γ - Complex.log (4 * ↑π)) / 2
-- completedRiemannZeta_one
lemma _root_.completedRiemannZeta_one :
    completedRiemannZeta 1 = (γ - Complex.log (4 * ↑π)) / 2 
Goal: completedRiemannZeta 1 = (↑γ - Complex.log (4 * ↑π)) / 2
-- completedRiemannZeta₀_one
lemma _root_.completedRiemannZeta₀_one :
    completedRiemannZeta₀ 1 = (γ - Complex.log (4 * ↑π)) / 2 + 1 
Goal: completedRiemannZeta₀ 1 = (↑γ - Complex.log (4 * ↑π)) / 2 + 1
-- riemannZeta_one_ne_zero
lemma _root_.riemannZeta_one_ne_zero : riemannZeta 1 ≠ 0 
Goal: riemannZeta 1 ≠ 0
-- PadicSeq.stationary
theorem stationary {f : CauSeq ℚ (padicNorm p)} (hf : ¬f ≈ 0) :
    ∃ N, ∀ m n, N ≤ m → N ≤ n → padicNorm p (f n) = padicNorm p (f m) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {f : CauSeq ℚ (padicNorm p)} (hf : ¬f ≈ 0)
Goal: ∃ N, ∀ (m n : ℕ), N ≤ m → N ≤ n → padicNorm p (↑f n) = padicNorm p (↑f m)
-- PadicSeq.stationaryPoint_spec
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) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {f : PadicSeq p} (hf : ¬f ≈ 0) {m n : ℕ}
Goal: PadicSeq.stationaryPoint hf ≤ m → PadicSeq.stationaryPoint hf ≤ n → padicNorm p (↑f n) = padicNorm p (↑f m)
-- PadicSeq.norm_zero_iff
theorem norm_zero_iff (f : PadicSeq p) : f.norm = 0 ↔ f ≈ 0 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (f : PadicSeq p)
Goal: f.norm = 0 ↔ f ≈ 0
-- PadicSeq.equiv_zero_of_val_eq_of_equiv_zero
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 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {f g : PadicSeq p} (h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k)) (hf : f ≈ 0)
Goal: g ≈ 0
-- PadicSeq.norm_nonzero_of_not_equiv_zero
theorem norm_nonzero_of_not_equiv_zero {f : PadicSeq p} (hf : ¬f ≈ 0) : f.norm ≠ 0 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {f : PadicSeq p} (hf : ¬f ≈ 0)
Goal: f.norm ≠ 0
-- PadicSeq.norm_eq_norm_app_of_nonzero
theorem norm_eq_norm_app_of_nonzero {f : PadicSeq p} (hf : ¬f ≈ 0) :
    ∃ k, f.norm = padicNorm p k ∧ k ≠ 0 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {f : PadicSeq p} (hf : ¬f ≈ 0)
Goal: ∃ k, f.norm = padicNorm p k ∧ k ≠ 0
-- PadicSeq.not_limZero_const_of_nonzero
theorem not_limZero_const_of_nonzero {q : ℚ} (hq : q ≠ 0) : ¬LimZero (const (padicNorm p) q) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {q : ℚ} (hq : q ≠ 0)
Goal: ¬(CauSeq.const (padicNorm p) q).LimZero
-- PadicSeq.not_equiv_zero_const_of_nonzero
theorem not_equiv_zero_const_of_nonzero {q : ℚ} (hq : q ≠ 0) : ¬const (padicNorm p) q ≈ 0 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {q : ℚ} (hq : q ≠ 0)
Goal: ¬CauSeq.const (padicNorm p) q ≈ 0
-- PadicSeq.norm_nonneg
theorem norm_nonneg (f : PadicSeq p) : 0 ≤ f.norm 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (f : PadicSeq p)
Goal: 0 ≤ f.norm
-- PadicSeq.lift_index_left_left
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))) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {f : PadicSeq p} (hf : ¬f ≈ 0) (v2 v3 : ℕ)
Goal: padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑f (max (PadicSeq.stationaryPoint hf) (max v2 v3)))
-- PadicSeq.lift_index_left
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))) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {f : PadicSeq p} (hf : ¬f ≈ 0) (v1 v3 : ℕ)
Goal: padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑f (max v1 (max (PadicSeq.stationaryPoint hf) v3)))
-- PadicSeq.lift_index_right
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)))) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {f : PadicSeq p} (hf : ¬f ≈ 0) (v1 v2 : ℕ)
Goal: padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑f (max v1 (max v2 (PadicSeq.stationaryPoint hf))))
-- PadicSeq.norm_eq_pow_val
theorem norm_eq_pow_val {f : PadicSeq p} (hf : ¬f ≈ 0) : f.norm = (p : ℚ) ^ (-f.valuation : ℤ) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {f : PadicSeq p} (hf : ¬f ≈ 0)
Goal: f.norm = ↑p ^ (-f.valuation)
-- PadicSeq.val_eq_iff_norm_eq
theorem val_eq_iff_norm_eq {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0) :
    f.valuation = g.valuation ↔ f.norm = g.norm 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0)
Goal: f.valuation = g.valuation ↔ f.norm = g.norm
-- PadicSeq.norm_mul
theorem norm_mul (f g : PadicSeq p) : (f * g).norm = f.norm * g.norm 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (f g : PadicSeq p)
Goal: (f * g).norm = f.norm * g.norm
-- PadicSeq.eq_zero_iff_equiv_zero
theorem eq_zero_iff_equiv_zero (f : PadicSeq p) : mk f = 0 ↔ f ≈ 0 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (f : PadicSeq p)
Goal: CauSeq.Completion.mk f = 0 ↔ f ≈ 0
-- PadicSeq.ne_zero_iff_nequiv_zero
theorem ne_zero_iff_nequiv_zero (f : PadicSeq p) : mk f ≠ 0 ↔ ¬f ≈ 0 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (f : PadicSeq p)
Goal: CauSeq.Completion.mk f ≠ 0 ↔ ¬f ≈ 0
-- PadicSeq.norm_const
theorem norm_const (q : ℚ) : norm (const (padicNorm p) q) = padicNorm p q 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ)
Goal: PadicSeq.norm (CauSeq.const (padicNorm p) q) = padicNorm p q
-- PadicSeq.norm_values_discrete
theorem norm_values_discrete (a : PadicSeq p) (ha : ¬a ≈ 0) : ∃ z : ℤ, a.norm = (p : ℚ) ^ (-z) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (a : PadicSeq p) (ha : ¬a ≈ 0)
Goal: ∃ z, a.norm = ↑p ^ (-z)
-- PadicSeq.norm_one
theorem norm_one : norm (1 : PadicSeq p) = 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: PadicSeq.norm 1 = 1
-- _private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.norm_eq_of_equiv_aux
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 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0) (hfg : f ≈ g) (h : padicNorm p (↑f (PadicSeq.stationaryPoint hf)) ≠ padicNorm p (↑g (PadicSeq.stationaryPoint hg))) (hlt : padicNorm p (↑g (PadicSeq.stationaryPoint hg)) < padicNorm p (↑f (PadicSeq.stationaryPoint hf)))
Goal: False
-- _private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.norm_eq_of_equiv
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)) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (hf : ¬f ≈ 0) (hg : ¬g ≈ 0) (hfg : f ≈ g)
Goal: padicNorm p (↑f (PadicSeq.stationaryPoint hf)) = padicNorm p (↑g (PadicSeq.stationaryPoint hg))
-- PadicSeq.norm_equiv
theorem norm_equiv {f g : PadicSeq p} (hfg : f ≈ g) : f.norm = g.norm 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (hfg : f ≈ g)
Goal: f.norm = g.norm
-- _private.Mathlib.NumberTheory.Padics.PadicNumbers.0.PadicSeq.norm_nonarchimedean_aux
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 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (hfg : ¬f + g ≈ 0) (hf : ¬f ≈ 0) (hg : ¬g ≈ 0)
Goal: (f + g).norm ≤ max f.norm g.norm
-- PadicSeq.norm_nonarchimedean
theorem norm_nonarchimedean (f g : PadicSeq p) : (f + g).norm ≤ max f.norm g.norm 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (f g : PadicSeq p)
Goal: (f + g).norm ≤ max f.norm g.norm
-- PadicSeq.norm_eq
theorem norm_eq {f g : PadicSeq p} (h : ∀ k, padicNorm p (f k) = padicNorm p (g k)) :
    f.norm = g.norm 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (h : ∀ (k : ℕ), padicNorm p (↑f k) = padicNorm p (↑g k))
Goal: f.norm = g.norm
-- PadicSeq.norm_neg
theorem norm_neg (a : PadicSeq p) : (-a).norm = a.norm 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (a : PadicSeq p)
Goal: (-a).norm = a.norm
-- PadicSeq.norm_eq_of_add_equiv_zero
theorem norm_eq_of_add_equiv_zero {f g : PadicSeq p} (h : f + g ≈ 0) : f.norm = g.norm 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (h : f + g ≈ 0)
Goal: f.norm = g.norm
-- PadicSeq.add_eq_max_of_ne
theorem add_eq_max_of_ne {f g : PadicSeq p} (hfgne : f.norm ≠ g.norm) :
    (f + g).norm = max f.norm g.norm 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {f g : PadicSeq p} (hfgne : f.norm ≠ g.norm)
Goal: (f + g).norm = max f.norm g.norm
-- Padic.zero_def
theorem zero_def : (0 : ℚ_[p]) = ⟦0⟧ 
Arguments: (p : ℕ) [Fact (Nat.Prime p)]
Goal: 0 = ⟦0⟧