ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.Icc_factorization_eq_pow_dvd
theorem Icc_factorization_eq_pow_dvd (n : ℕ) {p : ℕ} (pp : Prime p) :
    Icc 1 (n.factorization p) = (Ico 1 n).filter fun i : ℕ => p ^ i ∣ n 
Arguments: (n : ℕ) {p : ℕ} (pp : Nat.Prime p)
Goal: Finset.Icc 1 (n.factorization p) = Finset.filter (fun i => p ^ i ∣ n) (Finset.Ico 1 n)
-- Nat.factorization_eq_card_pow_dvd
theorem factorization_eq_card_pow_dvd (n : ℕ) {p : ℕ} (pp : p.Prime) :
    n.factorization p = ((Ico 1 n).filter fun i => p ^ i ∣ n).card 
Arguments: (n : ℕ) {p : ℕ} (pp : Nat.Prime p)
Goal: n.factorization p = (Finset.filter (fun i => p ^ i ∣ n) (Finset.Ico 1 n)).card
-- Nat.Ico_filter_pow_dvd_eq
theorem Ico_filter_pow_dvd_eq {n p b : ℕ} (pp : p.Prime) (hn : n ≠ 0) (hb : n ≤ p ^ b) :
    ((Ico 1 n).filter fun i => p ^ i ∣ n) = (Icc 1 b).filter fun i => p ^ i ∣ n 
Arguments: {n p b : ℕ} (pp : Nat.Prime p) (hn : n ≠ 0) (hb : n ≤ p ^ b)
Goal: Finset.filter (fun i => p ^ i ∣ n) (Finset.Ico 1 n) = Finset.filter (fun i => p ^ i ∣ n) (Finset.Icc 1 b)
-- Nat.factorization_eq_of_coprime_left
theorem factorization_eq_of_coprime_left {p a b : ℕ} (hab : Coprime a b)
    (hpa : p ∈ a.primeFactorsList) : (a * b).factorization p = a.factorization p 
Arguments: {p a b : ℕ} (hab : a.Coprime b) (hpa : p ∈ a.primeFactorsList)
Goal: (a * b).factorization p = a.factorization p
-- Nat.factorization_eq_of_coprime_right
theorem factorization_eq_of_coprime_right {p a b : ℕ} (hab : Coprime a b)
    (hpb : p ∈ b.primeFactorsList) : (a * b).factorization p = b.factorization p 
Arguments: {p a b : ℕ} (hab : a.Coprime b) (hpb : p ∈ b.primeFactorsList)
Goal: (a * b).factorization p = b.factorization p
-- Nat.eq_iff_prime_padicValNat_eq
theorem eq_iff_prime_padicValNat_eq (a b : ℕ) (ha : a ≠ 0) (hb : b ≠ 0) :
    a = b ↔ ∀ p : ℕ, p.Prime → padicValNat p a = padicValNat p b 
Arguments: (a b : ℕ) (ha : a ≠ 0) (hb : b ≠ 0)
Goal: a = b ↔ ∀ (p : ℕ), Nat.Prime p → padicValNat p a = padicValNat p b
-- Nat.prod_pow_prime_padicValNat
theorem prod_pow_prime_padicValNat (n : Nat) (hn : n ≠ 0) (m : Nat) (pr : n < m) :
    (∏ p ∈ Finset.filter Nat.Prime (Finset.range m), p ^ padicValNat p n) = n 
Arguments: (n : ℕ) (hn : n ≠ 0) (m : ℕ) (pr : n < m)
Goal: ∏ p ∈ Finset.filter Nat.Prime (Finset.range m), p ^ padicValNat p n = n
-- Nat.card_multiples
theorem card_multiples (n p : ℕ) : card ((Finset.range n).filter fun e => p ∣ e + 1) = n / p 
Arguments: (n p : ℕ)
Goal: (Finset.filter (fun e => p ∣ e + 1) (Finset.range n)).card = n / p
-- Nat.Ioc_filter_dvd_card_eq_div
theorem Ioc_filter_dvd_card_eq_div (n p : ℕ) : ((Ioc 0 n).filter fun x => p ∣ x).card = n / p 
Arguments: (n p : ℕ)
Goal: (Finset.filter (fun x => p ∣ x) (Finset.Ioc 0 n)).card = n / p
-- Nat.card_multiples'
lemma card_multiples' (N n : ℕ) :
    ((Finset.range N.succ).filter (fun k ↦ k ≠ 0 ∧ n ∣ k)).card = N / n 
Arguments: (N n : ℕ)
Goal: (Finset.filter (fun k => k ≠ 0 ∧ n ∣ k) (Finset.range N.succ)).card = N / n
-- Nat.multiplicity_eq_card_pow_dvd
theorem multiplicity_eq_card_pow_dvd {m n b : ℕ} (hm : m ≠ 1) (hn : 0 < n) (hb : log m n < b) :
    multiplicity m n = ↑((Finset.Ico 1 b).filter fun i => m ^ i ∣ n).card 
