ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.superFactorial_dvd_vandermonde_det
theorem superFactorial_dvd_vandermonde_det {n : ℕ} (v : Fin (n + 1) → ℤ) :
    ↑(Nat.superFactorial n) ∣ (Matrix.vandermonde v).det 
Arguments: {n : ℕ} (v : Fin (n + 1) → ℤ)
Goal: ↑n.superFactorial ∣ (Matrix.vandermonde v).det
-- Nat.WithBot.add_eq_zero_iff
theorem add_eq_zero_iff {n m : WithBot ℕ} : n + m = 0 ↔ n = 0 ∧ m = 0 
Arguments: {n m : WithBot ℕ}
Goal: n + m = 0 ↔ n = 0 ∧ m = 0
-- Nat.WithBot.add_eq_one_iff
theorem add_eq_one_iff {n m : WithBot ℕ} : n + m = 1 ↔ n = 0 ∧ m = 1 ∨ n = 1 ∧ m = 0 
Arguments: {n m : WithBot ℕ}
Goal: n + m = 1 ↔ n = 0 ∧ m = 1 ∨ n = 1 ∧ m = 0
-- Nat.WithBot.add_eq_two_iff
theorem add_eq_two_iff {n m : WithBot ℕ} :
    n + m = 2 ↔ n = 0 ∧ m = 2 ∨ n = 1 ∧ m = 1 ∨ n = 2 ∧ m = 0 
Arguments: {n m : WithBot ℕ}
Goal: n + m = 2 ↔ n = 0 ∧ m = 2 ∨ n = 1 ∧ m = 1 ∨ n = 2 ∧ m = 0
-- Nat.WithBot.add_eq_three_iff
theorem add_eq_three_iff {n m : WithBot ℕ} :
    n + m = 3 ↔ n = 0 ∧ m = 3 ∨ n = 1 ∧ m = 2 ∨ n = 2 ∧ m = 1 ∨ n = 3 ∧ m = 0 
