ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- LiouvilleWith.neg_iff
@[simp]
theorem neg_iff : LiouvilleWith p (-x) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ}
Goal: LiouvilleWith p (-x) ↔ LiouvilleWith p x
-- LiouvilleWith.sub_rat_iff
@[simp]
theorem sub_rat_iff : LiouvilleWith p (x - r) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {r : ℚ}
Goal: LiouvilleWith p (x - ↑r) ↔ LiouvilleWith p x
-- LiouvilleWith.sub_rat
theorem sub_rat (h : LiouvilleWith p x) (r : ℚ) : LiouvilleWith p (x - r) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (r : ℚ)
Goal: LiouvilleWith p (x - ↑r)
-- LiouvilleWith.sub_int_iff
@[simp]
theorem sub_int_iff : LiouvilleWith p (x - m) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {m : ℤ}
Goal: LiouvilleWith p (x - ↑m) ↔ LiouvilleWith p x
-- LiouvilleWith.sub_int
theorem sub_int (h : LiouvilleWith p x) (m : ℤ) : LiouvilleWith p (x - m) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (m : ℤ)
Goal: LiouvilleWith p (x - ↑m)
-- LiouvilleWith.sub_nat_iff
@[simp]
theorem sub_nat_iff : LiouvilleWith p (x - n) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {n : ℕ}
Goal: LiouvilleWith p (x - ↑n) ↔ LiouvilleWith p x
-- LiouvilleWith.sub_nat
theorem sub_nat (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (x - n) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (n : ℕ)
Goal: LiouvilleWith p (x - ↑n)
-- LiouvilleWith.rat_sub_iff
@[simp]
theorem rat_sub_iff : LiouvilleWith p (r - x) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {r : ℚ}
Goal: LiouvilleWith p (↑r - x) ↔ LiouvilleWith p x
-- LiouvilleWith.rat_sub
theorem rat_sub (h : LiouvilleWith p x) (r : ℚ) : LiouvilleWith p (r - x) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (r : ℚ)
Goal: LiouvilleWith p (↑r - x)
-- LiouvilleWith.int_sub_iff
@[simp]
theorem int_sub_iff : LiouvilleWith p (m - x) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {m : ℤ}
Goal: LiouvilleWith p (↑m - x) ↔ LiouvilleWith p x
-- LiouvilleWith.int_sub
theorem int_sub (h : LiouvilleWith p x) (m : ℤ) : LiouvilleWith p (m - x) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (m : ℤ)
Goal: LiouvilleWith p (↑m - x)
-- LiouvilleWith.nat_sub_iff
@[simp]
theorem nat_sub_iff : LiouvilleWith p (n - x) ↔ LiouvilleWith p x 
Arguments: {p x : ℝ} {n : ℕ}
Goal: LiouvilleWith p (↑n - x) ↔ LiouvilleWith p x
-- LiouvilleWith.nat_sub
theorem nat_sub (h : LiouvilleWith p x) (n : ℕ) : LiouvilleWith p (n - x) 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (n : ℕ)
Goal: LiouvilleWith p (↑n - x)
-- LiouvilleWith.ne_cast_int
theorem ne_cast_int (h : LiouvilleWith p x) (hp : 1 < p) (m : ℤ) : x ≠ m 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (hp : 1 < p) (m : ℤ)
Goal: x ≠ ↑m
-- LiouvilleWith.irrational
protected theorem irrational (h : LiouvilleWith p x) (hp : 1 < p) : Irrational x 
Arguments: {p x : ℝ} (h : LiouvilleWith p x) (hp : 1 < p)
Goal: Irrational x
-- Liouville.frequently_exists_num
theorem frequently_exists_num (hx : Liouville x) (n : ℕ) :
    ∃ᶠ b : ℕ in atTop, ∃ a : ℤ, x ≠ a / b ∧ |x - a / b| < 1 / (b : ℝ) ^ n 
Arguments: {x : ℝ} (hx : Liouville x) (n : ℕ)
Goal: ∃ᶠ (b : ℕ) in Filter.atTop, ∃ a, x ≠ ↑a / ↑b ∧ |x - ↑a / ↑b| < 1 / ↑b ^ n
-- Liouville.liouvilleWith
protected theorem liouvilleWith (hx : Liouville x) (p : ℝ) : LiouvilleWith p x 
Arguments: {x : ℝ} (hx : Liouville x) (p : ℝ)
Goal: LiouvilleWith p x
-- forall_liouvilleWith_iff
theorem forall_liouvilleWith_iff {x : ℝ} : (∀ p, LiouvilleWith p x) ↔ Liouville x 
Arguments: {x : ℝ}
Goal: (∀ (p : ℝ), LiouvilleWith p x) ↔ Liouville x
-- ArithmeticFunction.log_apply
@[simp]
theorem log_apply {n : ℕ} : log n = Real.log n 
Arguments: {n : ℕ}
Goal: ArithmeticFunction.log n = Real.log ↑n
-- ArithmeticFunction.vonMangoldt_apply
theorem vonMangoldt_apply {n : ℕ} : Λ n = if IsPrimePow n then Real.log (minFac n) else 0 
Arguments: {n : ℕ}
Goal: ArithmeticFunction.vonMangoldt n = if IsPrimePow n then Real.log ↑n.minFac else 0
-- ArithmeticFunction.vonMangoldt_apply_one
@[simp]
theorem vonMangoldt_apply_one : Λ 1 = 0 
Goal: ArithmeticFunction.vonMangoldt 1 = 0
-- ArithmeticFunction.vonMangoldt_nonneg
@[simp]
theorem vonMangoldt_nonneg {n : ℕ} : 0 ≤ Λ n 
Arguments: {n : ℕ}
Goal: 0 ≤ ArithmeticFunction.vonMangoldt n
-- ArithmeticFunction.vonMangoldt_apply_pow
theorem vonMangoldt_apply_pow {n k : ℕ} (hk : k ≠ 0) : Λ (n ^ k) = Λ n 
Arguments: {n k : ℕ} (hk : k ≠ 0)
Goal: ArithmeticFunction.vonMangoldt (n ^ k) = ArithmeticFunction.vonMangoldt n
-- ArithmeticFunction.vonMangoldt_apply_prime
theorem vonMangoldt_apply_prime {p : ℕ} (hp : p.Prime) : Λ p = Real.log p 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: ArithmeticFunction.vonMangoldt p = Real.log ↑p
-- ArithmeticFunction.vonMangoldt_ne_zero_iff
theorem vonMangoldt_ne_zero_iff {n : ℕ} : Λ n ≠ 0 ↔ IsPrimePow n 
Arguments: {n : ℕ}
Goal: ArithmeticFunction.vonMangoldt n ≠ 0 ↔ IsPrimePow n
-- ArithmeticFunction.vonMangoldt_pos_iff
theorem vonMangoldt_pos_iff {n : ℕ} : 0 < Λ n ↔ IsPrimePow n 
Arguments: {n : ℕ}
Goal: 0 < ArithmeticFunction.vonMangoldt n ↔ IsPrimePow n
-- ArithmeticFunction.vonMangoldt_eq_zero_iff
theorem vonMangoldt_eq_zero_iff {n : ℕ} : Λ n = 0 ↔ ¬IsPrimePow n 
Arguments: {n : ℕ}
Goal: ArithmeticFunction.vonMangoldt n = 0 ↔ ¬IsPrimePow n
-- ArithmeticFunction.vonMangoldt_sum
theorem vonMangoldt_sum {n : ℕ} : ∑ i ∈ n.divisors, Λ i = Real.log n 
Arguments: {n : ℕ}
Goal: ∑ i ∈ n.divisors, ArithmeticFunction.vonMangoldt i = Real.log ↑n
-- ArithmeticFunction.vonMangoldt_mul_zeta
@[simp]
theorem vonMangoldt_mul_zeta : Λ * ζ = log 
Goal: ArithmeticFunction.vonMangoldt * ↑ArithmeticFunction.zeta = ArithmeticFunction.log
-- ArithmeticFunction.zeta_mul_vonMangoldt
@[simp]
theorem zeta_mul_vonMangoldt : (ζ : ArithmeticFunction ℝ) * Λ = log 
Goal: ↑ArithmeticFunction.zeta * ArithmeticFunction.vonMangoldt = ArithmeticFunction.log
-- ArithmeticFunction.log_mul_moebius_eq_vonMangoldt
@[simp]
theorem log_mul_moebius_eq_vonMangoldt : log * μ = Λ 
Goal: ArithmeticFunction.log * ↑ArithmeticFunction.moebius = ArithmeticFunction.vonMangoldt
-- ArithmeticFunction.moebius_mul_log_eq_vonMangoldt
@[simp]
theorem moebius_mul_log_eq_vonMangoldt : (μ : ArithmeticFunction ℝ) * log = Λ 
Goal: ↑ArithmeticFunction.moebius * ArithmeticFunction.log = ArithmeticFunction.vonMangoldt
-- ArithmeticFunction.sum_moebius_mul_log_eq
theorem sum_moebius_mul_log_eq {n : ℕ} : (∑ d ∈ n.divisors, (μ d : ℝ) * log d) = -Λ n 
Arguments: {n : ℕ}
Goal: ∑ d ∈ n.divisors, ↑(ArithmeticFunction.moebius d) * ArithmeticFunction.log d = -ArithmeticFunction.vonMangoldt n
-- ArithmeticFunction.vonMangoldt_le_log
theorem vonMangoldt_le_log : ∀ {n : ℕ}, Λ n ≤ Real.log (n : ℝ)
  
Arguments: {n : ℕ}
Goal: ArithmeticFunction.vonMangoldt n ≤ Real.log ↑n
-- euler_four_squares
theorem euler_four_squares {R : Type*} [CommRing R] (a b c d x y z w : R) :
    (a * x - b * y - c * z - d * w) ^ 2 + (a * y + b * x + c * w - d * z) ^ 2 +
      (a * z - b * w + c * x + d * y) ^ 2 + (a * w + b * z - c * y + d * x) ^ 2 =
      (a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2) * (x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2) 
Arguments: {R : Type u_1} [CommRing R] (a b c d x y z w : R)
Goal: (a * x - b * y - c * z - d * w) ^ 2 + (a * y + b * x + c * w - d * z) ^ 2 + (a * z - b * w + c * x + d * y) ^ 2 +
    (a * w + b * z - c * y + d * x) ^ 2 =
  (a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2) * (x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2)
-- Nat.euler_four_squares
theorem Nat.euler_four_squares (a b c d x y z w : ℕ) :
    ((a : ℤ) * x - b * y - c * z - d * w).natAbs ^ 2 +
      ((a : ℤ) * y + b * x + c * w - d * z).natAbs ^ 2 +
      ((a : ℤ) * z - b * w + c * x + d * y).natAbs ^ 2 +
      ((a : ℤ) * w + b * z - c * y + d * x).natAbs ^ 2 =
      (a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2) * (x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2) 
Arguments: (a b c d x y z w : ℕ)
Goal: (↑a * ↑x - ↑b * ↑y - ↑c * ↑z - ↑d * ↑w).natAbs ^ 2 + (↑a * ↑y + ↑b * ↑x + ↑c * ↑w - ↑d * ↑z).natAbs ^ 2 +
      (↑a * ↑z - ↑b * ↑w + ↑c * ↑x + ↑d * ↑y).natAbs ^ 2 +
    (↑a * ↑w + ↑b * ↑z - ↑c * ↑y + ↑d * ↑x).natAbs ^ 2 =
  (a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2) * (x ^ 2 + y ^ 2 + z ^ 2 + w ^ 2)
-- Int.sq_add_sq_of_two_mul_sq_add_sq
theorem sq_add_sq_of_two_mul_sq_add_sq {m x y : ℤ} (h : 2 * m = x ^ 2 + y ^ 2) :
    m = ((x - y) / 2) ^ 2 + ((x + y) / 2) ^ 2 
Arguments: {m x y : ℤ} (h : 2 * m = x ^ 2 + y ^ 2)
Goal: m = ((x - y) / 2) ^ 2 + ((x + y) / 2) ^ 2
-- Int.lt_of_sum_four_squares_eq_mul
theorem lt_of_sum_four_squares_eq_mul {a b c d k m : ℕ}
    (h : a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2 = k * m)
    (ha : 2 * a < m) (hb : 2 * b < m) (hc : 2 * c < m) (hd : 2 * d < m) :
    k < m 
Arguments: {a b c d k m : ℕ} (h : a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2 = k * m) (ha : 2 * a < m) (hb : 2 * b < m) (hc : 2 * c < m) (hd : 2 * d < m)
Goal: k < m
-- Int.exists_sq_add_sq_add_one_eq_mul
theorem exists_sq_add_sq_add_one_eq_mul (p : ℕ) [hp : Fact p.Prime] :
    ∃ (a b k : ℕ), 0 < k ∧ k < p ∧ a ^ 2 + b ^ 2 + 1 = k * p 
Arguments: (p : ℕ) [hp : Fact (Nat.Prime p)]
Goal: ∃ a b k, 0 < k ∧ k < p ∧ a ^ 2 + b ^ 2 + 1 = k * p
-- _private.Mathlib.NumberTheory.SumFourSquares.0.Nat.sum_four_squares_of_two_mul_sum_four_squares
private theorem sum_four_squares_of_two_mul_sum_four_squares {m a b c d : ℤ}
    (h : a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2 = 2 * m) :
    ∃ w x y z : ℤ, w ^ 2 + x ^ 2 + y ^ 2 + z ^ 2 = m 
Arguments: {m a b c d : ℤ} (h : a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2 = 2 * m)
Goal: ∃ w x y z, w ^ 2 + x ^ 2 + y ^ 2 + z ^ 2 = m
-- Nat.Prime.sum_four_squares
protected theorem Prime.sum_four_squares {p : ℕ} (hp : p.Prime) :
    ∃ a b c d : ℕ, a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2 = p 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: ∃ a b c d, a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2 = p
-- Nat.sum_four_squares
theorem sum_four_squares (n : ℕ) : ∃ a b c d : ℕ, a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2 = n 
Arguments: (n : ℕ)
Goal: ∃ a b c d, a ^ 2 + b ^ 2 + c ^ 2 + d ^ 2 = n
-- Nat.monotone_primeCounting'
theorem monotone_primeCounting' : Monotone primeCounting' 
Goal: Monotone Nat.primeCounting'
-- Nat.monotone_primeCounting
theorem monotone_primeCounting : Monotone primeCounting 
Goal: Monotone Nat.primeCounting
-- Nat.primeCounting'_nth_eq
@[simp]
theorem primeCounting'_nth_eq (n : ℕ) : π' (nth Prime n) = n 
Arguments: (n : ℕ)
Goal: (Nat.nth Nat.Prime n).primeCounting' = n
-- Nat.prime_nth_prime
@[simp]
theorem prime_nth_prime (n : ℕ) : Prime (nth Prime n) 
Arguments: (n : ℕ)
Goal: Nat.Prime (Nat.nth Nat.Prime n)
-- Nat.primesBelow_card_eq_primeCounting'
lemma primesBelow_card_eq_primeCounting' (n : ℕ) : n.primesBelow.card = primeCounting' n 
Arguments: (n : ℕ)
Goal: n.primesBelow.card = n.primeCounting'
-- Nat.primeCounting'_add_le
theorem primeCounting'_add_le {a k : ℕ} (h0 : 0 < a) (h1 : a < k) (n : ℕ) :
    π' (k + n) ≤ π' k + Nat.totient a * (n / a + 1) 
Arguments: {a k : ℕ} (h0 : 0 < a) (h1 : a < k) (n : ℕ)
Goal: (k + n).primeCounting' ≤ k.primeCounting' + a.totient * (n / a + 1)
-- Nat.zeroth_prime_eq_two
@[simp]
theorem zeroth_prime_eq_two : nth Prime 0 = 2 
Goal: Nat.nth Nat.Prime 0 = 2
-- Nat.add_two_le_nth_prime
lemma add_two_le_nth_prime (n : ℕ) : n + 2 ≤ nth Prime n 
Arguments: (n : ℕ)
Goal: n + 2 ≤ Nat.nth Nat.Prime n
-- Nat.primesBelow_zero
@[simp]
lemma primesBelow_zero : primesBelow 0 = ∅ 
Goal: Nat.primesBelow 0 = ∅
-- Nat.mem_primesBelow
lemma mem_primesBelow {k n : ℕ} :
    n ∈ primesBelow k ↔ n < k ∧ n.Prime 
Arguments: {k n : ℕ}
Goal: n ∈ k.primesBelow ↔ n < k ∧ Nat.Prime n
-- Nat.prime_of_mem_primesBelow
lemma prime_of_mem_primesBelow {p n : ℕ} (h : p ∈ n.primesBelow) : p.Prime 
Arguments: {p n : ℕ} (h : p ∈ n.primesBelow)
Goal: Nat.Prime p
-- Nat.lt_of_mem_primesBelow
lemma lt_of_mem_primesBelow {p n : ℕ} (h : p ∈ n.primesBelow) : p < n 
Arguments: {p n : ℕ} (h : p ∈ n.primesBelow)
Goal: p < n
-- Nat.primesBelow_succ
lemma primesBelow_succ (n : ℕ) :
    primesBelow n.succ = if n.Prime then insert n (primesBelow n) else primesBelow n 
Arguments: (n : ℕ)
Goal: n.succ.primesBelow = if Nat.Prime n then insert n n.primesBelow else n.primesBelow
-- Nat.not_mem_primesBelow
lemma not_mem_primesBelow (n : ℕ) : n ∉ primesBelow n 
Arguments: (n : ℕ)
Goal: n ∉ n.primesBelow
-- Nat.mem_factoredNumbers
lemma mem_factoredNumbers {s : Finset ℕ} {m : ℕ} :
    m ∈ factoredNumbers s ↔ m ≠ 0 ∧ ∀ p ∈ primeFactorsList m, p ∈ s 
Arguments: {s : Finset ℕ} {m : ℕ}
Goal: m ∈ Nat.factoredNumbers s ↔ m ≠ 0 ∧ ∀ p ∈ m.primeFactorsList, p ∈ s
-- Nat.mem_factoredNumbers_of_dvd
lemma mem_factoredNumbers_of_dvd {s : Finset ℕ} {m k : ℕ} (h : m ∈ factoredNumbers s)
    (h' : k ∣ m) :
    k ∈ factoredNumbers s 
Arguments: {s : Finset ℕ} {m k : ℕ} (h : m ∈ Nat.factoredNumbers s) (h' : k ∣ m)
Goal: k ∈ Nat.factoredNumbers s
-- Nat.mem_factoredNumbers_iff_forall_le
lemma mem_factoredNumbers_iff_forall_le {s : Finset ℕ} {m : ℕ} :
    m ∈ factoredNumbers s ↔ m ≠ 0 ∧ ∀ p ≤ m, p.Prime → p ∣ m → p ∈ s 
Arguments: {s : Finset ℕ} {m : ℕ}
Goal: m ∈ Nat.factoredNumbers s ↔ m ≠ 0 ∧ ∀ p ≤ m, Nat.Prime p → p ∣ m → p ∈ s
-- Nat.mem_factoredNumbers'
lemma mem_factoredNumbers' {s : Finset ℕ} {m : ℕ} :
    m ∈ factoredNumbers s ↔ ∀ p, p.Prime → p ∣ m → p ∈ s 
Arguments: {s : Finset ℕ} {m : ℕ}
Goal: m ∈ Nat.factoredNumbers s ↔ ∀ (p : ℕ), Nat.Prime p → p ∣ m → p ∈ s
-- Nat.ne_zero_of_mem_factoredNumbers
lemma ne_zero_of_mem_factoredNumbers {s : Finset ℕ} {m : ℕ} (h : m ∈ factoredNumbers s) : m ≠ 0 
Arguments: {s : Finset ℕ} {m : ℕ} (h : m ∈ Nat.factoredNumbers s)
Goal: m ≠ 0
-- Nat.primeFactors_subset_of_mem_factoredNumbers
lemma primeFactors_subset_of_mem_factoredNumbers {s : Finset ℕ} {m : ℕ}
    (hm : m ∈ factoredNumbers s) :
    m.primeFactors ⊆ s 
Arguments: {s : Finset ℕ} {m : ℕ} (hm : m ∈ Nat.factoredNumbers s)
Goal: m.primeFactors ⊆ s
-- Nat.mem_factoredNumbers_of_primeFactors_subset
lemma mem_factoredNumbers_of_primeFactors_subset {s : Finset ℕ} {m : ℕ} (hm : m ≠ 0)
    (hp : m.primeFactors ⊆ s) :
    m ∈ factoredNumbers s 
Arguments: {s : Finset ℕ} {m : ℕ} (hm : m ≠ 0) (hp : m.primeFactors ⊆ s)
Goal: m ∈ Nat.factoredNumbers s
-- Nat.mem_factoredNumbers_iff_primeFactors_subset
lemma mem_factoredNumbers_iff_primeFactors_subset {s : Finset ℕ} {m : ℕ} :
    m ∈ factoredNumbers s ↔ m ≠ 0 ∧ m.primeFactors ⊆ s 
Arguments: {s : Finset ℕ} {m : ℕ}
Goal: m ∈ Nat.factoredNumbers s ↔ m ≠ 0 ∧ m.primeFactors ⊆ s
-- Nat.factoredNumbers_empty
@[simp]
lemma factoredNumbers_empty : factoredNumbers ∅ = {1} 
Goal: Nat.factoredNumbers ∅ = {1}
-- Nat.mul_mem_factoredNumbers
lemma mul_mem_factoredNumbers {s : Finset ℕ} {m n : ℕ} (hm : m ∈ factoredNumbers s)
    (hn : n ∈ factoredNumbers s) :
    m * n ∈ factoredNumbers s 
Arguments: {s : Finset ℕ} {m n : ℕ} (hm : m ∈ Nat.factoredNumbers s) (hn : n ∈ Nat.factoredNumbers s)
Goal: m * n ∈ Nat.factoredNumbers s
-- Nat.prod_mem_factoredNumbers
lemma prod_mem_factoredNumbers (s : Finset ℕ) (n : ℕ) :
    (n.primeFactorsList.filter (· ∈ s)).prod ∈ factoredNumbers s 
Arguments: (s : Finset ℕ) (n : ℕ)
Goal: (List.filter (fun x => decide (x ∈ s)) n.primeFactorsList).prod ∈ Nat.factoredNumbers s
-- Nat.factoredNumbers_insert
lemma factoredNumbers_insert (s : Finset ℕ) {N : ℕ} (hN : ¬ N.Prime) :
    factoredNumbers (insert N s) = factoredNumbers s 
Arguments: (s : Finset ℕ) {N : ℕ} (hN : ¬Nat.Prime N)
Goal: Nat.factoredNumbers (insert N s) = Nat.factoredNumbers s
-- Nat.factoredNumbers_mono
@[gcongr] lemma factoredNumbers_mono {s t : Finset ℕ} (hst : s ≤ t) :
    factoredNumbers s ⊆ factoredNumbers t 
Arguments: {s t : Finset ℕ} (hst : s ≤ t)
Goal: Nat.factoredNumbers s ⊆ Nat.factoredNumbers t
-- Nat.factoredNumbers_compl
lemma factoredNumbers_compl {N : ℕ} {s : Finset ℕ} (h : primesBelow N ≤ s) :
    (factoredNumbers s)ᶜ \ {0} ⊆ {n | N ≤ n} 
Arguments: {N : ℕ} {s : Finset ℕ} (h : N.primesBelow ≤ s)
Goal: (Nat.factoredNumbers s)ᶜ \ {0} ⊆ {n | N ≤ n}
-- Nat.pow_mul_mem_factoredNumbers
lemma pow_mul_mem_factoredNumbers {s : Finset ℕ} {p n : ℕ} (hp : p.Prime) (e : ℕ)
    (hn : n ∈ factoredNumbers s) :
    p ^ e * n ∈ factoredNumbers (insert p s) 
Arguments: {s : Finset ℕ} {p n : ℕ} (hp : Nat.Prime p) (e : ℕ) (hn : n ∈ Nat.factoredNumbers s)
Goal: p ^ e * n ∈ Nat.factoredNumbers (insert p s)
-- Nat.Prime.factoredNumbers_coprime
lemma Prime.factoredNumbers_coprime {s : Finset ℕ} {p n : ℕ} (hp : p.Prime) (hs : p ∉ s)
    (hn : n ∈ factoredNumbers s) :
    Nat.Coprime p n 
Arguments: {s : Finset ℕ} {p n : ℕ} (hp : Nat.Prime p) (hs : p ∉ s) (hn : n ∈ Nat.factoredNumbers s)
Goal: p.Coprime n
-- Nat.factoredNumbers.map_prime_pow_mul
lemma factoredNumbers.map_prime_pow_mul {F : Type*} [CommSemiring F] {f : ℕ → F}
    (hmul : ∀ {m n}, Coprime m n → f (m * n) = f m * f n) {s : Finset ℕ} {p : ℕ}
    (hp : p.Prime) (hs : p ∉ s) (e : ℕ) {m : factoredNumbers s} :
    f (p ^ e * m) = f (p ^ e) * f m 
Arguments: {F : Type u_1} [CommSemiring F] {f : ℕ → F} (hmul : ∀ {m n : ℕ}, m.Coprime n → f (m * n) = f m * f n) {s : Finset ℕ} {p : ℕ} (hp : Nat.Prime p) (hs : p ∉ s) (e : ℕ) {m : ↑(Nat.factoredNumbers s)}
Goal: f (p ^ e * ↑m) = f (p ^ e) * f ↑m
-- Nat.equivProdNatFactoredNumbers_apply
@[simp]
lemma equivProdNatFactoredNumbers_apply {s : Finset ℕ} {p e m : ℕ} (hp : p.Prime) (hs : p ∉ s)
    (hm : m ∈ factoredNumbers s) :
    equivProdNatFactoredNumbers hp hs (e, ⟨m, hm⟩) = p ^ e * m 
Arguments: {s : Finset ℕ} {p e m : ℕ} (hp : Nat.Prime p) (hs : p ∉ s) (hm : m ∈ Nat.factoredNumbers s)
Goal: ↑((Nat.equivProdNatFactoredNumbers hp hs) (e, ⟨m, hm⟩)) = p ^ e * m
-- Nat.equivProdNatFactoredNumbers_apply'
@[simp]
lemma equivProdNatFactoredNumbers_apply' {s : Finset ℕ} {p : ℕ} (hp : p.Prime) (hs : p ∉ s)
    (x : ℕ × factoredNumbers s) :
    equivProdNatFactoredNumbers hp hs x = p ^ x.1 * x.2 
Arguments: {s : Finset ℕ} {p : ℕ} (hp : Nat.Prime p) (hs : p ∉ s) (x : ℕ × ↑(Nat.factoredNumbers s))
Goal: ↑((Nat.equivProdNatFactoredNumbers hp hs) x) = p ^ x.1 * ↑x.2
-- Nat.mem_smoothNumbers
lemma mem_smoothNumbers {n m : ℕ} : m ∈ smoothNumbers n ↔ m ≠ 0 ∧ ∀ p ∈ primeFactorsList m, p < n 
Arguments: {n m : ℕ}
Goal: m ∈ n.smoothNumbers ↔ m ≠ 0 ∧ ∀ p ∈ m.primeFactorsList, p < n
-- Nat.smoothNumbers_eq_factoredNumbers
lemma smoothNumbers_eq_factoredNumbers (n : ℕ) :
    smoothNumbers n = factoredNumbers (Finset.range n) 
Arguments: (n : ℕ)
Goal: n.smoothNumbers = Nat.factoredNumbers (Finset.range n)
-- Nat.smmoothNumbers_eq_factoredNumbers_primesBelow
lemma smmoothNumbers_eq_factoredNumbers_primesBelow (n : ℕ) :
    smoothNumbers n = factoredNumbers n.primesBelow 
Arguments: (n : ℕ)
Goal: n.smoothNumbers = Nat.factoredNumbers n.primesBelow
-- Nat.mem_smoothNumbers_of_dvd
lemma mem_smoothNumbers_of_dvd {n m k : ℕ} (h : m ∈ smoothNumbers n) (h' : k ∣ m) :
    k ∈ smoothNumbers n 
Arguments: {n m k : ℕ} (h : m ∈ n.smoothNumbers) (h' : k ∣ m)
Goal: k ∈ n.smoothNumbers
-- Nat.mem_smoothNumbers_iff_forall_le
lemma mem_smoothNumbers_iff_forall_le {n m : ℕ} :
    m ∈ smoothNumbers n ↔ m ≠ 0 ∧ ∀ p ≤ m, p.Prime → p ∣ m → p < n 
Arguments: {n m : ℕ}
Goal: m ∈ n.smoothNumbers ↔ m ≠ 0 ∧ ∀ p ≤ m, Nat.Prime p → p ∣ m → p < n
-- Nat.mem_smoothNumbers'
lemma mem_smoothNumbers' {n m : ℕ} : m ∈ smoothNumbers n ↔ ∀ p, p.Prime → p ∣ m → p < n 
Arguments: {n m : ℕ}
Goal: m ∈ n.smoothNumbers ↔ ∀ (p : ℕ), Nat.Prime p → p ∣ m → p < n
-- Nat.primeFactors_subset_of_mem_smoothNumbers
lemma primeFactors_subset_of_mem_smoothNumbers {m n : ℕ} (hms : m ∈ n.smoothNumbers) :
    m.primeFactors ⊆ n.primesBelow 
Arguments: {m n : ℕ} (hms : m ∈ n.smoothNumbers)
Goal: m.primeFactors ⊆ n.primesBelow
-- Nat.mem_smoothNumbers_of_primeFactors_subset
lemma mem_smoothNumbers_of_primeFactors_subset {m n : ℕ} (hm : m ≠ 0)
    (hp : m.primeFactors ⊆ Finset.range n) : m ∈ n.smoothNumbers 
Arguments: {m n : ℕ} (hm : m ≠ 0) (hp : m.primeFactors ⊆ Finset.range n)
Goal: m ∈ n.smoothNumbers
-- Nat.mem_smoothNumbers_iff_primeFactors_subset
lemma mem_smoothNumbers_iff_primeFactors_subset {m n : ℕ} :
    m ∈ n.smoothNumbers ↔ m ≠ 0 ∧ m.primeFactors ⊆ n.primesBelow 
Arguments: {m n : ℕ}
Goal: m ∈ n.smoothNumbers ↔ m ≠ 0 ∧ m.primeFactors ⊆ n.primesBelow
-- Nat.ne_zero_of_mem_smoothNumbers
lemma ne_zero_of_mem_smoothNumbers {n m : ℕ} (h : m ∈ smoothNumbers n) : m ≠ 0 
Arguments: {n m : ℕ} (h : m ∈ n.smoothNumbers)
Goal: m ≠ 0
-- Nat.smoothNumbers_zero
@[simp]
lemma smoothNumbers_zero : smoothNumbers 0 = {1} 
Goal: Nat.smoothNumbers 0 = {1}
-- Nat.mul_mem_smoothNumbers
theorem mul_mem_smoothNumbers {m₁ m₂ n : ℕ}
    (hm1 : m₁ ∈ n.smoothNumbers) (hm2 : m₂ ∈ n.smoothNumbers) : m₁ * m₂ ∈ n.smoothNumbers 
Arguments: {m₁ m₂ n : ℕ} (hm1 : m₁ ∈ n.smoothNumbers) (hm2 : m₂ ∈ n.smoothNumbers)
Goal: m₁ * m₂ ∈ n.smoothNumbers
-- Nat.prod_mem_smoothNumbers
lemma prod_mem_smoothNumbers (n N : ℕ) :
    (n.primeFactorsList.filter (· < N)).prod ∈ smoothNumbers N 
Arguments: (n N : ℕ)
Goal: (List.filter (fun x => decide (x < N)) n.primeFactorsList).prod ∈ N.smoothNumbers
-- Nat.smoothNumbers_succ
lemma smoothNumbers_succ {N : ℕ} (hN : ¬ N.Prime) : N.succ.smoothNumbers = N.smoothNumbers 
Arguments: {N : ℕ} (hN : ¬Nat.Prime N)
Goal: N.succ.smoothNumbers = N.smoothNumbers
-- Nat.smoothNumbers_one
@[simp] lemma smoothNumbers_one : smoothNumbers 1 = {1} 
Goal: Nat.smoothNumbers 1 = {1}
-- Nat.smoothNumbers_mono
@[gcongr] lemma smoothNumbers_mono {N M : ℕ} (hNM : N ≤ M) : N.smoothNumbers ⊆ M.smoothNumbers 
Arguments: {N M : ℕ} (hNM : N ≤ M)
Goal: N.smoothNumbers ⊆ M.smoothNumbers
-- Nat.mem_smoothNumbers_of_lt
lemma mem_smoothNumbers_of_lt {m n : ℕ} (hm : 0 < m) (hmn : m < n) : m ∈ n.smoothNumbers 
Arguments: {m n : ℕ} (hm : 0 < m) (hmn : m < n)
Goal: m ∈ n.smoothNumbers
-- Nat.smoothNumbers_compl
lemma smoothNumbers_compl (N : ℕ) : (N.smoothNumbers)ᶜ \ {0} ⊆ {n | N ≤ n} 
Arguments: (N : ℕ)
Goal: N.smoothNumbersᶜ \ {0} ⊆ {n | N ≤ n}
-- Nat.pow_mul_mem_smoothNumbers
lemma pow_mul_mem_smoothNumbers {p n : ℕ} (hp : p ≠ 0) (e : ℕ) (hn : n ∈ smoothNumbers p) :
    p ^ e * n ∈ smoothNumbers (succ p) 
Arguments: {p n : ℕ} (hp : p ≠ 0) (e : ℕ) (hn : n ∈ p.smoothNumbers)
Goal: p ^ e * n ∈ p.succ.smoothNumbers
-- Nat.Prime.smoothNumbers_coprime
lemma Prime.smoothNumbers_coprime {p n : ℕ} (hp : p.Prime) (hn : n ∈ smoothNumbers p) :
    Nat.Coprime p n 
Arguments: {p n : ℕ} (hp : Nat.Prime p) (hn : n ∈ p.smoothNumbers)
Goal: p.Coprime n
-- Nat.map_prime_pow_mul
lemma map_prime_pow_mul {F : Type*} [CommSemiring F] {f : ℕ → F}
    (hmul : ∀ {m n}, Nat.Coprime m n → f (m * n) = f m * f n) {p : ℕ} (hp : p.Prime) (e : ℕ)
    {m : p.smoothNumbers} :
    f (p ^ e * m) = f (p ^ e) * f m 
Arguments: {F : Type u_1} [CommSemiring F] {f : ℕ → F} (hmul : ∀ {m n : ℕ}, m.Coprime n → f (m * n) = f m * f n) {p : ℕ} (hp : Nat.Prime p) (e : ℕ) {m : ↑p.smoothNumbers}
Goal: f (p ^ e * ↑m) = f (p ^ e) * f ↑m
-- Nat.equivProdNatSmoothNumbers_apply
@[simp]
lemma equivProdNatSmoothNumbers_apply {p e m : ℕ} (hp : p.Prime) (hm : m ∈ p.smoothNumbers) :
    equivProdNatSmoothNumbers hp (e, ⟨m, hm⟩) = p ^ e * m 
Arguments: {p e m : ℕ} (hp : Nat.Prime p) (hm : m ∈ p.smoothNumbers)
Goal: ↑((Nat.equivProdNatSmoothNumbers hp) (e, ⟨m, hm⟩)) = p ^ e * m
-- Nat.equivProdNatSmoothNumbers_apply'
@[simp]
lemma equivProdNatSmoothNumbers_apply' {p : ℕ} (hp : p.Prime) (x : ℕ × p.smoothNumbers) :
    equivProdNatSmoothNumbers hp x = p ^ x.1 * x.2 
Arguments: {p : ℕ} (hp : Nat.Prime p) (x : ℕ × ↑p.smoothNumbers)
Goal: ↑((Nat.equivProdNatSmoothNumbers hp) x) = p ^ x.1 * ↑x.2
-- Nat.mem_smoothNumbersUpTo
lemma mem_smoothNumbersUpTo {N k n : ℕ} :
    n ∈ smoothNumbersUpTo N k ↔ n ≤ N ∧ n ∈ smoothNumbers k 
Arguments: {N k n : ℕ}
Goal: n ∈ N.smoothNumbersUpTo k ↔ n ≤ N ∧ n ∈ k.smoothNumbers
-- Nat.smoothNumbersUpTo_card_add_roughNumbersUpTo_card
lemma smoothNumbersUpTo_card_add_roughNumbersUpTo_card (N k : ℕ) :
    (smoothNumbersUpTo N k).card + (roughNumbersUpTo N k).card = N 
Arguments: (N k : ℕ)
Goal: (N.smoothNumbersUpTo k).card + (N.roughNumbersUpTo k).card = N
-- Nat.eq_prod_primes_mul_sq_of_mem_smoothNumbers
lemma eq_prod_primes_mul_sq_of_mem_smoothNumbers {n k : ℕ} (h : n ∈ smoothNumbers k) :
    ∃ s ∈ k.primesBelow.powerset, ∃ m, n = m ^ 2 * (s.prod id) 
Arguments: {n k : ℕ} (h : n ∈ k.smoothNumbers)
Goal: ∃ s ∈ k.primesBelow.powerset, ∃ m, n = m ^ 2 * s.prod id
-- Nat.smoothNumbersUpTo_subset_image
lemma smoothNumbersUpTo_subset_image (N k : ℕ) :
    smoothNumbersUpTo N k ⊆ Finset.image (fun (s, m) ↦ m ^ 2 * (s.prod id))
      (k.primesBelow.powerset ×ˢ (Finset.range N.sqrt.succ).erase 0) 
Arguments: (N k : ℕ)
Goal: N.smoothNumbersUpTo k ⊆
  Finset.image
    (fun x =>
      match x with
      | (s, m) => m ^ 2 * s.prod id)
    (k.primesBelow.powerset ×ˢ (Finset.range N.sqrt.succ).erase 0)