ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
File: Mathlib/Data/Nat/Choose/Central.lean

full_name: Nat.centralBinom
code: /-- The central binomial coefficient, `Nat.choose (2 * n) n`.
-/
def centralBinom (n : ℕ) 
goal: ℕ

full_name: Nat.centralBinom_eq_two_mul_choose
code: theorem centralBinom_eq_two_mul_choose (n : ℕ) : centralBinom n = (2 * n).choose n 
goal: n.centralBinom = (2 * n).choose n

full_name: Nat.centralBinom_pos
code: theorem centralBinom_pos (n : ℕ) : 0 < centralBinom n 
goal: 0 < n.centralBinom

full_name: Nat.centralBinom_ne_zero
code: theorem centralBinom_ne_zero (n : ℕ) : centralBinom n ≠ 0 
goal: n.centralBinom ≠ 0

full_name: Nat.centralBinom_zero
code: @[simp]
theorem centralBinom_zero : centralBinom 0 = 1 
goal: Nat.centralBinom 0 = 1

full_name: Nat.choose_le_centralBinom
code: /-- The central binomial coefficient is the largest binomial coefficient.
-/
theorem choose_le_centralBinom (r n : ℕ) : choose (2 * n) r ≤ centralBinom n 
goal: (2 * n).choose r ≤ n.centralBinom

full_name: Nat.two_le_centralBinom
code: theorem two_le_centralBinom (n : ℕ) (n_pos : 0 < n) : 2 ≤ centralBinom n 
goal: 2 ≤ n.centralBinom

full_name: Nat.succ_mul_centralBinom_succ
code: /-- An inductive property of the central binomial coefficient.
-/
theorem succ_mul_centralBinom_succ (n : ℕ) :
    (n + 1) * centralBinom (n + 1) = 2 * (2 * n + 1) * centralBinom n 
goal: (n + 1) * (n + 1).centralBinom = 2 * (2 * n + 1) * n.centralBinom