Arguments: {n m : WithBot ℕ}
Goal: n + m = 3 ↔ n = 0 ∧ m = 3 ∨ n = 1 ∧ m = 2 ∨ n = 2 ∧ m = 1 ∨ n = 3 ∧ m = 0
-- Nat.WithBot.coe_nonneg
theorem coe_nonneg {n : ℕ} : 0 ≤ (n : WithBot ℕ) 
Arguments: {n : ℕ}
Goal: 0 ≤ ↑n
-- Nat.WithBot.lt_zero_iff
@[simp]
theorem lt_zero_iff {n : WithBot ℕ} : n < 0 ↔ n = ⊥ 
Arguments: {n : WithBot ℕ}
Goal: n < 0 ↔ n = ⊥
-- Nat.WithBot.one_le_iff_zero_lt
theorem one_le_iff_zero_lt {x : WithBot ℕ} : 1 ≤ x ↔ 0 < x 
Arguments: {x : WithBot ℕ}
Goal: 1 ≤ x ↔ 0 < x
-- Nat.WithBot.lt_one_iff_le_zero
theorem lt_one_iff_le_zero {x : WithBot ℕ} : x < 1 ↔ x ≤ 0 
Arguments: {x : WithBot ℕ}
Goal: x < 1 ↔ x ≤ 0
-- Nat.WithBot.add_one_le_of_lt
theorem add_one_le_of_lt {n m : WithBot ℕ} (h : n < m) : n + 1 ≤ m 
Arguments: {n m : WithBot ℕ} (h : n < m)
Goal: n + 1 ≤ m
-- Nat.ModEq.refl
@[refl]
protected theorem refl (a : ℕ) : a ≡ a [MOD n] 
Arguments: {n : ℕ} (a : ℕ)
Goal: a ≡ a [MOD n]
-- Nat.ModEq.rfl
protected theorem rfl : a ≡ a [MOD n] 
Arguments: {n a : ℕ}
Goal: a ≡ a [MOD n]
-- Nat.ModEq.symm
@[symm]
protected theorem symm : a ≡ b [MOD n] → b ≡ a [MOD n] 
Arguments: {n a b : ℕ}
Goal: a ≡ b [MOD n] → b ≡ a [MOD n]
-- Nat.ModEq.trans
@[trans]
protected theorem trans : a ≡ b [MOD n] → b ≡ c [MOD n] → a ≡ c [MOD n] 
Arguments: {n a b c : ℕ}
Goal: a ≡ b [MOD n] → b ≡ c [MOD n] → a ≡ c [MOD n]
-- Nat.ModEq.comm
protected theorem comm : a ≡ b [MOD n] ↔ b ≡ a [MOD n] 
Arguments: {n a b : ℕ}
Goal: a ≡ b [MOD n] ↔ b ≡ a [MOD n]
-- Nat.modEq_zero_iff_dvd
theorem modEq_zero_iff_dvd : a ≡ 0 [MOD n] ↔ n ∣ a 
Arguments: {n a : ℕ}
Goal: a ≡ 0 [MOD n] ↔ n ∣ a
-- Dvd.dvd.modEq_zero_nat
theorem _root_.Dvd.dvd.modEq_zero_nat (h : n ∣ a) : a ≡ 0 [MOD n] 
Arguments: {n a : ℕ} (h : n ∣ a)
Goal: a ≡ 0 [MOD n]
-- Dvd.dvd.zero_modEq_nat
theorem _root_.Dvd.dvd.zero_modEq_nat (h : n ∣ a) : 0 ≡ a [MOD n] 
Arguments: {n a : ℕ} (h : n ∣ a)
Goal: 0 ≡ a [MOD n]
-- Nat.modEq_iff_dvd
theorem modEq_iff_dvd : a ≡ b [MOD n] ↔ (n : ℤ) ∣ b - a 
Arguments: {n a b : ℕ}
Goal: a ≡ b [MOD n] ↔ ↑n ∣ ↑b - ↑a
-- Nat.modEq_iff_dvd'
theorem modEq_iff_dvd' (h : a ≤ b) : a ≡ b [MOD n] ↔ n ∣ b - a 
Arguments: {n a b : ℕ} (h : a ≤ b)
Goal: a ≡ b [MOD n] ↔ n ∣ b - a
-- Nat.mod_modEq
theorem mod_modEq (a n) : a % n ≡ a [MOD n] 
Arguments: (a n : ℕ)
Goal: a % n ≡ a [MOD n]
-- Nat.ModEq.of_dvd
lemma of_dvd (d : m ∣ n) (h : a ≡ b [MOD n]) : a ≡ b [MOD m] 
Arguments: {m n a b : ℕ} (d : m ∣ n) (h : a ≡ b [MOD n])
Goal: a ≡ b [MOD m]
-- Nat.ModEq.mul_left'
protected theorem mul_left' (c : ℕ) (h : a ≡ b [MOD n]) : c * a ≡ c * b [MOD c * n] 
Arguments: {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n])
Goal: c * a ≡ c * b [MOD c * n]
-- Nat.ModEq.mul_left
@[gcongr]
protected theorem mul_left (c : ℕ) (h : a ≡ b [MOD n]) : c * a ≡ c * b [MOD n] 
Arguments: {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n])
Goal: c * a ≡ c * b [MOD n]
-- Nat.ModEq.mul_right'
protected theorem mul_right' (c : ℕ) (h : a ≡ b [MOD n]) : a * c ≡ b * c [MOD n * c] 
Arguments: {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n])
Goal: a * c ≡ b * c [MOD n * c]
-- Nat.ModEq.mul_right
@[gcongr]
protected theorem mul_right (c : ℕ) (h : a ≡ b [MOD n]) : a * c ≡ b * c [MOD n] 
Arguments: {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n])
Goal: a * c ≡ b * c [MOD n]
-- Nat.ModEq.mul
@[gcongr]
protected theorem mul (h₁ : a ≡ b [MOD n]) (h₂ : c ≡ d [MOD n]) : a * c ≡ b * d [MOD n] 
Arguments: {n a b c d : ℕ} (h₁ : a ≡ b [MOD n]) (h₂ : c ≡ d [MOD n])
Goal: a * c ≡ b * d [MOD n]
-- Nat.ModEq.pow
@[gcongr]
protected theorem pow (m : ℕ) (h : a ≡ b [MOD n]) : a ^ m ≡ b ^ m [MOD n] 
Arguments: {n a b : ℕ} (m : ℕ) (h : a ≡ b [MOD n])
Goal: a ^ m ≡ b ^ m [MOD n]
-- Nat.ModEq.add
@[gcongr]
protected theorem add (h₁ : a ≡ b [MOD n]) (h₂ : c ≡ d [MOD n]) : a + c ≡ b + d [MOD n] 
Arguments: {n a b c d : ℕ} (h₁ : a ≡ b [MOD n]) (h₂ : c ≡ d [MOD n])
Goal: a + c ≡ b + d [MOD n]
-- Nat.ModEq.add_left
@[gcongr]
protected theorem add_left (c : ℕ) (h : a ≡ b [MOD n]) : c + a ≡ c + b [MOD n] 
Arguments: {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n])
Goal: c + a ≡ c + b [MOD n]
-- Nat.ModEq.add_right
@[gcongr]
protected theorem add_right (c : ℕ) (h : a ≡ b [MOD n]) : a + c ≡ b + c [MOD n] 
Arguments: {n a b : ℕ} (c : ℕ) (h : a ≡ b [MOD n])
Goal: a + c ≡ b + c [MOD n]
-- Nat.ModEq.add_left_cancel
protected theorem add_left_cancel (h₁ : a ≡ b [MOD n]) (h₂ : a + c ≡ b + d [MOD n]) :
    c ≡ d [MOD n] 
