ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LucasLehmer.norm_num_ext.isNat_lucasLehmerTest
theorem isNat_lucasLehmerTest : {p np : ℕ} →
    IsNat p np → LucasLehmerTest np → LucasLehmerTest p
  
Arguments: {p np : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat p np → LucasLehmerTest np → LucasLehmerTest p
-- LucasLehmer.norm_num_ext.isNat_not_lucasLehmerTest
theorem isNat_not_lucasLehmerTest : {p np : ℕ} →
    IsNat p np → ¬ LucasLehmerTest np → ¬ LucasLehmerTest p
  
Arguments: {p np : ℕ}
Goal: Mathlib.Meta.NormNum.IsNat p np → ¬LucasLehmerTest np → ¬LucasLehmerTest p
-- modEq_mersenne
theorem modEq_mersenne (n k : ℕ) : k ≡ k / 2 ^ n + k % 2 ^ n [MOD 2 ^ n - 1] 
Arguments: (n k : ℕ)
Goal: k ≡ k / 2 ^ n + k % 2 ^ n [MOD 2 ^ n - 1]
-- Real.eulerMascheroniSeq_zero
lemma eulerMascheroniSeq_zero : eulerMascheroniSeq 0 = 0 
Goal: Real.eulerMascheroniSeq 0 = 0
-- Real.strictMono_eulerMascheroniSeq
lemma strictMono_eulerMascheroniSeq : StrictMono eulerMascheroniSeq 
Goal: StrictMono Real.eulerMascheroniSeq
-- Real.one_half_lt_eulerMascheroniSeq_six
lemma one_half_lt_eulerMascheroniSeq_six : 1 / 2 < eulerMascheroniSeq 6 
Goal: 1 / 2 < Real.eulerMascheroniSeq 6
-- Real.eulerMascheroniSeq'_one
lemma eulerMascheroniSeq'_one : eulerMascheroniSeq' 1 = 1 
Goal: Real.eulerMascheroniSeq' 1 = 1
-- Real.strictAnti_eulerMascheroniSeq'
lemma strictAnti_eulerMascheroniSeq' : StrictAnti eulerMascheroniSeq' 
Goal: StrictAnti Real.eulerMascheroniSeq'
-- Real.eulerMascheroniSeq'_six_lt_two_thirds
lemma eulerMascheroniSeq'_six_lt_two_thirds : eulerMascheroniSeq' 6 < 2 / 3 
Goal: Real.eulerMascheroniSeq' 6 < 2 / 3
-- Real.eulerMascheroniSeq_lt_eulerMascheroniSeq'
lemma eulerMascheroniSeq_lt_eulerMascheroniSeq' (m n : ℕ) :
    eulerMascheroniSeq m < eulerMascheroniSeq' n 
Arguments: (m n : ℕ)
Goal: Real.eulerMascheroniSeq m < Real.eulerMascheroniSeq' n
-- Real.tendsto_eulerMascheroniSeq
lemma tendsto_eulerMascheroniSeq :
    Tendsto eulerMascheroniSeq atTop (𝓝 eulerMascheroniConstant) 
Goal: Filter.Tendsto Real.eulerMascheroniSeq Filter.atTop (𝓝 Real.eulerMascheroniConstant)
-- Real.tendsto_harmonic_sub_log_add_one
lemma tendsto_harmonic_sub_log_add_one :
    Tendsto (fun n : ℕ ↦ harmonic n - log (n + 1)) atTop (𝓝 eulerMascheroniConstant) 
Goal: Filter.Tendsto (fun n => ↑(harmonic n) - Real.log (↑n + 1)) Filter.atTop (𝓝 Real.eulerMascheroniConstant)
-- Real.tendsto_eulerMascheroniSeq'
lemma tendsto_eulerMascheroniSeq' :
    Tendsto eulerMascheroniSeq' atTop (𝓝 eulerMascheroniConstant) 
Goal: Filter.Tendsto Real.eulerMascheroniSeq' Filter.atTop (𝓝 Real.eulerMascheroniConstant)
-- Real.tendsto_harmonic_sub_log
lemma tendsto_harmonic_sub_log :
    Tendsto (fun n : ℕ ↦ harmonic n - log n) atTop (𝓝 eulerMascheroniConstant) 
Goal: Filter.Tendsto (fun n => ↑(harmonic n) - Real.log ↑n) Filter.atTop (𝓝 Real.eulerMascheroniConstant)
-- Real.eulerMascheroniSeq_lt_eulerMascheroniConstant
lemma eulerMascheroniSeq_lt_eulerMascheroniConstant (n : ℕ) :
    eulerMascheroniSeq n < eulerMascheroniConstant 
Arguments: (n : ℕ)
Goal: Real.eulerMascheroniSeq n < Real.eulerMascheroniConstant
-- Real.eulerMascheroniConstant_lt_eulerMascheroniSeq'
lemma eulerMascheroniConstant_lt_eulerMascheroniSeq' (n : ℕ) :
    eulerMascheroniConstant < eulerMascheroniSeq' n 
Arguments: (n : ℕ)
Goal: Real.eulerMascheroniConstant < Real.eulerMascheroniSeq' n
-- Real.one_half_lt_eulerMascheroniConstant
lemma one_half_lt_eulerMascheroniConstant : 1 / 2 < eulerMascheroniConstant 
Goal: 1 / 2 < Real.eulerMascheroniConstant
-- Real.eulerMascheroniConstant_lt_two_thirds
lemma eulerMascheroniConstant_lt_two_thirds : eulerMascheroniConstant < 2 / 3 
Goal: Real.eulerMascheroniConstant < 2 / 3
-- MulChar.eq_iff
lemma eq_iff {R R' : Type*} [CommMonoid R] [CommMonoidWithZero R'] {g : Rˣ}
    (hg : ∀ x, x ∈ Subgroup.zpowers g) (χ₁ χ₂ : MulChar R R') :
    χ₁ = χ₂ ↔ χ₁ g.val = χ₂ g.val 
Arguments: {R : Type u_1} {R' : Type u_2} [CommMonoid R] [CommMonoidWithZero R'] {g : Rˣ} (hg : ∀ (x : Rˣ), x ∈ Subgroup.zpowers g) (χ₁ χ₂ : MulChar R R')
Goal: χ₁ = χ₂ ↔ χ₁ ↑g = χ₂ ↑g
-- MulChar.starComp_apply
@[simps!]
def starComp [StarRing R'] (χ : MulChar R R') : MulChar R R' 
Arguments: {R : Type u_1} {R' : Type u_2} [CommRing R] [CommRing R'] [StarRing R'] (χ : MulChar R R') (a : R)
Goal: χ.starComp a = (starRingEnd R') (χ a)
-- MulChar.star_apply
@[simp]
lemma star_apply [StarRing R'] (χ : MulChar R R') (a : R) : (star χ) a = star (χ a) 
Arguments: {R : Type u_1} {R' : Type u_2} [CommRing R] [CommRing R'] [StarRing R'] (χ : MulChar R R') (a : R)
Goal: (star χ) a = star (χ a)
-- MulChar.apply_mem_rootsOfUnity
lemma apply_mem_rootsOfUnity [Fintype Rˣ] (a : Rˣ) {χ : MulChar R R'} :
    equivToUnitHom χ a ∈ rootsOfUnity ⟨Fintype.card Rˣ, Fintype.card_pos⟩ R' 
Arguments: {R : Type u_1} {R' : Type u_2} [CommRing R] [CommRing R'] [Fintype Rˣ] (a : Rˣ) {χ : MulChar R R'}
Goal: (MulChar.equivToUnitHom χ) a ∈ rootsOfUnity ⟨Fintype.card Rˣ, ⋯⟩ R'
-- MulChar.star_eq_inv
lemma star_eq_inv (χ : MulChar R ℂ) : star χ = χ⁻¹ 
Arguments: {R : Type u_1} [CommRing R] [Finite Rˣ] (χ : MulChar R ℂ)
Goal: star χ = χ⁻¹
-- MulChar.star_apply'
lemma star_apply' (χ : MulChar R ℂ) (a : R) : star (χ a) = χ⁻¹ a 
Arguments: {R : Type u_1} [CommRing R] [Finite Rˣ] (χ : MulChar R ℂ) (a : R)
Goal: star (χ a) = χ⁻¹ a
-- MulChar.ofRootOfUnity_spec
lemma ofRootOfUnity_spec {ζ : Rˣ} (hζ : ζ ∈ rootsOfUnity (Monoid.orderUnits M) R)
    {g : Mˣ} (hg : ∀ x, x ∈ Subgroup.zpowers g) :
    ofRootOfUnity hζ hg g = ζ 
Arguments: {M : Type u_1} [CommMonoid M] [Fintype M] [DecidableEq M] {R : Type u_2} [CommMonoidWithZero R] {ζ : Rˣ} (hζ : ζ ∈ rootsOfUnity (MulChar.Monoid.orderUnits M) R) {g : Mˣ} (hg : ∀ (x : Mˣ), x ∈ Subgroup.zpowers g)
Goal: (MulChar.ofRootOfUnity hζ hg) ↑g = ↑ζ
-- MulChar.exists_mulChar_orderOf
lemma exists_mulChar_orderOf {n : ℕ} (h : n ∣ Fintype.card F - 1) {ζ : R}
    (hζ : IsPrimitiveRoot ζ n) :
    ∃ χ : MulChar F R, orderOf χ = n 
Arguments: (F : Type u_1) [Field F] [Fintype F] {R : Type u_2} [CommRing R] {n : ℕ} (h : n ∣ Fintype.card F - 1) {ζ : R} (hζ : IsPrimitiveRoot ζ n)
Goal: ∃ χ, orderOf χ = n
-- MulChar.orderOf_dvd_card_sub_one
lemma orderOf_dvd_card_sub_one (χ : MulChar F R) : orderOf χ ∣ Fintype.card F - 1 
Arguments: (F : Type u_1) [Field F] [Fintype F] {R : Type u_2} [CommRing R] (χ : MulChar F R)
Goal: orderOf χ ∣ Fintype.card F - 1
-- MulChar.exists_mulChar_orderOf_eq_card_units
lemma exists_mulChar_orderOf_eq_card_units [DecidableEq F]
    {ζ : R} (hζ : IsPrimitiveRoot ζ (Monoid.orderUnits F)) :
    ∃ χ : MulChar F R, orderOf χ = Fintype.card Fˣ 
Arguments: (F : Type u_1) [Field F] [Fintype F] {R : Type u_2} [CommRing R] [DecidableEq F] {ζ : R} (hζ : IsPrimitiveRoot ζ ↑(MulChar.Monoid.orderUnits F))
Goal: ∃ χ, orderOf χ = Fintype.card Fˣ
-- MulChar.apply_mem_rootsOfUnity_orderOf
lemma apply_mem_rootsOfUnity_orderOf (χ : MulChar F R) {a : F} (ha : a ≠ 0) :
    ∃ ζ ∈ rootsOfUnity ⟨orderOf χ, χ.orderOf_pos⟩ R, ζ = χ a 
Arguments: {F : Type u_1} [Field F] [Finite F] {R : Type u_2} [CommRing R] (χ : MulChar F R) {a : F} (ha : a ≠ 0)
Goal: ∃ ζ ∈ rootsOfUnity ⟨orderOf χ, ⋯⟩ R, ↑ζ = χ a
-- MulChar.apply_mem_rootsOfUnity_of_pow_eq_one
lemma apply_mem_rootsOfUnity_of_pow_eq_one {χ : MulChar F R} {n : ℕ} (hn : n ≠ 0) (hχ : χ ^ n = 1)
    {a : F} (ha : a ≠ 0) :
    ∃ ζ ∈ rootsOfUnity ⟨n, Nat.pos_of_ne_zero hn⟩ R, ζ = χ a 
Arguments: {F : Type u_1} [Field F] [Finite F] {R : Type u_2} [CommRing R] {χ : MulChar F R} {n : ℕ} (hn : n ≠ 0) (hχ : χ ^ n = 1) {a : F} (ha : a ≠ 0)
Goal: ∃ ζ ∈ rootsOfUnity ⟨n, ⋯⟩ R, ↑ζ = χ a
-- MulChar.exists_apply_eq_pow
lemma exists_apply_eq_pow {χ : MulChar F R} {n : ℕ} (hn : n ≠ 0) (hχ : χ ^ n = 1) {μ : R}
    (hμ : IsPrimitiveRoot μ n) {a : F} (ha : a ≠ 0) :
    ∃ k < n, χ a = μ ^ k 
Arguments: {F : Type u_1} [Field F] [Finite F] {R : Type u_2} [CommRing R] [IsDomain R] {χ : MulChar F R} {n : ℕ} (hn : n ≠ 0) (hχ : χ ^ n = 1) {μ : R} (hμ : IsPrimitiveRoot μ n) {a : F} (ha : a ≠ 0)
Goal: ∃ k < n, χ a = μ ^ k
-- MulChar.apply_mem_algebraAdjoin_of_pow_eq_one
lemma apply_mem_algebraAdjoin_of_pow_eq_one {χ : MulChar F R} {n : ℕ} (hn : n ≠ 0) (hχ : χ ^ n = 1)
    {μ : R} (hμ : IsPrimitiveRoot μ n) (a : F) :
    χ a ∈ Algebra.adjoin ℤ {μ} 
Arguments: {F : Type u_1} [Field F] [Finite F] {R : Type u_2} [CommRing R] [IsDomain R] {χ : MulChar F R} {n : ℕ} (hn : n ≠ 0) (hχ : χ ^ n = 1) {μ : R} (hμ : IsPrimitiveRoot μ n) (a : F)
Goal: χ a ∈ Algebra.adjoin ℤ {μ}
-- MulChar.apply_mem_algebraAdjoin
lemma apply_mem_algebraAdjoin {χ : MulChar F R} {μ : R} (hμ : IsPrimitiveRoot μ (orderOf χ))
    (a : F) :
    χ a ∈ Algebra.adjoin ℤ {μ} 
Arguments: {F : Type u_1} [Field F] [Finite F] {R : Type u_2} [CommRing R] [IsDomain R] {χ : MulChar F R} {μ : R} (hμ : IsPrimitiveRoot μ (orderOf χ)) (a : F)
Goal: χ a ∈ Algebra.adjoin ℤ {μ}
-- padicValNat.zero
@[simp]
protected theorem zero : padicValNat p 0 = 0 
Arguments: {p : ℕ}
Goal: padicValNat p 0 = 0
-- padicValNat.one
@[simp]
protected theorem one : padicValNat p 1 = 0 
Arguments: {p : ℕ}
Goal: padicValNat p 1 = 0
-- padicValNat.self
@[simp]
theorem self (hp : 1 < p) : padicValNat p p = 1 
Arguments: {p : ℕ} (hp : 1 < p)
Goal: padicValNat p p = 1
-- padicValNat.eq_zero_iff
@[simp]
theorem eq_zero_iff {n : ℕ} : padicValNat p n = 0 ↔ p = 1 ∨ n = 0 ∨ ¬p ∣ n 
Arguments: {p n : ℕ}
Goal: padicValNat p n = 0 ↔ p = 1 ∨ n = 0 ∨ ¬p ∣ n
-- padicValNat.eq_zero_of_not_dvd
theorem eq_zero_of_not_dvd {n : ℕ} (h : ¬p ∣ n) : padicValNat p n = 0 
Arguments: {p n : ℕ} (h : ¬p ∣ n)
Goal: padicValNat p n = 0
-- padicValNat.maxPowDiv_eq_multiplicity
theorem maxPowDiv_eq_multiplicity {p n : ℕ} (hp : 1 < p) (hn : 0 < n) :
    p.maxPowDiv n = multiplicity p n 
Arguments: {p n : ℕ} (hp : 1 < p) (hn : 0 < n)
Goal: ↑(p.maxPowDiv n) = multiplicity p n
-- padicValNat.maxPowDiv_eq_multiplicity_get
theorem maxPowDiv_eq_multiplicity_get {p n : ℕ} (hp : 1 < p) (hn : 0 < n) (h : Finite p n) :
    p.maxPowDiv n = (multiplicity p n).get h 
Arguments: {p n : ℕ} (hp : 1 < p) (hn : 0 < n) (h : multiplicity.Finite p n)
Goal: p.maxPowDiv n = (multiplicity p n).get h
-- padicValNat.padicValNat_eq_maxPowDiv
@[csimp]
theorem padicValNat_eq_maxPowDiv : @padicValNat = @maxPowDiv 
Goal: padicValNat = Nat.maxPowDiv
-- padicValInt.of_ne_one_ne_zero
theorem of_ne_one_ne_zero {z : ℤ} (hp : p ≠ 1) (hz : z ≠ 0) :
    padicValInt p z =
      (multiplicity (p : ℤ) z).get
        (by
          apply multiplicity.finite_int_iff.2
          simp [hp, hz]) 
Arguments: {p : ℕ} {z : ℤ} (hp : p ≠ 1) (hz : z ≠ 0)
Goal: padicValInt p z = (multiplicity (↑p) z).get ⋯
-- padicValInt.zero
@[simp]
protected theorem zero : padicValInt p 0 = 0 
Arguments: {p : ℕ}
Goal: padicValInt p 0 = 0
-- padicValInt.one
@[simp]
protected theorem one : padicValInt p 1 = 0 
Arguments: {p : ℕ}
Goal: padicValInt p 1 = 0
-- padicValInt.of_nat
@[simp]
theorem of_nat {n : ℕ} : padicValInt p n = padicValNat p n 
Arguments: {p n : ℕ}
Goal: padicValInt p ↑n = padicValNat p n
-- padicValInt.self
theorem self (hp : 1 < p) : padicValInt p p = 1 
Arguments: {p : ℕ} (hp : 1 < p)
Goal: padicValInt p ↑p = 1
-- padicValInt.eq_zero_of_not_dvd
theorem eq_zero_of_not_dvd {z : ℤ} (h : ¬(p : ℤ) ∣ z) : padicValInt p z = 0 
Arguments: {p : ℕ} {z : ℤ} (h : ¬↑p ∣ z)
Goal: padicValInt p z = 0
-- padicValRat_def
lemma padicValRat_def (p : ℕ) (q : ℚ) :
    padicValRat p q = padicValInt p q.num - padicValNat p q.den 
Arguments: (p : ℕ) (q : ℚ)
Goal: padicValRat p q = ↑(padicValInt p q.num) - ↑(padicValNat p q.den)
-- padicValRat.neg
@[simp]
protected theorem neg (q : ℚ) : padicValRat p (-q) = padicValRat p q 
Arguments: {p : ℕ} (q : ℚ)
Goal: padicValRat p (-q) = padicValRat p q
-- padicValRat.zero
@[simp]
protected theorem zero : padicValRat p 0 = 0 
Arguments: {p : ℕ}
Goal: padicValRat p 0 = 0
-- padicValRat.one
@[simp]
protected theorem one : padicValRat p 1 = 0 
Arguments: {p : ℕ}
Goal: padicValRat p 1 = 0
-- padicValRat.of_int
@[simp]
theorem of_int {z : ℤ} : padicValRat p z = padicValInt p z 
Arguments: {p : ℕ} {z : ℤ}
Goal: padicValRat p ↑z = ↑(padicValInt p z)
-- padicValRat.of_int_multiplicity
theorem of_int_multiplicity {z : ℤ} (hp : p ≠ 1) (hz : z ≠ 0) :
    padicValRat p (z : ℚ) = (multiplicity (p : ℤ) z).get (finite_int_iff.2 ⟨hp, hz⟩) 
Arguments: {p : ℕ} {z : ℤ} (hp : p ≠ 1) (hz : z ≠ 0)
Goal: padicValRat p ↑z = ↑((multiplicity (↑p) z).get ⋯)
-- padicValRat.multiplicity_sub_multiplicity
theorem multiplicity_sub_multiplicity {q : ℚ} (hp : p ≠ 1) (hq : q ≠ 0) :
    padicValRat p q =
      (multiplicity (p : ℤ) q.num).get (finite_int_iff.2 ⟨hp, Rat.num_ne_zero.2 hq⟩) -
        (multiplicity p q.den).get
          (by
            rw [← finite_iff_dom, finite_nat_iff]
            exact ⟨hp, q.pos⟩) 
Arguments: {p : ℕ} {q : ℚ} (hp : p ≠ 1) (hq : q ≠ 0)
Goal: padicValRat p q = ↑((multiplicity (↑p) q.num).get ⋯) - ↑((multiplicity p q.den).get ⋯)
-- padicValRat.of_nat
@[simp]
theorem of_nat {n : ℕ} : padicValRat p n = padicValNat p n 
Arguments: {p n : ℕ}
Goal: padicValRat p ↑n = ↑(padicValNat p n)
-- padicValRat.self
theorem self (hp : 1 < p) : padicValRat p p = 1 
Arguments: {p : ℕ} (hp : 1 < p)
Goal: padicValRat p ↑p = 1
-- zero_le_padicValRat_of_nat
theorem zero_le_padicValRat_of_nat (n : ℕ) : 0 ≤ padicValRat p n 
Arguments: {p : ℕ} (n : ℕ)
Goal: 0 ≤ padicValRat p ↑n
-- padicValRat_of_nat
@[norm_cast]
theorem padicValRat_of_nat (n : ℕ) : ↑(padicValNat p n) = padicValRat p n 
Arguments: {p : ℕ} (n : ℕ)
Goal: ↑(padicValNat p n) = padicValRat p ↑n
-- padicValNat_def
theorem padicValNat_def [hp : Fact p.Prime] {n : ℕ} (hn : 0 < n) :
    padicValNat p n = (multiplicity p n).get (multiplicity.finite_nat_iff.2 ⟨hp.out.ne_one, hn⟩) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {n : ℕ} (hn : 0 < n)
Goal: padicValNat p n = (multiplicity p n).get ⋯
-- padicValNat_def'
theorem padicValNat_def' {n : ℕ} (hp : p ≠ 1) (hn : 0 < n) :
    ↑(padicValNat p n) = multiplicity p n 
Arguments: {p n : ℕ} (hp : p ≠ 1) (hn : 0 < n)
Goal: ↑(padicValNat p n) = multiplicity p n
-- padicValNat_self
@[simp]
theorem padicValNat_self [Fact p.Prime] : padicValNat p p = 1 
Arguments: {p : ℕ} [Fact (Nat.Prime p)]
Goal: padicValNat p p = 1
-- one_le_padicValNat_of_dvd
theorem one_le_padicValNat_of_dvd {n : ℕ} [hp : Fact p.Prime] (hn : 0 < n) (div : p ∣ n) :
    1 ≤ padicValNat p n 
Arguments: {p n : ℕ} [hp : Fact (Nat.Prime p)] (hn : 0 < n) (div : p ∣ n)
Goal: 1 ≤ padicValNat p n
-- dvd_iff_padicValNat_ne_zero
theorem dvd_iff_padicValNat_ne_zero {p n : ℕ} [Fact p.Prime] (hn0 : n ≠ 0) :
    p ∣ n ↔ padicValNat p n ≠ 0 
Arguments: {p n : ℕ} [Fact (Nat.Prime p)] (hn0 : n ≠ 0)
Goal: p ∣ n ↔ padicValNat p n ≠ 0
-- le_multiplicity_iff_replicate_subperm_primeFactorsList
theorem le_multiplicity_iff_replicate_subperm_primeFactorsList {a b : ℕ} {n : ℕ} (ha : a.Prime)
    (hb : b ≠ 0) :
    ↑n ≤ multiplicity a b ↔ replicate n a <+~ b.primeFactorsList 
Arguments: {a b n : ℕ} (ha : Nat.Prime a) (hb : b ≠ 0)
Goal: ↑n ≤ multiplicity a b ↔ (List.replicate n a).Subperm b.primeFactorsList
-- le_padicValNat_iff_replicate_subperm_primeFactorsList
theorem le_padicValNat_iff_replicate_subperm_primeFactorsList {a b : ℕ} {n : ℕ} (ha : a.Prime)
    (hb : b ≠ 0) :
    n ≤ padicValNat a b ↔ replicate n a <+~ b.primeFactorsList 
Arguments: {a b n : ℕ} (ha : Nat.Prime a) (hb : b ≠ 0)
Goal: n ≤ padicValNat a b ↔ (List.replicate n a).Subperm b.primeFactorsList
-- padicValRat.finite_int_prime_iff
theorem finite_int_prime_iff {a : ℤ} : Finite (p : ℤ) a ↔ a ≠ 0 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {a : ℤ}
Goal: multiplicity.Finite (↑p) a ↔ a ≠ 0
-- padicValRat.defn
protected theorem defn (p : ℕ) [hp : Fact p.Prime] {q : ℚ} {n d : ℤ} (hqz : q ≠ 0)
    (qdf : q = n /. d) :
    padicValRat p q =
      (multiplicity (p : ℤ) n).get
          (finite_int_iff.2 ⟨hp.1.ne_one, fun hn => by simp_all⟩) -
        (multiplicity (p : ℤ) d).get
          (finite_int_iff.2 ⟨hp.1.ne_one, fun hd => by simp_all⟩) 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)] {q : ℚ} {n d : ℤ} (hqz : q ≠ 0) (qdf : q = n /. d)
Goal: padicValRat p q = ↑((multiplicity (↑p) n).get ⋯) - ↑((multiplicity (↑p) d).get ⋯)
-- padicValRat.mul
protected theorem mul {q r : ℚ} (hq : q ≠ 0) (hr : r ≠ 0) :
    padicValRat p (q * r) = padicValRat p q + padicValRat p r 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ} (hq : q ≠ 0) (hr : r ≠ 0)
Goal: padicValRat p (q * r) = padicValRat p q + padicValRat p r
-- padicValRat.pow
protected theorem pow {q : ℚ} (hq : q ≠ 0) {k : ℕ} :
    padicValRat p (q ^ k) = k * padicValRat p q 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q : ℚ} (hq : q ≠ 0) {k : ℕ}
Goal: padicValRat p (q ^ k) = ↑k * padicValRat p q
-- padicValRat.inv
protected theorem inv (q : ℚ) : padicValRat p q⁻¹ = -padicValRat p q 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (q : ℚ)
Goal: padicValRat p q⁻¹ = -padicValRat p q
-- padicValRat.div
protected theorem div {q r : ℚ} (hq : q ≠ 0) (hr : r ≠ 0) :
    padicValRat p (q / r) = padicValRat p q - padicValRat p r 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ} (hq : q ≠ 0) (hr : r ≠ 0)
Goal: padicValRat p (q / r) = padicValRat p q - padicValRat p r
-- padicValRat.padicValRat_le_padicValRat_iff
theorem padicValRat_le_padicValRat_iff {n₁ n₂ d₁ d₂ : ℤ} (hn₁ : n₁ ≠ 0) (hn₂ : n₂ ≠ 0)
    (hd₁ : d₁ ≠ 0) (hd₂ : d₂ ≠ 0) :
    padicValRat p (n₁ /. d₁) ≤ padicValRat p (n₂ /. d₂) ↔
      ∀ n : ℕ, (p : ℤ) ^ n ∣ n₁ * d₂ → (p : ℤ) ^ n ∣ n₂ * d₁ 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {n₁ n₂ d₁ d₂ : ℤ} (hn₁ : n₁ ≠ 0) (hn₂ : n₂ ≠ 0) (hd₁ : d₁ ≠ 0) (hd₂ : d₂ ≠ 0)
Goal: padicValRat p (n₁ /. d₁) ≤ padicValRat p (n₂ /. d₂) ↔ ∀ (n : ℕ), ↑p ^ n ∣ n₁ * d₂ → ↑p ^ n ∣ n₂ * d₁
-- padicValRat.le_padicValRat_add_of_le
theorem le_padicValRat_add_of_le {q r : ℚ} (hqr : q + r ≠ 0)
    (h : padicValRat p q ≤ padicValRat p r) : padicValRat p q ≤ padicValRat p (q + r) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ} (hqr : q + r ≠ 0) (h : padicValRat p q ≤ padicValRat p r)
