ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.ceilRoot_one_right
@[simp] lemma ceilRoot_one_right (hn : n ≠ 0) : ceilRoot n 1 = 1 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: n.ceilRoot 1 = 1
-- Nat.ceilRoot_pow_self
@[simp] lemma ceilRoot_pow_self (hn : n ≠ 0) (a : ℕ) : ceilRoot n (a ^ n) = a 
Arguments: {n : ℕ} (hn : n ≠ 0) (a : ℕ)
Goal: n.ceilRoot (a ^ n) = a
-- Nat.ceilRoot_ne_zero
lemma ceilRoot_ne_zero : ceilRoot n a ≠ 0 ↔ n ≠ 0 ∧ a ≠ 0 
Arguments: {a n : ℕ}
Goal: n.ceilRoot a ≠ 0 ↔ n ≠ 0 ∧ a ≠ 0
-- Nat.ceilRoot_eq_zero
@[simp] lemma ceilRoot_eq_zero : ceilRoot n a = 0 ↔ n = 0 ∨ a = 0 
Arguments: {a n : ℕ}
Goal: n.ceilRoot a = 0 ↔ n = 0 ∨ a = 0
-- Nat.factorization_ceilRoot
@[simp] lemma factorization_ceilRoot (n a : ℕ) :
    (ceilRoot n a).factorization = a.factorization ⌈/⌉ n 
Arguments: (n a : ℕ)
Goal: (n.ceilRoot a).factorization = a.factorization ⌈/⌉ n
-- Nat.dvd_pow_iff_ceilRoot_dvd
lemma dvd_pow_iff_ceilRoot_dvd (hn : n ≠ 0) : a ∣ b ^ n ↔ ceilRoot n a ∣ b 
Arguments: {a b n : ℕ} (hn : n ≠ 0)
Goal: a ∣ b ^ n ↔ n.ceilRoot a ∣ b
-- Nat.dvd_ceilRoot_pow
lemma dvd_ceilRoot_pow (hn : n ≠ 0) : a ∣ ceilRoot n a ^ n 
Arguments: {a n : ℕ} (hn : n ≠ 0)
Goal: a ∣ n.ceilRoot a ^ n
-- Nat.monotone_factorial
lemma monotone_factorial : Monotone factorial 
Goal: Monotone Nat.factorial
-- Nat.prod_factorial_pos
theorem prod_factorial_pos : 0 < ∏ i ∈ s, (f i)! 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℕ)
Goal: 0 < ∏ i ∈ s, (f i)!
-- Nat.prod_factorial_dvd_factorial_sum
theorem prod_factorial_dvd_factorial_sum : (∏ i ∈ s, (f i)!) ∣ (∑ i ∈ s, f i)! 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℕ)
Goal: ∏ i ∈ s, (f i)! ∣ (∑ i ∈ s, f i)!
-- Nat.descFactorial_eq_prod_range
theorem descFactorial_eq_prod_range (n : ℕ) : ∀ k, n.descFactorial k = ∏ i ∈ range k, (n - i)
  
Arguments: (n k : ℕ)
Goal: n.descFactorial k = ∏ i ∈ Finset.range k, (n - i)
-- IsPrimePow.minFac_pow_factorization_eq
theorem IsPrimePow.minFac_pow_factorization_eq {n : ℕ} (hn : IsPrimePow n) :
    n.minFac ^ n.factorization n.minFac = n 
Arguments: {n : ℕ} (hn : IsPrimePow n)
Goal: n.minFac ^ n.factorization n.minFac = n
-- isPrimePow_of_minFac_pow_factorization_eq
theorem isPrimePow_of_minFac_pow_factorization_eq {n : ℕ}
    (h : n.minFac ^ n.factorization n.minFac = n) (hn : n ≠ 1) : IsPrimePow n 
Arguments: {n : ℕ} (h : n.minFac ^ n.factorization n.minFac = n) (hn : n ≠ 1)
Goal: IsPrimePow n
-- isPrimePow_iff_minFac_pow_factorization_eq
theorem isPrimePow_iff_minFac_pow_factorization_eq {n : ℕ} (hn : n ≠ 1) :
    IsPrimePow n ↔ n.minFac ^ n.factorization n.minFac = n 
Arguments: {n : ℕ} (hn : n ≠ 1)
Goal: IsPrimePow n ↔ n.minFac ^ n.factorization n.minFac = n
-- isPrimePow_iff_factorization_eq_single
theorem isPrimePow_iff_factorization_eq_single {n : ℕ} :
    IsPrimePow n ↔ ∃ p k : ℕ, 0 < k ∧ n.factorization = Finsupp.single p k 
Arguments: {n : ℕ}
Goal: IsPrimePow n ↔ ∃ p k, 0 < k ∧ n.factorization = Finsupp.single p k
-- isPrimePow_iff_card_primeFactors_eq_one
theorem isPrimePow_iff_card_primeFactors_eq_one {n : ℕ} :
    IsPrimePow n ↔ n.primeFactors.card = 1 