Arguments: {n a b c d : ℕ} (h₁ : a ≡ b [MOD n]) (h₂ : a + c ≡ b + d [MOD n])
Goal: c ≡ d [MOD n]
-- Nat.ModEq.add_left_cancel'
protected theorem add_left_cancel' (c : ℕ) (h : c + a ≡ c + b [MOD n]) : a ≡ b [MOD n] 
Arguments: {n a b : ℕ} (c : ℕ) (h : c + a ≡ c + b [MOD n])
Goal: a ≡ b [MOD n]
-- Nat.ModEq.add_right_cancel
protected theorem add_right_cancel (h₁ : c ≡ d [MOD n]) (h₂ : a + c ≡ b + d [MOD n]) :
    a ≡ b [MOD n] 
Arguments: {n a b c d : ℕ} (h₁ : c ≡ d [MOD n]) (h₂ : a + c ≡ b + d [MOD n])
Goal: a ≡ b [MOD n]
-- Nat.ModEq.add_right_cancel'
protected theorem add_right_cancel' (c : ℕ) (h : a + c ≡ b + c [MOD n]) : a ≡ b [MOD n] 
Arguments: {n a b : ℕ} (c : ℕ) (h : a + c ≡ b + c [MOD n])
Goal: a ≡ b [MOD n]
-- Nat.ModEq.mul_left_cancel'
protected theorem mul_left_cancel' {a b c m : ℕ} (hc : c ≠ 0) :
    c * a ≡ c * b [MOD c * m] → a ≡ b [MOD m] 
Arguments: {a b c m : ℕ} (hc : c ≠ 0)
Goal: c * a ≡ c * b [MOD c * m] → a ≡ b [MOD m]
-- Nat.ModEq.mul_left_cancel_iff'
protected theorem mul_left_cancel_iff' {a b c m : ℕ} (hc : c ≠ 0) :
    c * a ≡ c * b [MOD c * m] ↔ a ≡ b [MOD m] 
Arguments: {a b c m : ℕ} (hc : c ≠ 0)
Goal: c * a ≡ c * b [MOD c * m] ↔ a ≡ b [MOD m]
-- Nat.ModEq.mul_right_cancel'
protected theorem mul_right_cancel' {a b c m : ℕ} (hc : c ≠ 0) :
    a * c ≡ b * c [MOD m * c] → a ≡ b [MOD m] 
Arguments: {a b c m : ℕ} (hc : c ≠ 0)
Goal: a * c ≡ b * c [MOD m * c] → a ≡ b [MOD m]
-- Nat.ModEq.mul_right_cancel_iff'
protected theorem mul_right_cancel_iff' {a b c m : ℕ} (hc : c ≠ 0) :
    a * c ≡ b * c [MOD m * c] ↔ a ≡ b [MOD m] 
Arguments: {a b c m : ℕ} (hc : c ≠ 0)
Goal: a * c ≡ b * c [MOD m * c] ↔ a ≡ b [MOD m]
-- Nat.ModEq.of_mul_left
lemma of_mul_left (m : ℕ) (h : a ≡ b [MOD m * n]) : a ≡ b [MOD n] 
Arguments: {n a b : ℕ} (m : ℕ) (h : a ≡ b [MOD m * n])
Goal: a ≡ b [MOD n]
-- Nat.ModEq.of_mul_right
lemma of_mul_right (m : ℕ) : a ≡ b [MOD n * m] → a ≡ b [MOD n] 
Arguments: {n a b : ℕ} (m : ℕ)
Goal: a ≡ b [MOD n * m] → a ≡ b [MOD n]
-- Nat.ModEq.of_div
theorem of_div (h : a / c ≡ b / c [MOD m / c]) (ha : c ∣ a) (ha : c ∣ b) (ha : c ∣ m) :
    a ≡ b [MOD m] 