Goal: padicValRat p q ≤ padicValRat p (q + r)
-- padicValRat.min_le_padicValRat_add
theorem min_le_padicValRat_add {q r : ℚ} (hqr : q + r ≠ 0) :
    min (padicValRat p q) (padicValRat p r) ≤ padicValRat p (q + r) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ} (hqr : q + r ≠ 0)
Goal: min (padicValRat p q) (padicValRat p r) ≤ padicValRat p (q + r)
-- padicValRat.add_eq_min
lemma add_eq_min {q r : ℚ} (hqr : q + r ≠ 0) (hq : q ≠ 0) (hr : r ≠ 0)
    (hval : padicValRat p q ≠ padicValRat p r) :
    padicValRat p (q + r) = min (padicValRat p q) (padicValRat p r) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ} (hqr : q + r ≠ 0) (hq : q ≠ 0) (hr : r ≠ 0) (hval : padicValRat p q ≠ padicValRat p r)
Goal: padicValRat p (q + r) = min (padicValRat p q) (padicValRat p r)
-- padicValRat.add_eq_of_lt
lemma add_eq_of_lt {q r : ℚ} (hqr : q + r ≠ 0)
    (hq : q ≠ 0) (hr : r ≠ 0) (hval : padicValRat p q < padicValRat p r) :
    padicValRat p (q + r) = padicValRat p q 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ} (hqr : q + r ≠ 0) (hq : q ≠ 0) (hr : r ≠ 0) (hval : padicValRat p q < padicValRat p r)
