ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PadicInt.norm_le_one
theorem norm_le_one (z : ℤ_[p]) : ‖z‖ ≤ 1 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z : ℤ_[p])
Goal: ‖z‖ ≤ 1
-- PadicInt.norm_mul
@[simp]
theorem norm_mul (z1 z2 : ℤ_[p]) : ‖z1 * z2‖ = ‖z1‖ * ‖z2‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z1 z2 : ℤ_[p])
Goal: ‖z1 * z2‖ = ‖z1‖ * ‖z2‖
-- PadicInt.norm_pow
@[simp]
theorem norm_pow (z : ℤ_[p]) : ∀ n : ℕ, ‖z ^ n‖ = ‖z‖ ^ n
  
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z : ℤ_[p]) (n : ℕ)
Goal: ‖z ^ n‖ = ‖z‖ ^ n
-- PadicInt.nonarchimedean
theorem nonarchimedean (q r : ℤ_[p]) : ‖q + r‖ ≤ max ‖q‖ ‖r‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (q r : ℤ_[p])
Goal: ‖q + r‖ ≤ max ‖q‖ ‖r‖
-- PadicInt.norm_add_eq_max_of_ne
theorem norm_add_eq_max_of_ne {q r : ℤ_[p]} : ‖q‖ ≠ ‖r‖ → ‖q + r‖ = max ‖q‖ ‖r‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {q r : ℤ_[p]}
Goal: ‖q‖ ≠ ‖r‖ → ‖q + r‖ = max ‖q‖ ‖r‖
-- PadicInt.norm_eq_of_norm_add_lt_right
theorem norm_eq_of_norm_add_lt_right {z1 z2 : ℤ_[p]} (h : ‖z1 + z2‖ < ‖z2‖) : ‖z1‖ = ‖z2‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {z1 z2 : ℤ_[p]} (h : ‖z1 + z2‖ < ‖z2‖)
Goal: ‖z1‖ = ‖z2‖
-- PadicInt.norm_eq_of_norm_add_lt_left
theorem norm_eq_of_norm_add_lt_left {z1 z2 : ℤ_[p]} (h : ‖z1 + z2‖ < ‖z1‖) : ‖z1‖ = ‖z2‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {z1 z2 : ℤ_[p]} (h : ‖z1 + z2‖ < ‖z1‖)
Goal: ‖z1‖ = ‖z2‖
-- PadicInt.padic_norm_e_of_padicInt
@[simp]
theorem padic_norm_e_of_padicInt (z : ℤ_[p]) : ‖(z : ℚ_[p])‖ = ‖z‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z : ℤ_[p])
Goal: ‖↑z‖ = ‖z‖
-- PadicInt.norm_intCast_eq_padic_norm
theorem norm_intCast_eq_padic_norm (z : ℤ) : ‖(z : ℤ_[p])‖ = ‖(z : ℚ_[p])‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (z : ℤ)
Goal: ‖↑z‖ = ‖↑z‖
-- PadicInt.norm_eq_padic_norm
@[simp]
theorem norm_eq_padic_norm {q : ℚ_[p]} (hq : ‖q‖ ≤ 1) : @norm ℤ_[p] _ ⟨q, hq⟩ = ‖q‖ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] {q : ℚ_[p]} (hq : ‖q‖ ≤ 1)
Goal: ‖⟨q, hq⟩‖ = ‖q‖
-- PadicInt.norm_p
@[simp]
theorem norm_p : ‖(p : ℤ_[p])‖ = (p : ℝ)⁻¹ 
Arguments: {p : ℕ} [Fact (Nat.Prime p)]
Goal: ‖↑p‖ = (↑p)⁻¹
-- PadicInt.norm_p_pow
theorem norm_p_pow (n : ℕ) : ‖(p : ℤ_[p]) ^ n‖ = (p : ℝ) ^ (-n : ℤ) 
Arguments: {p : ℕ} [Fact (Nat.Prime p)] (n : ℕ)
Goal: ‖↑p ^ n‖ = ↑p ^ (-↑n)
-- PadicInt.exists_pow_neg_lt
theorem exists_pow_neg_lt {ε : ℝ} (hε : 0 < ε) : ∃ k : ℕ, (p : ℝ) ^ (-(k : ℤ)) < ε 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {ε : ℝ} (hε : 0 < ε)
Goal: ∃ k, ↑p ^ (-↑k) < ε
-- PadicInt.exists_pow_neg_lt_rat
theorem exists_pow_neg_lt_rat {ε : ℚ} (hε : 0 < ε) : ∃ k : ℕ, (p : ℚ) ^ (-(k : ℤ)) < ε 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {ε : ℚ} (hε : 0 < ε)
Goal: ∃ k, ↑p ^ (-↑k) < ε
-- PadicInt.norm_int_lt_one_iff_dvd
theorem norm_int_lt_one_iff_dvd (k : ℤ) : ‖(k : ℤ_[p])‖ < 1 ↔ (p : ℤ) ∣ k 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (k : ℤ)
Goal: ‖↑k‖ < 1 ↔ ↑p ∣ k
-- PadicInt.norm_int_le_pow_iff_dvd
theorem norm_int_le_pow_iff_dvd {k : ℤ} {n : ℕ} :
    ‖(k : ℤ_[p])‖ ≤ (p : ℝ) ^ (-n : ℤ) ↔ (p ^ n : ℤ) ∣ k 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {k : ℤ} {n : ℕ}