Arguments: {m a b c : ℕ} (h : a / c ≡ b / c [MOD m / c]) (ha : c ∣ a)
Goal: c ∣ b → c ∣ m → a ≡ b [MOD m]
-- Nat.modEq_sub
lemma modEq_sub (h : b ≤ a) : a ≡ b [MOD a - b] 
Arguments: {a b : ℕ} (h : b ≤ a)
Goal: a ≡ b [MOD a - b]
-- Nat.modEq_one
lemma modEq_one : a ≡ b [MOD 1] 
Arguments: {a b : ℕ}
Goal: a ≡ b [MOD 1]
-- Nat.modEq_zero_iff
@[simp] lemma modEq_zero_iff : a ≡ b [MOD 0] ↔ a = b 
Arguments: {a b : ℕ}
Goal: a ≡ b [MOD 0] ↔ a = b
-- Nat.add_modEq_left
@[simp] lemma add_modEq_left : n + a ≡ a [MOD n] 
Arguments: {n a : ℕ}
Goal: n + a ≡ a [MOD n]
-- Nat.add_modEq_right
@[simp] lemma add_modEq_right : a + n ≡ a [MOD n] 
Arguments: {n a : ℕ}
Goal: a + n ≡ a [MOD n]
-- Nat.ModEq.le_of_lt_add
theorem le_of_lt_add (h1 : a ≡ b [MOD m]) (h2 : a < b + m) : a ≤ b 
Arguments: {m a b : ℕ} (h1 : a ≡ b [MOD m]) (h2 : a < b + m)
Goal: a ≤ b
-- Nat.ModEq.add_le_of_lt
theorem add_le_of_lt (h1 : a ≡ b [MOD m]) (h2 : a < b) : a + m ≤ b 
Arguments: {m a b : ℕ} (h1 : a ≡ b [MOD m]) (h2 : a < b)
Goal: a + m ≤ b
-- Nat.ModEq.dvd_iff
theorem dvd_iff (h : a ≡ b [MOD m]) (hdm : d ∣ m) : d ∣ a ↔ d ∣ b 
Arguments: {m a b d : ℕ} (h : a ≡ b [MOD m]) (hdm : d ∣ m)
Goal: d ∣ a ↔ d ∣ b
-- Nat.ModEq.gcd_eq
theorem gcd_eq (h : a ≡ b [MOD m]) : gcd a m = gcd b m 
Arguments: {m a b : ℕ} (h : a ≡ b [MOD m])
Goal: a.gcd m = b.gcd m
-- Nat.ModEq.eq_of_abs_lt
lemma eq_of_abs_lt (h : a ≡ b [MOD m]) (h2 : |(b : ℤ) - a| < m) : a = b 
Arguments: {m a b : ℕ} (h : a ≡ b [MOD m]) (h2 : |↑b - ↑a| < ↑m)
Goal: a = b
-- Nat.ModEq.eq_of_lt_of_lt
lemma eq_of_lt_of_lt (h : a ≡ b [MOD m]) (ha : a < m) (hb : b < m) : a = b 
Arguments: {m a b : ℕ} (h : a ≡ b [MOD m]) (ha : a < m) (hb : b < m)
Goal: a = b
-- Nat.ModEq.cancel_left_div_gcd
lemma cancel_left_div_gcd (hm : 0 < m) (h : c * a ≡ c * b [MOD m]) :  a ≡ b [MOD m / gcd m c] 
Arguments: {m a b c : ℕ} (hm : 0 < m) (h : c * a ≡ c * b [MOD m])
Goal: a ≡ b [MOD m / m.gcd c]
-- Nat.ModEq.cancel_right_div_gcd
lemma cancel_right_div_gcd (hm : 0 < m) (h : a * c ≡ b * c [MOD m]) : a ≡ b [MOD m / gcd m c] 
Arguments: {m a b c : ℕ} (hm : 0 < m) (h : a * c ≡ b * c [MOD m])
Goal: a ≡ b [MOD m / m.gcd c]
-- Nat.ModEq.cancel_left_div_gcd'
lemma cancel_left_div_gcd' (hm : 0 < m) (hcd : c ≡ d [MOD m]) (h : c * a ≡ d * b [MOD m]) :
    a ≡ b [MOD m / gcd m c] 
Arguments: {m a b c d : ℕ} (hm : 0 < m) (hcd : c ≡ d [MOD m]) (h : c * a ≡ d * b [MOD m])
Goal: a ≡ b [MOD m / m.gcd c]
-- Nat.ModEq.cancel_right_div_gcd'
lemma cancel_right_div_gcd' (hm : 0 < m) (hcd : c ≡ d [MOD m]) (h : a * c ≡ b * d [MOD m]) :
    a ≡ b [MOD m / gcd m c] 
