ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.nth_mem
theorem nth_mem (n : ℕ) (h : ∀ hf : (setOf p).Finite, n < hf.toFinset.card) : p (nth p n) 
Arguments: {p : ℕ → Prop} (n : ℕ) (h : ∀ (hf : (setOf p).Finite), n < hf.toFinset.card)
Goal: p (Nat.nth p n)
-- Nat.nth_lt_nth'
theorem nth_lt_nth' {m n : ℕ} (hlt : m < n) (h : ∀ hf : (setOf p).Finite, n < hf.toFinset.card) :
    nth p m < nth p n 
Arguments: {p : ℕ → Prop} {m n : ℕ} (hlt : m < n) (h : ∀ (hf : (setOf p).Finite), n < hf.toFinset.card)
Goal: Nat.nth p m < Nat.nth p n
-- Nat.nth_le_nth'
theorem nth_le_nth' {m n : ℕ} (hle : m ≤ n) (h : ∀ hf : (setOf p).Finite, n < hf.toFinset.card) :
    nth p m ≤ nth p n 
Arguments: {p : ℕ → Prop} {m n : ℕ} (hle : m ≤ n) (h : ∀ (hf : (setOf p).Finite), n < hf.toFinset.card)
Goal: Nat.nth p m ≤ Nat.nth p n
-- Nat.le_nth
theorem le_nth {n : ℕ} (h : ∀ hf : (setOf p).Finite, n < hf.toFinset.card) : n ≤ nth p n 
Arguments: {p : ℕ → Prop} {n : ℕ} (h : ∀ (hf : (setOf p).Finite), n < hf.toFinset.card)
Goal: n ≤ Nat.nth p n
-- Nat.isLeast_nth
theorem isLeast_nth {n} (h : ∀ hf : (setOf p).Finite, n < hf.toFinset.card) :
    IsLeast {i | p i ∧ ∀ k < n, nth p k < i} (nth p n) 
Arguments: {p : ℕ → Prop} {n : ℕ} (h : ∀ (hf : (setOf p).Finite), n < hf.toFinset.card)
Goal: IsLeast {i | p i ∧ ∀ k < n, Nat.nth p k < i} (Nat.nth p n)
-- Nat.isLeast_nth_of_lt_card
theorem isLeast_nth_of_lt_card {n : ℕ} (hf : (setOf p).Finite) (hn : n < hf.toFinset.card) :
    IsLeast {i | p i ∧ ∀ k < n, nth p k < i} (nth p n) 
Arguments: {p : ℕ → Prop} {n : ℕ} (hf : (setOf p).Finite) (hn : n < hf.toFinset.card)
Goal: IsLeast {i | p i ∧ ∀ k < n, Nat.nth p k < i} (Nat.nth p n)
-- Nat.isLeast_nth_of_infinite
theorem isLeast_nth_of_infinite (hf : (setOf p).Infinite) (n : ℕ) :
    IsLeast {i | p i ∧ ∀ k < n, nth p k < i} (nth p n) 
Arguments: {p : ℕ → Prop} (hf : (setOf p).Infinite) (n : ℕ)
Goal: IsLeast {i | p i ∧ ∀ k < n, Nat.nth p k < i} (Nat.nth p n)
-- Nat.nth_eq_sInf
theorem nth_eq_sInf (p : ℕ → Prop) (n : ℕ) : nth p n = sInf {x | p x ∧ ∀ k < n, nth p k < x} 
Arguments: (p : ℕ → Prop) (n : ℕ)
Goal: Nat.nth p n = sInf {x | p x ∧ ∀ k < n, Nat.nth p k < x}
-- Nat.nth_zero
theorem nth_zero : nth p 0 = sInf (setOf p) 
Arguments: {p : ℕ → Prop}
Goal: Nat.nth p 0 = sInf (setOf p)
-- Nat.nth_zero_of_zero
@[simp]
theorem nth_zero_of_zero (h : p 0) : nth p 0 = 0 
Arguments: {p : ℕ → Prop} (h : p 0)
Goal: Nat.nth p 0 = 0
-- Nat.nth_zero_of_exists
theorem nth_zero_of_exists [DecidablePred p] (h : ∃ n, p n) : nth p 0 = Nat.find h 
Arguments: {p : ℕ → Prop} [DecidablePred p] (h : ∃ n, p n)
Goal: Nat.nth p 0 = Nat.find h
-- Nat.nth_eq_zero
theorem nth_eq_zero {n} :
    nth p n = 0 ↔ p 0 ∧ n = 0 ∨ ∃ hf : (setOf p).Finite, hf.toFinset.card ≤ n 