Goal: ‖↑k‖ ≤ ↑p ^ (-↑n) ↔ ↑p ^ n ∣ k
-- PadicInt.norm_eq_pow_val
theorem norm_eq_pow_val {x : ℤ_[p]} (hx : x ≠ 0) : ‖x‖ = (p : ℝ) ^ (-x.valuation) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {x : ℤ_[p]} (hx : x ≠ 0)
Goal: ‖x‖ = ↑p ^ (-x.valuation)
-- PadicInt.valuation_zero
@[simp]
theorem valuation_zero : valuation (0 : ℤ_[p]) = 0 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: PadicInt.valuation 0 = 0
-- PadicInt.valuation_one
@[simp]
theorem valuation_one : valuation (1 : ℤ_[p]) = 0 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: PadicInt.valuation 1 = 0
-- PadicInt.valuation_p
@[simp]
theorem valuation_p : valuation (p : ℤ_[p]) = 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: (↑p).valuation = 1
-- PadicInt.valuation_nonneg
theorem valuation_nonneg (x : ℤ_[p]) : 0 ≤ x.valuation 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p])
Goal: 0 ≤ x.valuation
-- PadicInt.valuation_p_pow_mul
@[simp]
theorem valuation_p_pow_mul (n : ℕ) (c : ℤ_[p]) (hc : c ≠ 0) :
    ((p : ℤ_[p]) ^ n * c).valuation = n + c.valuation 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (n : ℕ) (c : ℤ_[p]) (hc : c ≠ 0)
Goal: (↑p ^ n * c).valuation = ↑n + c.valuation
-- PadicInt.mul_inv
theorem mul_inv : ∀ {z : ℤ_[p]}, ‖z‖ = 1 → z * z.inv = 1
  
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {z : ℤ_[p]}
Goal: ‖z‖ = 1 → z * z.inv = 1
-- PadicInt.inv_mul
theorem inv_mul {z : ℤ_[p]} (hz : ‖z‖ = 1) : z.inv * z = 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {z : ℤ_[p]} (hz : ‖z‖ = 1)
Goal: z.inv * z = 1
-- PadicInt.isUnit_iff
theorem isUnit_iff {z : ℤ_[p]} : IsUnit z ↔ ‖z‖ = 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {z : ℤ_[p]}
Goal: IsUnit z ↔ ‖z‖ = 1
-- PadicInt.norm_lt_one_add
theorem norm_lt_one_add {z1 z2 : ℤ_[p]} (hz1 : ‖z1‖ < 1) (hz2 : ‖z2‖ < 1) : ‖z1 + z2‖ < 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {z1 z2 : ℤ_[p]} (hz1 : ‖z1‖ < 1) (hz2 : ‖z2‖ < 1)
Goal: ‖z1 + z2‖ < 1
-- PadicInt.norm_lt_one_mul
theorem norm_lt_one_mul {z1 z2 : ℤ_[p]} (hz2 : ‖z2‖ < 1) : ‖z1 * z2‖ < 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {z1 z2 : ℤ_[p]} (hz2 : ‖z2‖ < 1)
Goal: ‖z1 * z2‖ < 1
-- PadicInt.mem_nonunits
theorem mem_nonunits {z : ℤ_[p]} : z ∈ nonunits ℤ_[p] ↔ ‖z‖ < 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {z : ℤ_[p]}
Goal: z ∈ nonunits ℤ_[p] ↔ ‖z‖ < 1
-- PadicInt.mkUnits_eq
@[simp]
theorem mkUnits_eq {u : ℚ_[p]} (h : ‖u‖ = 1) : ((mkUnits h : ℤ_[p]) : ℚ_[p]) = u 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {u : ℚ_[p]} (h : ‖u‖ = 1)
Goal: ↑↑(PadicInt.mkUnits h) = u
-- PadicInt.norm_units
@[simp]
theorem norm_units (u : ℤ_[p]ˣ) : ‖(u : ℤ_[p])‖ = 1 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (u : ℤ_[p]ˣ)
Goal: ‖↑u‖ = 1
-- PadicInt.unitCoeff_coe
@[simp]
theorem unitCoeff_coe {x : ℤ_[p]} (hx : x ≠ 0) :
    (unitCoeff hx : ℚ_[p]) = x * (p : ℚ_[p]) ^ (-x.valuation) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {x : ℤ_[p]} (hx : x ≠ 0)