Arguments: {m n b : ℕ} (hm : m ≠ 1) (hn : 0 < n) (hb : Nat.log m n < b)
Goal: multiplicity m n = ↑(Finset.filter (fun i => m ^ i ∣ n) (Finset.Ico 1 b)).card
-- Nat.Prime.multiplicity_one
theorem multiplicity_one {p : ℕ} (hp : p.Prime) : multiplicity p 1 = 0 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: multiplicity p 1 = 0
-- Nat.Prime.multiplicity_mul
theorem multiplicity_mul {p m n : ℕ} (hp : p.Prime) :
    multiplicity p (m * n) = multiplicity p m + multiplicity p n 
Arguments: {p m n : ℕ} (hp : Nat.Prime p)
Goal: multiplicity p (m * n) = multiplicity p m + multiplicity p n
-- Nat.Prime.multiplicity_pow
theorem multiplicity_pow {p m n : ℕ} (hp : p.Prime) :
    multiplicity p (m ^ n) = n • multiplicity p m 
Arguments: {p m n : ℕ} (hp : Nat.Prime p)
Goal: multiplicity p (m ^ n) = n • multiplicity p m
-- Nat.Prime.multiplicity_self
theorem multiplicity_self {p : ℕ} (hp : p.Prime) : multiplicity p p = 1 
Arguments: {p : ℕ} (hp : Nat.Prime p)
Goal: multiplicity p p = 1
-- Nat.Prime.multiplicity_pow_self
theorem multiplicity_pow_self {p n : ℕ} (hp : p.Prime) : multiplicity p (p ^ n) = n 
Arguments: {p n : ℕ} (hp : Nat.Prime p)
Goal: multiplicity p (p ^ n) = ↑n
-- Nat.Prime.multiplicity_factorial
theorem multiplicity_factorial {p : ℕ} (hp : p.Prime) :
    ∀ {n b : ℕ}, log p n < b → multiplicity p n ! = (∑ i ∈ Ico 1 b, n / p ^ i : ℕ)
  
Arguments: {p : ℕ} (hp : Nat.Prime p) {n b : ℕ}
Goal: Nat.log p n < b → multiplicity p n ! = ↑(∑ i ∈ Finset.Ico 1 b, n / p ^ i)
-- Nat.Prime.sub_one_mul_multiplicity_factorial
 theorem sub_one_mul_multiplicity_factorial {n p : ℕ} (hp : p.Prime) :
     (p - 1) * (multiplicity p n !).get (finite_nat_iff.mpr ⟨hp.ne_one, factorial_pos n⟩) =
     n - (p.digits n).sum 
Arguments: {n p : ℕ} (hp : Nat.Prime p)
Goal: (p - 1) * (multiplicity p n !).get ⋯ = n - (p.digits n).sum
-- Nat.Prime.multiplicity_factorial_mul_succ
theorem multiplicity_factorial_mul_succ {n p : ℕ} (hp : p.Prime) :
    multiplicity p (p * (n + 1))! = multiplicity p (p * n)! + multiplicity p (n + 1) + 1 
Arguments: {n p : ℕ} (hp : Nat.Prime p)
Goal: multiplicity p (p * (n + 1))! = multiplicity p (p * n)! + multiplicity p (n + 1) + 1
-- Nat.Prime.multiplicity_factorial_mul
theorem multiplicity_factorial_mul {n p : ℕ} (hp : p.Prime) :
    multiplicity p (p * n)! = multiplicity p n ! + n 
Arguments: {n p : ℕ} (hp : Nat.Prime p)
Goal: multiplicity p (p * n)! = multiplicity p n ! + ↑n
-- Nat.Prime.pow_dvd_factorial_iff
theorem pow_dvd_factorial_iff {p : ℕ} {n r b : ℕ} (hp : p.Prime) (hbn : log p n < b) :
    p ^ r ∣ n ! ↔ r ≤ ∑ i ∈ Ico 1 b, n / p ^ i 
Arguments: {p n r b : ℕ} (hp : Nat.Prime p) (hbn : Nat.log p n < b)
Goal: p ^ r ∣ n ! ↔ r ≤ ∑ i ∈ Finset.Ico 1 b, n / p ^ i
-- Nat.Prime.multiplicity_factorial_le_div_pred
theorem multiplicity_factorial_le_div_pred {p : ℕ} (hp : p.Prime) (n : ℕ) :
    multiplicity p n ! ≤ (n / (p - 1) : ℕ) 
Arguments: {p : ℕ} (hp : Nat.Prime p) (n : ℕ)
Goal: multiplicity p n ! ≤ ↑(n / (p - 1))
-- Nat.Prime.multiplicity_choose_aux
theorem multiplicity_choose_aux {p n b k : ℕ} (hp : p.Prime) (hkn : k ≤ n) :
    ∑ i ∈ Finset.Ico 1 b, n / p ^ i =
      ((∑ i ∈ Finset.Ico 1 b, k / p ^ i) + ∑ i ∈ Finset.Ico 1 b, (n - k) / p ^ i) +
        ((Finset.Ico 1 b).filter fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i).card 