Goal: padicValRat p (q + r) = padicValRat p q
-- padicValRat.lt_add_of_lt
lemma lt_add_of_lt {q r₁ r₂ : ℚ} (hqr : r₁ + r₂ ≠ 0)
    (hval₁ : padicValRat p q < padicValRat p r₁) (hval₂ : padicValRat p q < padicValRat p r₂) :
    padicValRat p q < padicValRat p (r₁ + r₂) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {q r₁ r₂ : ℚ} (hqr : r₁ + r₂ ≠ 0) (hval₁ : padicValRat p q < padicValRat p r₁) (hval₂ : padicValRat p q < padicValRat p r₂)
Goal: padicValRat p q < padicValRat p (r₁ + r₂)
-- padicValRat.self_pow_inv
@[simp]
lemma self_pow_inv (r : ℕ) : padicValRat p ((p : ℚ) ^ r)⁻¹ = -r 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (r : ℕ)
Goal: padicValRat p (↑p ^ r)⁻¹ = -↑r
-- padicValRat.sum_pos_of_pos
theorem sum_pos_of_pos {n : ℕ} {F : ℕ → ℚ} (hF : ∀ i, i < n → 0 < padicValRat p (F i))
    (hn0 : ∑ i ∈ Finset.range n, F i ≠ 0) : 0 < padicValRat p (∑ i ∈ Finset.range n, F i) 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {n : ℕ} {F : ℕ → ℚ} (hF : ∀ i < n, 0 < padicValRat p (F i)) (hn0 : ∑ i ∈ Finset.range n, F i ≠ 0)
