ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Commute.add_pow
theorem add_pow (h : Commute x y) (n : ℕ) :
    (x + y) ^ n = ∑ m ∈ range (n + 1), x ^ m * y ^ (n - m) * choose n m 
Arguments: {R : Type u_1} [Semiring R] {x y : R} (h : Commute x y) (n : ℕ)
Goal: (x + y) ^ n = ∑ m ∈ Finset.range (n + 1), x ^ m * y ^ (n - m) * ↑(n.choose m)
-- Commute.add_pow'
theorem add_pow' (h : Commute x y) (n : ℕ) :
    (x + y) ^ n = ∑ m ∈ antidiagonal n, choose n m.fst • (x ^ m.fst * y ^ m.snd) 
Arguments: {R : Type u_1} [Semiring R] {x y : R} (h : Commute x y) (n : ℕ)
Goal: (x + y) ^ n = ∑ m ∈ Finset.antidiagonal n, n.choose m.1 • (x ^ m.1 * y ^ m.2)
-- add_pow
theorem add_pow [CommSemiring R] (x y : R) (n : ℕ) :
    (x + y) ^ n = ∑ m ∈ range (n + 1), x ^ m * y ^ (n - m) * choose n m 
Arguments: {R : Type u_1} [CommSemiring R] (x y : R) (n : ℕ)
Goal: (x + y) ^ n = ∑ m ∈ Finset.range (n + 1), x ^ m * y ^ (n - m) * ↑(n.choose m)
-- Nat.sum_range_choose
theorem sum_range_choose (n : ℕ) : (∑ m ∈ range (n + 1), choose n m) = 2 ^ n 
Arguments: (n : ℕ)
Goal: ∑ m ∈ Finset.range (n + 1), n.choose m = 2 ^ n
-- Nat.sum_range_choose_halfway
theorem sum_range_choose_halfway (m : Nat) : (∑ i ∈ range (m + 1), choose (2 * m + 1) i) = 4 ^ m 
Arguments: (m : ℕ)
Goal: ∑ i ∈ Finset.range (m + 1), (2 * m + 1).choose i = 4 ^ m
-- Nat.choose_middle_le_pow
theorem choose_middle_le_pow (n : ℕ) : choose (2 * n + 1) n ≤ 4 ^ n 
Arguments: (n : ℕ)
Goal: (2 * n + 1).choose n ≤ 4 ^ n
-- Nat.four_pow_le_two_mul_add_one_mul_central_binom
theorem four_pow_le_two_mul_add_one_mul_central_binom (n : ℕ) :
    4 ^ n ≤ (2 * n + 1) * choose (2 * n) n 
Arguments: (n : ℕ)
Goal: 4 ^ n ≤ (2 * n + 1) * (2 * n).choose n
-- Nat.sum_Icc_choose
theorem sum_Icc_choose (n k : ℕ) : ∑ m ∈ Icc k n, m.choose k = (n + 1).choose (k + 1) 
Arguments: (n k : ℕ)
Goal: ∑ m ∈ Finset.Icc k n, m.choose k = (n + 1).choose (k + 1)
-- Int.alternating_sum_range_choose
theorem Int.alternating_sum_range_choose {n : ℕ} :
    (∑ m ∈ range (n + 1), ((-1) ^ m * ↑(choose n m) : ℤ)) = if n = 0 then 1 else 0 
Arguments: {n : ℕ}
Goal: ∑ m ∈ Finset.range (n + 1), (-1) ^ m * ↑(n.choose m) = if n = 0 then 1 else 0
-- Int.alternating_sum_range_choose_of_ne
theorem Int.alternating_sum_range_choose_of_ne {n : ℕ} (h0 : n ≠ 0) :
    (∑ m ∈ range (n + 1), ((-1) ^ m * ↑(choose n m) : ℤ)) = 0 
Arguments: {n : ℕ} (h0 : n ≠ 0)
Goal: ∑ m ∈ Finset.range (n + 1), (-1) ^ m * ↑(n.choose m) = 0
-- Finset.sum_powerset_apply_card
theorem sum_powerset_apply_card {α β : Type*} [AddCommMonoid α] (f : ℕ → α) {x : Finset β} :
    ∑ m ∈ x.powerset, f m.card = ∑ m ∈ range (x.card + 1), x.card.choose m • f m 
Arguments: {α : Type u_2} {β : Type u_3} [AddCommMonoid α] (f : ℕ → α) {x : Finset β}
Goal: ∑ m ∈ x.powerset, f m.card = ∑ m ∈ Finset.range (x.card + 1), x.card.choose m • f m
-- Finset.sum_powerset_neg_one_pow_card
theorem sum_powerset_neg_one_pow_card {α : Type*} [DecidableEq α] {x : Finset α} :
    (∑ m ∈ x.powerset, (-1 : ℤ) ^ m.card) = if x = ∅ then 1 else 0 