Arguments: {p : ℕ → Prop} {n : ℕ}
Goal: Nat.nth p n = 0 ↔ p 0 ∧ n = 0 ∨ ∃ (hf : (setOf p).Finite), hf.toFinset.card ≤ n
-- Nat.nth_eq_zero_mono
theorem nth_eq_zero_mono (h₀ : ¬p 0) {a b : ℕ} (hab : a ≤ b) (ha : nth p a = 0) : nth p b = 0 
Arguments: {p : ℕ → Prop} (h₀ : ¬p 0) {a b : ℕ} (hab : a ≤ b) (ha : Nat.nth p a = 0)
Goal: Nat.nth p b = 0
-- Nat.le_nth_of_lt_nth_succ
theorem le_nth_of_lt_nth_succ {k a : ℕ} (h : a < nth p (k + 1)) (ha : p a) : a ≤ nth p k 
Arguments: {p : ℕ → Prop} {k a : ℕ} (h : a < Nat.nth p (k + 1)) (ha : p a)
Goal: a ≤ Nat.nth p k
-- Nat.count_nth_zero
@[simp]
theorem count_nth_zero : count p (nth p 0) = 0 
Arguments: (p : ℕ → Prop) [DecidablePred p]
Goal: Nat.count p (Nat.nth p 0) = 0
-- Nat.filter_range_nth_subset_insert
theorem filter_range_nth_subset_insert (k : ℕ) :
    (range (nth p (k + 1))).filter p ⊆ insert (nth p k) ((range (nth p k)).filter p) 
Arguments: (p : ℕ → Prop) [DecidablePred p] (k : ℕ)
Goal: Finset.filter p (Finset.range (Nat.nth p (k + 1))) ⊆ insert (Nat.nth p k) (Finset.filter p (Finset.range (Nat.nth p k)))
-- Nat.filter_range_nth_eq_insert
theorem filter_range_nth_eq_insert {k : ℕ}
    (hlt : ∀ hf : (setOf p).Finite, k + 1 < hf.toFinset.card) :
    (range (nth p (k + 1))).filter p = insert (nth p k) ((range (nth p k)).filter p) 
Arguments: {p : ℕ → Prop} [DecidablePred p] {k : ℕ} (hlt : ∀ (hf : (setOf p).Finite), k + 1 < hf.toFinset.card)
Goal: Finset.filter p (Finset.range (Nat.nth p (k + 1))) = insert (Nat.nth p k) (Finset.filter p (Finset.range (Nat.nth p k)))
-- Nat.filter_range_nth_eq_insert_of_finite
theorem filter_range_nth_eq_insert_of_finite (hf : (setOf p).Finite) {k : ℕ}
    (hlt : k + 1 < hf.toFinset.card) :
    (range (nth p (k + 1))).filter p = insert (nth p k) ((range (nth p k)).filter p) 
Arguments: {p : ℕ → Prop} [DecidablePred p] (hf : (setOf p).Finite) {k : ℕ} (hlt : k + 1 < hf.toFinset.card)
Goal: Finset.filter p (Finset.range (Nat.nth p (k + 1))) = insert (Nat.nth p k) (Finset.filter p (Finset.range (Nat.nth p k)))
-- Nat.filter_range_nth_eq_insert_of_infinite
theorem filter_range_nth_eq_insert_of_infinite (hp : (setOf p).Infinite) (k : ℕ) :
    (range (nth p (k + 1))).filter p = insert (nth p k) ((range (nth p k)).filter p) 
Arguments: {p : ℕ → Prop} [DecidablePred p] (hp : (setOf p).Infinite) (k : ℕ)
Goal: Finset.filter p (Finset.range (Nat.nth p (k + 1))) = insert (Nat.nth p k) (Finset.filter p (Finset.range (Nat.nth p k)))
-- Nat.count_nth
theorem count_nth {n : ℕ} (hn : ∀ hf : (setOf p).Finite, n < hf.toFinset.card) :
    count p (nth p n) = n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ} (hn : ∀ (hf : (setOf p).Finite), n < hf.toFinset.card)
Goal: Nat.count p (Nat.nth p n) = n
-- Nat.count_nth_of_lt_card_finite
theorem count_nth_of_lt_card_finite {n : ℕ} (hp : (setOf p).Finite) (hlt : n < hp.toFinset.card) :
    count p (nth p n) = n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ} (hp : (setOf p).Finite) (hlt : n < hp.toFinset.card)
Goal: Nat.count p (Nat.nth p n) = n
-- Nat.count_nth_of_infinite
theorem count_nth_of_infinite (hp : (setOf p).Infinite) (n : ℕ) : count p (nth p n) = n 
Arguments: {p : ℕ → Prop} [DecidablePred p] (hp : (setOf p).Infinite) (n : ℕ)
Goal: Nat.count p (Nat.nth p n) = n
-- Nat.count_nth_succ
theorem count_nth_succ {n : ℕ} (hn : ∀ hf : (setOf p).Finite, n < hf.toFinset.card) :
    count p (nth p n + 1) = n + 1 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ} (hn : ∀ (hf : (setOf p).Finite), n < hf.toFinset.card)