Arguments: {p n b k : ℕ} (hp : Nat.Prime p) (hkn : k ≤ n)
Goal: ∑ i ∈ Finset.Ico 1 b, n / p ^ i =
  ∑ i ∈ Finset.Ico 1 b, k / p ^ i + ∑ i ∈ Finset.Ico 1 b, (n - k) / p ^ i +
    (Finset.filter (fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i) (Finset.Ico 1 b)).card
-- Nat.Prime.multiplicity_choose'
theorem multiplicity_choose' {p n k b : ℕ} (hp : p.Prime) (hnb : log p (n + k) < b) :
    multiplicity p (choose (n + k) k) =
      ((Ico 1 b).filter fun i => p ^ i ≤ k % p ^ i + n % p ^ i).card 
Arguments: {p n k b : ℕ} (hp : Nat.Prime p) (hnb : Nat.log p (n + k) < b)
Goal: multiplicity p ((n + k).choose k) = ↑(Finset.filter (fun i => p ^ i ≤ k % p ^ i + n % p ^ i) (Finset.Ico 1 b)).card
-- Nat.Prime.multiplicity_choose
theorem multiplicity_choose {p n k b : ℕ} (hp : p.Prime) (hkn : k ≤ n) (hnb : log p n < b) :
    multiplicity p (choose n k) =
      ((Ico 1 b).filter fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i).card 
Arguments: {p n k b : ℕ} (hp : Nat.Prime p) (hkn : k ≤ n) (hnb : Nat.log p n < b)
Goal: multiplicity p (n.choose k) = ↑(Finset.filter (fun i => p ^ i ≤ k % p ^ i + (n - k) % p ^ i) (Finset.Ico 1 b)).card
-- Nat.Prime.multiplicity_le_multiplicity_choose_add
theorem multiplicity_le_multiplicity_choose_add {p : ℕ} (hp : p.Prime) :
    ∀ n k : ℕ, multiplicity p n ≤ multiplicity p (choose n k) + multiplicity p k
  
Arguments: {p : ℕ} (hp : Nat.Prime p) (n k : ℕ)
Goal: multiplicity p n ≤ multiplicity p (n.choose k) + multiplicity p k
-- Nat.Prime.multiplicity_choose_prime_pow_add_multiplicity
theorem multiplicity_choose_prime_pow_add_multiplicity (hp : p.Prime) (hkn : k ≤ p ^ n)
    (hk0 : k ≠ 0) : multiplicity p (choose (p ^ n) k) + multiplicity p k = n 
Arguments: {p n k : ℕ} (hp : Nat.Prime p) (hkn : k ≤ p ^ n) (hk0 : k ≠ 0)
Goal: multiplicity p ((p ^ n).choose k) + multiplicity p k = ↑n
-- Nat.Prime.multiplicity_choose_prime_pow
theorem multiplicity_choose_prime_pow {p n k : ℕ} (hp : p.Prime) (hkn : k ≤ p ^ n) (hk0 : k ≠ 0) :
    multiplicity p (choose (p ^ n) k) =
      ↑(n - (multiplicity p k).get (finite_nat_iff.2 ⟨hp.ne_one, hk0.bot_lt⟩)) 
Arguments: {p n k : ℕ} (hp : Nat.Prime p) (hkn : k ≤ p ^ n) (hk0 : k ≠ 0)
Goal: multiplicity p ((p ^ n).choose k) = ↑(n - (multiplicity p k).get ⋯)
-- Nat.Prime.dvd_choose_pow
theorem dvd_choose_pow (hp : Prime p) (hk : k ≠ 0) (hkp : k ≠ p ^ n) : p ∣ (p ^ n).choose k 
Arguments: {p n k : ℕ} (hp : Nat.Prime p) (hk : k ≠ 0) (hkp : k ≠ p ^ n)
Goal: p ∣ (p ^ n).choose k
-- Nat.Prime.dvd_choose_pow_iff
theorem dvd_choose_pow_iff (hp : Prime p) : p ∣ (p ^ n).choose k ↔ k ≠ 0 ∧ k ≠ p ^ n 
Arguments: {p n k : ℕ} (hp : Nat.Prime p)
Goal: p ∣ (p ^ n).choose k ↔ k ≠ 0 ∧ k ≠ p ^ n
-- Nat.multiplicity_two_factorial_lt
theorem multiplicity_two_factorial_lt : ∀ {n : ℕ} (_ : n ≠ 0), multiplicity 2 n ! < n 
Arguments: {n : ℕ}
Goal: n ≠ 0 → multiplicity 2 n ! < ↑n
-- Nat.fib_zero
@[simp]
theorem fib_zero : fib 0 = 0 
Goal: Nat.fib 0 = 0
-- Nat.fib_one
@[simp]
theorem fib_one : fib 1 = 1 
Goal: Nat.fib 1 = 1
-- Nat.fib_two
@[simp]
theorem fib_two : fib 2 = 1 
Goal: Nat.fib 2 = 1
-- Nat.fib_add_two
theorem fib_add_two {n : ℕ} : fib (n + 2) = fib n + fib (n + 1) 
Arguments: {n : ℕ}
Goal: Nat.fib (n + 2) = Nat.fib n + Nat.fib (n + 1)
-- Nat.fib_add_one
lemma fib_add_one : ∀ {n}, n ≠ 0 → fib (n + 1) = fib (n - 1) + fib n
  