Arguments: {α : Type u_2} [DecidableEq α] {x : Finset α}
Goal: ∑ m ∈ x.powerset, (-1) ^ m.card = if x = ∅ then 1 else 0
-- Finset.sum_powerset_neg_one_pow_card_of_nonempty
theorem sum_powerset_neg_one_pow_card_of_nonempty {α : Type*} {x : Finset α} (h0 : x.Nonempty) :
    (∑ m ∈ x.powerset, (-1 : ℤ) ^ m.card) = 0 
Arguments: {α : Type u_2} {x : Finset α} (h0 : x.Nonempty)
Goal: ∑ m ∈ x.powerset, (-1) ^ m.card = 0
-- Finset.prod_pow_choose_succ
@[to_additive sum_choose_succ_nsmul]
theorem prod_pow_choose_succ {M : Type*} [CommMonoid M] (f : ℕ → ℕ → M) (n : ℕ) :
    (∏ i ∈ range (n + 2), f i (n + 1 - i) ^ (n + 1).choose i) =
      (∏ i ∈ range (n + 1), f i (n + 1 - i) ^ n.choose i) *
        ∏ i ∈ range (n + 1), f (i + 1) (n - i) ^ n.choose i 
Arguments: {M : Type u_4} [CommMonoid M] (f : ℕ → ℕ → M) (n : ℕ)
Goal: ∏ i ∈ Finset.range (n + 2), f i (n + 1 - i) ^ (n + 1).choose i =
  (∏ i ∈ Finset.range (n + 1), f i (n + 1 - i) ^ n.choose i) *
    ∏ i ∈ Finset.range (n + 1), f (i + 1) (n - i) ^ n.choose i
-- Finset.sum_choose_succ_nsmul
@[to_additive sum_choose_succ_nsmul]
theorem prod_pow_choose_succ {M : Type*} [CommMonoid M] (f : ℕ → ℕ → M) (n : ℕ) :
    (∏ i ∈ range (n + 2), f i (n + 1 - i) ^ (n + 1).choose i) =
      (∏ i ∈ range (n + 1), f i (n + 1 - i) ^ n.choose i) *
        ∏ i ∈ range (n + 1), f (i + 1) (n - i) ^ n.choose i 
Arguments: {M : Type u_4} [AddCommMonoid M] (f : ℕ → ℕ → M) (n : ℕ)
Goal: ∑ i ∈ Finset.range (n + 2), (n + 1).choose i • f i (n + 1 - i) =
  ∑ i ∈ Finset.range (n + 1), n.choose i • f i (n + 1 - i) + ∑ i ∈ Finset.range (n + 1), n.choose i • f (i + 1) (n - i)
-- Finset.prod_antidiagonal_pow_choose_succ
@[to_additive sum_antidiagonal_choose_succ_nsmul]
theorem prod_antidiagonal_pow_choose_succ {M : Type*} [CommMonoid M] (f : ℕ → ℕ → M) (n : ℕ) :
    (∏ ij ∈ antidiagonal (n + 1), f ij.1 ij.2 ^ (n + 1).choose ij.1) =
      (∏ ij ∈ antidiagonal n, f ij.1 (ij.2 + 1) ^ n.choose ij.1) *
        ∏ ij ∈ antidiagonal n, f (ij.1 + 1) ij.2 ^ n.choose ij.2 
Arguments: {M : Type u_4} [CommMonoid M] (f : ℕ → ℕ → M) (n : ℕ)
Goal: ∏ ij ∈ Finset.antidiagonal (n + 1), f ij.1 ij.2 ^ (n + 1).choose ij.1 =
  (∏ ij ∈ Finset.antidiagonal n, f ij.1 (ij.2 + 1) ^ n.choose ij.1) *
    ∏ ij ∈ Finset.antidiagonal n, f (ij.1 + 1) ij.2 ^ n.choose ij.2
-- Finset.sum_antidiagonal_choose_succ_nsmul
@[to_additive sum_antidiagonal_choose_succ_nsmul]
theorem prod_antidiagonal_pow_choose_succ {M : Type*} [CommMonoid M] (f : ℕ → ℕ → M) (n : ℕ) :
    (∏ ij ∈ antidiagonal (n + 1), f ij.1 ij.2 ^ (n + 1).choose ij.1) =
      (∏ ij ∈ antidiagonal n, f ij.1 (ij.2 + 1) ^ n.choose ij.1) *
        ∏ ij ∈ antidiagonal n, f (ij.1 + 1) ij.2 ^ n.choose ij.2 
Arguments: {M : Type u_4} [AddCommMonoid M] (f : ℕ → ℕ → M) (n : ℕ)
Goal: ∑ ij ∈ Finset.antidiagonal (n + 1), (n + 1).choose ij.1 • f ij.1 ij.2 =
  ∑ ij ∈ Finset.antidiagonal n, n.choose ij.1 • f ij.1 (ij.2 + 1) +
    ∑ ij ∈ Finset.antidiagonal n, n.choose ij.2 • f (ij.1 + 1) ij.2