Arguments: {m a b c d : ℕ} (hm : 0 < m) (hcd : c ≡ d [MOD m]) (h : a * c ≡ b * d [MOD m])
Goal: a ≡ b [MOD m / m.gcd c]
-- Nat.ModEq.cancel_left_of_coprime
lemma cancel_left_of_coprime (hmc : gcd m c = 1) (h : c * a ≡ c * b [MOD m]) : a ≡ b [MOD m] 
Arguments: {m a b c : ℕ} (hmc : m.gcd c = 1) (h : c * a ≡ c * b [MOD m])
Goal: a ≡ b [MOD m]
-- Nat.ModEq.cancel_right_of_coprime
lemma cancel_right_of_coprime (hmc : gcd m c = 1) (h : a * c ≡ b * c [MOD m]) : a ≡ b [MOD m] 
Arguments: {m a b c : ℕ} (hmc : m.gcd c = 1) (h : a * c ≡ b * c [MOD m])
Goal: a ≡ b [MOD m]
-- Nat.chineseRemainder'_lt_lcm
theorem chineseRemainder'_lt_lcm (h : a ≡ b [MOD gcd n m]) (hn : n ≠ 0) (hm : m ≠ 0) :
    ↑(chineseRemainder' h) < lcm n m 
Arguments: {m n a b : ℕ} (h : a ≡ b [MOD n.gcd m]) (hn : n ≠ 0) (hm : m ≠ 0)
Goal: ↑(Nat.chineseRemainder' h) < n.lcm m
-- Nat.chineseRemainder_lt_mul
theorem chineseRemainder_lt_mul (co : n.Coprime m) (a b : ℕ) (hn : n ≠ 0) (hm : m ≠ 0) :
    ↑(chineseRemainder co a b) < n * m 
Arguments: {m n : ℕ} (co : n.Coprime m) (a b : ℕ) (hn : n ≠ 0) (hm : m ≠ 0)
Goal: ↑(Nat.chineseRemainder co a b) < n * m
-- Nat.mod_lcm
theorem mod_lcm (hn : a ≡ b [MOD n]) (hm : a ≡ b [MOD m]) : a ≡ b [MOD lcm n m] 
Arguments: {m n a b : ℕ} (hn : a ≡ b [MOD n]) (hm : a ≡ b [MOD m])
Goal: a ≡ b [MOD n.lcm m]
-- Nat.chineseRemainder_modEq_unique
theorem chineseRemainder_modEq_unique (co : n.Coprime m) {a b z}
    (hzan : z ≡ a [MOD n]) (hzbm : z ≡ b [MOD m]) : z ≡ chineseRemainder co a b [MOD n*m] 
Arguments: {m n : ℕ} (co : n.Coprime m) {a b z : ℕ} (hzan : z ≡ a [MOD n]) (hzbm : z ≡ b [MOD m])
Goal: z ≡ ↑(Nat.chineseRemainder co a b) [MOD n * m]
-- Nat.modEq_and_modEq_iff_modEq_mul
theorem modEq_and_modEq_iff_modEq_mul {a b m n : ℕ} (hmn : m.Coprime n) :
    a ≡ b [MOD m] ∧ a ≡ b [MOD n] ↔ a ≡ b [MOD m * n] 
Arguments: {a b m n : ℕ} (hmn : m.Coprime n)
Goal: a ≡ b [MOD m] ∧ a ≡ b [MOD n] ↔ a ≡ b [MOD m * n]
-- Nat.coprime_of_mul_modEq_one
theorem coprime_of_mul_modEq_one (b : ℕ) {a n : ℕ} (h : a * b ≡ 1 [MOD n]) : a.Coprime n 
Arguments: (b : ℕ) {a n : ℕ} (h : a * b ≡ 1 [MOD n])
Goal: a.Coprime n
-- Nat.add_mod_add_ite
theorem add_mod_add_ite (a b c : ℕ) :
    ((a + b) % c + if c ≤ a % c + b % c then c else 0) = a % c + b % c 
Arguments: (a b c : ℕ)
Goal: ((a + b) % c + if c ≤ a % c + b % c then c else 0) = a % c + b % c
-- Nat.add_mod_of_add_mod_lt
theorem add_mod_of_add_mod_lt {a b c : ℕ} (hc : a % c + b % c < c) :
    (a + b) % c = a % c + b % c 
Arguments: {a b c : ℕ} (hc : a % c + b % c < c)
Goal: (a + b) % c = a % c + b % c
-- Nat.add_mod_add_of_le_add_mod
theorem add_mod_add_of_le_add_mod {a b c : ℕ} (hc : c ≤ a % c + b % c) :
    (a + b) % c + c = a % c + b % c 
Arguments: {a b c : ℕ} (hc : c ≤ a % c + b % c)
Goal: (a + b) % c + c = a % c + b % c
-- Nat.add_div
theorem add_div {a b c : ℕ} (hc0 : 0 < c) :
    (a + b) / c = a / c + b / c + if c ≤ a % c + b % c then 1 else 0 
Arguments: {a b c : ℕ} (hc0 : 0 < c)
Goal: (a + b) / c = a / c + b / c + if c ≤ a % c + b % c then 1 else 0
-- Nat.add_div_eq_of_add_mod_lt
theorem add_div_eq_of_add_mod_lt {a b c : ℕ} (hc : a % c + b % c < c) :
    (a + b) / c = a / c + b / c 
Arguments: {a b c : ℕ} (hc : a % c + b % c < c)
Goal: (a + b) / c = a / c + b / c
-- Nat.add_div_of_dvd_right
protected theorem add_div_of_dvd_right {a b c : ℕ} (hca : c ∣ a) : (a + b) / c = a / c + b / c 
Arguments: {a b c : ℕ} (hca : c ∣ a)
Goal: (a + b) / c = a / c + b / c
-- Nat.add_div_of_dvd_left
protected theorem add_div_of_dvd_left {a b c : ℕ} (hca : c ∣ b) : (a + b) / c = a / c + b / c 
Arguments: {a b c : ℕ} (hca : c ∣ b)
Goal: (a + b) / c = a / c + b / c
-- Nat.add_div_eq_of_le_mod_add_mod
theorem add_div_eq_of_le_mod_add_mod {a b c : ℕ} (hc : c ≤ a % c + b % c) (hc0 : 0 < c) :
    (a + b) / c = a / c + b / c + 1 
Arguments: {a b c : ℕ} (hc : c ≤ a % c + b % c) (hc0 : 0 < c)
Goal: (a + b) / c = a / c + b / c + 1
-- Nat.add_div_le_add_div
theorem add_div_le_add_div (a b c : ℕ) : a / c + b / c ≤ (a + b) / c 
Arguments: (a b c : ℕ)
Goal: a / c + b / c ≤ (a + b) / c
-- Nat.le_mod_add_mod_of_dvd_add_of_not_dvd
theorem le_mod_add_mod_of_dvd_add_of_not_dvd {a b c : ℕ} (h : c ∣ a + b) (ha : ¬c ∣ a) :
    c ≤ a % c + b % c 
Arguments: {a b c : ℕ} (h : c ∣ a + b) (ha : ¬c ∣ a)
Goal: c ≤ a % c + b % c
-- Nat.odd_mul_odd
theorem odd_mul_odd {n m : ℕ} : n % 2 = 1 → m % 2 = 1 → n * m % 2 = 1 
Arguments: {n m : ℕ}
Goal: n % 2 = 1 → m % 2 = 1 → n * m % 2 = 1
-- Nat.odd_mul_odd_div_two
theorem odd_mul_odd_div_two {m n : ℕ} (hm1 : m % 2 = 1) (hn1 : n % 2 = 1) :
    m * n / 2 = m * (n / 2) + m / 2 
Arguments: {m n : ℕ} (hm1 : m % 2 = 1) (hn1 : n % 2 = 1)
Goal: m * n / 2 = m * (n / 2) + m / 2
-- Nat.odd_of_mod_four_eq_one
theorem odd_of_mod_four_eq_one {n : ℕ} : n % 4 = 1 → n % 2 = 1 
Arguments: {n : ℕ}
Goal: n % 4 = 1 → n % 2 = 1
-- Nat.odd_of_mod_four_eq_three
theorem odd_of_mod_four_eq_three {n : ℕ} : n % 4 = 3 → n % 2 = 1 
Arguments: {n : ℕ}
Goal: n % 4 = 3 → n % 2 = 1
-- Nat.odd_mod_four_iff
theorem odd_mod_four_iff {n : ℕ} : n % 2 = 1 ↔ n % 4 = 1 ∨ n % 4 = 3 
Arguments: {n : ℕ}
Goal: n % 2 = 1 ↔ n % 4 = 1 ∨ n % 4 = 3
-- Nat.mod_eq_of_modEq
lemma mod_eq_of_modEq {a b n} (h : a ≡ b [MOD n]) (hb : b < n) : a % n = b 
Arguments: {a b n : ℕ} (h : a ≡ b [MOD n]) (hb : b < n)
Goal: a % n = b
-- Nat.count_zero
@[simp]
theorem count_zero : count p 0 = 0 
Arguments: (p : ℕ → Prop) [DecidablePred p]
Goal: Nat.count p 0 = 0
-- Nat.count_eq_card_filter_range
theorem count_eq_card_filter_range (n : ℕ) : count p n = ((range n).filter p).card 
Arguments: (p : ℕ → Prop) [DecidablePred p] (n : ℕ)
Goal: Nat.count p n = (Finset.filter p (Finset.range n)).card
-- Nat.count_eq_card_fintype
theorem count_eq_card_fintype (n : ℕ) : count p n = Fintype.card { k : ℕ // k < n ∧ p k } 
Arguments: (p : ℕ → Prop) [DecidablePred p] (n : ℕ)
Goal: Nat.count p n = Fintype.card { k // k < n ∧ p k }
-- Nat.count_succ
theorem count_succ (n : ℕ) : count p (n + 1) = count p n + if p n then 1 else 0 
Arguments: (p : ℕ → Prop) [DecidablePred p] (n : ℕ)
Goal: Nat.count p (n + 1) = Nat.count p n + if p n then 1 else 0
-- Nat.count_monotone
@[mono]
theorem count_monotone : Monotone (count p) 
Arguments: (p : ℕ → Prop) [DecidablePred p]
Goal: Monotone (Nat.count p)
-- Nat.count_add
theorem count_add (a b : ℕ) : count p (a + b) = count p a + count (fun k ↦ p (a + k)) b 
Arguments: (p : ℕ → Prop) [DecidablePred p] (a b : ℕ)
Goal: Nat.count p (a + b) = Nat.count p a + Nat.count (fun k => p (a + k)) b
-- Nat.count_add'
theorem count_add' (a b : ℕ) : count p (a + b) = count (fun k ↦ p (k + b)) a + count p b 
Arguments: (p : ℕ → Prop) [DecidablePred p] (a b : ℕ)
Goal: Nat.count p (a + b) = Nat.count (fun k => p (k + b)) a + Nat.count p b
-- Nat.count_one
theorem count_one : count p 1 = if p 0 then 1 else 0 
Arguments: (p : ℕ → Prop) [DecidablePred p]
Goal: Nat.count p 1 = if p 0 then 1 else 0
-- Nat.count_succ'
theorem count_succ' (n : ℕ) :
    count p (n + 1) = count (fun k ↦ p (k + 1)) n + if p 0 then 1 else 0 
Arguments: (p : ℕ → Prop) [DecidablePred p] (n : ℕ)
Goal: Nat.count p (n + 1) = Nat.count (fun k => p (k + 1)) n + if p 0 then 1 else 0
-- Nat.count_lt_count_succ_iff
@[simp]
theorem count_lt_count_succ_iff {n : ℕ} : count p n < count p (n + 1) ↔ p n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ}
Goal: Nat.count p n < Nat.count p (n + 1) ↔ p n
-- Nat.count_succ_eq_succ_count_iff
theorem count_succ_eq_succ_count_iff {n : ℕ} : count p (n + 1) = count p n + 1 ↔ p n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ}
Goal: Nat.count p (n + 1) = Nat.count p n + 1 ↔ p n
-- Nat.count_succ_eq_count_iff
theorem count_succ_eq_count_iff {n : ℕ} : count p (n + 1) = count p n ↔ ¬p n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ}
Goal: Nat.count p (n + 1) = Nat.count p n ↔ ¬p n
-- Nat.count_le_cardinal
theorem count_le_cardinal (n : ℕ) : (count p n : Cardinal) ≤ Cardinal.mk { k | p k } 
Arguments: {p : ℕ → Prop} [DecidablePred p] (n : ℕ)
Goal: ↑(Nat.count p n) ≤ Cardinal.mk ↑{k | p k}
-- Nat.lt_of_count_lt_count
theorem lt_of_count_lt_count {a b : ℕ} (h : count p a < count p b) : a < b 
Arguments: {p : ℕ → Prop} [DecidablePred p] {a b : ℕ} (h : Nat.count p a < Nat.count p b)
Goal: a < b
-- Nat.count_strict_mono
theorem count_strict_mono {m n : ℕ} (hm : p m) (hmn : m < n) : count p m < count p n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {m n : ℕ} (hm : p m) (hmn : m < n)
Goal: Nat.count p m < Nat.count p n
-- Nat.count_injective
theorem count_injective {m n : ℕ} (hm : p m) (hn : p n) (heq : count p m = count p n) : m = n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {m n : ℕ} (hm : p m) (hn : p n) (heq : Nat.count p m = Nat.count p n)
Goal: m = n
-- Nat.count_le_card
theorem count_le_card (hp : (setOf p).Finite) (n : ℕ) : count p n ≤ hp.toFinset.card 
Arguments: {p : ℕ → Prop} [DecidablePred p] (hp : (setOf p).Finite) (n : ℕ)
Goal: Nat.count p n ≤ hp.toFinset.card
-- Nat.count_lt_card
theorem count_lt_card {n : ℕ} (hp : (setOf p).Finite) (hpn : p n) : count p n < hp.toFinset.card 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ} (hp : (setOf p).Finite) (hpn : p n)
Goal: Nat.count p n < hp.toFinset.card
-- Nat.count_of_forall
theorem count_of_forall {n : ℕ} (hp : ∀ n' < n, p n') : count p n = n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ} (hp : ∀ n' < n, p n')
Goal: Nat.count p n = n
-- Nat.count_true
@[simp] theorem count_true (n : ℕ) : count (fun _ ↦ True) n = n 
Arguments: (n : ℕ)
Goal: Nat.count (fun x => True) n = n
-- Nat.count_of_forall_not
theorem count_of_forall_not {n : ℕ} (hp : ∀ n' < n, ¬p n') : count p n = 0 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ} (hp : ∀ n' < n, ¬p n')
Goal: Nat.count p n = 0
-- Nat.count_false
@[simp] theorem count_false (n : ℕ) : count (fun _ ↦ False) n = 0 
Arguments: (n : ℕ)
Goal: Nat.count (fun x => False) n = 0
-- Nat.count_mono_left
theorem count_mono_left {n : ℕ} (hpq : ∀ k, p k → q k) : count p n ≤ count q n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {q : ℕ → Prop} [DecidablePred q] {n : ℕ} (hpq : ∀ (k : ℕ), p k → q k)
Goal: Nat.count p n ≤ Nat.count q n
-- Nat.multinomial_pos
theorem multinomial_pos : 0 < multinomial s f 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℕ)
Goal: 0 < Nat.multinomial s f
-- Nat.multinomial_spec
theorem multinomial_spec : (∏ i ∈ s, (f i)!) * multinomial s f = (∑ i ∈ s, f i)! 
Arguments: {α : Type u_1} (s : Finset α) (f : α → ℕ)
Goal: (∏ i ∈ s, (f i)!) * Nat.multinomial s f = (∑ i ∈ s, f i)!
-- Nat.multinomial_empty
@[simp] lemma multinomial_empty : multinomial ∅ f = 1 
Arguments: {α : Type u_1} (f : α → ℕ)
Goal: Nat.multinomial ∅ f = 1
-- Nat.multinomial_cons
lemma multinomial_cons (ha : a ∉ s) (f : α → ℕ) :
    multinomial (s.cons a ha) f = (f a + ∑ i ∈ s, f i).choose (f a) * multinomial s f 