Goal: 0 < padicValRat p (∑ i ∈ Finset.range n, F i)
-- padicValRat.lt_sum_of_lt
theorem lt_sum_of_lt {p j : ℕ} [hp : Fact (Nat.Prime p)] {F : ℕ → ℚ} {S : Finset ℕ}
    (hS : S.Nonempty) (hF : ∀ i, i ∈ S → padicValRat p (F j) < padicValRat p (F i))
    (hn1 : ∀ i : ℕ, 0 < F i) : padicValRat p (F j) < padicValRat p (∑ i ∈ S, F i) 
Arguments: {p j : ℕ} [hp : Fact (Nat.Prime p)] {F : ℕ → ℚ} {S : Finset ℕ} (hS : S.Nonempty) (hF : ∀ i ∈ S, padicValRat p (F j) < padicValRat p (F i)) (hn1 : ∀ (i : ℕ), 0 < F i)
Goal: padicValRat p (F j) < padicValRat p (∑ i ∈ S, F i)
-- padicValNat.mul
protected theorem mul : a ≠ 0 → b ≠ 0 → padicValNat p (a * b) = padicValNat p a + padicValNat p b 
Arguments: {p a b : ℕ} [hp : Fact (Nat.Prime p)]
Goal: a ≠ 0 → b ≠ 0 → padicValNat p (a * b) = padicValNat p a + padicValNat p b
-- padicValNat.div_of_dvd
protected theorem div_of_dvd (h : b ∣ a) :
    padicValNat p (a / b) = padicValNat p a - padicValNat p b 