Arguments: {n : ℕ}
Goal: IsPrimePow n ↔ n.primeFactors.card = 1
-- IsPrimePow.exists_ord_compl_eq_one
theorem IsPrimePow.exists_ord_compl_eq_one {n : ℕ} (h : IsPrimePow n) :
    ∃ p : ℕ, p.Prime ∧ ord_compl[p] n = 1 
Arguments: {n : ℕ} (h : IsPrimePow n)
Goal: ∃ p, Nat.Prime p ∧ n / p ^ n.factorization p = 1
-- exists_ord_compl_eq_one_iff_isPrimePow
theorem exists_ord_compl_eq_one_iff_isPrimePow {n : ℕ} (hn : n ≠ 1) :
    IsPrimePow n ↔ ∃ p : ℕ, p.Prime ∧ ord_compl[p] n = 1 
Arguments: {n : ℕ} (hn : n ≠ 1)
Goal: IsPrimePow n ↔ ∃ p, Nat.Prime p ∧ n / p ^ n.factorization p = 1
-- isPrimePow_iff_unique_prime_dvd
theorem isPrimePow_iff_unique_prime_dvd {n : ℕ} : IsPrimePow n ↔ ∃! p : ℕ, p.Prime ∧ p ∣ n 
Arguments: {n : ℕ}
Goal: IsPrimePow n ↔ ∃! p, Nat.Prime p ∧ p ∣ n
-- isPrimePow_pow_iff
theorem isPrimePow_pow_iff {n k : ℕ} (hk : k ≠ 0) : IsPrimePow (n ^ k) ↔ IsPrimePow n 
Arguments: {n k : ℕ} (hk : k ≠ 0)
Goal: IsPrimePow (n ^ k) ↔ IsPrimePow n
-- Nat.Coprime.isPrimePow_dvd_mul
theorem Nat.Coprime.isPrimePow_dvd_mul {n a b : ℕ} (hab : Nat.Coprime a b) (hn : IsPrimePow n) :
    n ∣ a * b ↔ n ∣ a ∨ n ∣ b 
Arguments: {n a b : ℕ} (hab : a.Coprime b) (hn : IsPrimePow n)
Goal: n ∣ a * b ↔ n ∣ a ∨ n ∣ b
-- Nat.mul_divisors_filter_prime_pow
theorem Nat.mul_divisors_filter_prime_pow {a b : ℕ} (hab : a.Coprime b) :
    (a * b).divisors.filter IsPrimePow = (a.divisors ∪ b.divisors).filter IsPrimePow 
Arguments: {a b : ℕ} (hab : a.Coprime b)
Goal: Finset.filter IsPrimePow (a * b).divisors = Finset.filter IsPrimePow (a.divisors ∪ b.divisors)
-- Nat.infinite_setOf_prime
theorem infinite_setOf_prime : { p | Prime p }.Infinite 
Goal: {p | Nat.Prime p}.Infinite
-- Nat.toFinset_factors
@[simp] lemma toFinset_factors (n : ℕ) : n.primeFactorsList.toFinset = n.primeFactors 
Arguments: (n : ℕ)
Goal: n.primeFactorsList.toFinset = n.primeFactors
-- Nat.mem_primeFactors
@[simp] lemma mem_primeFactors : p ∈ n.primeFactors ↔ p.Prime ∧ p ∣ n ∧ n ≠ 0 
Arguments: {n p : ℕ}
Goal: p ∈ n.primeFactors ↔ Nat.Prime p ∧ p ∣ n ∧ n ≠ 0
-- Nat.mem_primeFactors_of_ne_zero
lemma mem_primeFactors_of_ne_zero (hn : n ≠ 0) : p ∈ n.primeFactors ↔ p.Prime ∧ p ∣ n 
Arguments: {n p : ℕ} (hn : n ≠ 0)
Goal: p ∈ n.primeFactors ↔ Nat.Prime p ∧ p ∣ n
-- Nat.primeFactors_mono
lemma primeFactors_mono (hmn : m ∣ n) (hn : n ≠ 0) : primeFactors m ⊆ primeFactors n 
Arguments: {m n : ℕ} (hmn : m ∣ n) (hn : n ≠ 0)
Goal: m.primeFactors ⊆ n.primeFactors
-- Nat.mem_primeFactors_iff_mem_primeFactorsList
lemma mem_primeFactors_iff_mem_primeFactorsList : p ∈ n.primeFactors ↔ p ∈ n.primeFactorsList 
Arguments: {n p : ℕ}
Goal: p ∈ n.primeFactors ↔ p ∈ n.primeFactorsList
-- Nat.prime_of_mem_primeFactors
lemma prime_of_mem_primeFactors (hp : p ∈ n.primeFactors) : p.Prime 
Arguments: {n p : ℕ} (hp : p ∈ n.primeFactors)
Goal: Nat.Prime p
-- Nat.dvd_of_mem_primeFactors
lemma dvd_of_mem_primeFactors (hp : p ∈ n.primeFactors) : p ∣ n 
Arguments: {n p : ℕ} (hp : p ∈ n.primeFactors)
Goal: p ∣ n
-- Nat.pos_of_mem_primeFactors
lemma pos_of_mem_primeFactors (hp : p ∈ n.primeFactors) : 0 < p 
Arguments: {n p : ℕ} (hp : p ∈ n.primeFactors)
Goal: 0 < p
-- Nat.le_of_mem_primeFactors
lemma le_of_mem_primeFactors (h : p ∈ n.primeFactors) : p ≤ n 
Arguments: {n p : ℕ} (h : p ∈ n.primeFactors)
Goal: p ≤ n
-- Nat.primeFactors_zero
@[simp] lemma primeFactors_zero : primeFactors 0 = ∅ 
Goal: Nat.primeFactors 0 = ∅
-- Nat.primeFactors_one
@[simp] lemma primeFactors_one : primeFactors 1 = ∅ 
Goal: Nat.primeFactors 1 = ∅
-- Nat.primeFactors_eq_empty
@[simp] lemma primeFactors_eq_empty : n.primeFactors = ∅ ↔ n = 0 ∨ n = 1 
Arguments: {n : ℕ}
Goal: n.primeFactors = ∅ ↔ n = 0 ∨ n = 1
-- Nat.nonempty_primeFactors
@[simp]
lemma nonempty_primeFactors {n : ℕ} : n.primeFactors.Nonempty ↔ 1 < n 
Arguments: {n : ℕ}
Goal: n.primeFactors.Nonempty ↔ 1 < n
-- Nat.Prime.primeFactors
@[simp] protected lemma Prime.primeFactors (hp : p.Prime) : p.primeFactors = {p} 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: p.primeFactors = {p}
-- Nat.primeFactors_mul
lemma primeFactors_mul (ha : a ≠ 0) (hb : b ≠ 0) :
    (a * b).primeFactors = a.primeFactors ∪ b.primeFactors 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: (a * b).primeFactors = a.primeFactors ∪ b.primeFactors
