ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.smoothNumbersUpTo_card_le
lemma smoothNumbersUpTo_card_le (N k : ℕ) :
    (smoothNumbersUpTo N k).card ≤ 2 ^ k.primesBelow.card * N.sqrt 
Arguments: (N k : ℕ)
Goal: (N.smoothNumbersUpTo k).card ≤ 2 ^ k.primesBelow.card * N.sqrt
-- Nat.roughNumbersUpTo_eq_biUnion
lemma roughNumbersUpTo_eq_biUnion (N k) :
    roughNumbersUpTo N k =
      (N.succ.primesBelow \ k.primesBelow).biUnion
        fun p ↦ (Finset.range N.succ).filter (fun m ↦ m ≠ 0 ∧ p ∣ m) 
Arguments: (N k : ℕ)
Goal: N.roughNumbersUpTo k =
  (N.succ.primesBelow \ k.primesBelow).biUnion fun p => Finset.filter (fun m => m ≠ 0 ∧ p ∣ m) (Finset.range N.succ)
-- Nat.roughNumbersUpTo_card_le
lemma roughNumbersUpTo_card_le (N k : ℕ) :
    (roughNumbersUpTo N k).card ≤ (N.succ.primesBelow \ k.primesBelow).sum (fun p ↦ N / p) 
Arguments: (N k : ℕ)
Goal: (N.roughNumbersUpTo k).card ≤ ∑ p ∈ N.succ.primesBelow \ k.primesBelow, N / p
-- ADEInequality.sumInv_pqr
theorem sumInv_pqr (p q r : ℕ+) : sumInv {p, q, r} = (p : ℚ)⁻¹ + (q : ℚ)⁻¹ + (r : ℚ)⁻¹ 
Arguments: (p q r : ℕ+)
Goal: ADEInequality.sumInv {p, q, r} = (↑↑p)⁻¹ + (↑↑q)⁻¹ + (↑↑r)⁻¹
-- ADEInequality.admissible_A'
theorem admissible_A' (q r : ℕ+) : Admissible (A' q r) 
Arguments: (q r : ℕ+)
Goal: ADEInequality.Admissible (ADEInequality.A' q r)
-- ADEInequality.admissible_D'
theorem admissible_D' (n : ℕ+) : Admissible (D' n) 
Arguments: (n : ℕ+)
Goal: ADEInequality.Admissible (ADEInequality.D' n)
-- ADEInequality.admissible_E'3
theorem admissible_E'3 : Admissible (E' 3) 
Goal: ADEInequality.Admissible (ADEInequality.E' 3)
-- ADEInequality.admissible_E'4
theorem admissible_E'4 : Admissible (E' 4) 
Goal: ADEInequality.Admissible (ADEInequality.E' 4)
-- ADEInequality.admissible_E'5
theorem admissible_E'5 : Admissible (E' 5) 
Goal: ADEInequality.Admissible (ADEInequality.E' 5)
-- ADEInequality.admissible_E6
theorem admissible_E6 : Admissible E6 
Goal: ADEInequality.Admissible ADEInequality.E6
-- ADEInequality.admissible_E7
theorem admissible_E7 : Admissible E7 
Goal: ADEInequality.Admissible ADEInequality.E7
-- ADEInequality.admissible_E8
theorem admissible_E8 : Admissible E8 
Goal: ADEInequality.Admissible ADEInequality.E8
-- ADEInequality.Admissible.one_lt_sumInv
theorem Admissible.one_lt_sumInv {pqr : Multiset ℕ+} : Admissible pqr → 1 < sumInv pqr 
Arguments: {pqr : Multiset ℕ+}
Goal: ADEInequality.Admissible pqr → 1 < ADEInequality.sumInv pqr
-- ADEInequality.lt_three
theorem lt_three {p q r : ℕ+} (hpq : p ≤ q) (hqr : q ≤ r) (H : 1 < sumInv {p, q, r}) : p < 3 
Arguments: {p q r : ℕ+} (hpq : p ≤ q) (hqr : q ≤ r) (H : 1 < ADEInequality.sumInv {p, q, r})
Goal: p < 3
-- ADEInequality.lt_four
theorem lt_four {q r : ℕ+} (hqr : q ≤ r) (H : 1 < sumInv {2, q, r}) : q < 4 
Arguments: {q r : ℕ+} (hqr : q ≤ r) (H : 1 < ADEInequality.sumInv {2, q, r})
Goal: q < 4
-- ADEInequality.lt_six
theorem lt_six {r : ℕ+} (H : 1 < sumInv {2, 3, r}) : r < 6 
Arguments: {r : ℕ+} (H : 1 < ADEInequality.sumInv {2, 3, r})
Goal: r < 6
-- ADEInequality.admissible_of_one_lt_sumInv_aux'
theorem admissible_of_one_lt_sumInv_aux' {p q r : ℕ+} (hpq : p ≤ q) (hqr : q ≤ r)
    (H : 1 < sumInv {p, q, r}) : Admissible {p, q, r} 
Arguments: {p q r : ℕ+} (hpq : p ≤ q) (hqr : q ≤ r) (H : 1 < ADEInequality.sumInv {p, q, r})
Goal: ADEInequality.Admissible {p, q, r}
-- ADEInequality.admissible_of_one_lt_sumInv_aux
theorem admissible_of_one_lt_sumInv_aux :
    ∀ {pqr : List ℕ+} (_ : pqr.Sorted (· ≤ ·)) (_ : pqr.length = 3) (_ : 1 < sumInv pqr),
      Admissible pqr
  
Arguments: {pqr : List ℕ+}
Goal: List.Sorted (fun x x_1 => x ≤ x_1) pqr → pqr.length = 3 → 1 < ADEInequality.sumInv ↑pqr → ADEInequality.Admissible ↑pqr
-- ADEInequality.admissible_of_one_lt_sumInv
theorem admissible_of_one_lt_sumInv {p q r : ℕ+} (H : 1 < sumInv {p, q, r}) :
    Admissible {p, q, r} 
Arguments: {p q r : ℕ+} (H : 1 < ADEInequality.sumInv {p, q, r})
Goal: ADEInequality.Admissible {p, q, r}
-- ADEInequality.classification
theorem classification (p q r : ℕ+) : 1 < sumInv {p, q, r} ↔ Admissible {p, q, r} 
Arguments: (p q r : ℕ+)
Goal: 1 < ADEInequality.sumInv {p, q, r} ↔ ADEInequality.Admissible {p, q, r}
-- fermatLastTheoremFor_zero
lemma fermatLastTheoremFor_zero : FermatLastTheoremFor 0 
Goal: FermatLastTheoremFor 0
-- not_fermatLastTheoremFor_one
lemma not_fermatLastTheoremFor_one : ¬ FermatLastTheoremFor 1 
Goal: ¬FermatLastTheoremFor 1
-- not_fermatLastTheoremFor_two
lemma not_fermatLastTheoremFor_two : ¬ FermatLastTheoremFor 2 
Goal: ¬FermatLastTheoremFor 2
-- FermatLastTheoremWith.mono
lemma FermatLastTheoremWith.mono (hmn : m ∣ n) (hm : FermatLastTheoremWith α m) :
    FermatLastTheoremWith α n 
Arguments: {α : Type u_1} [Semiring α] [NoZeroDivisors α] {m n : ℕ} (hmn : m ∣ n) (hm : FermatLastTheoremWith α m)
Goal: FermatLastTheoremWith α n
-- FermatLastTheoremFor.mono
lemma FermatLastTheoremFor.mono (hmn : m ∣ n) (hm : FermatLastTheoremFor m) :
    FermatLastTheoremFor n 
Arguments: {m n : ℕ} (hmn : m ∣ n) (hm : FermatLastTheoremFor m)
Goal: FermatLastTheoremFor n
-- fermatLastTheoremWith_nat_int_rat_tfae
lemma fermatLastTheoremWith_nat_int_rat_tfae (n : ℕ) :
    TFAE [FermatLastTheoremWith ℕ n, FermatLastTheoremWith ℤ n, FermatLastTheoremWith ℚ n] 
Arguments: (n : ℕ)
Goal: [FermatLastTheoremWith ℕ n, FermatLastTheoremWith ℤ n, FermatLastTheoremWith ℚ n].TFAE
-- fermatLastTheoremFor_iff_nat
lemma fermatLastTheoremFor_iff_nat {n : ℕ} : FermatLastTheoremFor n ↔ FermatLastTheoremWith ℕ n 
Arguments: {n : ℕ}
Goal: FermatLastTheoremFor n ↔ FermatLastTheoremWith ℕ n
-- fermatLastTheoremFor_iff_int
lemma fermatLastTheoremFor_iff_int {n : ℕ} : FermatLastTheoremFor n ↔ FermatLastTheoremWith ℤ n 
Arguments: {n : ℕ}
Goal: FermatLastTheoremFor n ↔ FermatLastTheoremWith ℤ n
-- fermatLastTheoremFor_iff_rat
lemma fermatLastTheoremFor_iff_rat {n : ℕ} : FermatLastTheoremFor n ↔ FermatLastTheoremWith ℚ n 
Arguments: {n : ℕ}
Goal: FermatLastTheoremFor n ↔ FermatLastTheoremWith ℚ n
-- fermatLastTheoremWith_of_fermatLastTheoremWith_coprime
lemma fermatLastTheoremWith_of_fermatLastTheoremWith_coprime {n : ℕ} {R : Type*} [CommSemiring R]
    [IsDomain R] [DecidableEq R] [NormalizedGCDMonoid R]
    (hn : ∀ a b c : R, a ≠ 0 → b ≠ 0 → c ≠ 0 → ({a, b, c} : Finset R).gcd id = 1 →
      a ^ n + b ^ n ≠ c ^ n) :
    FermatLastTheoremWith R n 
Arguments: {n : ℕ} {R : Type u_2} [CommSemiring R] [IsDomain R] [DecidableEq R] [NormalizedGCDMonoid R] (hn : ∀ (a b c : R), a ≠ 0 → b ≠ 0 → c ≠ 0 → {a, b, c}.gcd id = 1 → a ^ n + b ^ n ≠ c ^ n)
Goal: FermatLastTheoremWith R n
-- dvd_c_of_prime_of_dvd_a_of_dvd_b_of_FLT
lemma dvd_c_of_prime_of_dvd_a_of_dvd_b_of_FLT {n : ℕ} {p : ℤ} (hp : Prime p)  {a b c : ℤ}
    (hpa : p ∣ a) (hpb : p ∣ b) (HF : a ^ n + b ^ n + c ^ n = 0) : p ∣ c 
Arguments: {n : ℕ} {p : ℤ} (hp : Prime p) {a b c : ℤ} (hpa : p ∣ a) (hpb : p ∣ b) (HF : a ^ n + b ^ n + c ^ n = 0)
Goal: p ∣ c
-- isCoprime_of_gcd_eq_one_of_FLT
lemma isCoprime_of_gcd_eq_one_of_FLT {n : ℕ} {a b c : ℤ} (Hgcd : Finset.gcd {a, b, c} id = 1)
    (HF : a ^ n + b ^ n + c ^ n = 0) : IsCoprime a b 
Arguments: {n : ℕ} {a b c : ℤ} (Hgcd : {a, b, c}.gcd id = 1) (HF : a ^ n + b ^ n + c ^ n = 0)
Goal: IsCoprime a b
-- Nat.grahamConjecture_of_squarefree
lemma grahamConjecture_of_squarefree {n : ℕ} (f : ℕ → ℕ) (hf' : ∀ k < n, Squarefree (f k)) :
    GrahamConjecture n f 
Arguments: {n : ℕ} (f : ℕ → ℕ) (hf' : ∀ k < n, Squarefree (f k))
Goal: n.GrahamConjecture f
-- Nat.filter_dvd_eq_divisors
@[simp]
theorem filter_dvd_eq_divisors (h : n ≠ 0) : (Finset.range n.succ).filter (· ∣ n) = n.divisors 
Arguments: {n : ℕ} (h : n ≠ 0)
Goal: Finset.filter (fun x => x ∣ n) (Finset.range n.succ) = n.divisors
-- Nat.filter_dvd_eq_properDivisors
@[simp]
theorem filter_dvd_eq_properDivisors (h : n ≠ 0) :
    (Finset.range n).filter (· ∣ n) = n.properDivisors 
Arguments: {n : ℕ} (h : n ≠ 0)
Goal: Finset.filter (fun x => x ∣ n) (Finset.range n) = n.properDivisors
-- Nat.properDivisors.not_self_mem
theorem properDivisors.not_self_mem : ¬n ∈ properDivisors n 
Arguments: {n : ℕ}
Goal: n ∉ n.properDivisors
-- Nat.mem_properDivisors
@[simp]
theorem mem_properDivisors {m : ℕ} : n ∈ properDivisors m ↔ n ∣ m ∧ n < m 
Arguments: {n m : ℕ}
Goal: n ∈ m.properDivisors ↔ n ∣ m ∧ n < m
-- Nat.insert_self_properDivisors
theorem insert_self_properDivisors (h : n ≠ 0) : insert n (properDivisors n) = divisors n 
Arguments: {n : ℕ} (h : n ≠ 0)
Goal: insert n n.properDivisors = n.divisors
-- Nat.cons_self_properDivisors
theorem cons_self_properDivisors (h : n ≠ 0) :
    cons n (properDivisors n) properDivisors.not_self_mem = divisors n 
Arguments: {n : ℕ} (h : n ≠ 0)
Goal: Finset.cons n n.properDivisors ⋯ = n.divisors
-- Nat.mem_divisors
@[simp]
theorem mem_divisors {m : ℕ} : n ∈ divisors m ↔ n ∣ m ∧ m ≠ 0 
Arguments: {n m : ℕ}
Goal: n ∈ m.divisors ↔ n ∣ m ∧ m ≠ 0
-- Nat.one_mem_divisors
theorem one_mem_divisors : 1 ∈ divisors n ↔ n ≠ 0 
Arguments: {n : ℕ}
Goal: 1 ∈ n.divisors ↔ n ≠ 0
-- Nat.mem_divisors_self
theorem mem_divisors_self (n : ℕ) (h : n ≠ 0) : n ∈ n.divisors 
Arguments: (n : ℕ) (h : n ≠ 0)
Goal: n ∈ n.divisors
-- Nat.dvd_of_mem_divisors
theorem dvd_of_mem_divisors {m : ℕ} (h : n ∈ divisors m) : n ∣ m 
Arguments: {n m : ℕ} (h : n ∈ m.divisors)
Goal: n ∣ m
-- Nat.mem_divisorsAntidiagonal
@[simp]
theorem mem_divisorsAntidiagonal {x : ℕ × ℕ} :
    x ∈ divisorsAntidiagonal n ↔ x.fst * x.snd = n ∧ n ≠ 0 
Arguments: {n : ℕ} {x : ℕ × ℕ}
Goal: x ∈ n.divisorsAntidiagonal ↔ x.1 * x.2 = n ∧ n ≠ 0
-- Nat.ne_zero_of_mem_divisorsAntidiagonal
lemma ne_zero_of_mem_divisorsAntidiagonal {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal) :
    p.1 ≠ 0 ∧ p.2 ≠ 0 
Arguments: {n : ℕ} {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal)
Goal: p.1 ≠ 0 ∧ p.2 ≠ 0
-- Nat.left_ne_zero_of_mem_divisorsAntidiagonal
lemma left_ne_zero_of_mem_divisorsAntidiagonal {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal) :
    p.1 ≠ 0 
Arguments: {n : ℕ} {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal)
Goal: p.1 ≠ 0
-- Nat.right_ne_zero_of_mem_divisorsAntidiagonal
lemma right_ne_zero_of_mem_divisorsAntidiagonal {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal) :
    p.2 ≠ 0 
Arguments: {n : ℕ} {p : ℕ × ℕ} (hp : p ∈ n.divisorsAntidiagonal)
Goal: p.2 ≠ 0
-- Nat.divisor_le
theorem divisor_le {m : ℕ} : n ∈ divisors m → n ≤ m 
Arguments: {n m : ℕ}
Goal: n ∈ m.divisors → n ≤ m
-- Nat.divisors_subset_of_dvd
theorem divisors_subset_of_dvd {m : ℕ} (hzero : n ≠ 0) (h : m ∣ n) : divisors m ⊆ divisors n 
Arguments: {n m : ℕ} (hzero : n ≠ 0) (h : m ∣ n)
Goal: m.divisors ⊆ n.divisors
-- Nat.divisors_subset_properDivisors
theorem divisors_subset_properDivisors {m : ℕ} (hzero : n ≠ 0) (h : m ∣ n) (hdiff : m ≠ n) :
    divisors m ⊆ properDivisors n 
Arguments: {n m : ℕ} (hzero : n ≠ 0) (h : m ∣ n) (hdiff : m ≠ n)
Goal: m.divisors ⊆ n.properDivisors
-- Nat.divisors_filter_dvd_of_dvd
lemma divisors_filter_dvd_of_dvd {n m : ℕ} (hn : n ≠ 0) (hm : m ∣ n) :
    (n.divisors.filter (· ∣ m)) = m.divisors 
Arguments: {n m : ℕ} (hn : n ≠ 0) (hm : m ∣ n)
Goal: Finset.filter (fun x => x ∣ m) n.divisors = m.divisors
-- Nat.divisors_zero
@[simp]
theorem divisors_zero : divisors 0 = ∅ 
Goal: Nat.divisors 0 = ∅
-- Nat.properDivisors_zero
@[simp]
theorem properDivisors_zero : properDivisors 0 = ∅ 
Goal: Nat.properDivisors 0 = ∅
-- Nat.nonempty_divisors
@[simp]
lemma nonempty_divisors : (divisors n).Nonempty ↔ n ≠ 0 
Arguments: {n : ℕ}
Goal: n.divisors.Nonempty ↔ n ≠ 0
-- Nat.divisors_eq_empty
@[simp]
lemma divisors_eq_empty : divisors n = ∅ ↔ n = 0 
Arguments: {n : ℕ}
Goal: n.divisors = ∅ ↔ n = 0
-- Nat.properDivisors_subset_divisors
theorem properDivisors_subset_divisors : properDivisors n ⊆ divisors n 
Arguments: {n : ℕ}
Goal: n.properDivisors ⊆ n.divisors
-- Nat.divisors_one
@[simp]
theorem divisors_one : divisors 1 = {1} 
Goal: Nat.divisors 1 = {1}
-- Nat.properDivisors_one
@[simp]
theorem properDivisors_one : properDivisors 1 = ∅ 
Goal: Nat.properDivisors 1 = ∅
-- Nat.pos_of_mem_divisors
theorem pos_of_mem_divisors {m : ℕ} (h : m ∈ n.divisors) : 0 < m 
Arguments: {n m : ℕ} (h : m ∈ n.divisors)
Goal: 0 < m
-- Nat.pos_of_mem_properDivisors
theorem pos_of_mem_properDivisors {m : ℕ} (h : m ∈ n.properDivisors) : 0 < m 
Arguments: {n m : ℕ} (h : m ∈ n.properDivisors)
Goal: 0 < m
-- Nat.one_mem_properDivisors_iff_one_lt
theorem one_mem_properDivisors_iff_one_lt : 1 ∈ n.properDivisors ↔ 1 < n 
Arguments: {n : ℕ}
Goal: 1 ∈ n.properDivisors ↔ 1 < n
-- Nat.sup_divisors_id
@[simp]
lemma sup_divisors_id (n : ℕ) : n.divisors.sup id = n 
Arguments: (n : ℕ)
Goal: n.divisors.sup id = n
-- Nat.one_lt_of_mem_properDivisors
lemma one_lt_of_mem_properDivisors {m n : ℕ} (h : m ∈ n.properDivisors) : 1 < n 
Arguments: {m n : ℕ} (h : m ∈ n.properDivisors)
Goal: 1 < n
-- Nat.one_lt_div_of_mem_properDivisors
lemma one_lt_div_of_mem_properDivisors {m n : ℕ} (h : m ∈ n.properDivisors) :
    1 < n / m 
Arguments: {m n : ℕ} (h : m ∈ n.properDivisors)
Goal: 1 < n / m
-- Nat.mem_properDivisors_iff_exists
lemma mem_properDivisors_iff_exists {m n : ℕ} (hn : n ≠ 0) :
    m ∈ n.properDivisors ↔ ∃ k > 1, n = m * k 
Arguments: {m n : ℕ} (hn : n ≠ 0)
Goal: m ∈ n.properDivisors ↔ ∃ k > 1, n = m * k
-- Nat.nonempty_properDivisors
@[simp]
lemma nonempty_properDivisors : n.properDivisors.Nonempty ↔ 1 < n 
Arguments: {n : ℕ}
Goal: n.properDivisors.Nonempty ↔ 1 < n
-- Nat.properDivisors_eq_empty
@[simp]
lemma properDivisors_eq_empty : n.properDivisors = ∅ ↔ n ≤ 1 
Arguments: {n : ℕ}
Goal: n.properDivisors = ∅ ↔ n ≤ 1
-- Nat.divisorsAntidiagonal_zero
@[simp]
theorem divisorsAntidiagonal_zero : divisorsAntidiagonal 0 = ∅ 
Goal: Nat.divisorsAntidiagonal 0 = ∅
-- Nat.divisorsAntidiagonal_one
@[simp]
theorem divisorsAntidiagonal_one : divisorsAntidiagonal 1 = {(1, 1)} 
Goal: Nat.divisorsAntidiagonal 1 = {(1, 1)}
-- Nat.swap_mem_divisorsAntidiagonal
theorem swap_mem_divisorsAntidiagonal {x : ℕ × ℕ} :
    x.swap ∈ divisorsAntidiagonal n ↔ x ∈ divisorsAntidiagonal n 
Arguments: {n : ℕ} {x : ℕ × ℕ}
Goal: x.swap ∈ n.divisorsAntidiagonal ↔ x ∈ n.divisorsAntidiagonal
-- Nat.swap_mem_divisorsAntidiagonal_aux
@[simp]
theorem swap_mem_divisorsAntidiagonal_aux {x : ℕ × ℕ} :
    x.snd * x.fst = n ∧ ¬n = 0 ↔ x ∈ divisorsAntidiagonal n 
Arguments: {n : ℕ} {x : ℕ × ℕ}
Goal: x.2 * x.1 = n ∧ ¬n = 0 ↔ x ∈ n.divisorsAntidiagonal
-- Nat.fst_mem_divisors_of_mem_antidiagonal
theorem fst_mem_divisors_of_mem_antidiagonal {x : ℕ × ℕ} (h : x ∈ divisorsAntidiagonal n) :
    x.fst ∈ divisors n 
Arguments: {n : ℕ} {x : ℕ × ℕ} (h : x ∈ n.divisorsAntidiagonal)
Goal: x.1 ∈ n.divisors
-- Nat.snd_mem_divisors_of_mem_antidiagonal
theorem snd_mem_divisors_of_mem_antidiagonal {x : ℕ × ℕ} (h : x ∈ divisorsAntidiagonal n) :
    x.snd ∈ divisors n 
Arguments: {n : ℕ} {x : ℕ × ℕ} (h : x ∈ n.divisorsAntidiagonal)
Goal: x.2 ∈ n.divisors
-- Nat.map_swap_divisorsAntidiagonal
@[simp]
theorem map_swap_divisorsAntidiagonal :
    (divisorsAntidiagonal n).map (Equiv.prodComm _ _).toEmbedding = divisorsAntidiagonal n 
Arguments: {n : ℕ}
Goal: Finset.map (Equiv.prodComm ℕ ℕ).toEmbedding n.divisorsAntidiagonal = n.divisorsAntidiagonal
-- Nat.image_fst_divisorsAntidiagonal
@[simp]
theorem image_fst_divisorsAntidiagonal : (divisorsAntidiagonal n).image Prod.fst = divisors n 
Arguments: {n : ℕ}
Goal: Finset.image Prod.fst n.divisorsAntidiagonal = n.divisors
-- Nat.image_snd_divisorsAntidiagonal
@[simp]
theorem image_snd_divisorsAntidiagonal : (divisorsAntidiagonal n).image Prod.snd = divisors n 
Arguments: {n : ℕ}
Goal: Finset.image Prod.snd n.divisorsAntidiagonal = n.divisors
-- Nat.map_div_right_divisors
theorem map_div_right_divisors :
    n.divisors.map ⟨fun d => (d, n / d), fun p₁ p₂ => congr_arg Prod.fst⟩ =
      n.divisorsAntidiagonal 
Arguments: {n : ℕ}
Goal: Finset.map { toFun := fun d => (d, n / d), inj' := ⋯ } n.divisors = n.divisorsAntidiagonal
-- Nat.map_div_left_divisors
theorem map_div_left_divisors :
    n.divisors.map ⟨fun d => (n / d, d), fun p₁ p₂ => congr_arg Prod.snd⟩ =
      n.divisorsAntidiagonal 
Arguments: {n : ℕ}
Goal: Finset.map { toFun := fun d => (n / d, d), inj' := ⋯ } n.divisors = n.divisorsAntidiagonal
-- Nat.sum_divisors_eq_sum_properDivisors_add_self
theorem sum_divisors_eq_sum_properDivisors_add_self :
    ∑ i ∈ divisors n, i = (∑ i ∈ properDivisors n, i) + n 
Arguments: {n : ℕ}
Goal: ∑ i ∈ n.divisors, i = ∑ i ∈ n.properDivisors, i + n
-- Nat.perfect_iff_sum_properDivisors
theorem perfect_iff_sum_properDivisors (h : 0 < n) : Perfect n ↔ ∑ i ∈ properDivisors n, i = n 
Arguments: {n : ℕ} (h : 0 < n)
Goal: n.Perfect ↔ ∑ i ∈ n.properDivisors, i = n
-- Nat.perfect_iff_sum_divisors_eq_two_mul
theorem perfect_iff_sum_divisors_eq_two_mul (h : 0 < n) :
    Perfect n ↔ ∑ i ∈ divisors n, i = 2 * n 
Arguments: {n : ℕ} (h : 0 < n)
Goal: n.Perfect ↔ ∑ i ∈ n.divisors, i = 2 * n
-- Nat.mem_divisors_prime_pow
theorem mem_divisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) {x : ℕ} :
    x ∈ divisors (p ^ k) ↔ ∃ j ≤ k, x = p ^ j 
Arguments: {p : ℕ} (pp : Nat.Prime p) (k : ℕ) {x : ℕ}
Goal: x ∈ (p ^ k).divisors ↔ ∃ j ≤ k, x = p ^ j
-- Nat.Prime.divisors
theorem Prime.divisors {p : ℕ} (pp : p.Prime) : divisors p = {1, p} 
Arguments: {p : ℕ} (pp : Nat.Prime p)
Goal: p.divisors = {1, p}
-- Nat.Prime.properDivisors
theorem Prime.properDivisors {p : ℕ} (pp : p.Prime) : properDivisors p = {1} 
Arguments: {p : ℕ} (pp : Nat.Prime p)
Goal: p.properDivisors = {1}
-- Nat.divisors_prime_pow
theorem divisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) :
    divisors (p ^ k) = (Finset.range (k + 1)).map ⟨(p ^ ·), Nat.pow_right_injective pp.two_le⟩ 
Arguments: {p : ℕ} (pp : Nat.Prime p) (k : ℕ)
Goal: (p ^ k).divisors = Finset.map { toFun := fun x => p ^ x, inj' := ⋯ } (Finset.range (k + 1))
-- Nat.divisors_injective
theorem divisors_injective : Function.Injective divisors 
Goal: Function.Injective Nat.divisors
-- Nat.divisors_inj
@[simp]
theorem divisors_inj {a b : ℕ} : a.divisors = b.divisors ↔ a = b 
Arguments: {a b : ℕ}
Goal: a.divisors = b.divisors ↔ a = b
-- Nat.eq_properDivisors_of_subset_of_sum_eq_sum
theorem eq_properDivisors_of_subset_of_sum_eq_sum {s : Finset ℕ} (hsub : s ⊆ n.properDivisors) :
    ((∑ x ∈ s, x) = ∑ x ∈ n.properDivisors, x) → s = n.properDivisors 
Arguments: {n : ℕ} {s : Finset ℕ} (hsub : s ⊆ n.properDivisors)
Goal: ∑ x ∈ s, x = ∑ x ∈ n.properDivisors, x → s = n.properDivisors
-- Nat.sum_properDivisors_dvd
theorem sum_properDivisors_dvd (h : (∑ x ∈ n.properDivisors, x) ∣ n) :
    ∑ x ∈ n.properDivisors, x = 1 ∨ ∑ x ∈ n.properDivisors, x = n 
Arguments: {n : ℕ} (h : ∑ x ∈ n.properDivisors, x ∣ n)
Goal: ∑ x ∈ n.properDivisors, x = 1 ∨ ∑ x ∈ n.properDivisors, x = n
-- Nat.Prime.sum_properDivisors
@[to_additive (attr := simp)]
theorem Prime.prod_properDivisors {α : Type*} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) :
    ∏ x ∈ p.properDivisors, f x = f 1 
Arguments: {α : Type u_1} [AddCommMonoid α] {p : ℕ} {f : ℕ → α} (h : Nat.Prime p)
Goal: ∑ x ∈ p.properDivisors, f x = f 1
-- Nat.Prime.prod_properDivisors
@[to_additive (attr := simp)]
theorem Prime.prod_properDivisors {α : Type*} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) :
    ∏ x ∈ p.properDivisors, f x = f 1 
Arguments: {α : Type u_1} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : Nat.Prime p)
Goal: ∏ x ∈ p.properDivisors, f x = f 1
-- Nat.Prime.sum_divisors
@[to_additive (attr := simp)]
theorem Prime.prod_divisors {α : Type*} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) :
    ∏ x ∈ p.divisors, f x = f p * f 1 