Arguments: {p a b : ℕ} [hp : Fact (Nat.Prime p)] (h : b ∣ a)
Goal: padicValNat p (a / b) = padicValNat p a - padicValNat p b
-- padicValNat.div
protected theorem div (dvd : p ∣ b) : padicValNat p (b / p) = padicValNat p b - 1 
Arguments: {p b : ℕ} [hp : Fact (Nat.Prime p)] (dvd : p ∣ b)
Goal: padicValNat p (b / p) = padicValNat p b - 1
-- padicValNat.pow
protected theorem pow (n : ℕ) (ha : a ≠ 0) : padicValNat p (a ^ n) = n * padicValNat p a 
Arguments: {p a : ℕ} [hp : Fact (Nat.Prime p)] (n : ℕ) (ha : a ≠ 0)
Goal: padicValNat p (a ^ n) = n * padicValNat p a
-- padicValNat.prime_pow
@[simp]
protected theorem prime_pow (n : ℕ) : padicValNat p (p ^ n) = n 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] (n : ℕ)
Goal: padicValNat p (p ^ n) = n
-- padicValNat.div_pow
protected theorem div_pow (dvd : p ^ a ∣ b) : padicValNat p (b / p ^ a) = padicValNat p b - a 
Arguments: {p a b : ℕ} [hp : Fact (Nat.Prime p)] (dvd : p ^ a ∣ b)
Goal: padicValNat p (b / p ^ a) = padicValNat p b - a
-- padicValNat.div'
protected theorem div' {m : ℕ} (cpm : Coprime p m) {b : ℕ} (dvd : m ∣ b) :
    padicValNat p (b / m) = padicValNat p b 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {m : ℕ} (cpm : p.Coprime m) {b : ℕ} (dvd : m ∣ b)