-- Nat.Coprime.primeFactors_mul
lemma Coprime.primeFactors_mul {a b : ℕ} (hab : Coprime a b) :
    (a * b).primeFactors = a.primeFactors ∪ b.primeFactors 
Arguments: {a b : ℕ} (hab : a.Coprime b)
Goal: (a * b).primeFactors = a.primeFactors ∪ b.primeFactors
-- Nat.primeFactors_gcd
lemma primeFactors_gcd (ha : a ≠ 0) (hb : b ≠ 0) :
    (a.gcd b).primeFactors = a.primeFactors ∩ b.primeFactors 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: (a.gcd b).primeFactors = a.primeFactors ∩ b.primeFactors
-- Nat.disjoint_primeFactors
@[simp] lemma disjoint_primeFactors (ha : a ≠ 0) (hb : b ≠ 0) :
    Disjoint a.primeFactors b.primeFactors ↔ Coprime a b 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: Disjoint a.primeFactors b.primeFactors ↔ a.Coprime b
-- Nat.Coprime.disjoint_primeFactors
protected lemma Coprime.disjoint_primeFactors (hab : Coprime a b) :
    Disjoint a.primeFactors b.primeFactors 
Arguments: {a b : ℕ} (hab : a.Coprime b)
Goal: Disjoint a.primeFactors b.primeFactors
-- Nat.primeFactors_pow_succ
lemma primeFactors_pow_succ (n k : ℕ) : (n ^ (k + 1)).primeFactors = n.primeFactors 
Arguments: (n k : ℕ)
Goal: (n ^ (k + 1)).primeFactors = n.primeFactors
-- Nat.primeFactors_pow
lemma primeFactors_pow (n : ℕ) (hk : k ≠ 0) : (n ^ k).primeFactors = n.primeFactors 
Arguments: {k : ℕ} (n : ℕ) (hk : k ≠ 0)
Goal: (n ^ k).primeFactors = n.primeFactors
-- Nat.primeFactors_prime_pow
lemma primeFactors_prime_pow (hk : k ≠ 0) (hp : Prime p) :
    (p ^ k).primeFactors = {p} 
Arguments: {k p : ℕ} (hk : k ≠ 0) (hp : Nat.Prime p)
Goal: (p ^ k).primeFactors = {p}
-- Nat.support_factorization
@[simp] lemma support_factorization (n : ℕ) : (factorization n).support = n.primeFactors 
Arguments: (n : ℕ)
Goal: n.factorization.support = n.primeFactors
-- Nat.factorization_def
theorem factorization_def (n : ℕ) {p : ℕ} (pp : p.Prime) : n.factorization p = padicValNat p n 
Arguments: (n : ℕ) {p : ℕ} (pp : Nat.Prime p)
Goal: n.factorization p = padicValNat p n
-- Nat.primeFactorsList_count_eq
@[simp]
theorem primeFactorsList_count_eq {n p : ℕ} : n.primeFactorsList.count p = n.factorization p 
Arguments: {n p : ℕ}
Goal: List.count p n.primeFactorsList = n.factorization p
-- Nat.factorization_eq_primeFactorsList_multiset
theorem factorization_eq_primeFactorsList_multiset (n : ℕ) :
    n.factorization = Multiset.toFinsupp (n.primeFactorsList : Multiset ℕ) 