Arguments: {α : Type u_1} [AddCommMonoid α] {p : ℕ} {f : ℕ → α} (h : Nat.Prime p)
Goal: ∑ x ∈ p.divisors, f x = f p + f 1
-- Nat.Prime.prod_divisors
@[to_additive (attr := simp)]
theorem Prime.prod_divisors {α : Type*} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : p.Prime) :
    ∏ x ∈ p.divisors, f x = f p * f 1 
Arguments: {α : Type u_1} [CommMonoid α] {p : ℕ} {f : ℕ → α} (h : Nat.Prime p)
Goal: ∏ x ∈ p.divisors, f x = f p * f 1
-- Nat.properDivisors_eq_singleton_one_iff_prime
theorem properDivisors_eq_singleton_one_iff_prime : n.properDivisors = {1} ↔ n.Prime 
Arguments: {n : ℕ}
Goal: n.properDivisors = {1} ↔ Nat.Prime n
-- Nat.sum_properDivisors_eq_one_iff_prime
theorem sum_properDivisors_eq_one_iff_prime : ∑ x ∈ n.properDivisors, x = 1 ↔ n.Prime 
Arguments: {n : ℕ}
Goal: ∑ x ∈ n.properDivisors, x = 1 ↔ Nat.Prime n
-- Nat.mem_properDivisors_prime_pow
theorem mem_properDivisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) {x : ℕ} :
    x ∈ properDivisors (p ^ k) ↔ ∃ (j : ℕ) (_ : j < k), x = p ^ j 