Arguments: {α : Type u_1} {s : Finset α} {a : α} (ha : a ∉ s) (f : α → ℕ)
Goal: Nat.multinomial (Finset.cons a s ha) f = (f a + ∑ i ∈ s, f i).choose (f a) * Nat.multinomial s f
-- Nat.multinomial_insert
lemma multinomial_insert [DecidableEq α] (ha : a ∉ s) (f : α → ℕ) :
    multinomial (insert a s) f = (f a + ∑ i ∈ s, f i).choose (f a) * multinomial s f 
Arguments: {α : Type u_1} {s : Finset α} {a : α} [DecidableEq α] (ha : a ∉ s) (f : α → ℕ)
Goal: Nat.multinomial (insert a s) f = (f a + ∑ i ∈ s, f i).choose (f a) * Nat.multinomial s f
-- Nat.multinomial_singleton
@[simp] lemma multinomial_singleton (a : α) (f : α → ℕ) : multinomial {a} f = 1 
Arguments: {α : Type u_1} (a : α) (f : α → ℕ)
Goal: Nat.multinomial {a} f = 1
-- Nat.multinomial_insert_one
@[simp]
theorem multinomial_insert_one [DecidableEq α] (h : a ∉ s) (h₁ : f a = 1) :
    multinomial (insert a s) f = (s.sum f).succ * multinomial s f 