Arguments: (n : ℕ)
Goal: n.factorization = Multiset.toFinsupp ↑n.primeFactorsList
-- Nat.Prime.factorization_pos_of_dvd
theorem Prime.factorization_pos_of_dvd {n p : ℕ} (hp : p.Prime) (hn : n ≠ 0) (h : p ∣ n) :
    0 < n.factorization p 
Arguments: {n p : ℕ} (hp : Nat.Prime p) (hn : n ≠ 0) (h : p ∣ n)
Goal: 0 < n.factorization p
-- Nat.multiplicity_eq_factorization
theorem multiplicity_eq_factorization {n p : ℕ} (pp : p.Prime) (hn : n ≠ 0) :
    multiplicity p n = n.factorization p 
Arguments: {n p : ℕ} (pp : Nat.Prime p) (hn : n ≠ 0)
Goal: multiplicity p n = ↑(n.factorization p)
-- Nat.factorization_prod_pow_eq_self
@[simp]
theorem factorization_prod_pow_eq_self {n : ℕ} (hn : n ≠ 0) : n.factorization.prod (· ^ ·) = n 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: (n.factorization.prod fun x x_1 => x ^ x_1) = n
-- Nat.eq_of_factorization_eq
theorem eq_of_factorization_eq {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
    (h : ∀ p : ℕ, a.factorization p = b.factorization p) : a = b 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) (h : ∀ (p : ℕ), a.factorization p = b.factorization p)
Goal: a = b
-- Nat.factorization_inj
theorem factorization_inj : Set.InjOn factorization { x : ℕ | x ≠ 0 } 
Goal: Set.InjOn Nat.factorization {x | x ≠ 0}
-- Nat.factorization_zero
@[simp]
theorem factorization_zero : factorization 0 = 0 
Goal: Nat.factorization 0 = 0
-- Nat.factorization_one
@[simp]
theorem factorization_one : factorization 1 = 0 
Goal: Nat.factorization 1 = 0
-- Nat.factorization_eq_zero_iff
theorem factorization_eq_zero_iff (n p : ℕ) :
    n.factorization p = 0 ↔ ¬p.Prime ∨ ¬p ∣ n ∨ n = 0 
Arguments: (n p : ℕ)
Goal: n.factorization p = 0 ↔ ¬Nat.Prime p ∨ ¬p ∣ n ∨ n = 0
-- Nat.factorization_eq_zero_of_non_prime
@[simp]
theorem factorization_eq_zero_of_non_prime (n : ℕ) {p : ℕ} (hp : ¬p.Prime) :
    n.factorization p = 0 
Arguments: (n : ℕ) {p : ℕ} (hp : ¬Nat.Prime p)
Goal: n.factorization p = 0
-- Nat.factorization_zero_right
@[simp]
theorem factorization_zero_right (n : ℕ) : n.factorization 0 = 0 
Arguments: (n : ℕ)
Goal: n.factorization 0 = 0
-- Nat.factorization_eq_zero_of_not_dvd
theorem factorization_eq_zero_of_not_dvd {n p : ℕ} (h : ¬p ∣ n) : n.factorization p = 0 
Arguments: {n p : ℕ} (h : ¬p ∣ n)
Goal: n.factorization p = 0
-- Nat.factorization_eq_zero_of_remainder
theorem factorization_eq_zero_of_remainder {p r : ℕ} (i : ℕ) (hr : ¬p ∣ r) :
    (p * i + r).factorization p = 0 
Arguments: {p r : ℕ} (i : ℕ) (hr : ¬p ∣ r)
Goal: (p * i + r).factorization p = 0
-- Nat.factorization_mul
@[simp]
theorem factorization_mul {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) :
    (a * b).factorization = a.factorization + b.factorization 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: (a * b).factorization = a.factorization + b.factorization
-- Nat.factorization_le_iff_dvd
theorem factorization_le_iff_dvd {d n : ℕ} (hd : d ≠ 0) (hn : n ≠ 0) :
    d.factorization ≤ n.factorization ↔ d ∣ n 
Arguments: {d n : ℕ} (hd : d ≠ 0) (hn : n ≠ 0)
Goal: d.factorization ≤ n.factorization ↔ d ∣ n
-- Nat.factorization_prod
theorem factorization_prod {α : Type*} {S : Finset α} {g : α → ℕ} (hS : ∀ x ∈ S, g x ≠ 0) :
    (S.prod g).factorization = S.sum fun x => (g x).factorization 