Arguments: {p : ℕ} (pp : Nat.Prime p) (k : ℕ) {x : ℕ}
Goal: x ∈ (p ^ k).properDivisors ↔ ∃ j, ∃ (_ : j < k), x = p ^ j
-- Nat.properDivisors_prime_pow
theorem properDivisors_prime_pow {p : ℕ} (pp : p.Prime) (k : ℕ) :
    properDivisors (p ^ k) = (Finset.range k).map ⟨(p ^ ·), Nat.pow_right_injective pp.two_le⟩ 
Arguments: {p : ℕ} (pp : Nat.Prime p) (k : ℕ)
Goal: (p ^ k).properDivisors = Finset.map { toFun := fun x => p ^ x, inj' := ⋯ } (Finset.range k)
-- Nat.prod_properDivisors_prime_pow
@[to_additive (attr := simp)]
theorem prod_properDivisors_prime_pow {α : Type*} [CommMonoid α] {k p : ℕ} {f : ℕ → α}
    (h : p.Prime) : (∏ x ∈ (p ^ k).properDivisors, f x) = ∏ x ∈ range k, f (p ^ x) 
Arguments: {α : Type u_1} [CommMonoid α] {k p : ℕ} {f : ℕ → α} (h : Nat.Prime p)
Goal: ∏ x ∈ (p ^ k).properDivisors, f x = ∏ x ∈ Finset.range k, f (p ^ x)
-- Nat.sum_properDivisors_prime_nsmul
@[to_additive (attr := simp)]
theorem prod_properDivisors_prime_pow {α : Type*} [CommMonoid α] {k p : ℕ} {f : ℕ → α}
    (h : p.Prime) : (∏ x ∈ (p ^ k).properDivisors, f x) = ∏ x ∈ range k, f (p ^ x) 
Arguments: {α : Type u_1} [AddCommMonoid α] {k p : ℕ} {f : ℕ → α} (h : Nat.Prime p)
Goal: ∑ x ∈ (p ^ k).properDivisors, f x = ∑ x ∈ Finset.range k, f (p ^ x)
-- Nat.prod_divisors_prime_pow
@[to_additive (attr := simp) sum_divisors_prime_pow]
theorem prod_divisors_prime_pow {α : Type*} [CommMonoid α] {k p : ℕ} {f : ℕ → α} (h : p.Prime) :
    (∏ x ∈ (p ^ k).divisors, f x) = ∏ x ∈ range (k + 1), f (p ^ x) 
Arguments: {α : Type u_1} [CommMonoid α] {k p : ℕ} {f : ℕ → α} (h : Nat.Prime p)
Goal: ∏ x ∈ (p ^ k).divisors, f x = ∏ x ∈ Finset.range (k + 1), f (p ^ x)
-- Nat.sum_divisors_prime_pow
@[to_additive (attr := simp) sum_divisors_prime_pow]
theorem prod_divisors_prime_pow {α : Type*} [CommMonoid α] {k p : ℕ} {f : ℕ → α} (h : p.Prime) :
    (∏ x ∈ (p ^ k).divisors, f x) = ∏ x ∈ range (k + 1), f (p ^ x) 
Arguments: {α : Type u_1} [AddCommMonoid α] {k p : ℕ} {f : ℕ → α} (h : Nat.Prime p)
Goal: ∑ x ∈ (p ^ k).divisors, f x = ∑ x ∈ Finset.range (k + 1), f (p ^ x)
-- Nat.sum_divisorsAntidiagonal
@[to_additive]
theorem prod_divisorsAntidiagonal {M : Type*} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} :
    ∏ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∏ i ∈ n.divisors, f i (n / i) 