Arguments: {n : ℕ}
Goal: n ≠ 0 → Nat.fib (n + 1) = Nat.fib (n - 1) + Nat.fib n
-- Nat.fib_le_fib_succ
theorem fib_le_fib_succ {n : ℕ} : fib n ≤ fib (n + 1) 
Arguments: {n : ℕ}
Goal: Nat.fib n ≤ Nat.fib (n + 1)
-- Nat.fib_mono
@[mono]
theorem fib_mono : Monotone fib 
Goal: Monotone Nat.fib
-- Nat.fib_eq_zero
@[simp] lemma fib_eq_zero : ∀ {n}, fib n = 0 ↔ n = 0

Arguments: {n : ℕ}
Goal: Nat.fib n = 0 ↔ n = 0
-- Nat.fib_pos
@[simp] lemma fib_pos {n : ℕ} : 0 < fib n ↔ 0 < n 
Arguments: {n : ℕ}
Goal: 0 < Nat.fib n ↔ 0 < n
-- Nat.fib_add_two_sub_fib_add_one
theorem fib_add_two_sub_fib_add_one {n : ℕ} : fib (n + 2) - fib (n + 1) = fib n 
Arguments: {n : ℕ}
Goal: Nat.fib (n + 2) - Nat.fib (n + 1) = Nat.fib n
-- Nat.fib_lt_fib_succ
theorem fib_lt_fib_succ {n : ℕ} (hn : 2 ≤ n) : fib n < fib (n + 1) 
Arguments: {n : ℕ} (hn : 2 ≤ n)
Goal: Nat.fib n < Nat.fib (n + 1)
-- Nat.fib_add_two_strictMono
theorem fib_add_two_strictMono : StrictMono fun n => fib (n + 2) 
Goal: StrictMono fun n => Nat.fib (n + 2)
-- Nat.fib_strictMonoOn
lemma fib_strictMonoOn : StrictMonoOn fib (Set.Ici 2)
  
Goal: StrictMonoOn Nat.fib (Set.Ici 2)
-- Nat.fib_lt_fib
lemma fib_lt_fib {m : ℕ} (hm : 2 ≤ m) : ∀ {n}, fib m < fib n ↔ m < n
  
Arguments: {m : ℕ} (hm : 2 ≤ m) {n : ℕ}
Goal: Nat.fib m < Nat.fib n ↔ m < n
-- Nat.le_fib_self
theorem le_fib_self {n : ℕ} (five_le_n : 5 ≤ n) : n ≤ fib n 
Arguments: {n : ℕ} (five_le_n : 5 ≤ n)
Goal: n ≤ Nat.fib n
-- Nat.le_fib_add_one
lemma le_fib_add_one : ∀ n, n ≤ fib n + 1
  
Arguments: (n : ℕ)
Goal: n ≤ Nat.fib n + 1
-- Nat.fib_coprime_fib_succ
theorem fib_coprime_fib_succ (n : ℕ) : Nat.Coprime (fib n) (fib (n + 1)) 
Arguments: (n : ℕ)
Goal: (Nat.fib n).Coprime (Nat.fib (n + 1))
-- Nat.fib_add
theorem fib_add (m n : ℕ) : fib (m + n + 1) = fib m * fib n + fib (m + 1) * fib (n + 1) 
Arguments: (m n : ℕ)
Goal: Nat.fib (m + n + 1) = Nat.fib m * Nat.fib n + Nat.fib (m + 1) * Nat.fib (n + 1)
-- Nat.fib_two_mul
theorem fib_two_mul (n : ℕ) : fib (2 * n) = fib n * (2 * fib (n + 1) - fib n) 
Arguments: (n : ℕ)
Goal: Nat.fib (2 * n) = Nat.fib n * (2 * Nat.fib (n + 1) - Nat.fib n)
-- Nat.fib_two_mul_add_one
theorem fib_two_mul_add_one (n : ℕ) : fib (2 * n + 1) = fib (n + 1) ^ 2 + fib n ^ 2 
Arguments: (n : ℕ)
Goal: Nat.fib (2 * n + 1) = Nat.fib (n + 1) ^ 2 + Nat.fib n ^ 2
-- Nat.fib_two_mul_add_two
theorem fib_two_mul_add_two (n : ℕ) :
    fib (2 * n + 2) = fib (n + 1) * (2 * fib n + fib (n + 1)) 