Arguments: {α : Type u_1} {S : Finset α} {g : α → ℕ} (hS : ∀ x ∈ S, g x ≠ 0)
Goal: (S.prod g).factorization = ∑ x ∈ S, (g x).factorization
-- Nat.factorization_pow
@[simp]
theorem factorization_pow (n k : ℕ) : factorization (n ^ k) = k • n.factorization 
Arguments: (n k : ℕ)
Goal: (n ^ k).factorization = k • n.factorization
-- Nat.Prime.factorization
@[simp]
protected theorem Prime.factorization {p : ℕ} (hp : Prime p) : p.factorization = single p 1 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: p.factorization = Finsupp.single p 1
-- Nat.Prime.factorization_pow
theorem Prime.factorization_pow {p k : ℕ} (hp : Prime p) : (p ^ k).factorization = single p k 
Arguments: {p k : ℕ} (hp : Nat.Prime p)
Goal: (p ^ k).factorization = Finsupp.single p k
-- Nat.pow_succ_factorization_not_dvd
theorem pow_succ_factorization_not_dvd {n p : ℕ} (hn : n ≠ 0) (hp : p.Prime) :
    ¬p ^ (n.factorization p + 1) ∣ n 
Arguments: {n p : ℕ} (hn : n ≠ 0) (hp : Nat.Prime p)
Goal: ¬p ^ (n.factorization p + 1) ∣ n
-- Nat.prod_pow_factorization_eq_self
theorem prod_pow_factorization_eq_self {f : ℕ →₀ ℕ} (hf : ∀ p : ℕ, p ∈ f.support → Prime p) :
    (f.prod (· ^ ·)).factorization = f 
Arguments: {f : ℕ →₀ ℕ} (hf : ∀ p ∈ f.support, Nat.Prime p)
Goal: (f.prod fun x x_1 => x ^ x_1).factorization = f
-- Nat.factorization_mul_apply_of_coprime
theorem factorization_mul_apply_of_coprime {p a b : ℕ} (hab : Coprime a b) :
    (a * b).factorization p = a.factorization p + b.factorization p 
Arguments: {p a b : ℕ} (hab : a.Coprime b)
Goal: (a * b).factorization p = a.factorization p + b.factorization p
-- Nat.factorization_mul_of_coprime
theorem factorization_mul_of_coprime {a b : ℕ} (hab : Coprime a b) :
    (a * b).factorization = a.factorization + b.factorization 
Arguments: {a b : ℕ} (hab : a.Coprime b)
Goal: (a * b).factorization = a.factorization + b.factorization
-- Nat.ord_proj_dvd
theorem ord_proj_dvd (n p : ℕ) : ord_proj[p] n ∣ n 
Arguments: (n p : ℕ)
Goal: p ^ n.factorization p ∣ n
-- Nat.Prime.five_le_of_ne_two_of_ne_three
theorem Prime.five_le_of_ne_two_of_ne_three {p : ℕ} (hp : p.Prime) (h_two : p ≠ 2)
    (h_three : p ≠ 3) : 5 ≤ p 
Arguments: {p : ℕ} (hp : Nat.Prime p) (h_two : p ≠ 2) (h_three : p ≠ 3)
Goal: 5 ≤ p
-- Nat.Prime.pred_pos
theorem Prime.pred_pos {p : ℕ} (pp : Prime p) : 0 < pred p 
Arguments: {p : ℕ} (pp : Nat.Prime p)
Goal: 0 < p.pred
-- Nat.succ_pred_prime
theorem succ_pred_prime {p : ℕ} (pp : Prime p) : succ (pred p) = p 
Arguments: {p : ℕ} (pp : Nat.Prime p)
Goal: p.pred.succ = p
-- Nat.exists_dvd_of_not_prime
theorem exists_dvd_of_not_prime {n : ℕ} (n2 : 2 ≤ n) (np : ¬Prime n) : ∃ m, m ∣ n ∧ m ≠ 1 ∧ m ≠ n 
Arguments: {n : ℕ} (n2 : 2 ≤ n) (np : ¬Nat.Prime n)
Goal: ∃ m, m ∣ n ∧ m ≠ 1 ∧ m ≠ n
-- Nat.exists_dvd_of_not_prime2
theorem exists_dvd_of_not_prime2 {n : ℕ} (n2 : 2 ≤ n) (np : ¬Prime n) :
    ∃ m, m ∣ n ∧ 2 ≤ m ∧ m < n 
Arguments: {n : ℕ} (n2 : 2 ≤ n) (np : ¬Nat.Prime n)
Goal: ∃ m, m ∣ n ∧ 2 ≤ m ∧ m < n
-- Nat.not_prime_of_dvd_of_ne
theorem not_prime_of_dvd_of_ne {m n : ℕ} (h1 : m ∣ n) (h2 : m ≠ 1) (h3 : m ≠ n) : ¬Prime n 
Arguments: {m n : ℕ} (h1 : m ∣ n) (h2 : m ≠ 1) (h3 : m ≠ n)
Goal: ¬Nat.Prime n
-- Nat.not_prime_of_dvd_of_lt
theorem not_prime_of_dvd_of_lt {m n : ℕ} (h1 : m ∣ n) (h2 : 2 ≤ m) (h3 : m < n) : ¬Prime n 
Arguments: {m n : ℕ} (h1 : m ∣ n) (h2 : 2 ≤ m) (h3 : m < n)
Goal: ¬Nat.Prime n
-- Nat.not_prime_iff_exists_dvd_ne
theorem not_prime_iff_exists_dvd_ne {n : ℕ} (h : 2 ≤ n) : (¬Prime n) ↔ ∃ m, m ∣ n ∧ m ≠ 1 ∧ m ≠ n 
Arguments: {n : ℕ} (h : 2 ≤ n)
Goal: ¬Nat.Prime n ↔ ∃ m, m ∣ n ∧ m ≠ 1 ∧ m ≠ n
-- Nat.not_prime_iff_exists_dvd_lt
theorem not_prime_iff_exists_dvd_lt {n : ℕ} (h : 2 ≤ n) : (¬Prime n) ↔ ∃ m, m ∣ n ∧ 2 ≤ m ∧ m < n 
Arguments: {n : ℕ} (h : 2 ≤ n)
Goal: ¬Nat.Prime n ↔ ∃ m, m ∣ n ∧ 2 ≤ m ∧ m < n
-- Nat.dvd_of_forall_prime_mul_dvd
theorem dvd_of_forall_prime_mul_dvd {a b : ℕ}
    (hdvd : ∀ p : ℕ, p.Prime → p ∣ a → p * a ∣ b) : a ∣ b 
