ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.multinomial_univ_three
theorem multinomial_univ_three (a b c : ℕ) :
    multinomial Finset.univ ![a, b, c] = (a + b + c)! / (a ! * b ! * c !) 
Arguments: (a b c : ℕ)
Goal: Nat.multinomial Finset.univ ![a, b, c] = (a + b + c)! / (a ! * b ! * c !)
-- Finsupp.multinomial_eq
theorem multinomial_eq (f : α →₀ ℕ) : f.multinomial = Nat.multinomial f.support f 
Arguments: {α : Type u_1} (f : α →₀ ℕ)
Goal: f.multinomial = Nat.multinomial f.support ⇑f
-- Finsupp.multinomial_update
theorem multinomial_update (a : α) (f : α →₀ ℕ) :
    f.multinomial = (f.sum fun _ => id).choose (f a) * (f.update a 0).multinomial 
Arguments: {α : Type u_1} (a : α) (f : α →₀ ℕ)
Goal: f.multinomial = (f.sum fun x => id).choose (f a) * (f.update a 0).multinomial
-- Multiset.multinomial_filter_ne
theorem multinomial_filter_ne [DecidableEq α] (a : α) (m : Multiset α) :
    m.multinomial = m.card.choose (m.count a) * (m.filter (a ≠ ·)).multinomial 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (m : Multiset α)