Arguments: (n : ℕ)
Goal: Nat.fib (2 * n + 2) = Nat.fib (n + 1) * (2 * Nat.fib n + Nat.fib (n + 1))
-- Nat.fast_fib_aux_bit_ff
theorem fast_fib_aux_bit_ff (n : ℕ) :
    fastFibAux (bit false n) =
      let p := fastFibAux n
      (p.1 * (2 * p.2 - p.1), p.2 ^ 2 + p.1 ^ 2) 
Arguments: (n : ℕ)
Goal: (Nat.bit false n).fastFibAux =
  let p := n.fastFibAux;
  (p.1 * (2 * p.2 - p.1), p.2 ^ 2 + p.1 ^ 2)
-- Nat.fast_fib_aux_bit_tt
theorem fast_fib_aux_bit_tt (n : ℕ) :
    fastFibAux (bit true n) =
      let p := fastFibAux n
      (p.2 ^ 2 + p.1 ^ 2, p.2 * (2 * p.1 + p.2)) 
Arguments: (n : ℕ)
Goal: (Nat.bit true n).fastFibAux =
  let p := n.fastFibAux;
  (p.2 ^ 2 + p.1 ^ 2, p.2 * (2 * p.1 + p.2))
-- Nat.fast_fib_aux_eq
theorem fast_fib_aux_eq (n : ℕ) : fastFibAux n = (fib n, fib (n + 1)) 
Arguments: (n : ℕ)
Goal: n.fastFibAux = (Nat.fib n, Nat.fib (n + 1))
-- Nat.fast_fib_eq
theorem fast_fib_eq (n : ℕ) : fastFib n = fib n 
Arguments: (n : ℕ)
Goal: n.fastFib = Nat.fib n
-- Nat.gcd_fib_add_self
theorem gcd_fib_add_self (m n : ℕ) : gcd (fib m) (fib (n + m)) = gcd (fib m) (fib n) 
Arguments: (m n : ℕ)
Goal: (Nat.fib m).gcd (Nat.fib (n + m)) = (Nat.fib m).gcd (Nat.fib n)
-- Nat.gcd_fib_add_mul_self
theorem gcd_fib_add_mul_self (m n : ℕ) : ∀ k, gcd (fib m) (fib (n + k * m)) = gcd (fib m) (fib n)
  
Arguments: (m n k : ℕ)
Goal: (Nat.fib m).gcd (Nat.fib (n + k * m)) = (Nat.fib m).gcd (Nat.fib n)
-- Nat.fib_gcd
theorem fib_gcd (m n : ℕ) : fib (gcd m n) = gcd (fib m) (fib n) 
Arguments: (m n : ℕ)
Goal: Nat.fib (m.gcd n) = (Nat.fib m).gcd (Nat.fib n)
-- Nat.fib_dvd
theorem fib_dvd (m n : ℕ) (h : m ∣ n) : fib m ∣ fib n 
Arguments: (m n : ℕ) (h : m ∣ n)
Goal: Nat.fib m ∣ Nat.fib n
-- Nat.fib_succ_eq_sum_choose
theorem fib_succ_eq_sum_choose :
    ∀ n : ℕ, fib (n + 1) = ∑ p ∈ Finset.antidiagonal n, choose p.1 p.2 
Arguments: (n : ℕ)
Goal: Nat.fib (n + 1) = ∑ p ∈ Finset.antidiagonal n, p.1.choose p.2
-- Nat.fib_succ_eq_succ_sum
theorem fib_succ_eq_succ_sum (n : ℕ) : fib (n + 1) = (∑ k ∈ Finset.range n, fib k) + 1 
Arguments: (n : ℕ)
Goal: Nat.fib (n + 1) = ∑ k ∈ Finset.range n, Nat.fib k + 1
-- Array.extract_eq_nil_of_start_eq_end
@[simp]
theorem extract_eq_nil_of_start_eq_end {a : Array α} :
    a.extract i i = #[] 
Arguments: {α : Type u} {i : Nat} {a : Array α}
Goal: a.extract i i = #[]
-- Array.extract_append_left
theorem extract_append_left {a b : Array α} {i j : Nat} (h : j ≤ a.size) :
    (a ++ b).extract i j = a.extract i j 
Arguments: {α : Type u} {a b : Array α} {i j : Nat} (h : j ≤ a.size)
Goal: (a ++ b).extract i j = a.extract i j
-- Array.extract_append_right
theorem extract_append_right {a b : Array α} {i j : Nat} (h : a.size ≤ i) :
    (a ++ b).extract i j = b.extract (i - a.size) (j - a.size) 
Arguments: {α : Type u} {a b : Array α} {i j : Nat} (h : a.size ≤ i)
Goal: (a ++ b).extract i j = b.extract (i - a.size) (j - a.size)
-- Array.extract_eq_of_size_le_end
theorem extract_eq_of_size_le_end {l p : Nat} {a : Array α} (h : a.size ≤ l) :
    a.extract p l = a.extract p a.size 