Goal: ↑↑(PadicInt.unitCoeff hx) = ↑x * ↑p ^ (-x.valuation)
-- PadicInt.unitCoeff_spec
theorem unitCoeff_spec {x : ℤ_[p]} (hx : x ≠ 0) :
    x = (unitCoeff hx : ℤ_[p]) * (p : ℤ_[p]) ^ Int.natAbs (valuation x) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {x : ℤ_[p]} (hx : x ≠ 0)
Goal: x = ↑(PadicInt.unitCoeff hx) * ↑p ^ x.valuation.natAbs
-- PadicInt.norm_le_pow_iff_le_valuation
theorem norm_le_pow_iff_le_valuation (x : ℤ_[p]) (hx : x ≠ 0) (n : ℕ) :
    ‖x‖ ≤ (p : ℝ) ^ (-n : ℤ) ↔ ↑n ≤ x.valuation 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p]) (hx : x ≠ 0) (n : ℕ)
Goal: ‖x‖ ≤ ↑p ^ (-↑n) ↔ ↑n ≤ x.valuation
-- PadicInt.mem_span_pow_iff_le_valuation
theorem mem_span_pow_iff_le_valuation (x : ℤ_[p]) (hx : x ≠ 0) (n : ℕ) :
    x ∈ (Ideal.span {(p : ℤ_[p]) ^ n} : Ideal ℤ_[p]) ↔ ↑n ≤ x.valuation 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p]) (hx : x ≠ 0) (n : ℕ)
Goal: x ∈ Ideal.span {↑p ^ n} ↔ ↑n ≤ x.valuation
-- PadicInt.norm_le_pow_iff_mem_span_pow
theorem norm_le_pow_iff_mem_span_pow (x : ℤ_[p]) (n : ℕ) :
    ‖x‖ ≤ (p : ℝ) ^ (-n : ℤ) ↔ x ∈ (Ideal.span {(p : ℤ_[p]) ^ n} : Ideal ℤ_[p]) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p]) (n : ℕ)
Goal: ‖x‖ ≤ ↑p ^ (-↑n) ↔ x ∈ Ideal.span {↑p ^ n}
-- PadicInt.norm_le_pow_iff_norm_lt_pow_add_one
theorem norm_le_pow_iff_norm_lt_pow_add_one (x : ℤ_[p]) (n : ℤ) :
    ‖x‖ ≤ (p : ℝ) ^ n ↔ ‖x‖ < (p : ℝ) ^ (n + 1) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p]) (n : ℤ)
Goal: ‖x‖ ≤ ↑p ^ n ↔ ‖x‖ < ↑p ^ (n + 1)
-- PadicInt.norm_lt_pow_iff_norm_le_pow_sub_one
theorem norm_lt_pow_iff_norm_le_pow_sub_one (x : ℤ_[p]) (n : ℤ) :
    ‖x‖ < (p : ℝ) ^ n ↔ ‖x‖ ≤ (p : ℝ) ^ (n - 1) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p]) (n : ℤ)
Goal: ‖x‖ < ↑p ^ n ↔ ‖x‖ ≤ ↑p ^ (n - 1)
-- PadicInt.norm_lt_one_iff_dvd
theorem norm_lt_one_iff_dvd (x : ℤ_[p]) : ‖x‖ < 1 ↔ ↑p ∣ x 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p])
Goal: ‖x‖ < 1 ↔ ↑p ∣ x
-- PadicInt.pow_p_dvd_int_iff
@[simp]
theorem pow_p_dvd_int_iff (n : ℕ) (a : ℤ) : (p : ℤ_[p]) ^ n ∣ a ↔ (p ^ n : ℤ) ∣ a 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (n : ℕ) (a : ℤ)
Goal: ↑p ^ n ∣ ↑a ↔ ↑p ^ n ∣ a
-- PadicInt.p_nonnunit
theorem p_nonnunit : (p : ℤ_[p]) ∈ nonunits ℤ_[p] 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: ↑p ∈ nonunits ℤ_[p]
-- PadicInt.maximalIdeal_eq_span_p
theorem maximalIdeal_eq_span_p : maximalIdeal ℤ_[p] = Ideal.span {(p : ℤ_[p])} 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: LocalRing.maximalIdeal ℤ_[p] = Ideal.span {↑p}
-- PadicInt.prime_p
theorem prime_p : Prime (p : ℤ_[p]) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: Prime ↑p
-- PadicInt.irreducible_p
theorem irreducible_p : Irreducible (p : ℤ_[p]) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)]
Goal: Irreducible ↑p
-- PadicInt.ideal_eq_span_pow_p
theorem ideal_eq_span_pow_p {s : Ideal ℤ_[p]} (hs : s ≠ ⊥) :
    ∃ n : ℕ, s = Ideal.span {(p : ℤ_[p]) ^ n} 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {s : Ideal ℤ_[p]} (hs : s ≠ ⊥)