Arguments: {α : Type u_1} {s : Finset α} {f : α → ℕ} {a : α} [DecidableEq α] (h : a ∉ s) (h₁ : f a = 1)
Goal: Nat.multinomial (insert a s) f = (s.sum f).succ * Nat.multinomial s f
-- Nat.multinomial_congr
theorem multinomial_congr {f g : α → ℕ} (h : ∀ a ∈ s, f a = g a) :
    multinomial s f = multinomial s g 
Arguments: {α : Type u_1} {s : Finset α} {f g : α → ℕ} (h : ∀ a ∈ s, f a = g a)
Goal: Nat.multinomial s f = Nat.multinomial s g
-- Nat.binomial_eq
theorem binomial_eq [DecidableEq α] (h : a ≠ b) :
    multinomial {a, b} f = (f a + f b)! / ((f a)! * (f b)!) 
Arguments: {α : Type u_1} {f : α → ℕ} {a b : α} [DecidableEq α] (h : a ≠ b)
Goal: Nat.multinomial {a, b} f = (f a + f b)! / ((f a)! * (f b)!)
-- Nat.binomial_eq_choose
theorem binomial_eq_choose [DecidableEq α] (h : a ≠ b) :
    multinomial {a, b} f = (f a + f b).choose (f a) 
Arguments: {α : Type u_1} {f : α → ℕ} {a b : α} [DecidableEq α] (h : a ≠ b)
Goal: Nat.multinomial {a, b} f = (f a + f b).choose (f a)
-- Nat.binomial_spec
theorem binomial_spec [DecidableEq α] (hab : a ≠ b) :
    (f a)! * (f b)! * multinomial {a, b} f = (f a + f b)! 