Goal: padicValNat p (b / m) = padicValNat p b
-- dvd_of_one_le_padicValNat
theorem dvd_of_one_le_padicValNat {n : ℕ} (hp : 1 ≤ padicValNat p n) : p ∣ n 
Arguments: {p n : ℕ} (hp : 1 ≤ padicValNat p n)
Goal: p ∣ n
-- pow_padicValNat_dvd
theorem pow_padicValNat_dvd {n : ℕ} : p ^ padicValNat p n ∣ n 
Arguments: {p n : ℕ}
Goal: p ^ padicValNat p n ∣ n
-- padicValNat_dvd_iff_le
theorem padicValNat_dvd_iff_le [hp : Fact p.Prime] {a n : ℕ} (ha : a ≠ 0) :
    p ^ n ∣ a ↔ n ≤ padicValNat p a 
Arguments: {p : ℕ} [hp : Fact (Nat.Prime p)] {a n : ℕ} (ha : a ≠ 0)
Goal: p ^ n ∣ a ↔ n ≤ padicValNat p a
-- padicValNat_dvd_iff
theorem padicValNat_dvd_iff (n : ℕ) [hp : Fact p.Prime] (a : ℕ) :
    p ^ n ∣ a ↔ a = 0 ∨ n ≤ padicValNat p a 