-- Finset.sum_choose_succ_mul
theorem sum_choose_succ_mul (f : ℕ → ℕ → R) (n : ℕ) :
    (∑ i ∈ range (n + 2), ((n + 1).choose i : R) * f i (n + 1 - i)) =
      (∑ i ∈ range (n + 1), (n.choose i : R) * f i (n + 1 - i)) +
        ∑ i ∈ range (n + 1), (n.choose i : R) * f (i + 1) (n - i) 
Arguments: {R : Type u_3} [NonAssocSemiring R] (f : ℕ → ℕ → R) (n : ℕ)
Goal: ∑ i ∈ Finset.range (n + 2), ↑((n + 1).choose i) * f i (n + 1 - i) =
  ∑ i ∈ Finset.range (n + 1), ↑(n.choose i) * f i (n + 1 - i) +
    ∑ i ∈ Finset.range (n + 1), ↑(n.choose i) * f (i + 1) (n - i)
-- Finset.sum_antidiagonal_choose_succ_mul
theorem sum_antidiagonal_choose_succ_mul (f : ℕ → ℕ → R) (n : ℕ) :
    (∑ ij ∈ antidiagonal (n + 1), ((n + 1).choose ij.1 : R) * f ij.1 ij.2) =
      (∑ ij ∈ antidiagonal n, (n.choose ij.1 : R) * f ij.1 (ij.2 + 1)) +
        ∑ ij ∈ antidiagonal n, (n.choose ij.2 : R) * f (ij.1 + 1) ij.2 
Arguments: {R : Type u_3} [NonAssocSemiring R] (f : ℕ → ℕ → R) (n : ℕ)
Goal: ∑ ij ∈ Finset.antidiagonal (n + 1), ↑((n + 1).choose ij.1) * f ij.1 ij.2 =
  ∑ ij ∈ Finset.antidiagonal n, ↑(n.choose ij.1) * f ij.1 (ij.2 + 1) +
    ∑ ij ∈ Finset.antidiagonal n, ↑(n.choose ij.2) * f (ij.1 + 1) ij.2
-- Finset.sum_antidiagonal_choose_add
theorem sum_antidiagonal_choose_add (d n : ℕ) :
    (Finset.sum (antidiagonal n) fun ij => (d + ij.2).choose d) =
    (d + n).choose d + (d + n).choose (succ d) 
Arguments: (d n : ℕ)
Goal: ∑ ij ∈ Finset.antidiagonal n, (d + ij.2).choose d = (d + n).choose d + (d + n).choose d.succ
-- Nat.cast_ascFactorial
theorem cast_ascFactorial : (a.ascFactorial b : S) = (ascPochhammer S b).eval (a : S) 
Arguments: (S : Type u_1) [Semiring S] (a b : ℕ)
Goal: ↑(a.ascFactorial b) = Polynomial.eval (↑a) (ascPochhammer S b)
-- Nat.cast_descFactorial
theorem cast_descFactorial :
    (a.descFactorial b : S) = (ascPochhammer S b).eval (a - (b - 1) : S) 
Arguments: (S : Type u_1) [Semiring S] (a b : ℕ)
Goal: ↑(a.descFactorial b) = Polynomial.eval (↑(a - (b - 1))) (ascPochhammer S b)
-- Nat.cast_factorial
theorem cast_factorial : (a ! : S) = (ascPochhammer S a).eval 1 
Arguments: (S : Type u_1) [Semiring S] (a : ℕ)
Goal: ↑a ! = Polynomial.eval 1 (ascPochhammer S a)
-- Nat.cast_descFactorial_two
theorem cast_descFactorial_two : (a.descFactorial 2 : S) = a * (a - 1) 
Arguments: (S : Type u_1) [Ring S] (a : ℕ)
Goal: ↑(a.descFactorial 2) = ↑a * (↑a - 1)
-- Nat.Upto.wf
protected theorem wf : (∃ x, p x) → WellFounded (Upto.GT p)
  
Arguments: {p : ℕ → Prop}
Goal: (∃ x, p x) → WellFounded (Nat.Upto.GT p)
-- Nat.irreducible_iff_nat_prime
theorem irreducible_iff_nat_prime (a : ℕ) : Irreducible a ↔ Nat.Prime a 
Arguments: (a : ℕ)
Goal: Irreducible a ↔ Nat.Prime a
-- Nat.not_prime_zero
@[aesop safe destruct] theorem not_prime_zero : ¬Prime 0
  
Goal: ¬Nat.Prime 0
-- Nat.not_prime_one
@[aesop safe destruct] theorem not_prime_one : ¬Prime 1
  
Goal: ¬Nat.Prime 1
-- Nat.Prime.ne_zero
theorem Prime.ne_zero {n : ℕ} (h : Prime n) : n ≠ 0 
Arguments: {n : ℕ} (h : Nat.Prime n)
Goal: n ≠ 0
-- Nat.Prime.pos
theorem Prime.pos {p : ℕ} (pp : Prime p) : 0 < p 
Arguments: {p : ℕ} (pp : Nat.Prime p)
Goal: 0 < p
-- Nat.Prime.two_le
theorem Prime.two_le : ∀ {p : ℕ}, Prime p → 2 ≤ p
  