Arguments: {M : Type u_1} [AddCommMonoid M] (f : ℕ → ℕ → M) {n : ℕ}
Goal: ∑ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∑ i ∈ n.divisors, f i (n / i)
-- Nat.prod_divisorsAntidiagonal
@[to_additive]
theorem prod_divisorsAntidiagonal {M : Type*} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} :
    ∏ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∏ i ∈ n.divisors, f i (n / i) 
Arguments: {M : Type u_1} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ}
Goal: ∏ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∏ i ∈ n.divisors, f i (n / i)
-- Nat.prod_divisorsAntidiagonal'
@[to_additive]
theorem prod_divisorsAntidiagonal' {M : Type*} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} :
    ∏ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∏ i ∈ n.divisors, f (n / i) i 
Arguments: {M : Type u_1} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ}
Goal: ∏ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∏ i ∈ n.divisors, f (n / i) i
-- Nat.sum_divisorsAntidiagonal'
@[to_additive]
theorem prod_divisorsAntidiagonal' {M : Type*} [CommMonoid M] (f : ℕ → ℕ → M) {n : ℕ} :
    ∏ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∏ i ∈ n.divisors, f (n / i) i 
Arguments: {M : Type u_1} [AddCommMonoid M] (f : ℕ → ℕ → M) {n : ℕ}
Goal: ∑ i ∈ n.divisorsAntidiagonal, f i.1 i.2 = ∑ i ∈ n.divisors, f (n / i) i
-- Nat.primeFactors_eq_to_filter_divisors_prime
theorem primeFactors_eq_to_filter_divisors_prime (n : ℕ) :
    n.primeFactors = (divisors n).filter Prime 
Arguments: (n : ℕ)
Goal: n.primeFactors = Finset.filter Nat.Prime n.divisors
-- Nat.primeFactors_filter_dvd_of_dvd
lemma primeFactors_filter_dvd_of_dvd {m n : ℕ} (hn : n ≠ 0) (hmn : m ∣ n) :
    n.primeFactors.filter (· ∣ m) = m.primeFactors 
Arguments: {m n : ℕ} (hn : n ≠ 0) (hmn : m ∣ n)
Goal: Finset.filter (fun x => x ∣ m) n.primeFactors = m.primeFactors