Goal: ∃ n, s = Ideal.span {↑p ^ n}
-- PadicInt.algebraMap_apply
@[simp]
theorem algebraMap_apply (x : ℤ_[p]) : algebraMap ℤ_[p] ℚ_[p] x = x 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (x : ℤ_[p])
Goal: (algebraMap ℤ_[p] ℚ_[p]) x = ↑x
-- WeakFEPair.hg_int
structure WeakFEPair where
    (f g : ℝ → E)
    (k : ℝ)
    (ε : ℂ)
    (f₀ g₀ : E)
  (hf_int : LocallyIntegrableOn f (Ioi 0))
  (hg_int : LocallyIntegrableOn g (Ioi 0))
  (hk : 0 < k)
  (hε : ε ≠ 0)
  (h_feq : ∀ x ∈ Ioi 0, f (1 / x) = (ε * ↑(x ^ k)) • g x)
  (hf_top (r : ℝ) : (f · - f₀) =O[atTop] (· ^ r))
  (hg_top (r : ℝ) : (g · - g₀) =O[atTop] (· ^ r))
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (self : WeakFEPair E)
Goal: MeasureTheory.LocallyIntegrableOn self.g (Set.Ioi 0) MeasureTheory.volume
-- WeakFEPair.h_feq
structure WeakFEPair where
    (f g : ℝ → E)
    (k : ℝ)
    (ε : ℂ)
    (f₀ g₀ : E)
  (hf_int : LocallyIntegrableOn f (Ioi 0))
  (hg_int : LocallyIntegrableOn g (Ioi 0))
  (hk : 0 < k)
  (hε : ε ≠ 0)
  (h_feq : ∀ x ∈ Ioi 0, f (1 / x) = (ε * ↑(x ^ k)) • g x)
  (hf_top (r : ℝ) : (f · - f₀) =O[atTop] (· ^ r))
  (hg_top (r : ℝ) : (g · - g₀) =O[atTop] (· ^ r))
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (self : WeakFEPair E) (x : ℝ)
Goal: x ∈ Set.Ioi 0 → self.f (1 / x) = (self.ε * ↑(x ^ self.k)) • self.g x
-- WeakFEPair.hf_top
structure WeakFEPair where
    (f g : ℝ → E)
    (k : ℝ)
    (ε : ℂ)
    (f₀ g₀ : E)
  (hf_int : LocallyIntegrableOn f (Ioi 0))
  (hg_int : LocallyIntegrableOn g (Ioi 0))
  (hk : 0 < k)
  (hε : ε ≠ 0)
  (h_feq : ∀ x ∈ Ioi 0, f (1 / x) = (ε * ↑(x ^ k)) • g x)
  (hf_top (r : ℝ) : (f · - f₀) =O[atTop] (· ^ r))
  (hg_top (r : ℝ) : (g · - g₀) =O[atTop] (· ^ r))
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (self : WeakFEPair E) (r : ℝ)
Goal: (fun x => self.f x - self.f₀) =O[Filter.atTop] fun x => x ^ r
-- WeakFEPair.hg_top
structure WeakFEPair where
    (f g : ℝ → E)
    (k : ℝ)
    (ε : ℂ)
    (f₀ g₀ : E)
  (hf_int : LocallyIntegrableOn f (Ioi 0))
  (hg_int : LocallyIntegrableOn g (Ioi 0))
  (hk : 0 < k)
  (hε : ε ≠ 0)
  (h_feq : ∀ x ∈ Ioi 0, f (1 / x) = (ε * ↑(x ^ k)) • g x)
  (hf_top (r : ℝ) : (f · - f₀) =O[atTop] (· ^ r))
  (hg_top (r : ℝ) : (g · - g₀) =O[atTop] (· ^ r))
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (self : WeakFEPair E) (r : ℝ)
Goal: (fun x => self.g x - self.g₀) =O[Filter.atTop] fun x => x ^ r
-- WeakFEPair.hε
structure WeakFEPair where
    (f g : ℝ → E)
    (k : ℝ)
    (ε : ℂ)
    (f₀ g₀ : E)
  (hf_int : LocallyIntegrableOn f (Ioi 0))
  (hg_int : LocallyIntegrableOn g (Ioi 0))
  (hk : 0 < k)
  (hε : ε ≠ 0)
  (h_feq : ∀ x ∈ Ioi 0, f (1 / x) = (ε * ↑(x ^ k)) • g x)
  (hf_top (r : ℝ) : (f · - f₀) =O[atTop] (· ^ r))
  (hg_top (r : ℝ) : (g · - g₀) =O[atTop] (· ^ r))
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (self : WeakFEPair E)
Goal: self.ε ≠ 0
-- WeakFEPair.hk
structure WeakFEPair where
    (f g : ℝ → E)
    (k : ℝ)
    (ε : ℂ)
    (f₀ g₀ : E)
  (hf_int : LocallyIntegrableOn f (Ioi 0))
  (hg_int : LocallyIntegrableOn g (Ioi 0))
  (hk : 0 < k)
  (hε : ε ≠ 0)
  (h_feq : ∀ x ∈ Ioi 0, f (1 / x) = (ε * ↑(x ^ k)) • g x)
  (hf_top (r : ℝ) : (f · - f₀) =O[atTop] (· ^ r))
  (hg_top (r : ℝ) : (g · - g₀) =O[atTop] (· ^ r))
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (self : WeakFEPair E)
Goal: 0 < self.k
-- WeakFEPair.hf_int
structure WeakFEPair where
    (f g : ℝ → E)
    (k : ℝ)
    (ε : ℂ)
    (f₀ g₀ : E)
  (hf_int : LocallyIntegrableOn f (Ioi 0))
  (hg_int : LocallyIntegrableOn g (Ioi 0))
  (hk : 0 < k)
  (hε : ε ≠ 0)
  (h_feq : ∀ x ∈ Ioi 0, f (1 / x) = (ε * ↑(x ^ k)) • g x)
  (hf_top (r : ℝ) : (f · - f₀) =O[atTop] (· ^ r))
  (hg_top (r : ℝ) : (g · - g₀) =O[atTop] (· ^ r))
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (self : WeakFEPair E)
Goal: MeasureTheory.LocallyIntegrableOn self.f (Set.Ioi 0) MeasureTheory.volume
-- StrongFEPair.hg₀
structure StrongFEPair extends WeakFEPair E where (hf₀ : f₀ = 0) (hg₀ : g₀ = 0)
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (self : StrongFEPair E)
Goal: self.g₀ = 0
-- StrongFEPair.hf₀
structure StrongFEPair extends WeakFEPair E where (hf₀ : f₀ = 0) (hg₀ : g₀ = 0)
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (self : StrongFEPair E)
Goal: self.f₀ = 0
-- WeakFEPair.h_feq'
lemma WeakFEPair.h_feq' (P : WeakFEPair E) (x : ℝ) (hx : 0 < x) :
    P.g (1 / x) = (P.ε⁻¹ * ↑(x ^ P.k)) • P.f x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E) (x : ℝ) (hx : 0 < x)