Goal: Nat.count p (Nat.nth p n + 1) = n + 1
-- Nat.nth_count
@[simp]
theorem nth_count {n : ℕ} (hpn : p n) : nth p (count p n) = n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ} (hpn : p n)
Goal: Nat.nth p (Nat.count p n) = n
-- Nat.nth_lt_of_lt_count
theorem nth_lt_of_lt_count {n k : ℕ} (h : k < count p n) : nth p k < n 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n k : ℕ} (h : k < Nat.count p n)
Goal: Nat.nth p k < n
-- Nat.le_nth_of_count_le
theorem le_nth_of_count_le {n k : ℕ} (h : n ≤ nth p k) : count p n ≤ k 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n k : ℕ} (h : n ≤ Nat.nth p k)
Goal: Nat.count p n ≤ k
-- Nat.nth_count_eq_sInf
theorem nth_count_eq_sInf (n : ℕ) : nth p (count p n) = sInf {i : ℕ | p i ∧ n ≤ i} 
Arguments: (p : ℕ → Prop) [DecidablePred p] (n : ℕ)
Goal: Nat.nth p (Nat.count p n) = sInf {i | p i ∧ n ≤ i}
-- Nat.le_nth_count'
theorem le_nth_count' {n : ℕ} (hpn : ∃ k, p k ∧ n ≤ k) : n ≤ nth p (count p n) 
Arguments: {p : ℕ → Prop} [DecidablePred p] {n : ℕ} (hpn : ∃ k, p k ∧ n ≤ k)
Goal: n ≤ Nat.nth p (Nat.count p n)
-- Nat.le_nth_count
theorem le_nth_count (hp : (setOf p).Infinite) (n : ℕ) : n ≤ nth p (count p n) 
Arguments: {p : ℕ → Prop} [DecidablePred p] (hp : (setOf p).Infinite) (n : ℕ)
Goal: n ≤ Nat.nth p (Nat.count p n)
-- Nat.gc_count_nth
theorem gc_count_nth (hp : (setOf p).Infinite) : GaloisConnection (count p) (nth p) 
Arguments: {p : ℕ → Prop} [DecidablePred p] (hp : (setOf p).Infinite)
Goal: GaloisConnection (Nat.count p) (Nat.nth p)
-- Nat.count_le_iff_le_nth
theorem count_le_iff_le_nth (hp : (setOf p).Infinite) {a b : ℕ} : count p a ≤ b ↔ a ≤ nth p b 
Arguments: {p : ℕ → Prop} [DecidablePred p] (hp : (setOf p).Infinite) {a b : ℕ}
Goal: Nat.count p a ≤ b ↔ a ≤ Nat.nth p b
-- Nat.lt_nth_iff_count_lt
theorem lt_nth_iff_count_lt (hp : (setOf p).Infinite) {a b : ℕ} : a < count p b ↔ nth p a < b 
Arguments: {p : ℕ → Prop} [DecidablePred p] (hp : (setOf p).Infinite) {a b : ℕ}
Goal: a < Nat.count p b ↔ Nat.nth p a < b
-- Nat.nth_of_forall
theorem nth_of_forall {n : ℕ} (hp : ∀ n' ≤ n, p n') : nth p n = n 
Arguments: {p : ℕ → Prop} {n : ℕ} (hp : ∀ n' ≤ n, p n')
Goal: Nat.nth p n = n
-- Nat.nth_true
@[simp] theorem nth_true (n : ℕ) : nth (fun _ ↦ True) n = n 
Arguments: (n : ℕ)
Goal: Nat.nth (fun x => True) n = n
-- Nat.nth_of_forall_not
theorem nth_of_forall_not {n : ℕ} (hp : ∀ n' ≥ n, ¬p n') : nth p n = 0 
Arguments: {p : ℕ → Prop} {n : ℕ} (hp : ∀ n' ≥ n, ¬p n')
Goal: Nat.nth p n = 0
-- Nat.nth_false
@[simp] theorem nth_false (n : ℕ) : nth (fun _ ↦ False) n = 0 
Arguments: (n : ℕ)
Goal: Nat.nth (fun x => False) n = 0
-- Nat.factorial_zero
@[simp] theorem factorial_zero : 0! = 1 
Goal: Nat.factorial 0 = 1
-- Nat.factorial_succ
theorem factorial_succ (n : ℕ) : (n + 1)! = (n + 1) * n ! 
Arguments: (n : ℕ)
Goal: (n + 1).factorial = (n + 1) * n.factorial
-- Nat.factorial_one
@[simp] theorem factorial_one : 1! = 1 
Goal: Nat.factorial 1 = 1
-- Nat.factorial_two
@[simp] theorem factorial_two : 2! = 2 
Goal: Nat.factorial 2 = 2
-- Nat.mul_factorial_pred
theorem mul_factorial_pred (hn : 0 < n) : n * (n - 1)! = n ! 
Arguments: {n : ℕ} (hn : 0 < n)
Goal: n * (n - 1).factorial = n.factorial
-- Nat.factorial_pos
theorem factorial_pos : ∀ n, 0 < n !
  