Arguments: {p : ℕ} (n : ℕ) [hp : Fact (Nat.Prime p)] (a : ℕ)
Goal: p ^ n ∣ a ↔ a = 0 ∨ n ≤ padicValNat p a
-- pow_succ_padicValNat_not_dvd
theorem pow_succ_padicValNat_not_dvd {n : ℕ} [hp : Fact p.Prime] (hn : n ≠ 0) :
    ¬p ^ (padicValNat p n + 1) ∣ n 
Arguments: {p n : ℕ} [hp : Fact (Nat.Prime p)] (hn : n ≠ 0)
Goal: ¬p ^ (padicValNat p n + 1) ∣ n
-- padicValNat_primes
theorem padicValNat_primes {q : ℕ} [hp : Fact p.Prime] [hq : Fact q.Prime] (neq : p ≠ q) :
    padicValNat p q = 0 
Arguments: {p q : ℕ} [hp : Fact (Nat.Prime p)] [hq : Fact (Nat.Prime q)] (neq : p ≠ q)
Goal: padicValNat p q = 0
-- padicValNat_prime_prime_pow
theorem padicValNat_prime_prime_pow {q : ℕ} [hp : Fact p.Prime] [hq : Fact q.Prime]
    (n : ℕ) (neq : p ≠ q) : padicValNat p (q ^ n) = 0 
Arguments: {p q : ℕ} [hp : Fact (Nat.Prime p)] [hq : Fact (Nat.Prime q)] (n : ℕ) (neq : p ≠ q)
Goal: padicValNat p (q ^ n) = 0
-- padicValNat_mul_pow_left
theorem padicValNat_mul_pow_left {q : ℕ} [hp : Fact p.Prime] [hq : Fact q.Prime]
    (n m : ℕ) (neq : p ≠ q) : padicValNat p (p^n * q^m) = n 
Arguments: {p q : ℕ} [hp : Fact (Nat.Prime p)] [hq : Fact (Nat.Prime q)] (n m : ℕ) (neq : p ≠ q)
Goal: padicValNat p (p ^ n * q ^ m) = n
-- padicValNat_mul_pow_right
theorem padicValNat_mul_pow_right {q : ℕ} [hp : Fact p.Prime] [hq : Fact q.Prime]
    (n m : ℕ) (neq : q ≠ p) : padicValNat q (p^n * q^m) = m 
Arguments: {p q : ℕ} [hp : Fact (Nat.Prime p)] [hq : Fact (Nat.Prime q)] (n m : ℕ) (neq : q ≠ p)
Goal: padicValNat q (p ^ n * q ^ m) = m