Goal: P.g (1 / x) = (P.ε⁻¹ * ↑(x ^ P.k)) • P.f x
-- WeakFEPair.hf_zero
lemma hf_zero (P : WeakFEPair E) (r : ℝ) :
    (fun x ↦ P.f x - (P.ε * ↑(x ^ (-P.k))) • P.g₀) =O[𝓝[>] 0] (· ^ r) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E) (r : ℝ)
Goal: (fun x => P.f x - (P.ε * ↑(x ^ (-P.k))) • P.g₀) =O[𝓝[>] 0] fun x => x ^ r
-- WeakFEPair.hf_zero'
lemma hf_zero' (P : WeakFEPair E) :
    (fun x : ℝ ↦ P.f x - P.f₀) =O[𝓝[>] 0] (· ^ (-P.k)) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E)
Goal: (fun x => P.f x - P.f₀) =O[𝓝[>] 0] fun x => x ^ (-P.k)
-- StrongFEPair.hf_top'
lemma hf_top' (r : ℝ) : P.f =O[atTop] (· ^ r) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : StrongFEPair E) (r : ℝ)
Goal: P.f =O[Filter.atTop] fun x => x ^ r
-- StrongFEPair.hf_zero'
lemma hf_zero' (r : ℝ) : P.f =O[𝓝[>] 0] (· ^ r) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : StrongFEPair E) (r : ℝ)
Goal: P.f =O[𝓝[>] 0] fun x => x ^ r
-- StrongFEPair.hasMellin
theorem hasMellin (s : ℂ) : HasMellin P.f s (P.Λ s) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : StrongFEPair E) (s : ℂ)
Goal: HasMellin P.f s (P.Λ s)
-- StrongFEPair.Λ_eq
lemma Λ_eq : P.Λ = mellin P.f 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : StrongFEPair E)
Goal: P.Λ = mellin P.f
-- StrongFEPair.symm_Λ_eq
lemma symm_Λ_eq : P.symm.Λ = mellin P.g 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : StrongFEPair E)
Goal: P.symm.Λ = mellin P.g
-- StrongFEPair.differentiable_Λ
theorem differentiable_Λ : Differentiable ℂ P.Λ 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : StrongFEPair E)
Goal: Differentiable ℂ P.Λ
-- StrongFEPair.functional_equation
theorem functional_equation (s : ℂ) :
    P.Λ (P.k - s) = P.ε • P.symm.Λ s 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : StrongFEPair E) (s : ℂ)