Arguments: (n : ℕ)
Goal: 0 < n.factorial
-- Nat.factorial_ne_zero
theorem factorial_ne_zero (n : ℕ) : n ! ≠ 0 
Arguments: (n : ℕ)
Goal: n.factorial ≠ 0
-- Nat.factorial_dvd_factorial
theorem factorial_dvd_factorial {m n} (h : m ≤ n) : m ! ∣ n ! 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: m.factorial ∣ n.factorial
-- Nat.dvd_factorial
theorem dvd_factorial : ∀ {m n}, 0 < m → m ≤ n → m ∣ n !
  
Arguments: {m n : ℕ}
Goal: 0 < m → m ≤ n → m ∣ n.factorial
-- Nat.factorial_le
@[mono, gcongr]
theorem factorial_le {m n} (h : m ≤ n) : m ! ≤ n ! 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: m.factorial ≤ n.factorial
-- Nat.factorial_mul_pow_le_factorial
theorem factorial_mul_pow_le_factorial : ∀ {m n : ℕ}, m ! * (m + 1) ^ n ≤ (m + n)!
  
Arguments: {m n : ℕ}
Goal: m.factorial * (m + 1) ^ n ≤ (m + n).factorial
-- Nat.factorial_lt
theorem factorial_lt (hn : 0 < n) : n ! < m ! ↔ n < m 
Arguments: {m n : ℕ} (hn : 0 < n)
Goal: n.factorial < m.factorial ↔ n < m
-- Nat.factorial_lt_of_lt
@[gcongr]
lemma factorial_lt_of_lt {m n : ℕ} (hn : 0 < n) (h : n < m) : n ! < m ! 
Arguments: {m n : ℕ} (hn : 0 < n) (h : n < m)
Goal: n.factorial < m.factorial
-- Nat.one_lt_factorial
@[simp] lemma one_lt_factorial : 1 < n ! ↔ 1 < n 
Arguments: {n : ℕ}
Goal: 1 < n.factorial ↔ 1 < n
-- Nat.factorial_eq_one
@[simp]
theorem factorial_eq_one : n ! = 1 ↔ n ≤ 1 
Arguments: {n : ℕ}
Goal: n.factorial = 1 ↔ n ≤ 1
-- Nat.factorial_inj
theorem factorial_inj (hn : 1 < n) : n ! = m ! ↔ n = m 
Arguments: {m n : ℕ} (hn : 1 < n)
Goal: n.factorial = m.factorial ↔ n = m
-- Nat.factorial_inj'
theorem factorial_inj' (h : 1 < n ∨ 1 < m) : n ! = m ! ↔ n = m 
Arguments: {m n : ℕ} (h : 1 < n ∨ 1 < m)
Goal: n.factorial = m.factorial ↔ n = m
-- Nat.self_le_factorial
theorem self_le_factorial : ∀ n : ℕ, n ≤ n !
  
Arguments: (n : ℕ)
Goal: n ≤ n.factorial
-- Nat.lt_factorial_self
theorem lt_factorial_self {n : ℕ} (hi : 3 ≤ n) : n < n ! 
Arguments: {n : ℕ} (hi : 3 ≤ n)
Goal: n < n.factorial
-- Nat.add_factorial_succ_lt_factorial_add_succ
theorem add_factorial_succ_lt_factorial_add_succ {i : ℕ} (n : ℕ) (hi : 2 ≤ i) :
    i + (n + 1)! < (i + n + 1)! 
Arguments: {i : ℕ} (n : ℕ) (hi : 2 ≤ i)
Goal: i + (n + 1).factorial < (i + n + 1).factorial
-- Nat.add_factorial_lt_factorial_add
theorem add_factorial_lt_factorial_add {i n : ℕ} (hi : 2 ≤ i) (hn : 1 ≤ n) :
    i + n ! < (i + n)! 
Arguments: {i n : ℕ} (hi : 2 ≤ i) (hn : 1 ≤ n)
Goal: i + n.factorial < (i + n).factorial
-- Nat.add_factorial_succ_le_factorial_add_succ
theorem add_factorial_succ_le_factorial_add_succ (i : ℕ) (n : ℕ) :
    i + (n + 1)! ≤ (i + (n + 1))! 
Arguments: (i n : ℕ)
Goal: i + (n + 1).factorial ≤ (i + (n + 1)).factorial
-- Nat.add_factorial_le_factorial_add
theorem add_factorial_le_factorial_add (i : ℕ) {n : ℕ} (n1 : 1 ≤ n) : i + n ! ≤ (i + n)! 
Arguments: (i : ℕ) {n : ℕ} (n1 : 1 ≤ n)
Goal: i + n.factorial ≤ (i + n).factorial
-- Nat.factorial_mul_pow_sub_le_factorial
theorem factorial_mul_pow_sub_le_factorial {n m : ℕ} (hnm : n ≤ m) : n ! * n ^ (m - n) ≤ m ! 
Arguments: {n m : ℕ} (hnm : n ≤ m)
Goal: n.factorial * n ^ (m - n) ≤ m.factorial
-- Nat.factorial_le_pow
lemma factorial_le_pow : ∀ n, n ! ≤ n ^ n
  