Arguments: {p : ℕ}
Goal: Nat.Prime p → 2 ≤ p
-- Nat.Prime.one_lt
theorem Prime.one_lt {p : ℕ} : Prime p → 1 < p 
Arguments: {p : ℕ}
Goal: Nat.Prime p → 1 < p
-- Nat.Prime.one_le
lemma Prime.one_le {p : ℕ} (hp : p.Prime) : 1 ≤ p 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: 1 ≤ p
-- Nat.Prime.ne_one
theorem Prime.ne_one {p : ℕ} (hp : p.Prime) : p ≠ 1 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: p ≠ 1
-- Nat.Prime.eq_one_or_self_of_dvd
theorem Prime.eq_one_or_self_of_dvd {p : ℕ} (pp : p.Prime) (m : ℕ) (hm : m ∣ p) :
    m = 1 ∨ m = p 
Arguments: {p : ℕ} (pp : Nat.Prime p) (m : ℕ) (hm : m ∣ p)
Goal: m = 1 ∨ m = p
-- Nat.prime_def_lt''
theorem prime_def_lt'' {p : ℕ} : Prime p ↔ 2 ≤ p ∧ ∀ m, m ∣ p → m = 1 ∨ m = p 
Arguments: {p : ℕ}
Goal: Nat.Prime p ↔ 2 ≤ p ∧ ∀ (m : ℕ), m ∣ p → m = 1 ∨ m = p
-- Nat.prime_def_lt
theorem prime_def_lt {p : ℕ} : Prime p ↔ 2 ≤ p ∧ ∀ m < p, m ∣ p → m = 1 
Arguments: {p : ℕ}
Goal: Nat.Prime p ↔ 2 ≤ p ∧ ∀ (m : ℕ), m < p → m ∣ p → m = 1
-- Nat.prime_def_lt'
theorem prime_def_lt' {p : ℕ} : Prime p ↔ 2 ≤ p ∧ ∀ m, 2 ≤ m → m < p → ¬m ∣ p 
Arguments: {p : ℕ}
Goal: Nat.Prime p ↔ 2 ≤ p ∧ ∀ (m : ℕ), 2 ≤ m → m < p → ¬m ∣ p
-- Nat.prime_def_le_sqrt
theorem prime_def_le_sqrt {p : ℕ} : Prime p ↔ 2 ≤ p ∧ ∀ m, 2 ≤ m → m ≤ sqrt p → ¬m ∣ p 
Arguments: {p : ℕ}
Goal: Nat.Prime p ↔ 2 ≤ p ∧ ∀ (m : ℕ), 2 ≤ m → m ≤ p.sqrt → ¬m ∣ p
-- Nat.prime_of_coprime
theorem prime_of_coprime (n : ℕ) (h1 : 1 < n) (h : ∀ m < n, m ≠ 0 → n.Coprime m) : Prime n 
Arguments: (n : ℕ) (h1 : 1 < n) (h : ∀ (m : ℕ), m < n → m ≠ 0 → n.Coprime m)
Goal: Nat.Prime n
-- Nat.prime_two
theorem prime_two : Prime 2 
Goal: Nat.Prime 2
-- Nat.prime_three
theorem prime_three : Prime 3 
Goal: Nat.Prime 3
-- Nat.prime_five
theorem prime_five : Prime 5 
Goal: Nat.Prime 5
-- Nat.dvd_prime
theorem dvd_prime {p m : ℕ} (pp : Prime p) : m ∣ p ↔ m = 1 ∨ m = p 
Arguments: {p m : ℕ} (pp : Nat.Prime p)
Goal: m ∣ p ↔ m = 1 ∨ m = p
-- Nat.dvd_prime_two_le
theorem dvd_prime_two_le {p m : ℕ} (pp : Prime p) (H : 2 ≤ m) : m ∣ p ↔ m = p 
Arguments: {p m : ℕ} (pp : Nat.Prime p) (H : 2 ≤ m)
Goal: m ∣ p ↔ m = p
-- Nat.prime_dvd_prime_iff_eq
theorem prime_dvd_prime_iff_eq {p q : ℕ} (pp : p.Prime) (qp : q.Prime) : p ∣ q ↔ p = q 
Arguments: {p q : ℕ} (pp : Nat.Prime p) (qp : Nat.Prime q)
Goal: p ∣ q ↔ p = q
-- Nat.Prime.not_dvd_one
theorem Prime.not_dvd_one {p : ℕ} (pp : Prime p) : ¬p ∣ 1 
Arguments: {p : ℕ} (pp : Nat.Prime p)
Goal: ¬p ∣ 1
-- Nat.prime_mul_iff
theorem prime_mul_iff {a b : ℕ} : Nat.Prime (a * b) ↔ a.Prime ∧ b = 1 ∨ b.Prime ∧ a = 1 
Arguments: {a b : ℕ}
Goal: Nat.Prime (a * b) ↔ Nat.Prime a ∧ b = 1 ∨ Nat.Prime b ∧ a = 1
-- Nat.not_prime_mul
theorem not_prime_mul {a b : ℕ} (a1 : a ≠ 1) (b1 : b ≠ 1) : ¬Prime (a * b) 
Arguments: {a b : ℕ} (a1 : a ≠ 1) (b1 : b ≠ 1)
Goal: ¬Nat.Prime (a * b)
-- Nat.not_prime_mul'
theorem not_prime_mul' {a b n : ℕ} (h : a * b = n) (h₁ : a ≠ 1) (h₂ : b ≠ 1) : ¬Prime n 
Arguments: {a b n : ℕ} (h : a * b = n) (h₁ : a ≠ 1) (h₂ : b ≠ 1)
Goal: ¬Nat.Prime n
-- Nat.Prime.dvd_iff_eq
theorem Prime.dvd_iff_eq {p a : ℕ} (hp : p.Prime) (a1 : a ≠ 1) : a ∣ p ↔ p = a 
Arguments: {p a : ℕ} (hp : Nat.Prime p) (a1 : a ≠ 1)
Goal: a ∣ p ↔ p = a
-- Nat.Prime.eq_two_or_odd
theorem Prime.eq_two_or_odd {p : ℕ} (hp : Prime p) : p = 2 ∨ p % 2 = 1 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: p = 2 ∨ p % 2 = 1
-- Nat.Prime.eq_two_or_odd'
theorem Prime.eq_two_or_odd' {p : ℕ} (hp : Prime p) : p = 2 ∨ Odd p 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: p = 2 ∨ Odd p
-- Nat.minFac_lemma
theorem minFac_lemma (n k : ℕ) (h : ¬n < k * k) : sqrt n - k < sqrt n + 2 - k 
Arguments: (n k : ℕ) (h : ¬n < k * k)
Goal: n.sqrt - k < n.sqrt + 2 - k
-- Nat.minFac_zero
@[simp]
theorem minFac_zero : minFac 0 = 2 
Goal: Nat.minFac 0 = 2
-- Nat.minFac_one
@[simp]
theorem minFac_one : minFac 1 = 1 
Goal: Nat.minFac 1 = 1
-- Nat.minFac_two
@[simp]
theorem minFac_two : minFac 2 = 2 
Goal: Nat.minFac 2 = 2
-- Nat.minFac_eq
theorem minFac_eq (n : ℕ) : minFac n = if 2 ∣ n then 2 else minFacAux n 3 
Arguments: (n : ℕ)
Goal: n.minFac = if 2 ∣ n then 2 else n.minFacAux 3
-- Nat.minFacAux_has_prop
theorem minFacAux_has_prop {n : ℕ} (n2 : 2 ≤ n) :
    ∀ k i, k = 2 * i + 3 → (∀ m, 2 ≤ m → m ∣ n → k ≤ m) → minFacProp n (minFacAux n k)
  