full_name: Nat.four_pow_lt_mul_centralBinom
code: /-- An exponential lower bound on the central binomial coefficient.
This bound is of interest because it appears in
[Tochiori's refinement of Erdős's proof of Bertrand's postulate](tochiori_bertrand).
-/
theorem four_pow_lt_mul_centralBinom (n : ℕ) (n_big : 4 ≤ n) : 4 ^ n < n * centralBinom n 
goal: 4 ^ n < n * n.centralBinom

full_name: Nat.four_pow_le_two_mul_self_mul_centralBinom
code: /-- An exponential lower bound on the central binomial coefficient.
This bound is weaker than `Nat.four_pow_lt_mul_centralBinom`, but it is of historical interest
because it appears in Erdős's proof of Bertrand's postulate.
-/
theorem four_pow_le_two_mul_self_mul_centralBinom :
    ∀ (n : ℕ) (_ : 0 < n), 4 ^ n ≤ 2 * n * centralBinom n
  
goal: 0 < n → 4 ^ n ≤ 2 * n * n.centralBinom

full_name: Nat.two_dvd_centralBinom_succ
code: theorem two_dvd_centralBinom_succ (n : ℕ) : 2 ∣ centralBinom (n + 1) 
goal: 2 ∣ (n + 1).centralBinom

full_name: Nat.two_dvd_centralBinom_of_one_le
code: theorem two_dvd_centralBinom_of_one_le {n : ℕ} (h : 0 < n) : 2 ∣ centralBinom n 
goal: 2 ∣ n.centralBinom

full_name: Nat.succ_dvd_centralBinom
code: /-- A crucial lemma to ensure that Catalan numbers can be defined via their explicit formula
  `catalan n = n.centralBinom / (n + 1)`. -/
theorem succ_dvd_centralBinom (n : ℕ) : n + 1 ∣ n.centralBinom 
goal: n + 1 ∣ n.centralBinom
File: Mathlib/Data/Nat/Choose/Lucas.lean

full_name: Choose.choose_modEq_choose_mod_mul_choose_div
code: /-- For primes `p`, `choose n k` is congruent to `choose (n % p) (k % p) * choose (n / p) (k / p)`
modulo `p`. Also see `choose_modEq_choose_mod_mul_choose_div_nat` for the version with `MOD`. -/
theorem choose_modEq_choose_mod_mul_choose_div :
    choose n k ≡ choose (n % p) (k % p) * choose (n / p) (k / p) [ZMOD p] 
goal: ↑(n.choose k) ≡ ↑((n % p).choose (k % p)) * ↑((n / p).choose (k / p)) [ZMOD ↑p]

full_name: Choose.choose_modEq_choose_mod_mul_choose_div_nat
code: /-- For primes `p`, `choose n k` is congruent to `choose (n % p) (k % p) * choose (n / p) (k / p)`
modulo `p`. Also see `choose_modEq_choose_mod_mul_choose_div` for the version with `ZMOD`. -/
theorem choose_modEq_choose_mod_mul_choose_div_nat :
    choose n k ≡ choose (n % p) (k % p) * choose (n / p) (k / p) [MOD p] 
goal: n.choose k ≡ (n % p).choose (k % p) * (n / p).choose (k / p) [MOD p]

full_name: Choose.choose_modEq_choose_mul_prod_range_choose
code: /-- For primes `p`, `choose n k` is congruent to the product of `choose (⌊n / p ^ i⌋ % p)
(⌊k / p ^ i⌋ % p)` over i < a, multiplied by `choose (⌊n / p ^ a⌋) (⌊k / p ^ a⌋)`, modulo `p`. -/
theorem choose_modEq_choose_mul_prod_range_choose (a : ℕ) :
    choose n k ≡ choose (n / p ^ a) (k / p ^ a) *
      ∏ i in range a, choose (n / p ^ i % p) (k / p ^ i % p) [ZMOD p] 
goal: ↑(n.choose k) ≡
  ↑((n / p ^ a).choose (k / p ^ a)) * ↑(∏ i ∈ Finset.range a, (n / p ^ i % p).choose (k / p ^ i % p)) [ZMOD ↑p]

full_name: Choose.choose_modEq_prod_range_choose
code: /-- **Lucas's Theorem**: For primes `p`, `choose n k` is congruent to the product of
`choose (⌊n / p ^ i⌋ % p) (⌊k / p ^ i⌋ % p)` over `i` modulo `p`. -/
theorem choose_modEq_prod_range_choose {a : ℕ} (ha₁ : n < p ^ a) (ha₂ : k < p ^ a) :
    choose n k ≡ ∏ i in range a, choose (n / p ^ i % p) (k / p ^ i % p) [ZMOD p] 
goal: ↑(n.choose k) ≡ ∏ i ∈ Finset.range a, ↑((n / p ^ i % p).choose (k / p ^ i % p)) [ZMOD ↑p]

full_name: Choose.choose_modEq_prod_range_choose_nat
code: /-- **Lucas's Theorem**: For primes `p`, `choose n k` is congruent to the product of
`choose (⌊n / p ^ i⌋ % p) (⌊k / p ^ i⌋ % p)` over `i` modulo `p`. -/
theorem choose_modEq_prod_range_choose_nat {a : ℕ} (ha₁ : n < p ^ a) (ha₂ : k < p ^ a) :
    choose n k ≡ ∏ i in range a, choose (n / p ^ i % p) (k / p ^ i % p) [MOD p] 
goal: n.choose k ≡ ∏ i ∈ Finset.range a, (n / p ^ i % p).choose (k / p ^ i % p) [MOD p]
File: Mathlib/Data/Nat/Set.lean

full_name: Nat.zero_union_range_succ
code: theorem zero_union_range_succ : {0} ∪ range succ = univ 
goal: {0} ∪ Set.range Nat.succ = Set.univ

full_name: Nat.range_succ
code: @[simp]
protected theorem range_succ : range succ = { i | 0 < i } 
goal: Set.range Nat.succ = {i | 0 < i}

full_name: Nat.range_of_succ
code: theorem range_of_succ (f : ℕ → α) : {f 0} ∪ range (f ∘ succ) = range f 
goal: {f 0} ∪ Set.range (f ∘ Nat.succ) = Set.range f

full_name: Nat.range_rec
code: theorem range_rec {α : Type*} (x : α) (f : ℕ → α → α) :
    (Set.range fun n => Nat.rec x f n : Set α) =
      {x} ∪ Set.range fun n => Nat.rec (f 0 x) (f ∘ succ) n 
goal: (Set.range fun n => Nat.rec x f n) = {x} ∪ Set.range fun n => Nat.rec (f 0 x) (f ∘ Nat.succ) n

full_name: Nat.range_casesOn
code: theorem range_casesOn {α : Type*} (x : α) (f : ℕ → α) :
    (Set.range fun n => Nat.casesOn n x f : Set α) = {x} ∪ Set.range f 
goal: (Set.range fun n => Nat.casesOn n x f) = {x} ∪ Set.range f
File: Mathlib/Data/Nat/PSub.lean

full_name: Nat.ppred
code: /-- Partial predecessor operation. Returns `ppred n = some m`
  if `n = m + 1`, otherwise `none`. -/
def ppred : ℕ → Option ℕ
  
goal: ℕ → Option ℕ

full_name: Nat.ppred_zero
code: @[simp]
theorem ppred_zero : ppred 0 = none 
goal: Nat.ppred 0 = none

full_name: Nat.ppred_succ
code: @[simp]
theorem ppred_succ {n : ℕ} : ppred (succ n) = some n 
goal: n.succ.ppred = some n

full_name: Nat.psub
code: /-- Partial subtraction operation. Returns `psub m n = some k`
  if `m = n + k`, otherwise `none`. -/
def psub (m : ℕ) : ℕ → Option ℕ
  
goal: ℕ → Option ℕ

full_name: Nat.psub_zero
code: @[simp]
theorem psub_zero {m : ℕ} : psub m 0 = some m 
goal: m.psub 0 = some m

full_name: Nat.psub_succ
code: @[simp]
theorem psub_succ {m n : ℕ} : psub m (succ n) = psub m n >>= ppred 
goal: m.psub n.succ = m.psub n >>= Nat.ppred

full_name: Nat.pred_eq_ppred
code: theorem pred_eq_ppred (n : ℕ) : pred n = (ppred n).getD 0 
goal: n.pred = n.ppred.getD 0

full_name: Nat.sub_eq_psub
code: theorem sub_eq_psub (m : ℕ) : ∀ n, m - n = (psub m n).getD 0
  
goal: m - n = (m.psub n).getD 0

full_name: Nat.ppred_eq_some
code: @[simp]
theorem ppred_eq_some {m : ℕ} : ∀ {n}, ppred n = some m ↔ succ m = n
  
goal: n.ppred = some m ↔ m.succ = n

full_name: Nat.ppred_eq_none
code: @[simp]
theorem ppred_eq_none : ∀ {n : ℕ}, ppred n = none ↔ n = 0
  
goal: n.ppred = none ↔ n = 0

full_name: Nat.psub_eq_some
code: theorem psub_eq_some {m : ℕ} : ∀ {n k}, psub m n = some k ↔ k + n = m
  
goal: m.psub n = some k ↔ k + n = m

full_name: Nat.psub_eq_none
code: theorem psub_eq_none {m n : ℕ} : psub m n = none ↔ m < n 
goal: m.psub n = none ↔ m < n

full_name: Nat.ppred_eq_pred
code: theorem ppred_eq_pred {n} (h : 0 < n) : ppred n = some (pred n) 
goal: n.ppred = some n.pred

full_name: Nat.psub_eq_sub
code: theorem psub_eq_sub {m n} (h : n ≤ m) : psub m n = some (m - n) 
goal: m.psub n = some (m - n)

full_name: Nat.psub_add
code: theorem psub_add (m n k) :
    psub m (n + k) = (do psub (← psub m n) k) 
goal: m.psub (n + k) = do
  let __do_lift ← m.psub n
  __do_lift.psub k

full_name: Nat.psub'
code: /-- Same as `psub`, but with a more efficient implementation. -/
@[inline]
def psub' (m n : ℕ) : Option ℕ 
goal: Option ℕ

full_name: Nat.psub'_eq_psub
code: theorem psub'_eq_psub (m n) : psub' m n = psub m n 
goal: m.psub' n = m.psub n
File: Mathlib/Data/Nat/EvenOddRec.lean

full_name: Nat.evenOddRec
code: /-- Recursion principle on even and odd numbers: if we have `P 0`, and for all `i : ℕ` we can
extend from `P i` to both `P (2 * i)` and `P (2 * i + 1)`, then we have `P n` for all `n : ℕ`.
This is nothing more than a wrapper around `Nat.binaryRec`, to avoid having to switch to
dealing with `bit0` and `bit1`. -/
@[elab_as_elim]
def evenOddRec {P : ℕ → Sort*} (h0 : P 0) (h_even : ∀ n, P n → P (2 * n))
    (h_odd : ∀ n, P n → P (2 * n + 1)) (n : ℕ) : P n 
goal: P n

full_name: Nat.evenOddRec_zero
code: @[simp]
theorem evenOddRec_zero {P : ℕ → Sort*} (h0 : P 0) (h_even : ∀ i, P i → P (2 * i))
    (h_odd : ∀ i, P i → P (2 * i + 1)) : evenOddRec h0 h_even h_odd 0 = h0 
goal: Nat.evenOddRec h0 h_even h_odd 0 = h0

full_name: Nat.evenOddRec_even
code: @[simp]
theorem evenOddRec_even {P : ℕ → Sort*} (h0 : P 0) (h_even : ∀ i, P i → P (2 * i))
    (h_odd : ∀ i, P i → P (2 * i + 1)) (H : h_even 0 h0 = h0) (n : ℕ) :
    (2 * n).evenOddRec h0 h_even h_odd = h_even n (evenOddRec h0 h_even h_odd n) 
goal: Nat.evenOddRec h0 h_even h_odd (2 * n) = h_even n (Nat.evenOddRec h0 h_even h_odd n)

full_name: Nat.evenOddRec_odd
code: @[simp]
theorem evenOddRec_odd {P : ℕ → Sort*} (h0 : P 0) (h_even : ∀ i, P i → P (2 * i))
    (h_odd : ∀ i, P i → P (2 * i + 1)) (H : h_even 0 h0 = h0) (n : ℕ) :
    (2 * n + 1).evenOddRec h0 h_even h_odd = h_odd n (evenOddRec h0 h_even h_odd n) 
goal: Nat.evenOddRec h0 h_even h_odd (2 * n + 1) = h_odd n (Nat.evenOddRec h0 h_even h_odd n)

full_name: Nat.evenOddStrongRec
code: /-- Strong recursion principle on even and odd numbers: if for all `i : ℕ` we can prove `P (2 * i)`
from `P j` for all `j < 2 * i` and we can prove `P (2 * i + 1)` from `P j` for all `j < 2 * i + 1`,
then we have `P n` for all `n : ℕ`. -/
@[elab_as_elim]
noncomputable def evenOddStrongRec {P : ℕ → Sort*}
    (h_even : ∀ n : ℕ, (∀ k < 2 * n, P k) → P (2 * n))
    (h_odd : ∀ n : ℕ, (∀ k < 2 * n + 1, P k) → P (2 * n + 1)) (n : ℕ) : P n 
goal: P n
File: Mathlib/Data/Nat/Factorial/BigOperators.lean

full_name: Nat.monotone_factorial
code: lemma monotone_factorial : Monotone factorial 
goal: Monotone Nat.factorial

full_name: Nat.prod_factorial_pos
code: theorem prod_factorial_pos : 0 < ∏ i ∈ s, (f i)! 
goal: 0 < ∏ i ∈ s, (f i)!

full_name: Nat.prod_factorial_dvd_factorial_sum
code: theorem prod_factorial_dvd_factorial_sum : (∏ i ∈ s, (f i)!) ∣ (∑ i ∈ s, f i)! 
goal: ∏ i ∈ s, (f i)! ∣ (∑ i ∈ s, f i)!

full_name: Nat.descFactorial_eq_prod_range
code: theorem descFactorial_eq_prod_range (n : ℕ) : ∀ k, n.descFactorial k = ∏ i ∈ range k, (n - i)
  
goal: n.descFactorial k = ∏ i ∈ Finset.range k, (n - i)
File: Mathlib/Data/Nat/Factorization/PrimePow.lean

full_name: IsPrimePow.minFac_pow_factorization_eq
code: theorem IsPrimePow.minFac_pow_factorization_eq {n : ℕ} (hn : IsPrimePow n) :
    n.minFac ^ n.factorization n.minFac = n 
goal: n.minFac ^ n.factorization n.minFac = n

full_name: isPrimePow_of_minFac_pow_factorization_eq
code: theorem isPrimePow_of_minFac_pow_factorization_eq {n : ℕ}
    (h : n.minFac ^ n.factorization n.minFac = n) (hn : n ≠ 1) : IsPrimePow n 
goal: IsPrimePow n

full_name: isPrimePow_iff_minFac_pow_factorization_eq
code: theorem isPrimePow_iff_minFac_pow_factorization_eq {n : ℕ} (hn : n ≠ 1) :
    IsPrimePow n ↔ n.minFac ^ n.factorization n.minFac = n 
goal: IsPrimePow n ↔ n.minFac ^ n.factorization n.minFac = n

full_name: isPrimePow_iff_factorization_eq_single
code: theorem isPrimePow_iff_factorization_eq_single {n : ℕ} :
    IsPrimePow n ↔ ∃ p k : ℕ, 0 < k ∧ n.factorization = Finsupp.single p k 
goal: IsPrimePow n ↔ ∃ p k, 0 < k ∧ n.factorization = Finsupp.single p k

full_name: isPrimePow_iff_card_primeFactors_eq_one
code: theorem isPrimePow_iff_card_primeFactors_eq_one {n : ℕ} :
    IsPrimePow n ↔ n.primeFactors.card = 1 
goal: IsPrimePow n ↔ n.primeFactors.card = 1

full_name: IsPrimePow.exists_ord_compl_eq_one
code: theorem IsPrimePow.exists_ord_compl_eq_one {n : ℕ} (h : IsPrimePow n) :
    ∃ p : ℕ, p.Prime ∧ ord_compl[p] n = 1 
goal: ∃ p, Nat.Prime p ∧ n / p ^ n.factorization p = 1

full_name: exists_ord_compl_eq_one_iff_isPrimePow
code: theorem exists_ord_compl_eq_one_iff_isPrimePow {n : ℕ} (hn : n ≠ 1) :
    IsPrimePow n ↔ ∃ p : ℕ, p.Prime ∧ ord_compl[p] n = 1 
goal: IsPrimePow n ↔ ∃ p, Nat.Prime p ∧ n / p ^ n.factorization p = 1

full_name: isPrimePow_iff_unique_prime_dvd
code: /-- An equivalent definition for prime powers: `n` is a prime power iff there is a unique prime
dividing it. -/
theorem isPrimePow_iff_unique_prime_dvd {n : ℕ} : IsPrimePow n ↔ ∃! p : ℕ, p.Prime ∧ p ∣ n 
goal: IsPrimePow n ↔ ∃! p, Nat.Prime p ∧ p ∣ n

full_name: isPrimePow_pow_iff
code: theorem isPrimePow_pow_iff {n k : ℕ} (hk : k ≠ 0) : IsPrimePow (n ^ k) ↔ IsPrimePow n 
goal: IsPrimePow (n ^ k) ↔ IsPrimePow n

full_name: Nat.Coprime.isPrimePow_dvd_mul
code: theorem Nat.Coprime.isPrimePow_dvd_mul {n a b : ℕ} (hab : Nat.Coprime a b) (hn : IsPrimePow n) :
    n ∣ a * b ↔ n ∣ a ∨ n ∣ b 
goal: n ∣ a * b ↔ n ∣ a ∨ n ∣ b

full_name: Nat.mul_divisors_filter_prime_pow
code: theorem Nat.mul_divisors_filter_prime_pow {a b : ℕ} (hab : a.Coprime b) :
    (a * b).divisors.filter IsPrimePow = (a.divisors ∪ b.divisors).filter IsPrimePow 
goal: Finset.filter IsPrimePow (a * b).divisors = Finset.filter IsPrimePow (a.divisors ∪ b.divisors)
File: Mathlib/Data/Nat/Factorial/Cast.lean

full_name: Nat.cast_ascFactorial
code: theorem cast_ascFactorial : (a.ascFactorial b : S) = (ascPochhammer S b).eval (a : S) 
goal: ↑(a.ascFactorial b) = Polynomial.eval (↑a) (ascPochhammer S b)

full_name: Nat.cast_descFactorial
code: theorem cast_descFactorial :
    (a.descFactorial b : S) = (ascPochhammer S b).eval (a - (b - 1) : S) 
goal: ↑(a.descFactorial b) = Polynomial.eval (↑(a - (b - 1))) (ascPochhammer S b)

full_name: Nat.cast_factorial
code: theorem cast_factorial : (a ! : S) = (ascPochhammer S a).eval 1 
goal: ↑a ! = Polynomial.eval 1 (ascPochhammer S a)

full_name: Nat.cast_descFactorial_two
code: /-- Convenience lemma. The `a - 1` is not using truncated subtraction, as opposed to the definition
of `Nat.descFactorial` as a natural. -/
theorem cast_descFactorial_two : (a.descFactorial 2 : S) = a * (a - 1) 
goal: ↑(a.descFactorial 2) = ↑a * (↑a - 1)
File: Mathlib/Data/Nat/Upto.lean

full_name: Nat.Upto
code: /-- The subtype of natural numbers `i` which have the property that
no `j` less than `i` satisfies `p`. This is an initial segment of the
natural numbers, up to and including the first value satisfying `p`.

We will be particularly interested in the case where there exists a value
satisfying `p`, because in this case the `>` relation is well-founded.  -/
abbrev Upto (p : ℕ → Prop) : Type 
goal: Type

full_name: Nat.Upto.GT
code: /-- Lift the "greater than" relation on natural numbers to `Nat.Upto`. -/
protected def GT (p) (x y : Upto p) : Prop 
goal: Prop

full_name: Nat.Upto.instLT
code: instance : LT (Upto p) 
goal: LT (Nat.Upto p)

full_name: Nat.Upto.wf
code: /-- The "greater than" relation on `Upto p` is well founded if (and only if) there exists a value
satisfying `p`. -/
protected theorem wf : (∃ x, p x) → WellFounded (Upto.GT p)
  
goal: (∃ x, p x) → WellFounded (Nat.Upto.GT p)

full_name: Nat.Upto.zero
code: /-- Zero is always a member of `Nat.Upto p` because it has no predecessors. -/
def zero : Nat.Upto p 
goal: Nat.Upto p

full_name: Nat.Upto.succ
code: /-- The successor of `n` is in `Nat.Upto p` provided that `n` doesn't satisfy `p`. -/
def succ (x : Nat.Upto p) (h : ¬p x.val) : Nat.Upto p 
goal: Nat.Upto p
File: Mathlib/Data/Nat/Factorial/DoubleFactorial.lean

full_name: Nat.doubleFactorial
code: /-- `Nat.doubleFactorial n` is the double factorial of `n`. -/
@[simp]
def doubleFactorial : ℕ → ℕ
  
goal: ℕ → ℕ

full_name: Nat.«_aux_Mathlib_Data_Nat_Factorial_DoubleFactorial___macroRules_Nat_term_‼_1»
code: @[inherit_doc] scoped notation:10000 n "‼" => Nat.doubleFactorial n
goal: Lean.Macro

full_name: Nat._aux_Mathlib_Data_Nat_Factorial_DoubleFactorial___unexpand_Nat_doubleFactorial_1
code: @[inherit_doc] scoped notation:10000 n "‼" => Nat.doubleFactorial n
goal: Lean.PrettyPrinter.Unexpander

full_name: Nat.doubleFactorial_pos
code: lemma doubleFactorial_pos : ∀ n, 0 < n‼
  
goal: 0 < n‼

full_name: Nat.doubleFactorial_add_two
code: theorem doubleFactorial_add_two (n : ℕ) : (n + 2)‼ = (n + 2) * n‼ 
goal: (n + 2)‼ = (n + 2) * n‼

full_name: Nat.doubleFactorial_add_one
code: theorem doubleFactorial_add_one (n : ℕ) : (n + 1)‼ = (n + 1) * (n - 1)‼ 
goal: (n + 1)‼ = (n + 1) * (n - 1)‼

full_name: Nat.factorial_eq_mul_doubleFactorial
code: theorem factorial_eq_mul_doubleFactorial : ∀ n : ℕ, (n + 1)! = (n + 1)‼ * n‼
  
goal: (n + 1)! = (n + 1)‼ * n‼

full_name: Nat.doubleFactorial_le_factorial
code: lemma doubleFactorial_le_factorial : ∀ n, n‼ ≤ n !
  
goal: n‼ ≤ n !

full_name: Nat.doubleFactorial_two_mul
code: theorem doubleFactorial_two_mul : ∀ n : ℕ, (2 * n)‼ = 2 ^ n * n !
  
goal: (2 * n)‼ = 2 ^ n * n !

full_name: Nat.doubleFactorial_eq_prod_even
code: theorem doubleFactorial_eq_prod_even : ∀ n : ℕ, (2 * n)‼ = ∏ i ∈ Finset.range n, 2 * (i + 1)
  
goal: (2 * n)‼ = ∏ i ∈ Finset.range n, 2 * (i + 1)

full_name: Nat.doubleFactorial_eq_prod_odd
code: theorem doubleFactorial_eq_prod_odd :
    ∀ n : ℕ, (2 * n + 1)‼ = ∏ i ∈ Finset.range n, (2 * (i + 1) + 1)
  
goal: (2 * n + 1)‼ = ∏ i ∈ Finset.range n, (2 * (i + 1) + 1)

full_name: Mathlib.Meta.Positivity.evalDoubleFactorial
code: /-- Extension for `Nat.doubleFactorial`. -/
@[positivity Nat.doubleFactorial _]
def evalDoubleFactorial : PositivityExt 
goal: Mathlib.Meta.Positivity.PositivityExt
File: Mathlib/Data/Nat/Size.lean

full_name: Nat.shiftLeft_eq_mul_pow
code: theorem shiftLeft_eq_mul_pow (m) : ∀ n, m <<< n = m * 2 ^ n 
goal: m <<< n = m * 2 ^ n

full_name: Nat.shiftLeft'_tt_eq_mul_pow
code: theorem shiftLeft'_tt_eq_mul_pow (m) : ∀ n, shiftLeft' true m n + 1 = (m + 1) * 2 ^ n
  
goal: Nat.shiftLeft' true m n + 1 = (m + 1) * 2 ^ n

full_name: Nat.shiftLeft'_ne_zero_left
code: theorem shiftLeft'_ne_zero_left (b) {m} (h : m ≠ 0) (n) : shiftLeft' b m n ≠ 0 
goal: Nat.shiftLeft' b m n ≠ 0

full_name: Nat.shiftLeft'_tt_ne_zero
code: theorem shiftLeft'_tt_ne_zero (m) : ∀ {n}, (n ≠ 0) → shiftLeft' true m n ≠ 0
  
goal: n ≠ 0 → Nat.shiftLeft' true m n ≠ 0

full_name: Nat.size_zero
code: @[simp]
theorem size_zero : size 0 = 0 
goal: Nat.size 0 = 0

full_name: Nat.size_bit
code: @[simp]
theorem size_bit {b n} (h : bit b n ≠ 0) : size (bit b n) = succ (size n) 
goal: (Nat.bit b n).size = n.size.succ

full_name: Nat.size_one
code: @[simp]
theorem size_one : size 1 = 1 
goal: Nat.size 1 = 1

full_name: Nat.size_shiftLeft'
code: @[simp]
theorem size_shiftLeft' {b m n} (h : shiftLeft' b m n ≠ 0) :
    size (shiftLeft' b m n) = size m + n 
goal: (Nat.shiftLeft' b m n).size = m.size + n

full_name: Nat.size_shiftLeft
code: @[simp, nolint simpNF]
theorem size_shiftLeft {m} (h : m ≠ 0) (n) : size (m <<< n) = size m + n 
goal: (m <<< n).size = m.size + n

full_name: Nat.lt_size_self
code: theorem lt_size_self (n : ℕ) : n < 2 ^ size n 
goal: n < 2 ^ n.size

full_name: Nat.size_le
code: theorem size_le {m n : ℕ} : size m ≤ n ↔ m < 2 ^ n 
goal: m.size ≤ n ↔ m < 2 ^ n

full_name: Nat.lt_size
code: theorem lt_size {m n : ℕ} : m < size n ↔ 2 ^ m ≤ n 
goal: m < n.size ↔ 2 ^ m ≤ n

full_name: Nat.size_pos
code: theorem size_pos {n : ℕ} : 0 < size n ↔ 0 < n 
goal: 0 < n.size ↔ 0 < n

full_name: Nat.size_eq_zero
code: theorem size_eq_zero {n : ℕ} : size n = 0 ↔ n = 0 
goal: n.size = 0 ↔ n = 0

full_name: Nat.size_pow
code: theorem size_pow {n : ℕ} : size (2 ^ n) = n + 1 
goal: (2 ^ n).size = n + 1

full_name: Nat.size_le_size
code: theorem size_le_size {m n : ℕ} (h : m ≤ n) : size m ≤ size n 
goal: m.size ≤ n.size

full_name: Nat.size_eq_bits_len
code: theorem size_eq_bits_len (n : ℕ) : n.bits.length = n.size 
goal: n.bits.length = n.size
File: Mathlib/Data/Nat/WithBot.lean

full_name: Nat.WithBot.instWellFoundedRelationWithBot
code: instance : WellFoundedRelation (WithBot ℕ) 
goal: WellFoundedRelation (WithBot ℕ)

full_name: Nat.WithBot.add_eq_zero_iff
code: theorem add_eq_zero_iff {n m : WithBot ℕ} : n + m = 0 ↔ n = 0 ∧ m = 0 
goal: n + m = 0 ↔ n = 0 ∧ m = 0

full_name: Nat.WithBot.add_eq_one_iff
code: theorem add_eq_one_iff {n m : WithBot ℕ} : n + m = 1 ↔ n = 0 ∧ m = 1 ∨ n = 1 ∧ m = 0 
goal: n + m = 1 ↔ n = 0 ∧ m = 1 ∨ n = 1 ∧ m = 0

full_name: Nat.WithBot.add_eq_two_iff
code: theorem add_eq_two_iff {n m : WithBot ℕ} :
    n + m = 2 ↔ n = 0 ∧ m = 2 ∨ n = 1 ∧ m = 1 ∨ n = 2 ∧ m = 0 
goal: n + m = 2 ↔ n = 0 ∧ m = 2 ∨ n = 1 ∧ m = 1 ∨ n = 2 ∧ m = 0

full_name: Nat.WithBot.add_eq_three_iff
code: 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 
goal: n + m = 3 ↔ n = 0 ∧ m = 3 ∨ n = 1 ∧ m = 2 ∨ n = 2 ∧ m = 1 ∨ n = 3 ∧ m = 0

full_name: Nat.WithBot.coe_nonneg
code: theorem coe_nonneg {n : ℕ} : 0 ≤ (n : WithBot ℕ) 
goal: 0 ≤ ↑n

full_name: Nat.WithBot.lt_zero_iff
code: @[simp]
theorem lt_zero_iff {n : WithBot ℕ} : n < 0 ↔ n = ⊥ 
goal: n < 0 ↔ n = ⊥

full_name: Nat.WithBot.one_le_iff_zero_lt
code: theorem one_le_iff_zero_lt {x : WithBot ℕ} : 1 ≤ x ↔ 0 < x 
goal: 1 ≤ x ↔ 0 < x

full_name: Nat.WithBot.lt_one_iff_le_zero
code: theorem lt_one_iff_le_zero {x : WithBot ℕ} : x < 1 ↔ x ≤ 0 
goal: x < 1 ↔ x ≤ 0

full_name: Nat.WithBot.add_one_le_of_lt
code: theorem add_one_le_of_lt {n m : WithBot ℕ} (h : n < m) : n + 1 ≤ m 
goal: n + 1 ≤ m
File: Mathlib/Data/Array/Defs.lean

full_name: Array.cyclicPermute!.cyclicPermuteAux
code: /-- Permute the array using a sequence of indices defining a cyclic permutation.
  If the list of indices `l = [i₁, i₂, ..., iₙ]` are all distinct then
  `(cyclicPermute! a l)[iₖ₊₁] = a[iₖ]` and `(cyclicPermute! a l)[i₀] = a[iₙ]` -/
def cyclicPermute! [Inhabited α] : Array α → List Nat → Array α
  
goal: Array α → List Nat → α → Nat → Array α

full_name: Array.cyclicPermute!
code: /-- Permute the array using a sequence of indices defining a cyclic permutation.
  If the list of indices `l = [i₁, i₂, ..., iₙ]` are all distinct then
  `(cyclicPermute! a l)[iₖ₊₁] = a[iₖ]` and `(cyclicPermute! a l)[i₀] = a[iₙ]` -/
def cyclicPermute! [Inhabited α] : Array α → List Nat → Array α
  
goal: Array α → List Nat → Array α

full_name: Array.permute!
code: /-- Permute the array using a list of cycles. -/
def permute! [Inhabited α] (a : Array α) (ls : List (List Nat)) : Array α 
goal: Array α
File: Mathlib/Data/NNReal/Star.lean

full_name: instStarRingNNReal
code: instance : StarRing ℝ≥0 
goal: StarRing ℝ≥0

full_name: instTrivialStarNNReal
code: instance : TrivialStar ℝ≥0 
goal: TrivialStar ℝ≥0

full_name: instStarModuleNNRealReal
code: instance : StarModule ℝ≥0 ℝ 
goal: StarModule ℝ≥0 ℝ