Arguments: (n : ℕ)
Goal: n.factorial ≤ n ^ n
-- Nat.ascFactorial_zero
@[simp]
theorem ascFactorial_zero (n : ℕ) : n.ascFactorial 0 = 1 
Arguments: (n : ℕ)
Goal: n.ascFactorial 0 = 1
-- Nat.ascFactorial_succ
theorem ascFactorial_succ {n k : ℕ} : n.ascFactorial k.succ = (n + k) * n.ascFactorial k 
Arguments: {n k : ℕ}
Goal: n.ascFactorial k.succ = (n + k) * n.ascFactorial k
-- Nat.zero_ascFactorial
theorem zero_ascFactorial : ∀ (k : ℕ), (0 : ℕ).ascFactorial k.succ = 0
  
Arguments: (k : ℕ)
Goal: Nat.ascFactorial 0 k.succ = 0
-- Nat.one_ascFactorial
@[simp]
theorem one_ascFactorial : ∀ (k : ℕ), (1 : ℕ).ascFactorial k = k.factorial
  
Arguments: (k : ℕ)
Goal: Nat.ascFactorial 1 k = k.factorial
-- Nat.succ_ascFactorial
theorem succ_ascFactorial (n : ℕ) :
    ∀ k, n * n.succ.ascFactorial k = (n + k) * n.ascFactorial k
  
Arguments: (n k : ℕ)
Goal: n * n.succ.ascFactorial k = (n + k) * n.ascFactorial k
-- Nat.factorial_mul_ascFactorial
theorem factorial_mul_ascFactorial (n : ℕ) : ∀ k, n ! * (n + 1).ascFactorial k = (n + k)!
  
Arguments: (n k : ℕ)
Goal: n.factorial * (n + 1).ascFactorial k = (n + k).factorial
-- Nat.factorial_mul_ascFactorial'
theorem factorial_mul_ascFactorial' (n k : ℕ) (h : 0 < n) :
    (n - 1) ! * n.ascFactorial k = (n + k - 1)! 
Arguments: (n k : ℕ) (h : 0 < n)
Goal: (n - 1).factorial * n.ascFactorial k = (n + k - 1).factorial
-- Nat.ascFactorial_eq_div
theorem ascFactorial_eq_div (n k : ℕ) : (n + 1).ascFactorial k = (n + k)! / n ! 
Arguments: (n k : ℕ)
Goal: (n + 1).ascFactorial k = (n + k).factorial / n.factorial
-- Nat.ascFactorial_eq_div'
theorem ascFactorial_eq_div' (n k : ℕ) (h : 0 < n) :
    n.ascFactorial k = (n + k - 1)! / (n - 1) ! 
Arguments: (n k : ℕ) (h : 0 < n)
Goal: n.ascFactorial k = (n + k - 1).factorial / (n - 1).factorial
-- Nat.ascFactorial_of_sub
theorem ascFactorial_of_sub {n k : ℕ} :
    (n - k) * (n - k + 1).ascFactorial k = (n - k).ascFactorial (k + 1) 
Arguments: {n k : ℕ}
Goal: (n - k) * (n - k + 1).ascFactorial k = (n - k).ascFactorial (k + 1)
-- Nat.pow_succ_le_ascFactorial
theorem pow_succ_le_ascFactorial (n : ℕ) : ∀ k : ℕ, n ^ k ≤ n.ascFactorial k
  
Arguments: (n k : ℕ)
Goal: n ^ k ≤ n.ascFactorial k
-- Nat.pow_lt_ascFactorial'
theorem pow_lt_ascFactorial' (n k : ℕ) : (n + 1) ^ (k + 2) < (n + 1).ascFactorial (k + 2) 
Arguments: (n k : ℕ)
Goal: (n + 1) ^ (k + 2) < (n + 1).ascFactorial (k + 2)
-- Nat.pow_lt_ascFactorial
theorem pow_lt_ascFactorial (n : ℕ) : ∀ {k : ℕ}, 2 ≤ k → (n + 1) ^ k < (n + 1).ascFactorial k
  
Arguments: (n : ℕ) {k : ℕ}
Goal: 2 ≤ k → (n + 1) ^ k < (n + 1).ascFactorial k
-- Nat.ascFactorial_le_pow_add
theorem ascFactorial_le_pow_add (n : ℕ) : ∀ k : ℕ, (n+1).ascFactorial k ≤ (n + k) ^ k
  
Arguments: (n k : ℕ)
Goal: (n + 1).ascFactorial k ≤ (n + k) ^ k
-- Nat.ascFactorial_lt_pow_add
theorem ascFactorial_lt_pow_add (n : ℕ) : ∀ {k : ℕ}, 2 ≤ k → (n + 1).ascFactorial k < (n + k) ^ k
  