Goal: P.Λ (↑P.k - s) = P.ε • P.symm.Λ s
-- WeakFEPair.hf_modif_int
lemma hf_modif_int :
    LocallyIntegrableOn P.f_modif (Ioi 0) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E)
Goal: MeasureTheory.LocallyIntegrableOn P.f_modif (Set.Ioi 0) MeasureTheory.volume
-- WeakFEPair.hf_modif_FE
lemma hf_modif_FE (x : ℝ) (hx : 0 < x) :
    P.f_modif (1 / x) = (P.ε * ↑(x ^ P.k)) • P.g_modif x 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E) (x : ℝ) (hx : 0 < x)
Goal: P.f_modif (1 / x) = (P.ε * ↑(x ^ P.k)) • P.g_modif x
-- WeakFEPair.f_modif_aux1
lemma f_modif_aux1 : EqOn (fun x ↦ P.f_modif x - P.f x + P.f₀)
    ((Ioo 0 1).indicator (fun x : ℝ ↦ P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀)
    + ({1} : Set ℝ).indicator (fun _ ↦ P.f₀ - P.f 1)) (Ioi 0) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E)
Goal: Set.EqOn (fun x => P.f_modif x - P.f x + P.f₀)
  (((Set.Ioo 0 1).indicator fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) + {1}.indicator fun x => P.f₀ - P.f 1)
  (Set.Ioi 0)
-- WeakFEPair.f_modif_aux2
lemma f_modif_aux2 {s : ℂ} (hs : P.k < re s) :
    mellin (fun x ↦ P.f_modif x - P.f x + P.f₀) s = (1 / s) • P.f₀ + (P.ε  / (P.k - s)) • P.g₀ 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] (P : WeakFEPair E) {s : ℂ} (hs : P.k < s.re)
Goal: mellin (fun x => P.f_modif x - P.f x + P.f₀) s = (1 / s) • P.f₀ + (P.ε / (↑P.k - s)) • P.g₀
-- WeakFEPair.Λ₀_eq
lemma Λ₀_eq (s : ℂ) : P.Λ₀ s = P.Λ s + (1 / s) • P.f₀ + (P.ε / (P.k - s)) • P.g₀ 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E) (s : ℂ)
Goal: P.Λ₀ s = P.Λ s + (1 / s) • P.f₀ + (P.ε / (↑P.k - s)) • P.g₀
-- WeakFEPair.symm_Λ₀_eq
lemma symm_Λ₀_eq (s : ℂ) :
    P.symm.Λ₀ s = P.symm.Λ s + (1 / s) • P.g₀ + (P.ε⁻¹ / (P.k - s)) • P.f₀ 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E) (s : ℂ)
Goal: P.symm.Λ₀ s = P.symm.Λ s + (1 / s) • P.g₀ + (P.ε⁻¹ / (↑P.k - s)) • P.f₀
-- WeakFEPair.differentiable_Λ₀
theorem differentiable_Λ₀ : Differentiable ℂ P.Λ₀ 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E)
Goal: Differentiable ℂ P.Λ₀
-- WeakFEPair.differentiableAt_Λ
theorem differentiableAt_Λ {s : ℂ} (hs : s ≠ 0 ∨ P.f₀ = 0) (hs' : s ≠ P.k ∨ P.g₀ = 0) :
    DifferentiableAt ℂ P.Λ s 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E) {s : ℂ} (hs : s ≠ 0 ∨ P.f₀ = 0) (hs' : s ≠ ↑P.k ∨ P.g₀ = 0)
Goal: DifferentiableAt ℂ P.Λ s
-- WeakFEPair.hasMellin
theorem hasMellin {s : ℂ} (hs : P.k < s.re) : HasMellin (P.f · - P.f₀) s (P.Λ s) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] [CompleteSpace E] (P : WeakFEPair E) {s : ℂ} (hs : P.k < s.re)
Goal: HasMellin (fun x => P.f x - P.f₀) s (P.Λ s)
-- WeakFEPair.functional_equation₀
theorem functional_equation₀ (s : ℂ) : P.Λ₀ (P.k - s) = P.ε • P.symm.Λ₀ s 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E) (s : ℂ)
Goal: P.Λ₀ (↑P.k - s) = P.ε • P.symm.Λ₀ s
-- WeakFEPair.functional_equation
theorem functional_equation (s : ℂ) :
    P.Λ (P.k - s) = P.ε • P.symm.Λ s 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E) (s : ℂ)