Arguments: {n : ℕ} (n2 : 2 ≤ n) (k i : ℕ)
Goal: k = 2 * i + 3 → (∀ (m : ℕ), 2 ≤ m → m ∣ n → k ≤ m) → Nat.minFacProp n (n.minFacAux k)
-- Nat.minFac_has_prop
theorem minFac_has_prop {n : ℕ} (n1 : n ≠ 1) : minFacProp n (minFac n) 
Arguments: {n : ℕ} (n1 : n ≠ 1)
Goal: Nat.minFacProp n n.minFac
-- Nat.minFac_dvd
theorem minFac_dvd (n : ℕ) : minFac n ∣ n 
Arguments: (n : ℕ)
Goal: n.minFac ∣ n
-- Nat.minFac_prime
theorem minFac_prime {n : ℕ} (n1 : n ≠ 1) : Prime (minFac n) 
Arguments: {n : ℕ} (n1 : n ≠ 1)
Goal: Nat.Prime n.minFac
-- Nat.minFac_le_of_dvd
theorem minFac_le_of_dvd {n : ℕ} : ∀ {m : ℕ}, 2 ≤ m → m ∣ n → minFac n ≤ m 
Arguments: {n m : ℕ}
Goal: 2 ≤ m → m ∣ n → n.minFac ≤ m
-- Nat.minFac_pos
theorem minFac_pos (n : ℕ) : 0 < minFac n 
Arguments: (n : ℕ)
Goal: 0 < n.minFac
-- Nat.minFac_le
theorem minFac_le {n : ℕ} (H : 0 < n) : minFac n ≤ n 
Arguments: {n : ℕ} (H : 0 < n)
Goal: n.minFac ≤ n
-- Nat.le_minFac
theorem le_minFac {m n : ℕ} : n = 1 ∨ m ≤ minFac n ↔ ∀ p, Prime p → p ∣ n → m ≤ p 
Arguments: {m n : ℕ}
Goal: n = 1 ∨ m ≤ n.minFac ↔ ∀ (p : ℕ), Nat.Prime p → p ∣ n → m ≤ p
-- Nat.le_minFac'
theorem le_minFac' {m n : ℕ} : n = 1 ∨ m ≤ minFac n ↔ ∀ p, 2 ≤ p → p ∣ n → m ≤ p 
Arguments: {m n : ℕ}
Goal: n = 1 ∨ m ≤ n.minFac ↔ ∀ (p : ℕ), 2 ≤ p → p ∣ n → m ≤ p
-- Nat.prime_def_minFac
theorem prime_def_minFac {p : ℕ} : Prime p ↔ 2 ≤ p ∧ minFac p = p 
Arguments: {p : ℕ}
Goal: Nat.Prime p ↔ 2 ≤ p ∧ p.minFac = p
-- Nat.Prime.minFac_eq
@[simp]
theorem Prime.minFac_eq {p : ℕ} (hp : Prime p) : minFac p = p 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: p.minFac = p
-- Nat.not_prime_iff_minFac_lt
theorem not_prime_iff_minFac_lt {n : ℕ} (n2 : 2 ≤ n) : ¬Prime n ↔ minFac n < n 
Arguments: {n : ℕ} (n2 : 2 ≤ n)
Goal: ¬Nat.Prime n ↔ n.minFac < n
-- Nat.minFac_le_div
theorem minFac_le_div {n : ℕ} (pos : 0 < n) (np : ¬Prime n) : minFac n ≤ n / minFac n 
Arguments: {n : ℕ} (pos : 0 < n) (np : ¬Nat.Prime n)
Goal: n.minFac ≤ n / n.minFac
-- Nat.minFac_sq_le_self
theorem minFac_sq_le_self {n : ℕ} (w : 0 < n) (h : ¬Prime n) : minFac n ^ 2 ≤ n 
Arguments: {n : ℕ} (w : 0 < n) (h : ¬Nat.Prime n)
Goal: n.minFac ^ 2 ≤ n
-- Nat.minFac_eq_one_iff
@[simp]
theorem minFac_eq_one_iff {n : ℕ} : minFac n = 1 ↔ n = 1 
Arguments: {n : ℕ}
Goal: n.minFac = 1 ↔ n = 1
-- Nat.minFac_eq_two_iff
@[simp]
theorem minFac_eq_two_iff (n : ℕ) : minFac n = 2 ↔ 2 ∣ n 
Arguments: (n : ℕ)
Goal: n.minFac = 2 ↔ 2 ∣ n
-- Nat.factors_lemma
theorem factors_lemma {k} : (k + 2) / minFac (k + 2) < k + 2 
Arguments: {k : ℕ}
Goal: (k + 2) / (k + 2).minFac < k + 2
-- Nat.exists_prime_and_dvd
theorem exists_prime_and_dvd {n : ℕ} (hn : n ≠ 1) : ∃ p, Prime p ∧ p ∣ n 
Arguments: {n : ℕ} (hn : n ≠ 1)
Goal: ∃ p, Nat.Prime p ∧ p ∣ n
-- Nat.coprime_of_dvd
theorem coprime_of_dvd {m n : ℕ} (H : ∀ k, Prime k → k ∣ m → ¬k ∣ n) : Coprime m n 
Arguments: {m n : ℕ} (H : ∀ (k : ℕ), Nat.Prime k → k ∣ m → ¬k ∣ n)
Goal: m.Coprime n
-- Nat.Prime.coprime_iff_not_dvd
theorem Prime.coprime_iff_not_dvd {p n : ℕ} (pp : Prime p) : Coprime p n ↔ ¬p ∣ n 
Arguments: {p n : ℕ} (pp : Nat.Prime p)
Goal: p.Coprime n ↔ ¬p ∣ n
-- Nat.Prime.dvd_mul
theorem Prime.dvd_mul {p m n : ℕ} (pp : Prime p) : p ∣ m * n ↔ p ∣ m ∨ p ∣ n 
Arguments: {p m n : ℕ} (pp : Nat.Prime p)
Goal: p ∣ m * n ↔ p ∣ m ∨ p ∣ n
-- Nat.prime_iff
theorem prime_iff {p : ℕ} : p.Prime ↔ _root_.Prime p 
Arguments: {p : ℕ}
Goal: Nat.Prime p ↔ Prime p
-- Nat.irreducible_iff_prime
theorem irreducible_iff_prime {p : ℕ} : Irreducible p ↔ _root_.Prime p 
Arguments: {p : ℕ}
Goal: Irreducible p ↔ Prime p
-- Nat.Primes.coe_nat_injective
theorem coe_nat_injective : Function.Injective (fun (a : Nat.Primes) ↦ (a : ℕ)) 
Goal: Function.Injective fun a => ↑a
-- Nat.Primes.coe_nat_inj
theorem coe_nat_inj (p q : Nat.Primes) : (p : ℕ) = (q : ℕ) ↔ p = q 
Arguments: (p q : Nat.Primes)
Goal: ↑p = ↑q ↔ p = q
-- Nat.doubleFactorial_pos
lemma doubleFactorial_pos : ∀ n, 0 < n‼
  