Arguments: (n : ℕ) {k : ℕ}
Goal: 2 ≤ k → (n + 1).ascFactorial k < (n + k) ^ k
-- Nat.ascFactorial_pos
theorem ascFactorial_pos (n k : ℕ) : 0 < (n + 1).ascFactorial k 
Arguments: (n k : ℕ)
Goal: 0 < (n + 1).ascFactorial k
-- Nat.descFactorial_zero
@[simp]
theorem descFactorial_zero (n : ℕ) : n.descFactorial 0 = 1 
Arguments: (n : ℕ)
Goal: n.descFactorial 0 = 1
-- Nat.descFactorial_succ
@[simp]
theorem descFactorial_succ (n k : ℕ) : n.descFactorial (k + 1) = (n - k) * n.descFactorial k 
Arguments: (n k : ℕ)
Goal: n.descFactorial (k + 1) = (n - k) * n.descFactorial k
-- Nat.zero_descFactorial_succ
theorem zero_descFactorial_succ (k : ℕ) : (0 : ℕ).descFactorial (k + 1) = 0 
Arguments: (k : ℕ)
Goal: Nat.descFactorial 0 (k + 1) = 0
-- Nat.descFactorial_one
theorem descFactorial_one (n : ℕ) : n.descFactorial 1 = n 
Arguments: (n : ℕ)
Goal: n.descFactorial 1 = n
-- Nat.succ_descFactorial_succ
theorem succ_descFactorial_succ (n : ℕ) :
    ∀ k : ℕ, (n + 1).descFactorial (k + 1) = (n + 1) * n.descFactorial k
  
Arguments: (n k : ℕ)
Goal: (n + 1).descFactorial (k + 1) = (n + 1) * n.descFactorial k
-- Nat.succ_descFactorial
theorem succ_descFactorial (n : ℕ) :
    ∀ k, (n + 1 - k) * (n + 1).descFactorial k = (n + 1) * n.descFactorial k
  
Arguments: (n k : ℕ)
Goal: (n + 1 - k) * (n + 1).descFactorial k = (n + 1) * n.descFactorial k
-- Nat.descFactorial_self
theorem descFactorial_self : ∀ n : ℕ, n.descFactorial n = n !
  
Arguments: (n : ℕ)
Goal: n.descFactorial n = n.factorial
-- Nat.descFactorial_eq_zero_iff_lt
@[simp]
theorem descFactorial_eq_zero_iff_lt {n : ℕ} : ∀ {k : ℕ}, n.descFactorial k = 0 ↔ n < k
  
Arguments: {n k : ℕ}
Goal: n.descFactorial k = 0 ↔ n < k
-- Nat.add_descFactorial_eq_ascFactorial
theorem add_descFactorial_eq_ascFactorial (n : ℕ) : ∀ k : ℕ,
    (n + k).descFactorial k = (n + 1).ascFactorial k
  
Arguments: (n k : ℕ)
Goal: (n + k).descFactorial k = (n + 1).ascFactorial k
-- Nat.add_descFactorial_eq_ascFactorial'
theorem add_descFactorial_eq_ascFactorial' (n : ℕ) :
    ∀ k : ℕ, (n + k - 1).descFactorial k = n.ascFactorial k
  
Arguments: (n k : ℕ)
Goal: (n + k - 1).descFactorial k = n.ascFactorial k
-- Nat.factorial_mul_descFactorial
theorem factorial_mul_descFactorial : ∀ {n k : ℕ}, k ≤ n → (n - k)! * n.descFactorial k = n !
  
Arguments: {n k : ℕ}
Goal: k ≤ n → (n - k).factorial * n.descFactorial k = n.factorial
-- Nat.descFactorial_eq_div
theorem descFactorial_eq_div {n k : ℕ} (h : k ≤ n) : n.descFactorial k = n ! / (n - k)! 
Arguments: {n k : ℕ} (h : k ≤ n)
Goal: n.descFactorial k = n.factorial / (n - k).factorial
-- Nat.pow_sub_le_descFactorial
theorem pow_sub_le_descFactorial (n : ℕ) : ∀ k : ℕ, (n + 1 - k) ^ k ≤ n.descFactorial k
  
Arguments: (n k : ℕ)
Goal: (n + 1 - k) ^ k ≤ n.descFactorial k
-- Nat.pow_sub_lt_descFactorial'
theorem pow_sub_lt_descFactorial' {n : ℕ} :
    ∀ {k : ℕ}, k + 2 ≤ n → (n - (k + 1)) ^ (k + 2) < n.descFactorial (k + 2)
  
Arguments: {n k : ℕ}
Goal: k + 2 ≤ n → (n - (k + 1)) ^ (k + 2) < n.descFactorial (k + 2)
-- Nat.pow_sub_lt_descFactorial
theorem pow_sub_lt_descFactorial {n : ℕ} :
    ∀ {k : ℕ}, 2 ≤ k → k ≤ n → (n + 1 - k) ^ k < n.descFactorial k
  