Arguments: {a b : ℕ} (hdvd : ∀ (p : ℕ), Nat.Prime p → p ∣ a → p * a ∣ b)
Goal: a ∣ b
-- Nat.exists_infinite_primes
theorem exists_infinite_primes (n : ℕ) : ∃ p, n ≤ p ∧ Prime p 
Arguments: (n : ℕ)
Goal: ∃ p, n ≤ p ∧ Nat.Prime p
-- Nat.not_bddAbove_setOf_prime
theorem not_bddAbove_setOf_prime : ¬BddAbove { p | Prime p } 
Goal: ¬BddAbove {p | Nat.Prime p}
-- Nat.Prime.even_iff
theorem Prime.even_iff {p : ℕ} (hp : Prime p) : Even p ↔ p = 2 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: Even p ↔ p = 2
-- Nat.Prime.odd_of_ne_two
theorem Prime.odd_of_ne_two {p : ℕ} (hp : p.Prime) (h_two : p ≠ 2) : Odd p 
Arguments: {p : ℕ} (hp : Nat.Prime p) (h_two : p ≠ 2)
Goal: Odd p
-- Nat.Prime.even_sub_one
theorem Prime.even_sub_one {p : ℕ} (hp : p.Prime) (h2 : p ≠ 2) : Even (p - 1) 
Arguments: {p : ℕ} (hp : Nat.Prime p) (h2 : p ≠ 2)
Goal: Even (p - 1)
-- Nat.Prime.mod_two_eq_one_iff_ne_two
theorem Prime.mod_two_eq_one_iff_ne_two {p : ℕ} [Fact p.Prime] : p % 2 = 1 ↔ p ≠ 2 
Arguments: {p : ℕ} [Fact (Nat.Prime p)]
Goal: p % 2 = 1 ↔ p ≠ 2
-- Nat.coprime_of_dvd'
theorem coprime_of_dvd' {m n : ℕ} (H : ∀ k, Prime k → k ∣ m → k ∣ n → k ∣ 1) : Coprime m n 
Arguments: {m n : ℕ} (H : ∀ (k : ℕ), Nat.Prime k → k ∣ m → k ∣ n → k ∣ 1)
Goal: m.Coprime n
-- Nat.Prime.dvd_iff_not_coprime
theorem Prime.dvd_iff_not_coprime {p n : ℕ} (pp : Prime p) : p ∣ n ↔ ¬Coprime p n 
Arguments: {p n : ℕ} (pp : Nat.Prime p)
Goal: p ∣ n ↔ ¬p.Coprime n
-- Nat.Prime.not_coprime_iff_dvd
theorem Prime.not_coprime_iff_dvd {m n : ℕ} : ¬Coprime m n ↔ ∃ p, Prime p ∧ p ∣ m ∧ p ∣ n 
Arguments: {m n : ℕ}
Goal: ¬m.Coprime n ↔ ∃ p, Nat.Prime p ∧ p ∣ m ∧ p ∣ n
-- Nat.Prime.not_dvd_mul
theorem Prime.not_dvd_mul {p m n : ℕ} (pp : Prime p) (Hm : ¬p ∣ m) (Hn : ¬p ∣ n) : ¬p ∣ m * n 
Arguments: {p m n : ℕ} (pp : Nat.Prime p) (Hm : ¬p ∣ m) (Hn : ¬p ∣ n)
Goal: ¬p ∣ m * n
-- Nat.coprime_two_left
@[simp] lemma coprime_two_left : Coprime 2 n ↔ Odd n 
Arguments: {n : ℕ}
Goal: Nat.Coprime 2 n ↔ Odd n
-- Nat.coprime_two_right
@[simp] lemma coprime_two_right : n.Coprime 2 ↔ Odd n 
Arguments: {n : ℕ}
Goal: n.Coprime 2 ↔ Odd n
-- Nat.Prime.dvd_of_dvd_pow
theorem Prime.dvd_of_dvd_pow {p m n : ℕ} (pp : Prime p) (h : p ∣ m ^ n) : p ∣ m 
Arguments: {p m n : ℕ} (pp : Nat.Prime p) (h : p ∣ m ^ n)
Goal: p ∣ m
-- Nat.Prime.not_prime_pow'
theorem Prime.not_prime_pow' {x n : ℕ} (hn : n ≠ 1) : ¬(x ^ n).Prime 
Arguments: {x n : ℕ} (hn : n ≠ 1)
Goal: ¬Nat.Prime (x ^ n)
-- Nat.Prime.not_prime_pow
theorem Prime.not_prime_pow {x n : ℕ} (hn : 2 ≤ n) : ¬(x ^ n).Prime 
Arguments: {x n : ℕ} (hn : 2 ≤ n)
Goal: ¬Nat.Prime (x ^ n)
-- Nat.Prime.eq_one_of_pow
theorem Prime.eq_one_of_pow {x n : ℕ} (h : (x ^ n).Prime) : n = 1 
Arguments: {x n : ℕ} (h : Nat.Prime (x ^ n))
Goal: n = 1
-- Nat.Prime.pow_eq_iff
theorem Prime.pow_eq_iff {p a k : ℕ} (hp : p.Prime) : a ^ k = p ↔ a = p ∧ k = 1 
Arguments: {p a k : ℕ} (hp : Nat.Prime p)
Goal: a ^ k = p ↔ a = p ∧ k = 1
-- Nat.pow_minFac
theorem pow_minFac {n k : ℕ} (hk : k ≠ 0) : (n ^ k).minFac = n.minFac 
Arguments: {n k : ℕ} (hk : k ≠ 0)
Goal: (n ^ k).minFac = n.minFac
-- Nat.Prime.pow_minFac
theorem Prime.pow_minFac {p k : ℕ} (hp : p.Prime) (hk : k ≠ 0) : (p ^ k).minFac = p 
Arguments: {p k : ℕ} (hp : Nat.Prime p) (hk : k ≠ 0)
Goal: (p ^ k).minFac = p
-- Nat.Prime.mul_eq_prime_sq_iff
theorem Prime.mul_eq_prime_sq_iff {x y p : ℕ} (hp : p.Prime) (hx : x ≠ 1) (hy : y ≠ 1) :
    x * y = p ^ 2 ↔ x = p ∧ y = p 