Arguments: {α : Type u} {l p : Nat} {a : Array α} (h : a.size ≤ l)
Goal: a.extract p l = a.extract p a.size
-- Array.extract_extract
theorem extract_extract {s1 e2 e1 s2 : Nat} {a : Array α} (h : s1 + e2 ≤ e1) :
    (a.extract s1 e1).extract s2 e2 = a.extract (s1 + s2) (s1 + e2) 
Arguments: {α : Type u} {s1 e2 e1 s2 : Nat} {a : Array α} (h : s1 + e2 ≤ e1)
Goal: (a.extract s1 e1).extract s2 e2 = a.extract (s1 + s2) (s1 + e2)
-- Nat.bitwise_zero_left
@[simp]
lemma bitwise_zero_left (m : Nat) : bitwise f 0 m = if f false true then m else 0 
Arguments: {f : Bool → Bool → Bool} (m : ℕ)
Goal: Nat.bitwise f 0 m = if f false true = true then m else 0
-- Nat.bitwise_zero_right
@[simp]
lemma bitwise_zero_right (n : Nat) : bitwise f n 0 = if f true false then n else 0 
Arguments: {f : Bool → Bool → Bool} (n : ℕ)
Goal: Nat.bitwise f n 0 = if f true false = true then n else 0
-- Nat.bitwise_zero
lemma bitwise_zero : bitwise f 0 0 = 0 
Arguments: {f : Bool → Bool → Bool}
Goal: Nat.bitwise f 0 0 = 0
-- Nat.bitwise_of_ne_zero
lemma bitwise_of_ne_zero {n m : Nat} (hn : n ≠ 0) (hm : m ≠ 0) :
    bitwise f n m = bit (f (bodd n) (bodd m)) (bitwise f (n / 2) (m / 2)) 
Arguments: {f : Bool → Bool → Bool} {n m : ℕ} (hn : n ≠ 0) (hm : m ≠ 0)
Goal: Nat.bitwise f n m = Nat.bit (f n.bodd m.bodd) (Nat.bitwise f (n / 2) (m / 2))
-- Nat.binaryRec_of_ne_zero
theorem binaryRec_of_ne_zero {C : Nat → Sort*} (z : C 0) (f : ∀ b n, C n → C (bit b n)) {n}
    (h : n ≠ 0) :
    binaryRec z f n = bit_decomp n ▸ f (bodd n) (div2 n) (binaryRec z f (div2 n)) 
Arguments: {C : ℕ → Sort u_1} (z : C 0) (f : (b : Bool) → (n : ℕ) → C n → C (Nat.bit b n)) {n : ℕ} (h : n ≠ 0)
Goal: Nat.binaryRec z f n = ⋯ ▸ f n.bodd n.div2 (Nat.binaryRec z f n.div2)
-- Nat.bitwise_bit
@[simp]
lemma bitwise_bit {f : Bool → Bool → Bool} (h : f false false = false := by rfl) (a m b n) :
    bitwise f (bit a m) (bit b n) = bit (f a b) (bitwise f m n) 
Arguments: {f : Bool → Bool → Bool} (h : f false false = false := by rfl) (a : Bool) (m : ℕ) (b : Bool) (n : ℕ)
Goal: Nat.bitwise f (Nat.bit a m) (Nat.bit b n) = Nat.bit (f a b) (Nat.bitwise f m n)
-- Nat.bit_mod_two
lemma bit_mod_two (a : Bool) (x : ℕ) :
    bit a x % 2 = if a then 1 else 0 
Arguments: (a : Bool) (x : ℕ)
Goal: Nat.bit a x % 2 = if a = true then 1 else 0
-- Nat.bit_mod_two_eq_zero_iff
@[simp]
lemma bit_mod_two_eq_zero_iff (a x) :
    bit a x % 2 = 0 ↔ !a 
Arguments: (a : Bool) (x : ℕ)
Goal: Nat.bit a x % 2 = 0 ↔ (!a) = true
-- Nat.bit_mod_two_eq_one_iff
@[simp]
lemma bit_mod_two_eq_one_iff (a x) :
    bit a x % 2 = 1 ↔ a 