Arguments: {n k : ℕ}
Goal: 2 ≤ k → k ≤ n → (n + 1 - k) ^ k < n.descFactorial k
-- Nat.descFactorial_le_pow
theorem descFactorial_le_pow (n : ℕ) : ∀ k : ℕ, n.descFactorial k ≤ n ^ k
  
Arguments: (n k : ℕ)
Goal: n.descFactorial k ≤ n ^ k
-- Nat.descFactorial_lt_pow
theorem descFactorial_lt_pow {n : ℕ} (hn : 1 ≤ n) : ∀ {k : ℕ}, 2 ≤ k → n.descFactorial k < n ^ k
  
Arguments: {n : ℕ} (hn : 1 ≤ n) {k : ℕ}
Goal: 2 ≤ k → n.descFactorial k < n ^ k
-- Nat.factorial_two_mul_le
lemma factorial_two_mul_le (n : ℕ) : (2 * n)! ≤ (2 * n) ^ n * n ! 
Arguments: (n : ℕ)
Goal: (2 * n).factorial ≤ (2 * n) ^ n * n.factorial
-- Nat.two_pow_mul_factorial_le_factorial_two_mul
lemma two_pow_mul_factorial_le_factorial_two_mul (n : ℕ) : 2 ^ n * n ! ≤ (2 * n) ! 
Arguments: (n : ℕ)
Goal: 2 ^ n * n.factorial ≤ (2 * n).factorial
-- Nat.shiftLeft_eq_mul_pow
theorem shiftLeft_eq_mul_pow (m) : ∀ n, m <<< n = m * 2 ^ n 
Arguments: (m n : ℕ)
Goal: m <<< n = m * 2 ^ n
-- Nat.shiftLeft'_tt_eq_mul_pow
theorem shiftLeft'_tt_eq_mul_pow (m) : ∀ n, shiftLeft' true m n + 1 = (m + 1) * 2 ^ n
  
Arguments: (m n : ℕ)
Goal: Nat.shiftLeft' true m n + 1 = (m + 1) * 2 ^ n
-- Nat.shiftLeft'_ne_zero_left
theorem shiftLeft'_ne_zero_left (b) {m} (h : m ≠ 0) (n) : shiftLeft' b m n ≠ 0 
Arguments: (b : Bool) {m : ℕ} (h : m ≠ 0) (n : ℕ)
Goal: Nat.shiftLeft' b m n ≠ 0
-- Nat.shiftLeft'_tt_ne_zero
theorem shiftLeft'_tt_ne_zero (m) : ∀ {n}, (n ≠ 0) → shiftLeft' true m n ≠ 0
  