Arguments: (n : ℕ)
Goal: 0 < n‼
-- Nat.doubleFactorial_add_two
theorem doubleFactorial_add_two (n : ℕ) : (n + 2)‼ = (n + 2) * n‼ 
Arguments: (n : ℕ)
Goal: (n + 2)‼ = (n + 2) * n‼
-- Nat.doubleFactorial_add_one
theorem doubleFactorial_add_one (n : ℕ) : (n + 1)‼ = (n + 1) * (n - 1)‼ 
Arguments: (n : ℕ)
Goal: (n + 1)‼ = (n + 1) * (n - 1)‼
-- Nat.factorial_eq_mul_doubleFactorial
theorem factorial_eq_mul_doubleFactorial : ∀ n : ℕ, (n + 1)! = (n + 1)‼ * n‼
  
Arguments: (n : ℕ)
Goal: (n + 1)! = (n + 1)‼ * n‼
-- Nat.doubleFactorial_le_factorial
lemma doubleFactorial_le_factorial : ∀ n, n‼ ≤ n !
  
Arguments: (n : ℕ)
Goal: n‼ ≤ n !
-- Nat.doubleFactorial_two_mul
theorem doubleFactorial_two_mul : ∀ n : ℕ, (2 * n)‼ = 2 ^ n * n !
  