Arguments: {α : Type u_1} {f : α → ℕ} {a b : α} [DecidableEq α] (hab : a ≠ b)
Goal: (f a)! * (f b)! * Nat.multinomial {a, b} f = (f a + f b)!
-- Nat.binomial_one
@[simp]
theorem binomial_one [DecidableEq α] (h : a ≠ b) (h₁ : f a = 1) :
    multinomial {a, b} f = (f b).succ 
Arguments: {α : Type u_1} {f : α → ℕ} {a b : α} [DecidableEq α] (h : a ≠ b) (h₁ : f a = 1)
Goal: Nat.multinomial {a, b} f = (f b).succ
-- Nat.binomial_succ_succ
theorem binomial_succ_succ [DecidableEq α] (h : a ≠ b) :
    multinomial {a, b} (Function.update (Function.update f a (f a).succ) b (f b).succ) =
      multinomial {a, b} (Function.update f a (f a).succ) +
      multinomial {a, b} (Function.update f b (f b).succ) 
Arguments: {α : Type u_1} {f : α → ℕ} {a b : α} [DecidableEq α] (h : a ≠ b)
Goal: Nat.multinomial {a, b} (Function.update (Function.update f a (f a).succ) b (f b).succ) =
  Nat.multinomial {a, b} (Function.update f a (f a).succ) + Nat.multinomial {a, b} (Function.update f b (f b).succ)
-- Nat.succ_mul_binomial
theorem succ_mul_binomial [DecidableEq α] (h : a ≠ b) :
    (f a + f b).succ * multinomial {a, b} f =
      (f a).succ * multinomial {a, b} (Function.update f a (f a).succ) 
Arguments: {α : Type u_1} {f : α → ℕ} {a b : α} [DecidableEq α] (h : a ≠ b)
Goal: (f a + f b).succ * Nat.multinomial {a, b} f = (f a).succ * Nat.multinomial {a, b} (Function.update f a (f a).succ)
-- Nat.multinomial_univ_two
theorem multinomial_univ_two (a b : ℕ) :
    multinomial Finset.univ ![a, b] = (a + b)! / (a ! * b !) 
Arguments: (a b : ℕ)
Goal: Nat.multinomial Finset.univ ![a, b] = (a + b)! / (a ! * b !)