Arguments: {x y p : ℕ} (hp : Nat.Prime p) (hx : x ≠ 1) (hy : y ≠ 1)
Goal: x * y = p ^ 2 ↔ x = p ∧ y = p
-- Nat.Prime.dvd_factorial
theorem Prime.dvd_factorial : ∀ {n p : ℕ} (_ : Prime p), p ∣ n ! ↔ p ≤ n
  
Arguments: {n p : ℕ}
Goal: Nat.Prime p → (p ∣ n ! ↔ p ≤ n)
-- Nat.Prime.coprime_pow_of_not_dvd
theorem Prime.coprime_pow_of_not_dvd {p m a : ℕ} (pp : Prime p) (h : ¬p ∣ a) : Coprime a (p ^ m) 
Arguments: {p m a : ℕ} (pp : Nat.Prime p) (h : ¬p ∣ a)
Goal: a.Coprime (p ^ m)
-- Nat.coprime_primes
theorem coprime_primes {p q : ℕ} (pp : Prime p) (pq : Prime q) : Coprime p q ↔ p ≠ q 
Arguments: {p q : ℕ} (pp : Nat.Prime p) (pq : Nat.Prime q)
Goal: p.Coprime q ↔ p ≠ q
-- Nat.coprime_pow_primes
theorem coprime_pow_primes {p q : ℕ} (n m : ℕ) (pp : Prime p) (pq : Prime q) (h : p ≠ q) :
    Coprime (p ^ n) (q ^ m) 
Arguments: {p q : ℕ} (n m : ℕ) (pp : Nat.Prime p) (pq : Nat.Prime q) (h : p ≠ q)
Goal: (p ^ n).Coprime (q ^ m)
-- Nat.coprime_or_dvd_of_prime
theorem coprime_or_dvd_of_prime {p} (pp : Prime p) (i : ℕ) : Coprime p i ∨ p ∣ i 
Arguments: {p : ℕ} (pp : Nat.Prime p) (i : ℕ)
Goal: p.Coprime i ∨ p ∣ i
-- Nat.coprime_of_lt_prime
theorem coprime_of_lt_prime {n p} (n_pos : 0 < n) (hlt : n < p) (pp : Prime p) : Coprime p n 
Arguments: {n p : ℕ} (n_pos : 0 < n) (hlt : n < p) (pp : Nat.Prime p)
Goal: p.Coprime n
-- Nat.eq_or_coprime_of_le_prime
theorem eq_or_coprime_of_le_prime {n p} (n_pos : 0 < n) (hle : n ≤ p) (pp : Prime p) :
    p = n ∨ Coprime p n 