Goal: m.multinomial = (Multiset.card m).choose (Multiset.count a m) * (Multiset.filter (fun x => a ≠ x) m).multinomial
-- Multiset.multinomial_zero
@[simp]
theorem multinomial_zero [DecidableEq α] : multinomial (0 : Multiset α) = 1 
Arguments: {α : Type u_1} [DecidableEq α]
Goal: Multiset.multinomial 0 = 1
-- Finset.sum_pow_eq_sum_piAntidiag_of_commute
lemma sum_pow_eq_sum_piAntidiag_of_commute (s : Finset α) (f : α → R)
    (hc : (s : Set α).Pairwise fun i j ↦ Commute (f i) (f j)) (n : ℕ) :
    (∑ i in s, f i) ^ n = ∑ k in piAntidiag s n, multinomial s k *
      s.noncommProd (fun i ↦ f i ^ k i) (hc.mono' fun i j h ↦ h.pow_pow ..) 
Arguments: {α : Type u_1} {R : Type u_2} [DecidableEq α] [Semiring R] (s : Finset α) (f : α → R) (hc : (↑s).Pairwise fun i j => Commute (f i) (f j)) (n : ℕ)
Goal: (∑ i ∈ s, f i) ^ n = ∑ k ∈ s.piAntidiag n, ↑(Nat.multinomial s k) * s.noncommProd (fun i => f i ^ k i) ⋯
-- Finset.sum_pow_of_commute
theorem sum_pow_of_commute [Semiring R] (x : α → R) (s : Finset α)
    (hc : (s : Set α).Pairwise fun i j => Commute (x i) (x j)) :
    ∀ n,
      s.sum x ^ n =
        ∑ k : s.sym n,
          k.1.1.multinomial *
            (k.1.1.map <| x).noncommProd
              (Multiset.map_set_pairwise <| hc.mono <| mem_sym_iff.1 k.2) 
Arguments: {α : Type u_1} {R : Type u_2} [DecidableEq α] [Semiring R] (x : α → R) (s : Finset α) (hc : (↑s).Pairwise fun i j => Commute (x i) (x j)) (n : ℕ)
Goal: s.sum x ^ n = ∑ k : { x // x ∈ s.sym n }, ↑(↑↑k).multinomial * (Multiset.map x ↑↑k).noncommProd ⋯
-- Finset.sum_pow_eq_sum_piAntidiag
lemma sum_pow_eq_sum_piAntidiag (s : Finset α) (f : α → R) (n : ℕ) :
    (∑ i in s, f i) ^ n = ∑ k in piAntidiag s n, multinomial s k * ∏ i in s, f i ^ k i 
Arguments: {α : Type u_1} {R : Type u_2} [DecidableEq α] [CommSemiring R] (s : Finset α) (f : α → R) (n : ℕ)
Goal: (∑ i ∈ s, f i) ^ n = ∑ k ∈ s.piAntidiag n, ↑(Nat.multinomial s k) * ∏ i ∈ s, f i ^ k i
-- Finset.sum_pow
theorem sum_pow [CommSemiring R] (x : α → R) (n : ℕ) :
    s.sum x ^ n = ∑ k ∈ s.sym n, k.val.multinomial * (k.val.map x).prod 
Arguments: {α : Type u_1} {R : Type u_2} [DecidableEq α] {s : Finset α} [CommSemiring R] (x : α → R) (n : ℕ)
Goal: s.sum x ^ n = ∑ k ∈ s.sym n, ↑(↑k).multinomial * (Multiset.map x ↑k).prod
-- Sym.multinomial_coe_fill_of_not_mem
theorem multinomial_coe_fill_of_not_mem {m : Fin (n + 1)} {s : Sym α (n - m)} {x : α} (hx : x ∉ s) :
    (fill x m s : Multiset α).multinomial = n.choose m * (s : Multiset α).multinomial 
Arguments: {n : ℕ} {α : Type u_1} [DecidableEq α] {m : Fin (n + 1)} {s : Sym α (n - ↑m)} {x : α} (hx : x ∉ s)
Goal: (↑(Sym.fill x m s)).multinomial = n.choose ↑m * (↑s).multinomial
-- Nat.bitIndices_zero
@[simp] theorem bitIndices_zero : bitIndices 0 = [] 
Goal: Nat.bitIndices 0 = []
-- Nat.bitIndices_one
@[simp] theorem bitIndices_one : bitIndices 1 = [0] 
Goal: Nat.bitIndices 1 = [0]
-- Nat.bitIndices_bit_true
theorem bitIndices_bit_true (n : ℕ) :
    bitIndices (bit true n) = 0 :: ((bitIndices n).map (· + 1)) 
Arguments: (n : ℕ)
Goal: (Nat.bit true n).bitIndices = 0 :: List.map (fun x => x + 1) n.bitIndices
-- Nat.bitIndices_bit_false
theorem bitIndices_bit_false (n : ℕ) :
    bitIndices (bit false n) = (bitIndices n).map (· + 1) 
Arguments: (n : ℕ)
Goal: (Nat.bit false n).bitIndices = List.map (fun x => x + 1) n.bitIndices
-- Nat.bitIndices_two_mul_add_one
@[simp] theorem bitIndices_two_mul_add_one (n : ℕ) :
    bitIndices (2 * n + 1) = 0 :: (bitIndices n).map (· + 1) 
Arguments: (n : ℕ)
Goal: (2 * n + 1).bitIndices = 0 :: List.map (fun x => x + 1) n.bitIndices
-- Nat.bitIndices_two_mul
@[simp] theorem bitIndices_two_mul (n : ℕ) :
    bitIndices (2 * n) = (bitIndices n).map (· + 1) 
Arguments: (n : ℕ)
Goal: (2 * n).bitIndices = List.map (fun x => x + 1) n.bitIndices
-- Nat.bitIndices_sorted
@[simp] theorem bitIndices_sorted {n : ℕ} : n.bitIndices.Sorted (· < ·) 
Arguments: {n : ℕ}
Goal: List.Sorted (fun x x_1 => x < x_1) n.bitIndices
-- Nat.bitIndices_two_pow_mul
@[simp] theorem bitIndices_two_pow_mul (k n : ℕ) :
    bitIndices (2^k * n) = (bitIndices n).map (· + k) 
Arguments: (k n : ℕ)
Goal: (2 ^ k * n).bitIndices = List.map (fun x => x + k) n.bitIndices
-- Nat.bitIndices_two_pow
@[simp] theorem bitIndices_two_pow (k : ℕ) : bitIndices (2^k) = [k] 
Arguments: (k : ℕ)
Goal: (2 ^ k).bitIndices = [k]
-- Nat.twoPowSum_bitIndices
@[simp] theorem twoPowSum_bitIndices (n : ℕ) : (n.bitIndices.map (fun i ↦ 2 ^ i)).sum = n 
Arguments: (n : ℕ)
Goal: (List.map (fun i => 2 ^ i) n.bitIndices).sum = n
-- Nat.bitIndices_twoPowsum
theorem bitIndices_twoPowsum {L : List ℕ} (hL : List.Sorted (· < ·) L) :
    (L.map (fun i ↦ 2^i)).sum.bitIndices = L 
Arguments: {L : List ℕ} (hL : List.Sorted (fun x x_1 => x < x_1) L)
Goal: (List.map (fun i => 2 ^ i) L).sum.bitIndices = L
-- Nat.two_pow_le_of_mem_bitIndices
theorem two_pow_le_of_mem_bitIndices (ha : a ∈ n.bitIndices) : 2^a ≤ n 
Arguments: {a n : ℕ} (ha : a ∈ n.bitIndices)
Goal: 2 ^ a ≤ n
-- Nat.not_mem_bitIndices_self
theorem not_mem_bitIndices_self (n : ℕ) : n ∉ n.bitIndices 
Arguments: (n : ℕ)
Goal: n ∉ n.bitIndices
-- List.IsZeckendorfRep_nil
@[simp]
lemma IsZeckendorfRep_nil : IsZeckendorfRep [] 
Goal: [].IsZeckendorfRep
-- List.IsZeckendorfRep.sum_fib_lt
lemma IsZeckendorfRep.sum_fib_lt : ∀ {n l}, IsZeckendorfRep l → (∀ a ∈ (l ++ [0]).head?, a < n) →
    (l.map fib).sum < fib n
  
Arguments: {n : ℕ} {l : List ℕ}
Goal: l.IsZeckendorfRep → (∀ a ∈ (l ++ [0]).head?, a < n) → (List.map Nat.fib l).sum < Nat.fib n
-- Nat.fib_greatestFib_le
lemma fib_greatestFib_le (n : ℕ) : fib (greatestFib n) ≤ n 
Arguments: (n : ℕ)
Goal: Nat.fib n.greatestFib ≤ n
-- Nat.greatestFib_mono
lemma greatestFib_mono : Monotone greatestFib 
Goal: Monotone Nat.greatestFib
-- Nat.le_greatestFib
@[simp] lemma le_greatestFib : m ≤ greatestFib n ↔ fib m ≤ n 
Arguments: {m n : ℕ}
Goal: m ≤ n.greatestFib ↔ Nat.fib m ≤ n
-- Nat.greatestFib_lt
@[simp] lemma greatestFib_lt : greatestFib m < n ↔ m < fib n 
Arguments: {m n : ℕ}
Goal: m.greatestFib < n ↔ m < Nat.fib n
-- Nat.lt_fib_greatestFib_add_one
lemma lt_fib_greatestFib_add_one (n : ℕ) : n < fib (greatestFib n + 1) 
Arguments: (n : ℕ)
Goal: n < Nat.fib (n.greatestFib + 1)
-- Nat.greatestFib_fib
@[simp] lemma greatestFib_fib : ∀ {n}, n ≠ 1 → greatestFib (fib n) = n
  
Arguments: {n : ℕ}
Goal: n ≠ 1 → (Nat.fib n).greatestFib = n
-- Nat.greatestFib_eq_zero
@[simp] lemma greatestFib_eq_zero : greatestFib n = 0 ↔ n = 0 
Arguments: {n : ℕ}
Goal: n.greatestFib = 0 ↔ n = 0
-- Nat.greatestFib_ne_zero
lemma greatestFib_ne_zero : greatestFib n ≠ 0 ↔ n ≠ 0 
Arguments: {n : ℕ}
Goal: n.greatestFib ≠ 0 ↔ n ≠ 0
-- Nat.greatestFib_pos
@[simp] lemma greatestFib_pos : 0 < greatestFib n ↔ 0 < n 
Arguments: {n : ℕ}
Goal: 0 < n.greatestFib ↔ 0 < n
-- Nat.greatestFib_sub_fib_greatestFib_le_greatestFib
lemma greatestFib_sub_fib_greatestFib_le_greatestFib (hn : n ≠ 0) :
    greatestFib (n - fib (greatestFib n)) ≤ greatestFib n - 2 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: (n - Nat.fib n.greatestFib).greatestFib ≤ n.greatestFib - 2
-- _private.Mathlib.Data.Nat.Fib.Zeckendorf.0.Nat.zeckendorf_aux
private lemma zeckendorf_aux (hm : 0 < m) : m - fib (greatestFib m) < m 
Arguments: {m : ℕ} (hm : 0 < m)
Goal: m - Nat.fib m.greatestFib < m
-- Nat.zeckendorf_zero
@[simp] lemma zeckendorf_zero : zeckendorf 0 = [] 
Goal: Nat.zeckendorf 0 = []
-- Nat.zeckendorf_succ
@[simp] lemma zeckendorf_succ (n : ℕ) :
    zeckendorf (n + 1) = greatestFib (n + 1) :: zeckendorf (n + 1 - fib (greatestFib (n + 1))) 
Arguments: (n : ℕ)
Goal: (n + 1).zeckendorf = (n + 1).greatestFib :: (n + 1 - Nat.fib (n + 1).greatestFib).zeckendorf
-- Nat.zeckendorf_of_pos
@[simp] lemma zeckendorf_of_pos : ∀ {n}, 0 < n →
    zeckendorf n = greatestFib n :: zeckendorf (n - fib (greatestFib n))
  
Arguments: {n : ℕ}
Goal: 0 < n → n.zeckendorf = n.greatestFib :: (n - Nat.fib n.greatestFib).zeckendorf
-- Nat.isZeckendorfRep_zeckendorf
lemma isZeckendorfRep_zeckendorf : ∀ n, (zeckendorf n).IsZeckendorfRep
  
Arguments: (n : ℕ)
Goal: n.zeckendorf.IsZeckendorfRep
-- Nat.zeckendorf_sum_fib
lemma zeckendorf_sum_fib : ∀ {l}, IsZeckendorfRep l → zeckendorf (l.map fib).sum = l
  
Arguments: {l : List ℕ}
Goal: l.IsZeckendorfRep → (List.map Nat.fib l).sum.zeckendorf = l
-- Nat.sum_zeckendorf_fib
@[simp] lemma sum_zeckendorf_fib (n : ℕ) : (n.zeckendorf.map fib).sum = n 
Arguments: (n : ℕ)
Goal: (List.map Nat.fib n.zeckendorf).sum = n
-- FP.FloatCfg.precPos
@[nolint docBlame]
class FloatCfg where
  (prec emax : ℕ)
  precPos : 0 < prec
  precMax : prec ≤ emax
Arguments: [self : FP.FloatCfg]
Goal: 0 < FP.FloatCfg.prec
-- FP.FloatCfg.precMax
@[nolint docBlame]
class FloatCfg where
  (prec emax : ℕ)
  precPos : 0 < prec
  precMax : prec ≤ emax
Arguments: [self : FP.FloatCfg]
Goal: FP.FloatCfg.prec ≤ FP.FloatCfg.emax
-- FP.Float.Zero.valid
theorem Float.Zero.valid : ValidFinite emin 0 
Arguments: [C : FP.FloatCfg]
Goal: FP.ValidFinite FP.emin 0
-- Nat.factorization_eq_zero_of_lt
theorem factorization_eq_zero_of_lt {n p : ℕ} (h : n < p) : n.factorization p = 0 
Arguments: {n p : ℕ} (h : n < p)
Goal: n.factorization p = 0
-- Nat.factorization_one_right
@[simp]
theorem factorization_one_right (n : ℕ) : n.factorization 1 = 0 
Arguments: (n : ℕ)
Goal: n.factorization 1 = 0
-- Nat.dvd_of_factorization_pos
theorem dvd_of_factorization_pos {n p : ℕ} (hn : n.factorization p ≠ 0) : p ∣ n 
Arguments: {n p : ℕ} (hn : n.factorization p ≠ 0)
Goal: p ∣ n
-- Nat.factorization_eq_zero_iff_remainder
theorem factorization_eq_zero_iff_remainder {p r : ℕ} (i : ℕ) (pp : p.Prime) (hr0 : r ≠ 0) :
    ¬p ∣ r ↔ (p * i + r).factorization p = 0 
Arguments: {p r : ℕ} (i : ℕ) (pp : Nat.Prime p) (hr0 : r ≠ 0)
Goal: ¬p ∣ r ↔ (p * i + r).factorization p = 0
-- Nat.factorization_eq_zero_iff'
theorem factorization_eq_zero_iff' (n : ℕ) : n.factorization = 0 ↔ n = 0 ∨ n = 1 
Arguments: (n : ℕ)
Goal: n.factorization = 0 ↔ n = 0 ∨ n = 1
-- Nat.prod_factorization_eq_prod_primeFactors
lemma prod_factorization_eq_prod_primeFactors {β : Type*} [CommMonoid β] (f : ℕ → ℕ → β) :
    n.factorization.prod f = ∏ p ∈ n.primeFactors, f p (n.factorization p) 
Arguments: {n : ℕ} {β : Type u_1} [CommMonoid β] (f : ℕ → ℕ → β)
Goal: n.factorization.prod f = ∏ p ∈ n.primeFactors, f p (n.factorization p)
-- Nat.prod_primeFactors_prod_factorization
lemma prod_primeFactors_prod_factorization {β : Type*} [CommMonoid β] (f : ℕ → β) :
    ∏ p ∈ n.primeFactors, f p = n.factorization.prod (fun p _ ↦ f p) 
Arguments: {n : ℕ} {β : Type u_1} [CommMonoid β] (f : ℕ → β)
Goal: ∏ p ∈ n.primeFactors, f p = n.factorization.prod fun p x => f p
-- Nat.Prime.factorization_self
@[simp]
theorem Prime.factorization_self {p : ℕ} (hp : Prime p) : p.factorization p = 1 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: p.factorization p = 1
-- Nat.eq_pow_of_factorization_eq_single
theorem eq_pow_of_factorization_eq_single {n p k : ℕ} (hn : n ≠ 0)
    (h : n.factorization = Finsupp.single p k) : n = p ^ k 
Arguments: {n p k : ℕ} (hn : n ≠ 0) (h : n.factorization = Finsupp.single p k)
Goal: n = p ^ k
-- Nat.Prime.eq_of_factorization_pos
theorem Prime.eq_of_factorization_pos {p q : ℕ} (hp : Prime p) (h : p.factorization q ≠ 0) :
    p = q 
Arguments: {p q : ℕ} (hp : Nat.Prime p) (h : p.factorization q ≠ 0)
Goal: p = q
-- Nat.eq_factorization_iff
theorem eq_factorization_iff {n : ℕ} {f : ℕ →₀ ℕ} (hn : n ≠ 0) (hf : ∀ p ∈ f.support, Prime p) :
    f = n.factorization ↔ f.prod (· ^ ·) = n 
Arguments: {n : ℕ} {f : ℕ →₀ ℕ} (hn : n ≠ 0) (hf : ∀ p ∈ f.support, Nat.Prime p)
Goal: f = n.factorization ↔ (f.prod fun x x_1 => x ^ x_1) = n
-- Nat.factorizationEquiv_inv_apply
theorem factorizationEquiv_inv_apply {f : ℕ →₀ ℕ} (hf : ∀ p ∈ f.support, Prime p) :
    (factorizationEquiv.symm ⟨f, hf⟩).1 = f.prod (· ^ ·) 
Arguments: {f : ℕ →₀ ℕ} (hf : ∀ p ∈ f.support, Nat.Prime p)
Goal: ↑(Nat.factorizationEquiv.symm ⟨f, hf⟩) = f.prod fun x x_1 => x ^ x_1
-- Nat.ord_proj_of_not_prime
@[simp]
theorem ord_proj_of_not_prime (n p : ℕ) (hp : ¬p.Prime) : ord_proj[p] n = 1 
Arguments: (n p : ℕ) (hp : ¬Nat.Prime p)
Goal: p ^ n.factorization p = 1
-- Nat.ord_compl_of_not_prime
@[simp]
theorem ord_compl_of_not_prime (n p : ℕ) (hp : ¬p.Prime) : ord_compl[p] n = n 
Arguments: (n p : ℕ) (hp : ¬Nat.Prime p)
Goal: n / p ^ n.factorization p = n
-- Nat.ord_compl_dvd
theorem ord_compl_dvd (n p : ℕ) : ord_compl[p] n ∣ n 
Arguments: (n p : ℕ)
Goal: n / p ^ n.factorization p ∣ n
-- Nat.ord_proj_pos
theorem ord_proj_pos (n p : ℕ) : 0 < ord_proj[p] n 
Arguments: (n p : ℕ)
Goal: 0 < p ^ n.factorization p
-- Nat.ord_proj_le
theorem ord_proj_le {n : ℕ} (p : ℕ) (hn : n ≠ 0) : ord_proj[p] n ≤ n 
Arguments: {n : ℕ} (p : ℕ) (hn : n ≠ 0)
Goal: p ^ n.factorization p ≤ n
-- Nat.ord_compl_pos
theorem ord_compl_pos {n : ℕ} (p : ℕ) (hn : n ≠ 0) : 0 < ord_compl[p] n 
Arguments: {n : ℕ} (p : ℕ) (hn : n ≠ 0)
Goal: 0 < n / p ^ n.factorization p
-- Nat.ord_compl_le
theorem ord_compl_le (n p : ℕ) : ord_compl[p] n ≤ n 
Arguments: (n p : ℕ)
Goal: n / p ^ n.factorization p ≤ n
-- Nat.ord_proj_mul_ord_compl_eq_self
theorem ord_proj_mul_ord_compl_eq_self (n p : ℕ) : ord_proj[p] n * ord_compl[p] n = n 
Arguments: (n p : ℕ)
Goal: p ^ n.factorization p * (n / p ^ n.factorization p) = n
-- Nat.ord_proj_mul
theorem ord_proj_mul {a b : ℕ} (p : ℕ) (ha : a ≠ 0) (hb : b ≠ 0) :
    ord_proj[p] (a * b) = ord_proj[p] a * ord_proj[p] b 
Arguments: {a b : ℕ} (p : ℕ) (ha : a ≠ 0) (hb : b ≠ 0)
Goal: p ^ (a * b).factorization p = p ^ a.factorization p * p ^ b.factorization p
-- Nat.ord_compl_mul
theorem ord_compl_mul (a b p : ℕ) : ord_compl[p] (a * b) = ord_compl[p] a * ord_compl[p] b 
Arguments: (a b p : ℕ)
Goal: a * b / p ^ (a * b).factorization p = a / p ^ a.factorization p * (b / p ^ b.factorization p)
-- Nat.factorization_lt
theorem factorization_lt {n : ℕ} (p : ℕ) (hn : n ≠ 0) : n.factorization p < n 
Arguments: {n : ℕ} (p : ℕ) (hn : n ≠ 0)
Goal: n.factorization p < n
-- Nat.factorization_le_of_le_pow
theorem factorization_le_of_le_pow {n p b : ℕ} (hb : n ≤ p ^ b) : n.factorization p ≤ b 
Arguments: {n p b : ℕ} (hb : n ≤ p ^ b)
Goal: n.factorization p ≤ b
-- Nat.factorization_prime_le_iff_dvd
theorem factorization_prime_le_iff_dvd {d n : ℕ} (hd : d ≠ 0) (hn : n ≠ 0) :
    (∀ p : ℕ, p.Prime → d.factorization p ≤ n.factorization p) ↔ d ∣ n 
Arguments: {d n : ℕ} (hd : d ≠ 0) (hn : n ≠ 0)
Goal: (∀ (p : ℕ), Nat.Prime p → d.factorization p ≤ n.factorization p) ↔ d ∣ n
-- Nat.factorization_le_factorization_mul_left
theorem factorization_le_factorization_mul_left {a b : ℕ} (hb : b ≠ 0) :
    a.factorization ≤ (a * b).factorization 
Arguments: {a b : ℕ} (hb : b ≠ 0)
Goal: a.factorization ≤ (a * b).factorization
-- Nat.factorization_le_factorization_mul_right
theorem factorization_le_factorization_mul_right {a b : ℕ} (ha : a ≠ 0) :
    b.factorization ≤ (a * b).factorization 
Arguments: {a b : ℕ} (ha : a ≠ 0)
Goal: b.factorization ≤ (a * b).factorization
-- Nat.Prime.pow_dvd_iff_le_factorization
theorem Prime.pow_dvd_iff_le_factorization {p k n : ℕ} (pp : Prime p) (hn : n ≠ 0) :
    p ^ k ∣ n ↔ k ≤ n.factorization p 
Arguments: {p k n : ℕ} (pp : Nat.Prime p) (hn : n ≠ 0)
Goal: p ^ k ∣ n ↔ k ≤ n.factorization p
-- Nat.Prime.pow_dvd_iff_dvd_ord_proj
theorem Prime.pow_dvd_iff_dvd_ord_proj {p k n : ℕ} (pp : Prime p) (hn : n ≠ 0) :
    p ^ k ∣ n ↔ p ^ k ∣ ord_proj[p] n 
Arguments: {p k n : ℕ} (pp : Nat.Prime p) (hn : n ≠ 0)
Goal: p ^ k ∣ n ↔ p ^ k ∣ p ^ n.factorization p
-- Nat.Prime.dvd_iff_one_le_factorization
theorem Prime.dvd_iff_one_le_factorization {p n : ℕ} (pp : Prime p) (hn : n ≠ 0) :
    p ∣ n ↔ 1 ≤ n.factorization p 
Arguments: {p n : ℕ} (pp : Nat.Prime p) (hn : n ≠ 0)
Goal: p ∣ n ↔ 1 ≤ n.factorization p
-- Nat.exists_factorization_lt_of_lt
theorem exists_factorization_lt_of_lt {a b : ℕ} (ha : a ≠ 0) (hab : a < b) :
    ∃ p : ℕ, a.factorization p < b.factorization p 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hab : a < b)
Goal: ∃ p, a.factorization p < b.factorization p
-- Nat.factorization_div
@[simp]
theorem factorization_div {d n : ℕ} (h : d ∣ n) :
    (n / d).factorization = n.factorization - d.factorization 
Arguments: {d n : ℕ} (h : d ∣ n)
Goal: (n / d).factorization = n.factorization - d.factorization
-- Nat.dvd_ord_proj_of_dvd
theorem dvd_ord_proj_of_dvd {n p : ℕ} (hn : n ≠ 0) (pp : p.Prime) (h : p ∣ n) : p ∣ ord_proj[p] n 
Arguments: {n p : ℕ} (hn : n ≠ 0) (pp : Nat.Prime p) (h : p ∣ n)
Goal: p ∣ p ^ n.factorization p
-- Nat.not_dvd_ord_compl
theorem not_dvd_ord_compl {n p : ℕ} (hp : Prime p) (hn : n ≠ 0) : ¬p ∣ ord_compl[p] n 
Arguments: {n p : ℕ} (hp : Nat.Prime p) (hn : n ≠ 0)
Goal: ¬p ∣ n / p ^ n.factorization p
-- Nat.coprime_ord_compl
theorem coprime_ord_compl {n p : ℕ} (hp : Prime p) (hn : n ≠ 0) : Coprime p (ord_compl[p] n) 
Arguments: {n p : ℕ} (hp : Nat.Prime p) (hn : n ≠ 0)
Goal: p.Coprime (n / p ^ n.factorization p)
-- Nat.factorization_ord_compl
theorem factorization_ord_compl (n p : ℕ) :
    (ord_compl[p] n).factorization = n.factorization.erase p 
Arguments: (n p : ℕ)
Goal: (n / p ^ n.factorization p).factorization = Finsupp.erase p n.factorization
-- Nat.dvd_ord_compl_of_dvd_not_dvd
theorem dvd_ord_compl_of_dvd_not_dvd {p d n : ℕ} (hdn : d ∣ n) (hpd : ¬p ∣ d) :
    d ∣ ord_compl[p] n 
Arguments: {p d n : ℕ} (hdn : d ∣ n) (hpd : ¬p ∣ d)
Goal: d ∣ n / p ^ n.factorization p
-- Nat.exists_eq_pow_mul_and_not_dvd
theorem exists_eq_pow_mul_and_not_dvd {n : ℕ} (hn : n ≠ 0) (p : ℕ) (hp : p ≠ 1) :
    ∃ e n' : ℕ, ¬p ∣ n' ∧ n = p ^ e * n' 
Arguments: {n : ℕ} (hn : n ≠ 0) (p : ℕ) (hp : p ≠ 1)
Goal: ∃ e n', ¬p ∣ n' ∧ n = p ^ e * n'
-- Nat.exists_eq_two_pow_mul_odd
theorem exists_eq_two_pow_mul_odd {n : ℕ} (hn : n ≠ 0) :
    ∃ k m : ℕ, Odd m ∧ n = 2 ^ k * m 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: ∃ k m, Odd m ∧ n = 2 ^ k * m
-- Nat.dvd_iff_div_factorization_eq_tsub
theorem dvd_iff_div_factorization_eq_tsub {d n : ℕ} (hd : d ≠ 0) (hdn : d ≤ n) :
    d ∣ n ↔ (n / d).factorization = n.factorization - d.factorization 
Arguments: {d n : ℕ} (hd : d ≠ 0) (hdn : d ≤ n)
Goal: d ∣ n ↔ (n / d).factorization = n.factorization - d.factorization
-- Nat.ord_proj_dvd_ord_proj_of_dvd
theorem ord_proj_dvd_ord_proj_of_dvd {a b : ℕ} (hb0 : b ≠ 0) (hab : a ∣ b) (p : ℕ) :
    ord_proj[p] a ∣ ord_proj[p] b 
Arguments: {a b : ℕ} (hb0 : b ≠ 0) (hab : a ∣ b) (p : ℕ)
Goal: p ^ a.factorization p ∣ p ^ b.factorization p
-- Nat.ord_proj_dvd_ord_proj_iff_dvd
theorem ord_proj_dvd_ord_proj_iff_dvd {a b : ℕ} (ha0 : a ≠ 0) (hb0 : b ≠ 0) :
    (∀ p : ℕ, ord_proj[p] a ∣ ord_proj[p] b) ↔ a ∣ b 
Arguments: {a b : ℕ} (ha0 : a ≠ 0) (hb0 : b ≠ 0)
Goal: (∀ (p : ℕ), p ^ a.factorization p ∣ p ^ b.factorization p) ↔ a ∣ b
-- Nat.ord_compl_dvd_ord_compl_of_dvd
theorem ord_compl_dvd_ord_compl_of_dvd {a b : ℕ} (hab : a ∣ b) (p : ℕ) :
    ord_compl[p] a ∣ ord_compl[p] b 
Arguments: {a b : ℕ} (hab : a ∣ b) (p : ℕ)
Goal: a / p ^ a.factorization p ∣ b / p ^ b.factorization p
-- Nat.ord_compl_dvd_ord_compl_iff_dvd
theorem ord_compl_dvd_ord_compl_iff_dvd (a b : ℕ) :
    (∀ p : ℕ, ord_compl[p] a ∣ ord_compl[p] b) ↔ a ∣ b 
Arguments: (a b : ℕ)
Goal: (∀ (p : ℕ), a / p ^ a.factorization p ∣ b / p ^ b.factorization p) ↔ a ∣ b
-- Nat.dvd_iff_prime_pow_dvd_dvd
theorem dvd_iff_prime_pow_dvd_dvd (n d : ℕ) :
    d ∣ n ↔ ∀ p k : ℕ, Prime p → p ^ k ∣ d → p ^ k ∣ n 
Arguments: (n d : ℕ)
Goal: d ∣ n ↔ ∀ (p k : ℕ), Nat.Prime p → p ^ k ∣ d → p ^ k ∣ n
-- Nat.prod_primeFactors_dvd
theorem prod_primeFactors_dvd (n : ℕ) : ∏ p ∈ n.primeFactors, p ∣ n 
Arguments: (n : ℕ)
Goal: ∏ p ∈ n.primeFactors, p ∣ n
-- Nat.factorization_gcd
theorem factorization_gcd {a b : ℕ} (ha_pos : a ≠ 0) (hb_pos : b ≠ 0) :
    (gcd a b).factorization = a.factorization ⊓ b.factorization 
Arguments: {a b : ℕ} (ha_pos : a ≠ 0) (hb_pos : b ≠ 0)
Goal: (a.gcd b).factorization = a.factorization ⊓ b.factorization
-- Nat.factorization_lcm
theorem factorization_lcm {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0) :
    (a.lcm b).factorization = a.factorization ⊔ b.factorization 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: (a.lcm b).factorization = a.factorization ⊔ b.factorization
-- Nat.factorizationLCMLeft_zero_left
@[simp]
lemma factorizationLCMLeft_zero_left : factorizationLCMLeft 0 b = 1 
Arguments: (b : ℕ)
Goal: Nat.factorizationLCMLeft 0 b = 1
-- Nat.factorizationLCMLeft_zero_right
@[simp]
lemma factorizationLCMLeft_zero_right : factorizationLCMLeft a 0 = 1 
Arguments: (a : ℕ)
Goal: a.factorizationLCMLeft 0 = 1
-- Nat.factorizationLCRight_zero_left
@[simp]
lemma factorizationLCRight_zero_left : factorizationLCMRight 0 b = 1 
Arguments: (b : ℕ)
Goal: Nat.factorizationLCMRight 0 b = 1
-- Nat.factorizationLCMRight_zero_right
@[simp]
lemma factorizationLCMRight_zero_right : factorizationLCMRight a 0 = 1 
Arguments: (a : ℕ)
Goal: a.factorizationLCMRight 0 = 1
-- Nat.factorizationLCMLeft_pos
lemma factorizationLCMLeft_pos :
    0 < factorizationLCMLeft a b 
Arguments: (a b : ℕ)
Goal: 0 < a.factorizationLCMLeft b
-- Nat.factorizationLCMRight_pos
lemma factorizationLCMRight_pos :
    0 < factorizationLCMRight a b 
Arguments: (a b : ℕ)
Goal: 0 < a.factorizationLCMRight b
-- Nat.coprime_factorizationLCMLeft_factorizationLCMRight
lemma coprime_factorizationLCMLeft_factorizationLCMRight :
    (factorizationLCMLeft a b).Coprime (factorizationLCMRight a b) 
Arguments: (a b : ℕ)
Goal: (a.factorizationLCMLeft b).Coprime (a.factorizationLCMRight b)
-- Nat.factorizationLCMLeft_mul_factorizationLCMRight
lemma factorizationLCMLeft_mul_factorizationLCMRight (ha : a ≠ 0) (hb : b ≠ 0) :
    (factorizationLCMLeft a b) * (factorizationLCMRight a b) = lcm a b 
Arguments: {a b : ℕ} (ha : a ≠ 0) (hb : b ≠ 0)
Goal: a.factorizationLCMLeft b * a.factorizationLCMRight b = a.lcm b
-- Nat.factorizationLCMLeft_dvd_left
lemma factorizationLCMLeft_dvd_left : factorizationLCMLeft a b ∣ a 
Arguments: (a b : ℕ)
Goal: a.factorizationLCMLeft b ∣ a
-- Nat.factorizationLCMRight_dvd_right
lemma factorizationLCMRight_dvd_right : factorizationLCMRight a b ∣ b 
Arguments: (a b : ℕ)
Goal: a.factorizationLCMRight b ∣ b
-- Nat.prod_primeFactors_gcd_mul_prod_primeFactors_mul
@[to_additive sum_primeFactors_gcd_add_sum_primeFactors_mul]
theorem prod_primeFactors_gcd_mul_prod_primeFactors_mul {β : Type*} [CommMonoid β] (m n : ℕ)
    (f : ℕ → β) :
    (m.gcd n).primeFactors.prod f * (m * n).primeFactors.prod f =
      m.primeFactors.prod f * n.primeFactors.prod f 
Arguments: {β : Type u_1} [CommMonoid β] (m n : ℕ) (f : ℕ → β)
Goal: (m.gcd n).primeFactors.prod f * (m * n).primeFactors.prod f = m.primeFactors.prod f * n.primeFactors.prod f
-- Nat.sum_primeFactors_gcd_add_sum_primeFactors_mul
@[to_additive sum_primeFactors_gcd_add_sum_primeFactors_mul]
theorem prod_primeFactors_gcd_mul_prod_primeFactors_mul {β : Type*} [CommMonoid β] (m n : ℕ)
    (f : ℕ → β) :
    (m.gcd n).primeFactors.prod f * (m * n).primeFactors.prod f =
      m.primeFactors.prod f * n.primeFactors.prod f 
Arguments: {β : Type u_1} [AddCommMonoid β] (m n : ℕ) (f : ℕ → β)
Goal: (m.gcd n).primeFactors.sum f + (m * n).primeFactors.sum f = m.primeFactors.sum f + n.primeFactors.sum f
-- Nat.setOf_pow_dvd_eq_Icc_factorization
theorem setOf_pow_dvd_eq_Icc_factorization {n p : ℕ} (pp : p.Prime) (hn : n ≠ 0) :
    { i : ℕ | i ≠ 0 ∧ p ^ i ∣ n } = Set.Icc 1 (n.factorization p) 
Arguments: {n p : ℕ} (pp : Nat.Prime p) (hn : n ≠ 0)
Goal: {i | i ≠ 0 ∧ p ^ i ∣ n} = Set.Icc 1 (n.factorization p)