Arguments: (a : Bool) (x : ℕ)
Goal: Nat.bit a x % 2 = 1 ↔ a = true
-- Nat.lor_bit
@[simp]
theorem lor_bit : ∀ a m b n, bit a m ||| bit b n = bit (a || b) (m ||| n) 
Arguments: (a : Bool) (m : ℕ) (b : Bool) (n : ℕ)
Goal: Nat.bit a m ||| Nat.bit b n = Nat.bit (a || b) (m ||| n)
-- Nat.land_bit
@[simp]
theorem land_bit : ∀ a m b n, bit a m &&& bit b n = bit (a && b) (m &&& n) 
Arguments: (a : Bool) (m : ℕ) (b : Bool) (n : ℕ)
Goal: Nat.bit a m &&& Nat.bit b n = Nat.bit (a && b) (m &&& n)
-- Nat.ldiff_bit
@[simp]
theorem ldiff_bit : ∀ a m b n, ldiff (bit a m) (bit b n) = bit (a && not b) (ldiff m n) 
Arguments: (a : Bool) (m : ℕ) (b : Bool) (n : ℕ)
Goal: (Nat.bit a m).ldiff (Nat.bit b n) = Nat.bit (a && !b) (m.ldiff n)
-- Nat.xor_bit
@[simp]
theorem xor_bit : ∀ a m b n, bit a m ^^^ bit b n = bit (bne a b) (m ^^^ n) 
Arguments: (a : Bool) (m : ℕ) (b : Bool) (n : ℕ)
Goal: Nat.bit a m ^^^ Nat.bit b n = Nat.bit (a != b) (m ^^^ n)
-- Nat.testBit_lor
theorem testBit_lor : ∀ m n k, testBit (m ||| n) k = (testBit m k || testBit n k) 
Arguments: (m n k : ℕ)
Goal: (m ||| n).testBit k = (m.testBit k || n.testBit k)
-- Nat.testBit_land
theorem testBit_land : ∀ m n k, testBit (m &&& n) k = (testBit m k && testBit n k) 
Arguments: (m n k : ℕ)
Goal: (m &&& n).testBit k = (m.testBit k && n.testBit k)
-- Nat.testBit_ldiff
@[simp]
theorem testBit_ldiff : ∀ m n k, testBit (ldiff m n) k = (testBit m k && not (testBit n k)) 
Arguments: (m n k : ℕ)
Goal: (m.ldiff n).testBit k = (m.testBit k && !n.testBit k)
-- Nat.bit_false
@[simp]
theorem bit_false : bit false = (2 * ·) 
Goal: Nat.bit false = fun x => 2 * x
-- Nat.bit_true
@[simp]
theorem bit_true : bit true = (2 * · + 1) 
Goal: Nat.bit true = fun x => 2 * x + 1
-- Nat.bit_eq_zero
@[simp]
theorem bit_eq_zero {n : ℕ} {b : Bool} : n.bit b = 0 ↔ n = 0 ∧ b = false 
Arguments: {n : ℕ} {b : Bool}
Goal: Nat.bit b n = 0 ↔ n = 0 ∧ b = false
-- Nat.bit_ne_zero_iff
theorem bit_ne_zero_iff {n : ℕ} {b : Bool} : n.bit b ≠ 0 ↔ n = 0 → b = true 
Arguments: {n : ℕ} {b : Bool}
Goal: Nat.bit b n ≠ 0 ↔ n = 0 → b = true
-- Nat.bitwise_bit'
lemma bitwise_bit' {f : Bool → Bool → Bool} (a : Bool) (m : Nat) (b : Bool) (n : Nat)
    (ham : m = 0 → a = true) (hbn : n = 0 → b = true) :
    bitwise f (bit a m) (bit b n) = bit (f a b) (bitwise f m n) 
Arguments: {f : Bool → Bool → Bool} (a : Bool) (m : ℕ) (b : Bool) (n : ℕ) (ham : m = 0 → a = true) (hbn : n = 0 → b = true)
Goal: Nat.bitwise f (Nat.bit a m) (Nat.bit b n) = Nat.bit (f a b) (Nat.bitwise f m n)
-- Nat.bitwise_eq_binaryRec
lemma bitwise_eq_binaryRec (f : Bool → Bool → Bool) :
    bitwise f =
    binaryRec (fun n => cond (f false true) n 0) fun a m Ia =>
      binaryRec (cond (f true false) (bit a m) 0) fun b n _ => bit (f a b) (Ia n) 
Arguments: (f : Bool → Bool → Bool)
Goal: Nat.bitwise f =
  Nat.binaryRec (fun n => bif f false true then n else 0) fun a m Ia =>
    Nat.binaryRec (bif f true false then Nat.bit a m else 0) fun b n x => Nat.bit (f a b) (Ia n)
-- Nat.zero_of_testBit_eq_false
theorem zero_of_testBit_eq_false {n : ℕ} (h : ∀ i, testBit n i = false) : n = 0 
Arguments: {n : ℕ} (h : ∀ (i : ℕ), n.testBit i = false)
Goal: n = 0
-- Nat.testBit_eq_false_of_lt
theorem testBit_eq_false_of_lt {n i} (h : n < 2 ^ i) : n.testBit i = false 
Arguments: {n i : ℕ} (h : n < 2 ^ i)
Goal: n.testBit i = false
-- Nat.testBit_eq_inth
theorem testBit_eq_inth (n i : ℕ) : n.testBit i = n.bits.getI i 
Arguments: (n i : ℕ)
Goal: n.testBit i = n.bits.getI i
-- Nat.exists_most_significant_bit
theorem exists_most_significant_bit {n : ℕ} (h : n ≠ 0) :
    ∃ i, testBit n i = true ∧ ∀ j, i < j → testBit n j = false 