Goal: P.Λ (↑P.k - s) = P.ε • P.symm.Λ s
-- WeakFEPair.Λ_residue_k
theorem Λ_residue_k :
    Tendsto (fun s : ℂ ↦ (s - P.k) • P.Λ s) (𝓝[≠] P.k) (𝓝 (P.ε • P.g₀)) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E)
Goal: Filter.Tendsto (fun s => (s - ↑P.k) • P.Λ s) (𝓝[≠] ↑P.k) (𝓝 (P.ε • P.g₀))
-- WeakFEPair.Λ_residue_zero
theorem Λ_residue_zero :
    Tendsto (fun s : ℂ ↦ s • P.Λ s) (𝓝[≠] 0) (𝓝 (-P.f₀)) 
Arguments: {E : Type u_1} [NormedAddCommGroup E] [NormedSpace ℂ E] (P : WeakFEPair E)
Goal: Filter.Tendsto (fun s => s • P.Λ s) (𝓝[≠] 0) (𝓝 (-P.f₀))
-- GaussianInt.mod_four_eq_three_of_nat_prime_of_prime
theorem mod_four_eq_three_of_nat_prime_of_prime (p : ℕ) [hp : Fact p.Prime]
    (hpi : Prime (p : ℤ[i])) : p % 4 = 3 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (hpi : Prime ↑p)
Goal: p % 4 = 3
-- GaussianInt.prime_of_nat_prime_of_mod_four_eq_three
theorem prime_of_nat_prime_of_mod_four_eq_three (p : ℕ) [hp : Fact p.Prime] (hp3 : p % 4 = 3) :
    Prime (p : ℤ[i]) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] (hp3 : p % 4 = 3)
Goal: Prime ↑p
-- GaussianInt.prime_iff_mod_four_eq_three_of_nat_prime
theorem prime_iff_mod_four_eq_three_of_nat_prime (p : ℕ) [Fact p.Prime] :
    Prime (p : ℤ[i]) ↔ p % 4 = 3 
Arguments: (p : ℕ) [Fact (Nat.Prime p)]
Goal: Prime ↑p ↔ p % 4 = 3
-- Real.deriv_Gamma_nat
lemma deriv_Gamma_nat (n : ℕ) :
    deriv Gamma (n + 1) = n ! * (-γ + harmonic n) 
Arguments: (n : ℕ)
Goal: deriv Real.Gamma (↑n + 1) = ↑n ! * (-γ + ↑(harmonic n))
-- Real.hasDerivAt_Gamma_nat
lemma hasDerivAt_Gamma_nat (n : ℕ) :
    HasDerivAt Gamma (n ! * (-γ + harmonic n)) (n + 1) 