Arguments: (n : ℕ)
Goal: (2 * n)‼ = 2 ^ n * n !
-- Nat.doubleFactorial_eq_prod_even
theorem doubleFactorial_eq_prod_even : ∀ n : ℕ, (2 * n)‼ = ∏ i ∈ Finset.range n, 2 * (i + 1)
  
Arguments: (n : ℕ)
Goal: (2 * n)‼ = ∏ i ∈ Finset.range n, 2 * (i + 1)
-- Nat.doubleFactorial_eq_prod_odd
theorem doubleFactorial_eq_prod_odd :
    ∀ n : ℕ, (2 * n + 1)‼ = ∏ i ∈ Finset.range n, (2 * (i + 1) + 1)
  
Arguments: (n : ℕ)
Goal: (2 * n + 1)‼ = ∏ i ∈ Finset.range n, (2 * (i + 1) + 1)
-- Nat.nth_of_card_le
theorem nth_of_card_le (hf : (setOf p).Finite) {n : ℕ} (hn : hf.toFinset.card ≤ n) :
    nth p n = 0 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite) {n : ℕ} (hn : hf.toFinset.card ≤ n)
Goal: Nat.nth p n = 0
-- Nat.nth_eq_getD_sort
theorem nth_eq_getD_sort (h : (setOf p).Finite) (n : ℕ) :
    nth p n = (h.toFinset.sort (· ≤ ·)).getD n 0 
Arguments: {p : ℕ → Prop} (h : (setOf p).Finite) (n : ℕ)
Goal: Nat.nth p n = (Finset.sort (fun x x_1 => x ≤ x_1) h.toFinset).getD n 0
-- Nat.nth_eq_orderEmbOfFin
theorem nth_eq_orderEmbOfFin (hf : (setOf p).Finite) {n : ℕ} (hn : n < hf.toFinset.card) :
    nth p n = hf.toFinset.orderEmbOfFin rfl ⟨n, hn⟩ 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite) {n : ℕ} (hn : n < hf.toFinset.card)
Goal: Nat.nth p n = (hf.toFinset.orderEmbOfFin ⋯) ⟨n, hn⟩
-- Nat.nth_strictMonoOn
theorem nth_strictMonoOn (hf : (setOf p).Finite) :
    StrictMonoOn (nth p) (Set.Iio hf.toFinset.card) 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite)
Goal: StrictMonoOn (Nat.nth p) (Set.Iio hf.toFinset.card)
-- Nat.nth_lt_nth_of_lt_card
theorem nth_lt_nth_of_lt_card (hf : (setOf p).Finite) {m n : ℕ} (h : m < n)
    (hn : n < hf.toFinset.card) : nth p m < nth p n 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite) {m n : ℕ} (h : m < n) (hn : n < hf.toFinset.card)
Goal: Nat.nth p m < Nat.nth p n
-- Nat.nth_le_nth_of_lt_card
theorem nth_le_nth_of_lt_card (hf : (setOf p).Finite) {m n : ℕ} (h : m ≤ n)
    (hn : n < hf.toFinset.card) : nth p m ≤ nth p n 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite) {m n : ℕ} (h : m ≤ n) (hn : n < hf.toFinset.card)
Goal: Nat.nth p m ≤ Nat.nth p n
-- Nat.lt_of_nth_lt_nth_of_lt_card
theorem lt_of_nth_lt_nth_of_lt_card (hf : (setOf p).Finite) {m n : ℕ} (h : nth p m < nth p n)
    (hm : m < hf.toFinset.card) : m < n 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite) {m n : ℕ} (h : Nat.nth p m < Nat.nth p n) (hm : m < hf.toFinset.card)
Goal: m < n
-- Nat.le_of_nth_le_nth_of_lt_card
theorem le_of_nth_le_nth_of_lt_card (hf : (setOf p).Finite) {m n : ℕ} (h : nth p m ≤ nth p n)
    (hm : m < hf.toFinset.card) : m ≤ n 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite) {m n : ℕ} (h : Nat.nth p m ≤ Nat.nth p n) (hm : m < hf.toFinset.card)