Arguments: (m : ℕ) {n : ℕ}
Goal: n ≠ 0 → Nat.shiftLeft' true m n ≠ 0
-- Nat.size_zero
@[simp]
theorem size_zero : size 0 = 0 
Goal: Nat.size 0 = 0
-- Nat.size_bit
@[simp]
theorem size_bit {b n} (h : bit b n ≠ 0) : size (bit b n) = succ (size n) 
Arguments: {b : Bool} {n : ℕ} (h : Nat.bit b n ≠ 0)
Goal: (Nat.bit b n).size = n.size.succ
-- Nat.size_one
@[simp]
theorem size_one : size 1 = 1 
Goal: Nat.size 1 = 1
-- Nat.size_shiftLeft'
@[simp]
theorem size_shiftLeft' {b m n} (h : shiftLeft' b m n ≠ 0) :
    size (shiftLeft' b m n) = size m + n 
Arguments: {b : Bool} {m n : ℕ} (h : Nat.shiftLeft' b m n ≠ 0)
Goal: (Nat.shiftLeft' b m n).size = m.size + n
-- Nat.size_shiftLeft
@[simp, nolint simpNF]
theorem size_shiftLeft {m} (h : m ≠ 0) (n) : size (m <<< n) = size m + n 
Arguments: {m : ℕ} (h : m ≠ 0) (n : ℕ)
Goal: (m <<< n).size = m.size + n
-- Nat.lt_size_self
theorem lt_size_self (n : ℕ) : n < 2 ^ size n 
Arguments: (n : ℕ)
Goal: n < 2 ^ n.size
-- Nat.size_le
theorem size_le {m n : ℕ} : size m ≤ n ↔ m < 2 ^ n 
Arguments: {m n : ℕ}
Goal: m.size ≤ n ↔ m < 2 ^ n
-- Nat.lt_size
theorem lt_size {m n : ℕ} : m < size n ↔ 2 ^ m ≤ n 
Arguments: {m n : ℕ}
Goal: m < n.size ↔ 2 ^ m ≤ n
-- Nat.size_pos
theorem size_pos {n : ℕ} : 0 < size n ↔ 0 < n 
Arguments: {n : ℕ}
Goal: 0 < n.size ↔ 0 < n
-- Nat.size_eq_zero
theorem size_eq_zero {n : ℕ} : size n = 0 ↔ n = 0 
Arguments: {n : ℕ}
Goal: n.size = 0 ↔ n = 0
-- Nat.size_pow
theorem size_pow {n : ℕ} : size (2 ^ n) = n + 1 
Arguments: {n : ℕ}
Goal: (2 ^ n).size = n + 1
-- Nat.size_le_size
theorem size_le_size {m n : ℕ} (h : m ≤ n) : size m ≤ size n 
Arguments: {m n : ℕ} (h : m ≤ n)
Goal: m.size ≤ n.size
-- Nat.size_eq_bits_len
theorem size_eq_bits_len (n : ℕ) : n.bits.length = n.size 
Arguments: (n : ℕ)
Goal: n.bits.length = n.size
-- Nat.superFactorial_zero
@[simp]
theorem superFactorial_zero : sf 0 = 1 
Goal: Nat.superFactorial 0 = 1
-- Nat.superFactorial_succ
theorem superFactorial_succ (n : ℕ) : (sf n.succ) = (n + 1)! * sf n 
Arguments: (n : ℕ)
Goal: n.succ.superFactorial = (n + 1).factorial * n.superFactorial
-- Nat.superFactorial_one
@[simp]
theorem superFactorial_one : sf 1 = 1 
Goal: Nat.superFactorial 1 = 1
-- Nat.superFactorial_two
@[simp]
theorem superFactorial_two : sf 2 = 2 
Goal: Nat.superFactorial 2 = 2
-- Nat.prod_Icc_factorial
@[simp]
theorem prod_Icc_factorial : ∀ n : ℕ, ∏ x ∈ Icc 1 n, x ! = sf n
  
Arguments: (n : ℕ)
Goal: ∏ x ∈ Finset.Icc 1 n, x.factorial = n.superFactorial
-- Nat.prod_range_factorial_succ
@[simp]
theorem prod_range_factorial_succ (n : ℕ) : ∏ x ∈ range n, (x + 1)! = sf n 
Arguments: (n : ℕ)
Goal: ∏ x ∈ Finset.range n, (x + 1).factorial = n.superFactorial
-- Nat.prod_range_succ_factorial
@[simp]
theorem prod_range_succ_factorial : ∀ n : ℕ, ∏ x ∈ range (n + 1), x ! = sf n
  
Arguments: (n : ℕ)
Goal: ∏ x ∈ Finset.range (n + 1), x.factorial = n.superFactorial
-- Nat.det_vandermonde_id_eq_superFactorial
theorem det_vandermonde_id_eq_superFactorial (n : ℕ) :
    (Matrix.vandermonde (fun (i : Fin (n + 1)) ↦ (i : R))).det = Nat.superFactorial n 
Arguments: {R : Type u_1} [CommRing R] (n : ℕ)
Goal: (Matrix.vandermonde fun i => ↑↑i).det = ↑n.superFactorial
-- Nat.superFactorial_two_mul
theorem superFactorial_two_mul : ∀ n : ℕ,
    sf (2 * n) = (∏ i ∈ range n, (2 * i + 1) !) ^ 2 * 2 ^ n * n !
  
Arguments: (n : ℕ)
Goal: (2 * n).superFactorial = (∏ i ∈ Finset.range n, (2 * i + 1).factorial) ^ 2 * 2 ^ n * n.factorial
-- Nat.superFactorial_four_mul
theorem superFactorial_four_mul (n : ℕ) :
    sf (4 * n) = ((∏ i ∈ range (2 * n), (2 * i + 1) !) * 2 ^ n) ^ 2 * (2 * n) ! 
Arguments: (n : ℕ)
Goal: (4 * n).superFactorial = ((∏ i ∈ Finset.range (2 * n), (2 * i + 1).factorial) * 2 ^ n) ^ 2 * (2 * n).factorial
-- _private.Mathlib.Data.Nat.Factorial.SuperFactorial.0.Nat.matrixOf_eval_descPochhammer_eq_mul_matrixOf_choose
private theorem matrixOf_eval_descPochhammer_eq_mul_matrixOf_choose {n : ℕ} (v : Fin n → ℕ) :
    (Matrix.of (fun (i j : Fin n) => (descPochhammer ℤ j).eval (v i : ℤ))).det =
    (∏ i : Fin n, Nat.factorial i) *
      (Matrix.of (fun (i j : Fin n) => (Nat.choose (v i) (j : ℕ) : ℤ))).det 
Arguments: {n : ℕ} (v : Fin n → ℕ)
Goal: (Matrix.of fun i j => Polynomial.eval (↑(v i)) (descPochhammer ℤ ↑j)).det =
  ↑(∏ i : Fin n, (↑i).factorial) * (Matrix.of fun i j => ↑((v i).choose ↑j)).det