Arguments: (n : ℕ)
Goal: HasDerivAt Real.Gamma (↑n ! * (-γ + ↑(harmonic n))) (↑n + 1)
-- Real.eulerMascheroniConstant_eq_neg_deriv
lemma eulerMascheroniConstant_eq_neg_deriv : γ = -deriv Gamma 1 
Goal: γ = -deriv Real.Gamma 1
-- Real.hasDerivAt_Gamma_one
lemma hasDerivAt_Gamma_one : HasDerivAt Gamma (-γ) 1 
Goal: HasDerivAt Real.Gamma (-γ) 1
-- Real.hasDerivAt_Gamma_one_half
lemma hasDerivAt_Gamma_one_half : HasDerivAt Gamma (-√π * (γ + 2 * log 2)) (1 / 2) 
Goal: HasDerivAt Real.Gamma (-√Real.pi * (γ + 2 * Real.log 2)) (1 / 2)
-- _private.Mathlib.NumberTheory.Harmonic.GammaDeriv.0.Complex.HasDerivAt.complex_of_real
private lemma HasDerivAt.complex_of_real {f : ℂ → ℂ} {g : ℝ → ℝ} {g' s : ℝ}
    (hf : DifferentiableAt ℂ f s) (hg : HasDerivAt g g' s) (hfg : ∀ s : ℝ, f ↑s = ↑(g s)) :
    HasDerivAt f ↑g' s 
Arguments: {f : ℂ → ℂ} {g : ℝ → ℝ} {g' s : ℝ} (hf : DifferentiableAt ℂ f ↑s) (hg : HasDerivAt g g' s) (hfg : ∀ (s : ℝ), f ↑s = ↑(g s))
Goal: HasDerivAt f ↑g' ↑s
-- Complex.differentiable_at_Gamma_nat_add_one
lemma differentiable_at_Gamma_nat_add_one (n : ℕ) :
    DifferentiableAt ℂ Gamma (n + 1) 
Arguments: (n : ℕ)
Goal: DifferentiableAt ℂ Complex.Gamma (↑n + 1)
-- Complex.hasDerivAt_Gamma_nat
lemma hasDerivAt_Gamma_nat (n : ℕ) :
    HasDerivAt Gamma (n ! * (-γ + harmonic n)) (n + 1) 
Arguments: (n : ℕ)
Goal: HasDerivAt Complex.Gamma (↑n ! * (-↑γ + ↑(harmonic n))) (↑n + 1)
-- Complex.deriv_Gamma_nat
lemma deriv_Gamma_nat (n : ℕ) :
    deriv Gamma (n + 1) = n ! * (-γ + harmonic n) 
Arguments: (n : ℕ)
Goal: deriv Complex.Gamma (↑n + 1) = ↑n ! * (-↑γ + ↑(harmonic n))
-- Complex.hasDerivAt_Gamma_one
lemma hasDerivAt_Gamma_one : HasDerivAt Gamma (-γ) 1 
Goal: HasDerivAt Complex.Gamma (-↑γ) 1
-- Complex.hasDerivAt_Gamma_one_half
lemma hasDerivAt_Gamma_one_half : HasDerivAt Gamma (-√π * (γ + 2 * log 2)) (1 / 2) 
Goal: HasDerivAt Complex.Gamma (-↑√Real.pi * (↑γ + 2 * Complex.log 2)) (1 / 2)
-- Complex.hasDerivAt_Gammaℂ_one
lemma hasDerivAt_Gammaℂ_one : HasDerivAt Gammaℂ (-(γ + log (2 * π)) / π) 1 
Goal: HasDerivAt Complex.Gammaℂ (-(↑γ + Complex.log (2 * ↑Real.pi)) / ↑Real.pi) 1
-- Complex.hasDerivAt_Gammaℝ_one
lemma hasDerivAt_Gammaℝ_one : HasDerivAt Gammaℝ (-(γ + log (4 * π)) / 2) 1 
Goal: HasDerivAt Complex.Gammaℝ (-(↑γ + Complex.log (4 * ↑Real.pi)) / 2) 1
-- IsCyclotomicExtension.Rat.three_pid
theorem three_pid [IsCyclotomicExtension {3} ℚ K] : IsPrincipalIdealRing (𝓞 K) 
Arguments: (K : Type u) [Field K] [NumberField K] [IsCyclotomicExtension {3} ℚ K]
Goal: IsPrincipalIdealRing (NumberField.RingOfIntegers K)
-- IsCyclotomicExtension.Rat.five_pid
theorem five_pid [IsCyclotomicExtension {5} ℚ K] : IsPrincipalIdealRing (𝓞 K) 
Arguments: (K : Type u) [Field K] [NumberField K] [IsCyclotomicExtension {5} ℚ K]
Goal: IsPrincipalIdealRing (NumberField.RingOfIntegers K)
-- NumberField.canonicalEmbedding_injective
theorem _root_.NumberField.canonicalEmbedding_injective [NumberField K] :
    Function.Injective (NumberField.canonicalEmbedding K) 
Arguments: (K : Type u_1) [Field K] [NumberField K]
Goal: Function.Injective ⇑(NumberField.canonicalEmbedding K)
-- NumberField.canonicalEmbedding.apply_at
@[simp]
theorem apply_at (φ : K →+* ℂ) (x : K) : (NumberField.canonicalEmbedding K x) φ = φ x 
Arguments: {K : Type u_1} [Field K] (φ : K →+* ℂ) (x : K)
Goal: (NumberField.canonicalEmbedding K) x φ = φ x
-- NumberField.canonicalEmbedding.conj_apply
theorem conj_apply {x : ((K →+* ℂ) → ℂ)} (φ : K →+* ℂ)
    (hx : x ∈ Submodule.span ℝ (Set.range (canonicalEmbedding K))) :
    conj (x φ) = x (ComplexEmbedding.conjugate φ) 
Arguments: {K : Type u_1} [Field K] {x : (K →+* ℂ) → ℂ} (φ : K →+* ℂ) (hx : x ∈ Submodule.span ℝ (Set.range ⇑(NumberField.canonicalEmbedding K)))
Goal: (starRingEnd ℂ) (x φ) = x (NumberField.ComplexEmbedding.conjugate φ)