Arguments: {n : ℕ} (h : n ≠ 0)
Goal: ∃ i, n.testBit i = true ∧ ∀ (j : ℕ), i < j → n.testBit j = false
-- Nat.lt_of_testBit
theorem lt_of_testBit {n m : ℕ} (i : ℕ) (hn : testBit n i = false) (hm : testBit m i = true)
    (hnm : ∀ j, i < j → testBit n j = testBit m j) : n < m 
Arguments: {n m : ℕ} (i : ℕ) (hn : n.testBit i = false) (hm : m.testBit i = true) (hnm : ∀ (j : ℕ), i < j → n.testBit j = m.testBit j)
Goal: n < m
-- Nat.testBit_two_pow_self
@[simp]
theorem testBit_two_pow_self (n : ℕ) : testBit (2 ^ n) n = true 
Arguments: (n : ℕ)
Goal: (2 ^ n).testBit n = true
-- Nat.testBit_two_pow_of_ne
theorem testBit_two_pow_of_ne {n m : ℕ} (hm : n ≠ m) : testBit (2 ^ n) m = false 
Arguments: {n m : ℕ} (hm : n ≠ m)
Goal: (2 ^ n).testBit m = false
-- Nat.testBit_two_pow
theorem testBit_two_pow (n m : ℕ) : testBit (2 ^ n) m = (n = m) 
Arguments: (n m : ℕ)
Goal: ((2 ^ n).testBit m = true) = (n = m)
-- Nat.bitwise_swap
theorem bitwise_swap {f : Bool → Bool → Bool} :
    bitwise (Function.swap f) = Function.swap (bitwise f) 
Arguments: {f : Bool → Bool → Bool}
Goal: Nat.bitwise (Function.swap f) = Function.swap (Nat.bitwise f)
-- Nat.bitwise_comm
theorem bitwise_comm {f : Bool → Bool → Bool} (hf : ∀ b b', f b b' = f b' b) (n m : ℕ) :
    bitwise f n m = bitwise f m n 
Arguments: {f : Bool → Bool → Bool} (hf : ∀ (b b' : Bool), f b b' = f b' b) (n m : ℕ)
Goal: Nat.bitwise f n m = Nat.bitwise f m n
-- Nat.lor_comm
theorem lor_comm (n m : ℕ) : n ||| m = m ||| n 
Arguments: (n m : ℕ)
Goal: n ||| m = m ||| n
-- Nat.land_comm
theorem land_comm (n m : ℕ) : n &&& m = m &&& n 
Arguments: (n m : ℕ)
Goal: n &&& m = m &&& n
-- Nat.xor_comm
protected lemma xor_comm (n m : ℕ) : n ^^^ m = m ^^^ n 
Arguments: (n m : ℕ)
Goal: n ^^^ m = m ^^^ n
-- Nat.and_two_pow
lemma and_two_pow (n i : ℕ) : n &&& 2 ^ i = (n.testBit i).toNat * 2 ^ i 
Arguments: (n i : ℕ)
Goal: n &&& 2 ^ i = (n.testBit i).toNat * 2 ^ i
-- Nat.two_pow_and
lemma two_pow_and (n i : ℕ) : 2 ^ i &&& n = 2 ^ i * (n.testBit i).toNat 
Arguments: (n i : ℕ)
Goal: 2 ^ i &&& n = 2 ^ i * (n.testBit i).toNat
-- Nat.zero_xor
@[simp]
theorem zero_xor (n : ℕ) : 0 ^^^ n = n 
Arguments: (n : ℕ)
Goal: 0 ^^^ n = n
-- Nat.xor_zero
@[simp]
theorem xor_zero (n : ℕ) : n ^^^ 0 = n 
Arguments: (n : ℕ)
Goal: n ^^^ 0 = n
-- Nat.xor_assoc
protected lemma xor_assoc (n m k : ℕ) : (n ^^^ m) ^^^ k = n ^^^ (m ^^^ k) 
Arguments: (n m k : ℕ)
Goal: n ^^^ m ^^^ k = n ^^^ (m ^^^ k)
-- Nat.land_assoc
theorem land_assoc (n m k : ℕ) : (n &&& m) &&& k = n &&& (m &&& k) 
Arguments: (n m k : ℕ)
Goal: n &&& m &&& k = n &&& (m &&& k)
-- Nat.lor_assoc
theorem lor_assoc (n m k : ℕ) : (n ||| m) ||| k = n ||| (m ||| k) 
Arguments: (n m k : ℕ)
Goal: n ||| m ||| k = n ||| (m ||| k)
-- Nat.xor_self
@[simp]
theorem xor_self (n : ℕ) : n ^^^ n = 0 
Arguments: (n : ℕ)
Goal: n ^^^ n = 0
-- Nat.xor_cancel_right
theorem xor_cancel_right (n m : ℕ) : (m ^^^ n) ^^^ n = m 
Arguments: (n m : ℕ)
Goal: m ^^^ n ^^^ n = m
-- Nat.xor_cancel_left
theorem xor_cancel_left (n m : ℕ) : n ^^^ (n ^^^ m) = m 
Arguments: (n m : ℕ)
Goal: n ^^^ (n ^^^ m) = m