Arguments: {n p : ℕ} (n_pos : 0 < n) (hle : n ≤ p) (pp : Nat.Prime p)
Goal: p = n ∨ p.Coprime n
-- Nat.dvd_prime_pow
theorem dvd_prime_pow {p : ℕ} (pp : Prime p) {m i : ℕ} : i ∣ p ^ m ↔ ∃ k ≤ m, i = p ^ k 
Arguments: {p : ℕ} (pp : Nat.Prime p) {m i : ℕ}
Goal: i ∣ p ^ m ↔ ∃ k ≤ m, i = p ^ k
-- Nat.Prime.dvd_mul_of_dvd_ne
theorem Prime.dvd_mul_of_dvd_ne {p1 p2 n : ℕ} (h_neq : p1 ≠ p2) (pp1 : Prime p1) (pp2 : Prime p2)
    (h1 : p1 ∣ n) (h2 : p2 ∣ n) : p1 * p2 ∣ n 
Arguments: {p1 p2 n : ℕ} (h_neq : p1 ≠ p2) (pp1 : Nat.Prime p1) (pp2 : Nat.Prime p2) (h1 : p1 ∣ n) (h2 : p2 ∣ n)
Goal: p1 * p2 ∣ n
-- Nat.eq_prime_pow_of_dvd_least_prime_pow
theorem eq_prime_pow_of_dvd_least_prime_pow {a p k : ℕ} (pp : Prime p) (h₁ : ¬a ∣ p ^ k)
    (h₂ : a ∣ p ^ (k + 1)) : a = p ^ (k + 1) 
Arguments: {a p k : ℕ} (pp : Nat.Prime p) (h₁ : ¬a ∣ p ^ k) (h₂ : a ∣ p ^ (k + 1))
Goal: a = p ^ (k + 1)
-- Nat.ne_one_iff_exists_prime_dvd
theorem ne_one_iff_exists_prime_dvd : ∀ {n}, n ≠ 1 ↔ ∃ p : ℕ, p.Prime ∧ p ∣ n
  
Arguments: {n : ℕ}
Goal: n ≠ 1 ↔ ∃ p, Nat.Prime p ∧ p ∣ n
-- Nat.eq_one_iff_not_exists_prime_dvd
theorem eq_one_iff_not_exists_prime_dvd {n : ℕ} : n = 1 ↔ ∀ p : ℕ, p.Prime → ¬p ∣ n 
Arguments: {n : ℕ}
Goal: n = 1 ↔ ∀ (p : ℕ), Nat.Prime p → ¬p ∣ n
-- Nat.succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul
theorem succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul {p : ℕ} (p_prime : Prime p) {m n k l : ℕ}
    (hpm : p ^ k ∣ m) (hpn : p ^ l ∣ n) (hpmn : p ^ (k + l + 1) ∣ m * n) :
    p ^ (k + 1) ∣ m ∨ p ^ (l + 1) ∣ n 
Arguments: {p : ℕ} (p_prime : Nat.Prime p) {m n k l : ℕ} (hpm : p ^ k ∣ m) (hpn : p ^ l ∣ n) (hpmn : p ^ (k + l + 1) ∣ m * n)
Goal: p ^ (k + 1) ∣ m ∨ p ^ (l + 1) ∣ n
-- Nat.prime_iff_prime_int
theorem prime_iff_prime_int {p : ℕ} : p.Prime ↔ _root_.Prime (p : ℤ) 
Arguments: {p : ℕ}
Goal: Nat.Prime p ↔ Prime ↑p
-- Nat.Prime.pow_inj
lemma Prime.pow_inj {p q m n : ℕ} (hp : p.Prime) (hq : q.Prime)
    (h : p ^ (m + 1) = q ^ (n + 1)) : p = q ∧ m = n 
Arguments: {p q m n : ℕ} (hp : Nat.Prime p) (hq : Nat.Prime q) (h : p ^ (m + 1) = q ^ (n + 1))
Goal: p = q ∧ m = n
-- Nat.exists_pow_lt_factorial
theorem exists_pow_lt_factorial (c : ℕ) : ∃ n0 > 1, ∀ n ≥ n0, c ^ n < (n - 1)! 
Arguments: (c : ℕ)
Goal: ∃ n0 > 1, ∀ n ≥ n0, c ^ n < (n - 1)!
-- Nat.exists_mul_pow_lt_factorial
theorem exists_mul_pow_lt_factorial (a : ℕ) (c : ℕ) : ∃ n0, ∀ n ≥ n0, a * c ^ n < (n - 1)! 
Arguments: (a c : ℕ)
Goal: ∃ n0, ∀ n ≥ n0, a * c ^ n < (n - 1)!
-- Nat.exists_prime_mul_pow_lt_factorial
theorem exists_prime_mul_pow_lt_factorial (n a c : ℕ) : ∃ p > n, p.Prime ∧ a * c ^ p < (p - 1)! 
Arguments: (n a c : ℕ)
Goal: ∃ p > n, Nat.Prime p ∧ a * c ^ p < (p - 1)!
-- Int.prime_two
theorem prime_two : Prime (2 : ℤ) 
Goal: Prime 2
-- Int.prime_three
theorem prime_three : Prime (3 : ℤ) 
Goal: Prime 3