Goal: m ≤ n
-- Nat.nth_injOn
theorem nth_injOn (hf : (setOf p).Finite) : (Set.Iio hf.toFinset.card).InjOn (nth p) 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite)
Goal: Set.InjOn (Nat.nth p) (Set.Iio hf.toFinset.card)
-- Nat.range_nth_of_finite
theorem range_nth_of_finite (hf : (setOf p).Finite) : Set.range (nth p) = insert 0 (setOf p) 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite)
Goal: Set.range (Nat.nth p) = insert 0 (setOf p)
-- Nat.image_nth_Iio_card
@[simp]
theorem image_nth_Iio_card (hf : (setOf p).Finite) : nth p '' Set.Iio hf.toFinset.card = setOf p 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite)
Goal: Nat.nth p '' Set.Iio hf.toFinset.card = setOf p
-- Nat.nth_mem_of_lt_card
theorem nth_mem_of_lt_card {n : ℕ} (hf : (setOf p).Finite) (hlt : n < hf.toFinset.card) :
    p (nth p n) 
Arguments: {p : ℕ → Prop} {n : ℕ} (hf : (setOf p).Finite) (hlt : n < hf.toFinset.card)
Goal: p (Nat.nth p n)
-- Nat.exists_lt_card_finite_nth_eq
theorem exists_lt_card_finite_nth_eq (hf : (setOf p).Finite) {x} (h : p x) :
    ∃ n, n < hf.toFinset.card ∧ nth p n = x 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Finite) {x : ℕ} (h : p x)
Goal: ∃ n < hf.toFinset.card, Nat.nth p n = x
-- Nat.nth_apply_eq_orderIsoOfNat
theorem nth_apply_eq_orderIsoOfNat (hf : (setOf p).Infinite) (n : ℕ) :
    nth p n = @Nat.Subtype.orderIsoOfNat (setOf p) hf.to_subtype n 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Infinite) (n : ℕ)
Goal: Nat.nth p n = ↑((Nat.Subtype.orderIsoOfNat (setOf p)) n)
-- Nat.nth_eq_orderIsoOfNat
theorem nth_eq_orderIsoOfNat (hf : (setOf p).Infinite) :
    nth p = (↑) ∘ @Nat.Subtype.orderIsoOfNat (setOf p) hf.to_subtype 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Infinite)
Goal: Nat.nth p = Subtype.val ∘ ⇑(Nat.Subtype.orderIsoOfNat (setOf p))
-- Nat.nth_strictMono
theorem nth_strictMono (hf : (setOf p).Infinite) : StrictMono (nth p) 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Infinite)
Goal: StrictMono (Nat.nth p)
-- Nat.nth_injective
theorem nth_injective (hf : (setOf p).Infinite) : Function.Injective (nth p) 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Infinite)
Goal: Function.Injective (Nat.nth p)
-- Nat.nth_monotone
theorem nth_monotone (hf : (setOf p).Infinite) : Monotone (nth p) 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Infinite)
Goal: Monotone (Nat.nth p)
-- Nat.nth_lt_nth
theorem nth_lt_nth (hf : (setOf p).Infinite) {k n} : nth p k < nth p n ↔ k < n 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Infinite) {k n : ℕ}
Goal: Nat.nth p k < Nat.nth p n ↔ k < n
-- Nat.nth_le_nth
theorem nth_le_nth (hf : (setOf p).Infinite) {k n} : nth p k ≤ nth p n ↔ k ≤ n 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Infinite) {k n : ℕ}
Goal: Nat.nth p k ≤ Nat.nth p n ↔ k ≤ n
-- Nat.range_nth_of_infinite
theorem range_nth_of_infinite (hf : (setOf p).Infinite) : Set.range (nth p) = setOf p 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Infinite)
Goal: Set.range (Nat.nth p) = setOf p
-- Nat.nth_mem_of_infinite
theorem nth_mem_of_infinite (hf : (setOf p).Infinite) (n : ℕ) : p (nth p n) 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Infinite) (n : ℕ)
Goal: p (Nat.nth p n)
-- Nat.exists_lt_card_nth_eq
theorem exists_lt_card_nth_eq {x} (h : p x) :
    ∃ n, (∀ hf : (setOf p).Finite, n < hf.toFinset.card) ∧ nth p n = x 
Arguments: {p : ℕ → Prop} {x : ℕ} (h : p x)
Goal: ∃ n, (∀ (hf : (setOf p).Finite), n < hf.toFinset.card) ∧ Nat.nth p n = x
-- Nat.subset_range_nth
theorem subset_range_nth : setOf p ⊆ Set.range (nth p) 
Arguments: {p : ℕ → Prop}
Goal: setOf p ⊆ Set.range (Nat.nth p)
-- Nat.range_nth_subset
theorem range_nth_subset : Set.range (nth p) ⊆ insert 0 (setOf p) 
Arguments: {p : ℕ → Prop}
Goal: Set.range (Nat.nth p) ⊆ insert 0 (setOf p)