ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- ENNReal.mul_le_iff_le_inv
theorem mul_le_iff_le_inv {a b r : ℝ≥0∞} (hr₀ : r ≠ 0) (hr₁ : r ≠ ∞) : r * a ≤ b ↔ a ≤ r⁻¹ * b 
Arguments: {a b r : ENNReal} (hr₀ : r ≠ 0) (hr₁ : r ≠ ⊤)
Goal: r * a ≤ b ↔ a ≤ r⁻¹ * b
-- ENNReal.le_of_forall_nnreal_lt
theorem le_of_forall_nnreal_lt {x y : ℝ≥0∞} (h : ∀ r : ℝ≥0, ↑r < x → ↑r ≤ y) : x ≤ y 
Arguments: {x y : ENNReal} (h : ∀ (r : ℝ≥0), ↑r < x → ↑r ≤ y)
Goal: x ≤ y
-- ENNReal.le_of_forall_pos_nnreal_lt
theorem le_of_forall_pos_nnreal_lt {x y : ℝ≥0∞} (h : ∀ r : ℝ≥0, 0 < r → ↑r < x → ↑r ≤ y) : x ≤ y 
Arguments: {x y : ENNReal} (h : ∀ (r : ℝ≥0), 0 < r → ↑r < x → ↑r ≤ y)
Goal: x ≤ y
-- ENNReal.eq_top_of_forall_nnreal_le
theorem eq_top_of_forall_nnreal_le {x : ℝ≥0∞} (h : ∀ r : ℝ≥0, ↑r ≤ x) : x = ∞ 
Arguments: {x : ENNReal} (h : ∀ (r : ℝ≥0), ↑r ≤ x)
Goal: x = ⊤
-- ENNReal.add_div
protected theorem add_div : (a + b) / c = a / c + b / c 
Arguments: {a b c : ENNReal}
Goal: (a + b) / c = a / c + b / c
-- ENNReal.div_add_div_same
protected theorem div_add_div_same {a b c : ℝ≥0∞} : a / c + b / c = (a + b) / c 
Arguments: {a b c : ENNReal}
Goal: a / c + b / c = (a + b) / c
-- ENNReal.div_self
protected theorem div_self (h0 : a ≠ 0) (hI : a ≠ ∞) : a / a = 1 
Arguments: {a : ENNReal} (h0 : a ≠ 0) (hI : a ≠ ⊤)
Goal: a / a = 1
-- ENNReal.mul_div_le
theorem mul_div_le : a * (b / a) ≤ b 
Arguments: {a b : ENNReal}
Goal: a * (b / a) ≤ b
-- ENNReal.eq_div_iff
theorem eq_div_iff (ha : a ≠ 0) (ha' : a ≠ ∞) : b = c / a ↔ a * b = c 
Arguments: {a b c : ENNReal} (ha : a ≠ 0) (ha' : a ≠ ⊤)
Goal: b = c / a ↔ a * b = c
-- ENNReal.div_eq_div_iff
protected theorem div_eq_div_iff (ha : a ≠ 0) (ha' : a ≠ ∞) (hb : b ≠ 0) (hb' : b ≠ ∞) :
    c / b = d / a ↔ a * c = b * d 
Arguments: {a b c d : ENNReal} (ha : a ≠ 0) (ha' : a ≠ ⊤) (hb : b ≠ 0) (hb' : b ≠ ⊤)
Goal: c / b = d / a ↔ a * c = b * d
-- ENNReal.div_eq_one_iff
theorem div_eq_one_iff {a b : ℝ≥0∞} (hb₀ : b ≠ 0) (hb₁ : b ≠ ∞) : a / b = 1 ↔ a = b 
Arguments: {a b : ENNReal} (hb₀ : b ≠ 0) (hb₁ : b ≠ ⊤)
Goal: a / b = 1 ↔ a = b
-- ENNReal.inv_two_add_inv_two
theorem inv_two_add_inv_two : (2 : ℝ≥0∞)⁻¹ + 2⁻¹ = 1 
Goal: 2⁻¹ + 2⁻¹ = 1
-- ENNReal.inv_three_add_inv_three
theorem inv_three_add_inv_three : (3 : ℝ≥0∞)⁻¹ + 3⁻¹ + 3⁻¹ = 1 
Goal: 3⁻¹ + 3⁻¹ + 3⁻¹ = 1
-- ENNReal.add_halves
@[simp]
protected theorem add_halves (a : ℝ≥0∞) : a / 2 + a / 2 = a 
Arguments: (a : ENNReal)
Goal: a / 2 + a / 2 = a
-- ENNReal.add_thirds
@[simp]
theorem add_thirds (a : ℝ≥0∞) : a / 3 + a / 3 + a / 3 = a 
Arguments: (a : ENNReal)
Goal: a / 3 + a / 3 + a / 3 = a
-- ENNReal.div_eq_zero_iff
@[simp] theorem div_eq_zero_iff : a / b = 0 ↔ a = 0 ∨ b = ∞ 
Arguments: {a b : ENNReal}
Goal: a / b = 0 ↔ a = 0 ∨ b = ⊤
-- ENNReal.div_pos_iff
@[simp] theorem div_pos_iff : 0 < a / b ↔ a ≠ 0 ∧ b ≠ ∞ 
Arguments: {a b : ENNReal}
Goal: 0 < a / b ↔ a ≠ 0 ∧ b ≠ ⊤
-- ENNReal.div_ne_zero
protected lemma div_ne_zero : a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ ⊤ 
Arguments: {a b : ENNReal}
Goal: a / b ≠ 0 ↔ a ≠ 0 ∧ b ≠ ⊤
-- ENNReal.half_pos
protected theorem half_pos (h : a ≠ 0) : 0 < a / 2 
Arguments: {a : ENNReal} (h : a ≠ 0)
Goal: 0 < a / 2
-- ENNReal.one_half_lt_one
protected theorem one_half_lt_one : (2⁻¹ : ℝ≥0∞) < 1 
Goal: 2⁻¹ < 1
-- ENNReal.half_lt_self
protected theorem half_lt_self (hz : a ≠ 0) (ht : a ≠ ∞) : a / 2 < a 
Arguments: {a : ENNReal} (hz : a ≠ 0) (ht : a ≠ ⊤)
Goal: a / 2 < a
-- ENNReal.half_le_self
protected theorem half_le_self : a / 2 ≤ a 
Arguments: {a : ENNReal}
Goal: a / 2 ≤ a
-- ENNReal.sub_half
theorem sub_half (h : a ≠ ∞) : a - a / 2 = a / 2 
Arguments: {a : ENNReal} (h : a ≠ ⊤)
Goal: a - a / 2 = a / 2
-- ENNReal.one_sub_inv_two
@[simp]
theorem one_sub_inv_two : (1 : ℝ≥0∞) - 2⁻¹ = 2⁻¹ 
Goal: 1 - 2⁻¹ = 2⁻¹
-- ENNReal.orderIsoIicOneBirational_apply_coe
@[simps! apply_coe]
def orderIsoIicOneBirational : ℝ≥0∞ ≃o Iic (1 : ℝ≥0∞) 
Arguments: (x : ENNReal)
Goal: ↑(ENNReal.orderIsoIicOneBirational x) = (x⁻¹ + 1)⁻¹
-- ENNReal.orderIsoIicOneBirational_symm_apply
@[simp]
theorem orderIsoIicOneBirational_symm_apply (x : Iic (1 : ℝ≥0∞)) :
    orderIsoIicOneBirational.symm x = (x.1⁻¹ - 1)⁻¹ 
Arguments: (x : ↑(Set.Iic 1))
Goal: ENNReal.orderIsoIicOneBirational.symm x = ((↑x)⁻¹ - 1)⁻¹
-- ENNReal.orderIsoIicCoe_apply_coe
@[simps! apply_coe]
def orderIsoIicCoe (a : ℝ≥0) : Iic (a : ℝ≥0∞) ≃o Iic a 
Arguments: (a : ℝ≥0)
Goal: ∀ (a_1 : ↑(Set.Iic ↑a)), ↑((ENNReal.orderIsoIicCoe a) a_1) = (↑a_1).toNNReal
-- ENNReal.orderIsoIicCoe_symm_apply_coe
@[simp]
theorem orderIsoIicCoe_symm_apply_coe (a : ℝ≥0) (b : Iic a) :
    ((orderIsoIicCoe a).symm b : ℝ≥0∞) = b 
Arguments: (a : ℝ≥0) (b : ↑(Set.Iic a))
Goal: ↑((ENNReal.orderIsoIicCoe a).symm b) = ↑↑b
-- ENNReal.orderIsoUnitIntervalBirational_apply_coe
@[simp]
theorem orderIsoUnitIntervalBirational_apply_coe (x : ℝ≥0∞) :
    (orderIsoUnitIntervalBirational x : ℝ) = (x⁻¹ + 1)⁻¹.toReal 
Arguments: (x : ENNReal)
Goal: ↑(ENNReal.orderIsoUnitIntervalBirational x) = (x⁻¹ + 1)⁻¹.toReal
-- ENNReal.exists_inv_nat_lt
theorem exists_inv_nat_lt {a : ℝ≥0∞} (h : a ≠ 0) : ∃ n : ℕ, (n : ℝ≥0∞)⁻¹ < a 
Arguments: {a : ENNReal} (h : a ≠ 0)
Goal: ∃ n, (↑n)⁻¹ < a
-- ENNReal.exists_nat_pos_mul_gt
theorem exists_nat_pos_mul_gt (ha : a ≠ 0) (hb : b ≠ ∞) : ∃ n > 0, b < (n : ℕ) * a 
Arguments: {a b : ENNReal} (ha : a ≠ 0) (hb : b ≠ ⊤)
Goal: ∃ n > 0, b < ↑n * a
-- ENNReal.exists_nat_mul_gt
theorem exists_nat_mul_gt (ha : a ≠ 0) (hb : b ≠ ∞) : ∃ n : ℕ, b < n * a 
Arguments: {a b : ENNReal} (ha : a ≠ 0) (hb : b ≠ ⊤)
Goal: ∃ n, b < ↑n * a
-- ENNReal.exists_nat_pos_inv_mul_lt
theorem exists_nat_pos_inv_mul_lt (ha : a ≠ ∞) (hb : b ≠ 0) :
    ∃ n > 0, ((n : ℕ) : ℝ≥0∞)⁻¹ * a < b 
Arguments: {a b : ENNReal} (ha : a ≠ ⊤) (hb : b ≠ 0)
Goal: ∃ n > 0, (↑n)⁻¹ * a < b
-- ENNReal.exists_nnreal_pos_mul_lt
theorem exists_nnreal_pos_mul_lt (ha : a ≠ ∞) (hb : b ≠ 0) : ∃ n > 0, ↑(n : ℝ≥0) * a < b 
Arguments: {a b : ENNReal} (ha : a ≠ ⊤) (hb : b ≠ 0)
Goal: ∃ n > 0, ↑n * a < b
-- ENNReal.exists_inv_two_pow_lt
theorem exists_inv_two_pow_lt (ha : a ≠ 0) : ∃ n : ℕ, 2⁻¹ ^ n < a 
Arguments: {a : ENNReal} (ha : a ≠ 0)
Goal: ∃ n, 2⁻¹ ^ n < a
-- ENNReal.coe_zpow
@[simp, norm_cast]
theorem coe_zpow (hr : r ≠ 0) (n : ℤ) : (↑(r ^ n) : ℝ≥0∞) = (r : ℝ≥0∞) ^ n 
Arguments: {r : ℝ≥0} (hr : r ≠ 0) (n : ℤ)
Goal: ↑(r ^ n) = ↑r ^ n
-- ENNReal.zpow_pos
theorem zpow_pos (ha : a ≠ 0) (h'a : a ≠ ∞) (n : ℤ) : 0 < a ^ n 
Arguments: {a : ENNReal} (ha : a ≠ 0) (h'a : a ≠ ⊤) (n : ℤ)
Goal: 0 < a ^ n
-- ENNReal.zpow_lt_top
theorem zpow_lt_top (ha : a ≠ 0) (h'a : a ≠ ∞) (n : ℤ) : a ^ n < ∞ 
Arguments: {a : ENNReal} (ha : a ≠ 0) (h'a : a ≠ ⊤) (n : ℤ)
Goal: a ^ n < ⊤
-- ENNReal.exists_mem_Ico_zpow
theorem exists_mem_Ico_zpow {x y : ℝ≥0∞} (hx : x ≠ 0) (h'x : x ≠ ∞) (hy : 1 < y) (h'y : y ≠ ⊤) :
    ∃ n : ℤ, x ∈ Ico (y ^ n) (y ^ (n + 1)) 
Arguments: {x y : ENNReal} (hx : x ≠ 0) (h'x : x ≠ ⊤) (hy : 1 < y) (h'y : y ≠ ⊤)
Goal: ∃ n, x ∈ Set.Ico (y ^ n) (y ^ (n + 1))
-- ENNReal.exists_mem_Ioc_zpow
theorem exists_mem_Ioc_zpow {x y : ℝ≥0∞} (hx : x ≠ 0) (h'x : x ≠ ∞) (hy : 1 < y) (h'y : y ≠ ⊤) :
    ∃ n : ℤ, x ∈ Ioc (y ^ n) (y ^ (n + 1)) 
Arguments: {x y : ENNReal} (hx : x ≠ 0) (h'x : x ≠ ⊤) (hy : 1 < y) (h'y : y ≠ ⊤)
Goal: ∃ n, x ∈ Set.Ioc (y ^ n) (y ^ (n + 1))
-- ENNReal.Ioo_zero_top_eq_iUnion_Ico_zpow
theorem Ioo_zero_top_eq_iUnion_Ico_zpow {y : ℝ≥0∞} (hy : 1 < y) (h'y : y ≠ ⊤) :
    Ioo (0 : ℝ≥0∞) (∞ : ℝ≥0∞) = ⋃ n : ℤ, Ico (y ^ n) (y ^ (n + 1)) 
Arguments: {y : ENNReal} (hy : 1 < y) (h'y : y ≠ ⊤)
Goal: Set.Ioo 0 ⊤ = ⋃ n, Set.Ico (y ^ n) (y ^ (n + 1))
-- ENNReal.zpow_le_of_le
@[gcongr]
theorem zpow_le_of_le {x : ℝ≥0∞} (hx : 1 ≤ x) {a b : ℤ} (h : a ≤ b) : x ^ a ≤ x ^ b 
Arguments: {x : ENNReal} (hx : 1 ≤ x) {a b : ℤ} (h : a ≤ b)
Goal: x ^ a ≤ x ^ b
-- ENNReal.monotone_zpow
theorem monotone_zpow {x : ℝ≥0∞} (hx : 1 ≤ x) : Monotone ((x ^ ·) : ℤ → ℝ≥0∞) 
Arguments: {x : ENNReal} (hx : 1 ≤ x)
Goal: Monotone fun x_1 => x ^ x_1
-- ENNReal.zpow_add
protected theorem zpow_add {x : ℝ≥0∞} (hx : x ≠ 0) (h'x : x ≠ ∞) (m n : ℤ) :
    x ^ (m + n) = x ^ m * x ^ n 
Arguments: {x : ENNReal} (hx : x ≠ 0) (h'x : x ≠ ⊤) (m n : ℤ)
Goal: x ^ (m + n) = x ^ m * x ^ n
-- Nat.modEq_list_prod_iff
lemma modEq_list_prod_iff {a b} {l : List ℕ} (co : l.Pairwise Coprime) :
    a ≡ b [MOD l.prod] ↔ ∀ i, a ≡ b [MOD l.get i] 
Arguments: {a b : ℕ} {l : List ℕ} (co : List.Pairwise Nat.Coprime l)
Goal: a ≡ b [MOD l.prod] ↔ ∀ (i : Fin l.length), a ≡ b [MOD l.get i]
-- Nat.modEq_list_prod_iff'
lemma modEq_list_prod_iff' {a b} {s : ι → ℕ} {l : List ι} (co : l.Pairwise (Coprime on s)) :
    a ≡ b [MOD (l.map s).prod] ↔ ∀ i ∈ l, a ≡ b [MOD s i] 
Arguments: {ι : Type u_1} {a b : ℕ} {s : ι → ℕ} {l : List ι} (co : List.Pairwise (Nat.Coprime on s) l)
Goal: a ≡ b [MOD (List.map s l).prod] ↔ ∀ i ∈ l, a ≡ b [MOD s i]
-- Nat.chineseRemainderOfList_nil
@[simp] theorem chineseRemainderOfList_nil :
    (chineseRemainderOfList a s [] List.Pairwise.nil : ℕ) = 0 
Arguments: {ι : Type u_1} (a s : ι → ℕ)
Goal: ↑(Nat.chineseRemainderOfList a s [] ⋯) = 0
-- Nat.chineseRemainderOfList_lt_prod
theorem chineseRemainderOfList_lt_prod (l : List ι)
    (co : l.Pairwise (Coprime on s)) (hs : ∀ i ∈ l, s i ≠ 0) :
    chineseRemainderOfList a s l co < (l.map s).prod 
Arguments: {ι : Type u_1} (a s : ι → ℕ) (l : List ι) (co : List.Pairwise (Nat.Coprime on s) l) (hs : ∀ i ∈ l, s i ≠ 0)
Goal: ↑(Nat.chineseRemainderOfList a s l co) < (List.map s l).prod
-- Nat.chineseRemainderOfList_modEq_unique
theorem chineseRemainderOfList_modEq_unique (l : List ι)
    (co : l.Pairwise (Coprime on s)) {z} (hz : ∀ i ∈ l, z ≡ a i [MOD s i]) :
    z ≡ chineseRemainderOfList a s l co [MOD (l.map s).prod] 
Arguments: {ι : Type u_1} (a s : ι → ℕ) (l : List ι) (co : List.Pairwise (Nat.Coprime on s) l) {z : ℕ} (hz : ∀ i ∈ l, z ≡ a i [MOD s i])
Goal: z ≡ ↑(Nat.chineseRemainderOfList a s l co) [MOD (List.map s l).prod]
-- Nat.chineseRemainderOfList_perm
theorem chineseRemainderOfList_perm {l l' : List ι} (hl : l.Perm l')
    (hs : ∀ i ∈ l, s i ≠ 0) (co : l.Pairwise (Coprime on s)) :
    (chineseRemainderOfList a s l co : ℕ) =
    chineseRemainderOfList a s l' (co.perm hl coprime_comm.mpr) 
Arguments: {ι : Type u_1} (a s : ι → ℕ) {l l' : List ι} (hl : l.Perm l') (hs : ∀ i ∈ l, s i ≠ 0) (co : List.Pairwise (Nat.Coprime on s) l)
Goal: ↑(Nat.chineseRemainderOfList a s l co) = ↑(Nat.chineseRemainderOfList a s l' ⋯)
-- Nat.chineseRemainderOfMultiset_lt_prod
theorem chineseRemainderOfMultiset_lt_prod {m : Multiset ι}
    (nod : m.Nodup) (hs : ∀ i ∈ m, s i ≠ 0) (pp : Set.Pairwise {x | x ∈ m} (Coprime on s)) :
    chineseRemainderOfMultiset a s nod hs pp < (m.map s).prod 
Arguments: {ι : Type u_1} (a s : ι → ℕ) {m : Multiset ι} (nod : m.Nodup) (hs : ∀ i ∈ m, s i ≠ 0) (pp : {x | x ∈ m}.Pairwise (Nat.Coprime on s))
Goal: ↑(Nat.chineseRemainderOfMultiset a s nod hs pp) < (Multiset.map s m).prod
-- Nat.chineseRemainderOfFinset_lt_prod
theorem chineseRemainderOfFinset_lt_prod {t : Finset ι}
    (hs : ∀ i ∈ t, s i ≠ 0) (pp : Set.Pairwise t (Coprime on s)) :
    chineseRemainderOfFinset a s t hs pp < ∏ i ∈ t, s i 
Arguments: {ι : Type u_1} (a s : ι → ℕ) {t : Finset ι} (hs : ∀ i ∈ t, s i ≠ 0) (pp : (↑t).Pairwise (Nat.Coprime on s))
Goal: ↑(Nat.chineseRemainderOfFinset a s t hs pp) < ∏ i ∈ t, s i
-- Nat.choose_zero_right
@[simp]
theorem choose_zero_right (n : ℕ) : choose n 0 = 1 
Arguments: (n : ℕ)
Goal: n.choose 0 = 1
-- Nat.choose_zero_succ
@[simp]
theorem choose_zero_succ (k : ℕ) : choose 0 (succ k) = 0 
Arguments: (k : ℕ)
Goal: Nat.choose 0 k.succ = 0
-- Nat.choose_succ_succ
theorem choose_succ_succ (n k : ℕ) : choose (succ n) (succ k) = choose n k + choose n (succ k) 
Arguments: (n k : ℕ)
Goal: n.succ.choose k.succ = n.choose k + n.choose k.succ
-- Nat.choose_succ_succ'
theorem choose_succ_succ' (n k : ℕ) : choose (n + 1) (k + 1) = choose n k + choose n (k + 1) 
Arguments: (n k : ℕ)
Goal: (n + 1).choose (k + 1) = n.choose k + n.choose (k + 1)
-- Nat.choose_eq_zero_of_lt
theorem choose_eq_zero_of_lt : ∀ {n k}, n < k → choose n k = 0
  
Arguments: {n k : ℕ}
Goal: n < k → n.choose k = 0
-- Nat.choose_self
@[simp]
theorem choose_self (n : ℕ) : choose n n = 1 
Arguments: (n : ℕ)
Goal: n.choose n = 1
-- Nat.choose_succ_self
@[simp]
theorem choose_succ_self (n : ℕ) : choose n (succ n) = 0 
Arguments: (n : ℕ)
Goal: n.choose n.succ = 0
-- Nat.choose_one_right
@[simp]
lemma choose_one_right (n : ℕ) : choose n 1 = n 
Arguments: (n : ℕ)
Goal: n.choose 1 = n
-- Nat.triangle_succ
theorem triangle_succ (n : ℕ) : (n + 1) * (n + 1 - 1) / 2 = n * (n - 1) / 2 + n 
Arguments: (n : ℕ)
Goal: (n + 1) * (n + 1 - 1) / 2 = n * (n - 1) / 2 + n
-- Nat.choose_two_right
theorem choose_two_right (n : ℕ) : choose n 2 = n * (n - 1) / 2 
Arguments: (n : ℕ)
Goal: n.choose 2 = n * (n - 1) / 2
-- Nat.choose_pos
theorem choose_pos : ∀ {n k}, k ≤ n → 0 < choose n k
  
Arguments: {n k : ℕ}
Goal: k ≤ n → 0 < n.choose k
-- Nat.choose_eq_zero_iff
theorem choose_eq_zero_iff {n k : ℕ} : n.choose k = 0 ↔ n < k 
Arguments: {n k : ℕ}
Goal: n.choose k = 0 ↔ n < k
-- Nat.succ_mul_choose_eq
theorem succ_mul_choose_eq : ∀ n k, succ n * choose n k = choose (succ n) (succ k) * succ k
  
Arguments: (n k : ℕ)
Goal: n.succ * n.choose k = n.succ.choose k.succ * k.succ
-- Nat.choose_mul_factorial_mul_factorial
theorem choose_mul_factorial_mul_factorial : ∀ {n k}, k ≤ n → choose n k * k ! * (n - k)! = n !
  
Arguments: {n k : ℕ}
Goal: k ≤ n → n.choose k * k ! * (n - k)! = n !
-- Nat.choose_mul
theorem choose_mul {n k s : ℕ} (hkn : k ≤ n) (hsk : s ≤ k) :
    n.choose k * k.choose s = n.choose s * (n - s).choose (k - s) 
Arguments: {n k s : ℕ} (hkn : k ≤ n) (hsk : s ≤ k)
Goal: n.choose k * k.choose s = n.choose s * (n - s).choose (k - s)
-- Nat.choose_eq_factorial_div_factorial
theorem choose_eq_factorial_div_factorial {n k : ℕ} (hk : k ≤ n) :
    choose n k = n ! / (k ! * (n - k)!) 
Arguments: {n k : ℕ} (hk : k ≤ n)
Goal: n.choose k = n ! / (k ! * (n - k)!)
-- Nat.add_choose
theorem add_choose (i j : ℕ) : (i + j).choose j = (i + j)! / (i ! * j !) 
Arguments: (i j : ℕ)
Goal: (i + j).choose j = (i + j)! / (i ! * j !)
-- Nat.add_choose_mul_factorial_mul_factorial
theorem add_choose_mul_factorial_mul_factorial (i j : ℕ) :
    (i + j).choose j * i ! * j ! = (i + j)! 
Arguments: (i j : ℕ)
Goal: (i + j).choose j * i ! * j ! = (i + j)!
-- Nat.factorial_mul_factorial_dvd_factorial
theorem factorial_mul_factorial_dvd_factorial {n k : ℕ} (hk : k ≤ n) : k ! * (n - k)! ∣ n ! 
Arguments: {n k : ℕ} (hk : k ≤ n)
Goal: k ! * (n - k)! ∣ n !
-- Nat.factorial_mul_factorial_dvd_factorial_add
theorem factorial_mul_factorial_dvd_factorial_add (i j : ℕ) : i ! * j ! ∣ (i + j)! 
Arguments: (i j : ℕ)
Goal: i ! * j ! ∣ (i + j)!
-- Nat.choose_symm
@[simp]
theorem choose_symm {n k : ℕ} (hk : k ≤ n) : choose n (n - k) = choose n k 
Arguments: {n k : ℕ} (hk : k ≤ n)
Goal: n.choose (n - k) = n.choose k
-- Nat.choose_symm_of_eq_add
theorem choose_symm_of_eq_add {n a b : ℕ} (h : n = a + b) : Nat.choose n a = Nat.choose n b 
Arguments: {n a b : ℕ} (h : n = a + b)
Goal: n.choose a = n.choose b
-- Nat.choose_symm_add
theorem choose_symm_add {a b : ℕ} : choose (a + b) a = choose (a + b) b 
Arguments: {a b : ℕ}
Goal: (a + b).choose a = (a + b).choose b
-- Nat.choose_symm_half
theorem choose_symm_half (m : ℕ) : choose (2 * m + 1) (m + 1) = choose (2 * m + 1) m 
Arguments: (m : ℕ)
Goal: (2 * m + 1).choose (m + 1) = (2 * m + 1).choose m
-- Nat.choose_succ_right_eq
theorem choose_succ_right_eq (n k : ℕ) : choose n (k + 1) * (k + 1) = choose n k * (n - k) 
Arguments: (n k : ℕ)
Goal: n.choose (k + 1) * (k + 1) = n.choose k * (n - k)
-- Nat.choose_succ_self_right
@[simp]
theorem choose_succ_self_right : ∀ n : ℕ, (n + 1).choose n = n + 1
  
Arguments: (n : ℕ)
Goal: (n + 1).choose n = n + 1
-- Nat.choose_mul_succ_eq
theorem choose_mul_succ_eq (n k : ℕ) : n.choose k * (n + 1) = (n + 1).choose k * (n + 1 - k) 
Arguments: (n k : ℕ)
Goal: n.choose k * (n + 1) = (n + 1).choose k * (n + 1 - k)
-- Nat.ascFactorial_eq_factorial_mul_choose
theorem ascFactorial_eq_factorial_mul_choose (n k : ℕ) :
    (n + 1).ascFactorial k = k ! * (n + k).choose k 
Arguments: (n k : ℕ)
Goal: (n + 1).ascFactorial k = k ! * (n + k).choose k
-- Nat.ascFactorial_eq_factorial_mul_choose'
theorem ascFactorial_eq_factorial_mul_choose' (n k : ℕ) :
    n.ascFactorial k = k ! * (n + k - 1).choose k 
Arguments: (n k : ℕ)
Goal: n.ascFactorial k = k ! * (n + k - 1).choose k
-- Nat.factorial_dvd_ascFactorial
theorem factorial_dvd_ascFactorial (n k : ℕ) : k ! ∣ n.ascFactorial k 
Arguments: (n k : ℕ)
Goal: k ! ∣ n.ascFactorial k
-- Nat.choose_eq_asc_factorial_div_factorial
theorem choose_eq_asc_factorial_div_factorial (n k : ℕ) :
    (n + k).choose k = (n + 1).ascFactorial k / k ! 
Arguments: (n k : ℕ)
Goal: (n + k).choose k = (n + 1).ascFactorial k / k !
-- Nat.choose_eq_asc_factorial_div_factorial'
theorem choose_eq_asc_factorial_div_factorial' (n k : ℕ) :
    (n + k - 1).choose k = n.ascFactorial k / k ! 
Arguments: (n k : ℕ)
Goal: (n + k - 1).choose k = n.ascFactorial k / k !
-- Nat.descFactorial_eq_factorial_mul_choose
theorem descFactorial_eq_factorial_mul_choose (n k : ℕ) : n.descFactorial k = k ! * n.choose k 
Arguments: (n k : ℕ)
Goal: n.descFactorial k = k ! * n.choose k
-- Nat.factorial_dvd_descFactorial
theorem factorial_dvd_descFactorial (n k : ℕ) : k ! ∣ n.descFactorial k 
Arguments: (n k : ℕ)
Goal: k ! ∣ n.descFactorial k
-- Nat.choose_eq_descFactorial_div_factorial
theorem choose_eq_descFactorial_div_factorial (n k : ℕ) : n.choose k = n.descFactorial k / k ! 
Arguments: (n k : ℕ)
Goal: n.choose k = n.descFactorial k / k !
-- Nat.choose_eq_fast_choose
@[csimp] lemma choose_eq_fast_choose : Nat.choose = fast_choose 
Goal: Nat.choose = Nat.fast_choose
-- Nat.choose_le_succ_of_lt_half_left
theorem choose_le_succ_of_lt_half_left {r n : ℕ} (h : r < n / 2) :
    choose n r ≤ choose n (r + 1) 
Arguments: {r n : ℕ} (h : r < n / 2)
Goal: n.choose r ≤ n.choose (r + 1)
-- _private.Mathlib.Data.Nat.Choose.Basic.0.Nat.choose_le_middle_of_le_half_left
private theorem choose_le_middle_of_le_half_left {n r : ℕ} (hr : r ≤ n / 2) :
    choose n r ≤ choose n (n / 2) 
Arguments: {n r : ℕ} (hr : r ≤ n / 2)
Goal: n.choose r ≤ n.choose (n / 2)
-- Nat.choose_le_middle
theorem choose_le_middle (r n : ℕ) : choose n r ≤ choose n (n / 2) 
Arguments: (r n : ℕ)
Goal: n.choose r ≤ n.choose (n / 2)
-- Nat.choose_le_succ
theorem choose_le_succ (a c : ℕ) : choose a c ≤ choose a.succ c 
Arguments: (a c : ℕ)
Goal: a.choose c ≤ a.succ.choose c
-- Nat.choose_le_add
theorem choose_le_add (a b c : ℕ) : choose a c ≤ choose (a + b) c 
Arguments: (a b c : ℕ)
Goal: a.choose c ≤ (a + b).choose c
-- Nat.choose_le_choose
theorem choose_le_choose {a b : ℕ} (c : ℕ) (h : a ≤ b) : choose a c ≤ choose b c 
Arguments: {a b : ℕ} (c : ℕ) (h : a ≤ b)
Goal: a.choose c ≤ b.choose c
-- Nat.choose_mono
theorem choose_mono (b : ℕ) : Monotone fun a => choose a b 
Arguments: (b : ℕ)
Goal: Monotone fun a => a.choose b
-- Nat.multichoose_zero_right
@[simp]
theorem multichoose_zero_right (n : ℕ) : multichoose n 0 = 1 
Arguments: (n : ℕ)
Goal: n.multichoose 0 = 1
-- Nat.multichoose_zero_succ
@[simp]
theorem multichoose_zero_succ (k : ℕ) : multichoose 0 (k + 1) = 0 
Arguments: (k : ℕ)
Goal: Nat.multichoose 0 (k + 1) = 0
-- Nat.multichoose_succ_succ
theorem multichoose_succ_succ (n k : ℕ) :
    multichoose (n + 1) (k + 1) = multichoose n (k + 1) + multichoose (n + 1) k 
Arguments: (n k : ℕ)
Goal: (n + 1).multichoose (k + 1) = n.multichoose (k + 1) + (n + 1).multichoose k
-- Nat.multichoose_one
@[simp]
theorem multichoose_one (k : ℕ) : multichoose 1 k = 1 
Arguments: (k : ℕ)
Goal: Nat.multichoose 1 k = 1
-- Nat.multichoose_two
@[simp]
theorem multichoose_two (k : ℕ) : multichoose 2 k = k + 1 
Arguments: (k : ℕ)
Goal: Nat.multichoose 2 k = k + 1
-- Nat.multichoose_one_right
@[simp]
theorem multichoose_one_right (n : ℕ) : multichoose n 1 = n 
Arguments: (n : ℕ)
Goal: n.multichoose 1 = n
-- Nat.multichoose_eq
theorem multichoose_eq : ∀ n k : ℕ, multichoose n k = (n + k - 1).choose k
  
Arguments: (n k : ℕ)
Goal: n.multichoose k = (n + k - 1).choose k
-- Fin.tuple0_le
theorem tuple0_le {α : Fin 0 → Type*} [∀ i, Preorder (α i)] (f g : ∀ i, α i) : f ≤ g 
Arguments: {α : Fin 0 → Type u_1} [(i : Fin 0) → Preorder (α i)] (f g : (i : Fin 0) → α i)
Goal: f ≤ g
-- Fin.tail_def
theorem tail_def {n : ℕ} {α : Fin (n + 1) → Type*} {q : ∀ i, α i} :
    (tail fun k : Fin (n + 1) ↦ q k) = fun k : Fin n ↦ q k.succ 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} {q : (i : Fin (n + 1)) → α i}
Goal: (Fin.tail fun k => q k) = fun k => q k.succ
-- Fin.tail_cons
@[simp]
theorem tail_cons : tail (cons x p) = p 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α 0) (p : (i : Fin n) → α i.succ)
Goal: Fin.tail (Fin.cons x p) = p
-- Fin.cons_succ
@[simp]
theorem cons_succ : cons x p i.succ = p i 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α 0) (p : (i : Fin n) → α i.succ) (i : Fin n)
Goal: Fin.cons x p i.succ = p i
-- Fin.cons_zero
@[simp]
theorem cons_zero : cons x p 0 = x 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α 0) (p : (i : Fin n) → α i.succ)
Goal: Fin.cons x p 0 = x
-- Fin.cons_one
@[simp]
theorem cons_one {α : Fin (n + 2) → Type*} (x : α 0) (p : ∀ i : Fin n.succ, α i.succ) :
    cons x p 1 = p 0 
Arguments: {n : ℕ} {α : Fin (n + 2) → Type u_1} (x : α 0) (p : (i : Fin n.succ) → α i.succ)
Goal: Fin.cons x p 1 = p 0
-- Fin.cons_update
@[simp]
theorem cons_update : cons x (update p i y) = update (cons x p) i.succ y 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α 0) (p : (i : Fin n) → α i.succ) (i : Fin n) (y : α i.succ)
Goal: Fin.cons x (Function.update p i y) = Function.update (Fin.cons x p) i.succ y
-- Fin.cons_injective2
theorem cons_injective2 : Function.Injective2 (@cons n α) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u}
Goal: Function.Injective2 Fin.cons
-- Fin.cons_eq_cons
@[simp]
theorem cons_eq_cons {x₀ y₀ : α 0} {x y : ∀ i : Fin n, α i.succ} :
    cons x₀ x = cons y₀ y ↔ x₀ = y₀ ∧ x = y 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} {x₀ y₀ : α 0} {x y : (i : Fin n) → α i.succ}
Goal: Fin.cons x₀ x = Fin.cons y₀ y ↔ x₀ = y₀ ∧ x = y
-- Fin.cons_left_injective
theorem cons_left_injective (x : ∀ i : Fin n, α i.succ) : Function.Injective fun x₀ ↦ cons x₀ x 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : (i : Fin n) → α i.succ)
Goal: Function.Injective fun x₀ => Fin.cons x₀ x
-- Fin.cons_right_injective
theorem cons_right_injective (x₀ : α 0) : Function.Injective (cons x₀) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x₀ : α 0)
Goal: Function.Injective (Fin.cons x₀)
-- Fin.update_cons_zero
theorem update_cons_zero : update (cons x p) 0 z = cons z p 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (x : α 0) (p : (i : Fin n) → α i.succ) (z : α 0)
Goal: Function.update (Fin.cons x p) 0 z = Fin.cons z p
-- Fin.cons_self_tail
@[simp, nolint simpNF] -- Porting note: linter claims LHS doesn't simplify
theorem cons_self_tail : cons (q 0) (tail q) = q 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (q : (i : Fin (n + 1)) → α i)
Goal: Fin.cons (q 0) (Fin.tail q) = q
-- Fin.consCases_cons
@[simp]
theorem consCases_cons {P : (∀ i : Fin n.succ, α i) → Sort v} (h : ∀ x₀ x, P (Fin.cons x₀ x))
    (x₀ : α 0) (x : ∀ i : Fin n, α i.succ) : @consCases _ _ _ h (cons x₀ x) = h x₀ x 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} {P : ((i : Fin n.succ) → α i) → Sort v} (h : (x₀ : α 0) → (x : (i : Fin n) → α i.succ) → P (Fin.cons x₀ x)) (x₀ : α 0) (x : (i : Fin n) → α i.succ)
Goal: Fin.consCases h (Fin.cons x₀ x) = h x₀ x
-- Fin.cons_injective_of_injective
theorem cons_injective_of_injective {α} {x₀ : α} {x : Fin n → α} (hx₀ : x₀ ∉ Set.range x)
    (hx : Function.Injective x) : Function.Injective (cons x₀ x : Fin n.succ → α) 
Arguments: {n : ℕ} {α : Type u_1} {x₀ : α} {x : Fin n → α} (hx₀ : x₀ ∉ Set.range x) (hx : Function.Injective x)
Goal: Function.Injective (Fin.cons x₀ x)
-- Fin.cons_injective_iff
theorem cons_injective_iff {α} {x₀ : α} {x : Fin n → α} :
    Function.Injective (cons x₀ x : Fin n.succ → α) ↔ x₀ ∉ Set.range x ∧ Function.Injective x 
Arguments: {n : ℕ} {α : Type u_1} {x₀ : α} {x : Fin n → α}
Goal: Function.Injective (Fin.cons x₀ x) ↔ x₀ ∉ Set.range x ∧ Function.Injective x
-- Fin.forall_fin_zero_pi
@[simp]
theorem forall_fin_zero_pi {α : Fin 0 → Sort*} {P : (∀ i, α i) → Prop} :
    (∀ x, P x) ↔ P finZeroElim 
Arguments: {α : Fin 0 → Sort u_1} {P : ((i : Fin 0) → α i) → Prop}
Goal: (∀ (x : (i : Fin 0) → α i), P x) ↔ P finZeroElim