ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Fin.le_insertNth_iff
theorem le_insertNth_iff {i : Fin (n + 1)} {x : α i} {p : ∀ j, α (i.succAbove j)} {q : ∀ j, α j} :
    q ≤ i.insertNth x p ↔ q i ≤ x ∧ (fun j ↦ q (i.succAbove j)) ≤ p 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} [(i : Fin (n + 1)) → Preorder (α i)] {i : Fin (n + 1)} {x : α i} {p : (j : Fin n) → α (i.succAbove j)} {q : (j : Fin (n + 1)) → α j}
Goal: q ≤ i.insertNth x p ↔ q i ≤ x ∧ (fun j => q (i.succAbove j)) ≤ p
-- Fin.removeNth_update
@[simp] lemma removeNth_update (p : Fin (n + 1)) (x) (f : ∀ j, α j) :
    removeNth p (update f p x) = removeNth p f 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (p : Fin (n + 1)) (x : α p) (f : (j : Fin (n + 1)) → α j)
Goal: p.removeNth (Function.update f p x) = p.removeNth f
-- Fin.insertNth_removeNth
@[simp] lemma insertNth_removeNth (p : Fin (n + 1)) (x) (f : ∀ j, α j) :
    insertNth p x (removeNth p f) = update f p x 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (p : Fin (n + 1)) (x : α p) (f : (j : Fin (n + 1)) → α j)
Goal: p.insertNth x (p.removeNth f) = Function.update f p x
-- Fin.insertNth_self_removeNth
lemma insertNth_self_removeNth (p : Fin (n + 1)) (f : ∀ j, α j) :
    insertNth p (f p) (removeNth p f) = f 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u} (p : Fin (n + 1)) (f : (j : Fin (n + 1)) → α j)
Goal: p.insertNth (f p) (p.removeNth f) = f
-- Fin.find_spec
theorem find_spec :
    ∀ {n : ℕ} (p : Fin n → Prop) [DecidablePred p] {i : Fin n} (_ : i ∈ Fin.find p), p i
  
Arguments: {n : ℕ} (p : Fin n → Prop) [DecidablePred p] {i : Fin n}
Goal: i ∈ Fin.find p → p i
-- Fin.isSome_find_iff
theorem isSome_find_iff :
    ∀ {n : ℕ} {p : Fin n → Prop} [DecidablePred p], (find p).isSome ↔ ∃ i, p i
  
Arguments: {n : ℕ} {p : Fin n → Prop} [DecidablePred p]
Goal: (Fin.find p).isSome = true ↔ ∃ i, p i
-- Fin.find_eq_none_iff
theorem find_eq_none_iff {n : ℕ} {p : Fin n → Prop} [DecidablePred p] :
    find p = none ↔ ∀ i, ¬p i 
Arguments: {n : ℕ} {p : Fin n → Prop} [DecidablePred p]
Goal: Fin.find p = none ↔ ∀ (i : Fin n), ¬p i
-- Fin.find_min
theorem find_min :
    ∀ {n : ℕ} {p : Fin n → Prop} [DecidablePred p] {i : Fin n} (_ : i ∈ Fin.find p) {j : Fin n}
      (_ : j < i), ¬p j
  
Arguments: {n : ℕ} {p : Fin n → Prop} [DecidablePred p] {i : Fin n}
Goal: i ∈ Fin.find p → ∀ {j : Fin n}, j < i → ¬p j
-- Fin.find_min'
theorem find_min' {p : Fin n → Prop} [DecidablePred p] {i : Fin n} (h : i ∈ Fin.find p) {j : Fin n}
    (hj : p j) : i ≤ j 
Arguments: {n : ℕ} {p : Fin n → Prop} [DecidablePred p] {i : Fin n} (h : i ∈ Fin.find p) {j : Fin n} (hj : p j)
Goal: i ≤ j
-- Fin.nat_find_mem_find
theorem nat_find_mem_find {p : Fin n → Prop} [DecidablePred p]
    (h : ∃ i, ∃ hin : i < n, p ⟨i, hin⟩) :
    (⟨Nat.find h, (Nat.find_spec h).fst⟩ : Fin n) ∈ find p 
Arguments: {n : ℕ} {p : Fin n → Prop} [DecidablePred p] (h : ∃ i, ∃ (hin : i < n), p ⟨i, hin⟩)
Goal: ⟨Nat.find h, ⋯⟩ ∈ Fin.find p
-- Fin.mem_find_iff
theorem mem_find_iff {p : Fin n → Prop} [DecidablePred p] {i : Fin n} :
    i ∈ Fin.find p ↔ p i ∧ ∀ j, p j → i ≤ j 
Arguments: {n : ℕ} {p : Fin n → Prop} [DecidablePred p] {i : Fin n}
Goal: i ∈ Fin.find p ↔ p i ∧ ∀ (j : Fin n), p j → i ≤ j
-- Fin.find_eq_some_iff
theorem find_eq_some_iff {p : Fin n → Prop} [DecidablePred p] {i : Fin n} :
    Fin.find p = some i ↔ p i ∧ ∀ j, p j → i ≤ j 
Arguments: {n : ℕ} {p : Fin n → Prop} [DecidablePred p] {i : Fin n}
Goal: Fin.find p = some i ↔ p i ∧ ∀ (j : Fin n), p j → i ≤ j
-- Fin.mem_find_of_unique
theorem mem_find_of_unique {p : Fin n → Prop} [DecidablePred p] (h : ∀ i j, p i → p j → i = j)
    {i : Fin n} (hi : p i) : i ∈ Fin.find p 
Arguments: {n : ℕ} {p : Fin n → Prop} [DecidablePred p] (h : ∀ (i j : Fin n), p i → p j → i = j) {i : Fin n} (hi : p i)
Goal: i ∈ Fin.find p
-- Fin.contractNth_apply_of_lt
theorem contractNth_apply_of_lt (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n)
    (h : (k : ℕ) < j) : contractNth j op g k = g (Fin.castSucc k) 
Arguments: {n : ℕ} {α : Type u_1} (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n) (h : ↑k < ↑j)
Goal: j.contractNth op g k = g k.castSucc
-- Fin.contractNth_apply_of_eq
theorem contractNth_apply_of_eq (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n)
    (h : (k : ℕ) = j) : contractNth j op g k = op (g (Fin.castSucc k)) (g k.succ) 
Arguments: {n : ℕ} {α : Type u_1} (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n) (h : ↑k = ↑j)
Goal: j.contractNth op g k = op (g k.castSucc) (g k.succ)
-- Fin.contractNth_apply_of_gt
theorem contractNth_apply_of_gt (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n)
    (h : (j : ℕ) < k) : contractNth j op g k = g k.succ 
Arguments: {n : ℕ} {α : Type u_1} (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n) (h : ↑j < ↑k)
Goal: j.contractNth op g k = g k.succ
-- Fin.contractNth_apply_of_ne
theorem contractNth_apply_of_ne (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n)
    (hjk : (j : ℕ) ≠ k) : contractNth j op g k = g (j.succAbove k) 
Arguments: {n : ℕ} {α : Type u_1} (j : Fin (n + 1)) (op : α → α → α) (g : Fin (n + 1) → α) (k : Fin n) (hjk : ↑j ≠ ↑k)
Goal: j.contractNth op g k = g (j.succAbove k)
-- Fin.sigma_eq_of_eq_comp_cast
theorem sigma_eq_of_eq_comp_cast {α : Type*} :
    ∀ {a b : Σii, Fin ii → α} (h : a.fst = b.fst), a.snd = b.snd ∘ Fin.cast h → a = b
  
Arguments: {α : Type u_1} {a b : (ii : ℕ) × (Fin ii → α)} (h : a.fst = b.fst)
Goal: a.snd = b.snd ∘ Fin.cast h → a = b
-- Fin.sigma_eq_iff_eq_comp_cast
theorem sigma_eq_iff_eq_comp_cast {α : Type*} {a b : Σii, Fin ii → α} :
    a = b ↔ ∃ h : a.fst = b.fst, a.snd = b.snd ∘ Fin.cast h 
Arguments: {α : Type u_1} {a b : (ii : ℕ) × (Fin ii → α)}
Goal: a = b ↔ ∃ (h : a.fst = b.fst), a.snd = b.snd ∘ Fin.cast h
-- Choose.choose_modEq_choose_mod_mul_choose_div
theorem choose_modEq_choose_mod_mul_choose_div :
    choose n k ≡ choose (n % p) (k % p) * choose (n / p) (k / p) [ZMOD p] 
Arguments: {n k p : ℕ} [Fact (Nat.Prime p)]
Goal: ↑(n.choose k) ≡ ↑((n % p).choose (k % p)) * ↑((n / p).choose (k / p)) [ZMOD ↑p]
-- Choose.choose_modEq_choose_mod_mul_choose_div_nat
theorem choose_modEq_choose_mod_mul_choose_div_nat :
    choose n k ≡ choose (n % p) (k % p) * choose (n / p) (k / p) [MOD p] 
Arguments: {n k p : ℕ} [Fact (Nat.Prime p)]
Goal: n.choose k ≡ (n % p).choose (k % p) * (n / p).choose (k / p) [MOD p]
-- Choose.choose_modEq_choose_mul_prod_range_choose
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] 
Arguments: {n k p : ℕ} [Fact (Nat.Prime p)] (a : ℕ)
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]
-- Choose.choose_modEq_prod_range_choose
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] 
Arguments: {n k p : ℕ} [Fact (Nat.Prime p)] {a : ℕ} (ha₁ : n < p ^ a) (ha₂ : k < p ^ a)
Goal: ↑(n.choose k) ≡ ∏ i ∈ Finset.range a, ↑((n / p ^ i % p).choose (k / p ^ i % p)) [ZMOD ↑p]
-- Choose.choose_modEq_prod_range_choose_nat
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] 
Arguments: {n k p : ℕ} [Fact (Nat.Prime p)] {a : ℕ} (ha₁ : n < p ^ a) (ha₂ : k < p ^ a)
Goal: n.choose k ≡ ∏ i ∈ Finset.range a, (n / p ^ i % p).choose (k / p ^ i % p) [MOD p]
-- Nat.zero_union_range_succ
theorem zero_union_range_succ : {0} ∪ range succ = univ 
Goal: {0} ∪ Set.range Nat.succ = Set.univ
-- Nat.range_succ
@[simp]
protected theorem range_succ : range succ = { i | 0 < i } 
Goal: Set.range Nat.succ = {i | 0 < i}
-- Nat.range_of_succ
theorem range_of_succ (f : ℕ → α) : {f 0} ∪ range (f ∘ succ) = range f 
Arguments: {α : Type u_1} (f : ℕ → α)
Goal: {f 0} ∪ Set.range (f ∘ Nat.succ) = Set.range f
-- Nat.range_rec
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 
Arguments: {α : Type u_2} (x : α) (f : ℕ → α → α)
Goal: (Set.range fun n => Nat.rec x f n) = {x} ∪ Set.range fun n => Nat.rec (f 0 x) (f ∘ Nat.succ) n
-- Nat.range_casesOn
theorem range_casesOn {α : Type*} (x : α) (f : ℕ → α) :
    (Set.range fun n => Nat.casesOn n x f : Set α) = {x} ∪ Set.range f 
Arguments: {α : Type u_2} (x : α) (f : ℕ → α)
Goal: (Set.range fun n => Nat.casesOn n x f) = {x} ∪ Set.range f
-- Nat.ppred_zero
@[simp]
theorem ppred_zero : ppred 0 = none 
Goal: Nat.ppred 0 = none
-- Nat.ppred_succ
@[simp]
theorem ppred_succ {n : ℕ} : ppred (succ n) = some n 
Arguments: {n : ℕ}
Goal: n.succ.ppred = some n
-- Nat.psub_zero
@[simp]
theorem psub_zero {m : ℕ} : psub m 0 = some m 
Arguments: {m : ℕ}
Goal: m.psub 0 = some m
-- Nat.psub_succ
@[simp]
theorem psub_succ {m n : ℕ} : psub m (succ n) = psub m n >>= ppred 
Arguments: {m n : ℕ}
Goal: m.psub n.succ = m.psub n >>= Nat.ppred
-- Nat.pred_eq_ppred
theorem pred_eq_ppred (n : ℕ) : pred n = (ppred n).getD 0 
Arguments: (n : ℕ)
Goal: n.pred = n.ppred.getD 0
-- Nat.sub_eq_psub
theorem sub_eq_psub (m : ℕ) : ∀ n, m - n = (psub m n).getD 0
  
Arguments: (m n : ℕ)
Goal: m - n = (m.psub n).getD 0
-- Nat.ppred_eq_some
@[simp]
theorem ppred_eq_some {m : ℕ} : ∀ {n}, ppred n = some m ↔ succ m = n
  
Arguments: {m n : ℕ}
Goal: n.ppred = some m ↔ m.succ = n
-- Nat.ppred_eq_none
@[simp]
theorem ppred_eq_none : ∀ {n : ℕ}, ppred n = none ↔ n = 0
  
Arguments: {n : ℕ}
Goal: n.ppred = none ↔ n = 0
-- Nat.psub_eq_some
theorem psub_eq_some {m : ℕ} : ∀ {n k}, psub m n = some k ↔ k + n = m
  
Arguments: {m n k : ℕ}
Goal: m.psub n = some k ↔ k + n = m
-- Nat.psub_eq_none
theorem psub_eq_none {m n : ℕ} : psub m n = none ↔ m < n 
Arguments: {m n : ℕ}
Goal: m.psub n = none ↔ m < n
-- Nat.ppred_eq_pred
theorem ppred_eq_pred {n} (h : 0 < n) : ppred n = some (pred n) 
Arguments: {n : ℕ} (h : 0 < n)
Goal: n.ppred = some n.pred
-- Nat.psub_eq_sub
theorem psub_eq_sub {m n} (h : n ≤ m) : psub m n = some (m - n) 
Arguments: {m n : ℕ} (h : n ≤ m)
Goal: m.psub n = some (m - n)
-- Nat.psub_add
theorem psub_add (m n k) :
    psub m (n + k) = (do psub (← psub m n) k) 
Arguments: (m n k : ℕ)
Goal: m.psub (n + k) = do
  let __do_lift ← m.psub n
  __do_lift.psub k
-- Nat.psub'_eq_psub
theorem psub'_eq_psub (m n) : psub' m n = psub m n 
Arguments: (m n : ℕ)
Goal: m.psub' n = m.psub n
-- Nat.evenOddRec_zero
@[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 
Arguments: {P : ℕ → Sort u_1} (h0 : P 0) (h_even : (i : ℕ) → P i → P (2 * i)) (h_odd : (i : ℕ) → P i → P (2 * i + 1))
Goal: Nat.evenOddRec h0 h_even h_odd 0 = h0
-- Nat.evenOddRec_even
@[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) 
Arguments: {P : ℕ → Sort u_1} (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 : ℕ)
Goal: Nat.evenOddRec h0 h_even h_odd (2 * n) = h_even n (Nat.evenOddRec h0 h_even h_odd n)
-- Nat.evenOddRec_odd
@[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) 
Arguments: {P : ℕ → Sort u_1} (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 : ℕ)
Goal: Nat.evenOddRec h0 h_even h_odd (2 * n + 1) = h_odd n (Nat.evenOddRec h0 h_even h_odd n)
-- induction_on_primes
lemma _root_.induction_on_primes {P : ℕ → Prop} (h₀ : P 0) (h₁ : P 1)
    (h : ∀ p a : ℕ, p.Prime → P a → P (p * a)) : ∀ n, P n 
Arguments: {P : ℕ → Prop} (h₀ : P 0) (h₁ : P 1) (h : ∀ (p a : ℕ), Nat.Prime p → P a → P (p * a)) (n : ℕ)
Goal: P n
-- Nat.prime_composite_induction
lemma prime_composite_induction {P : ℕ → Prop} (zero : P 0) (one : P 1)
    (prime : ∀ p : ℕ, p.Prime → P p) (composite : ∀ a, 2 ≤ a → P a → ∀ b, 2 ≤ b → P b → P (a * b))
    (n : ℕ) : P n 
Arguments: {P : ℕ → Prop} (zero : P 0) (one : P 1) (prime : ∀ (p : ℕ), Nat.Prime p → P p) (composite : ∀ (a : ℕ), 2 ≤ a → P a → ∀ (b : ℕ), 2 ≤ b → P b → P (a * b)) (n : ℕ)
Goal: P n
-- Nat.multiplicative_factorization
theorem multiplicative_factorization {β : Type*} [CommMonoid β] (f : ℕ → β)
    (h_mult : ∀ x y : ℕ, Coprime x y → f (x * y) = f x * f y) (hf : f 1 = 1) :
    ∀ {n : ℕ}, n ≠ 0 → f n = n.factorization.prod fun p k => f (p ^ k) 
Arguments: {β : Type u_1} [CommMonoid β] (f : ℕ → β) (h_mult : ∀ (x y : ℕ), x.Coprime y → f (x * y) = f x * f y) (hf : f 1 = 1) {n : ℕ}
Goal: n ≠ 0 → f n = n.factorization.prod fun p k => f (p ^ k)
-- Nat.multiplicative_factorization'
theorem multiplicative_factorization' {β : Type*} [CommMonoid β] (f : ℕ → β)
    (h_mult : ∀ x y : ℕ, Coprime x y → f (x * y) = f x * f y) (hf0 : f 0 = 1) (hf1 : f 1 = 1) :
    f n = n.factorization.prod fun p k => f (p ^ k) 
Arguments: {n : ℕ} {β : Type u_1} [CommMonoid β] (f : ℕ → β) (h_mult : ∀ (x y : ℕ), x.Coprime y → f (x * y) = f x * f y) (hf0 : f 0 = 1) (hf1 : f 1 = 1)
Goal: f n = n.factorization.prod fun p k => f (p ^ k)
-- Nat.bodd_zero
@[simp] lemma bodd_zero : bodd 0 = false 
Goal: Nat.bodd 0 = false
-- Nat.bodd_one
lemma bodd_one : bodd 1 = true 
Goal: Nat.bodd 1 = true
-- Nat.bodd_two
lemma bodd_two : bodd 2 = false 
Goal: Nat.bodd 2 = false
-- Nat.bodd_succ
@[simp]
lemma bodd_succ (n : ℕ) : bodd (succ n) = not (bodd n) 
Arguments: (n : ℕ)
Goal: n.succ.bodd = !n.bodd
-- Nat.bodd_add
@[simp]
lemma bodd_add (m n : ℕ) : bodd (m + n) = bxor (bodd m) (bodd n) 
Arguments: (m n : ℕ)
Goal: (m + n).bodd = bxor m.bodd n.bodd
-- Nat.bodd_mul
@[simp]
lemma bodd_mul (m n : ℕ) : bodd (m * n) = (bodd m && bodd n) 
Arguments: (m n : ℕ)
Goal: (m * n).bodd = (m.bodd && n.bodd)
-- Nat.mod_two_of_bodd
lemma mod_two_of_bodd (n : ℕ) : n % 2 = cond (bodd n) 1 0 
Arguments: (n : ℕ)
Goal: n % 2 = bif n.bodd then 1 else 0
-- Nat.div2_zero
@[simp] lemma div2_zero : div2 0 = 0 
Goal: Nat.div2 0 = 0
-- Nat.div2_one
lemma div2_one : div2 1 = 0 
Goal: Nat.div2 1 = 0
-- Nat.div2_two
lemma div2_two : div2 2 = 1 
Goal: Nat.div2 2 = 1
-- Nat.div2_succ
@[simp]
lemma div2_succ (n : ℕ) : div2 (succ n) = cond (bodd n) (succ (div2 n)) (div2 n) 
Arguments: (n : ℕ)
Goal: n.succ.div2 = bif n.bodd then n.div2.succ else n.div2
-- Nat.bodd_add_div2
lemma bodd_add_div2 : ∀ n, cond (bodd n) 1 0 + 2 * div2 n = n
  
Arguments: (n : ℕ)
Goal: (bif n.bodd then 1 else 0) + 2 * n.div2 = n
-- Nat.div2_val
lemma div2_val (n) : div2 n = n / 2 
Arguments: (n : ℕ)
Goal: n.div2 = n / 2
-- Nat.bit_val
lemma bit_val (b n) : bit b n = 2 * n + cond b 1 0 
Arguments: (b : Bool) (n : ℕ)
Goal: Nat.bit b n = 2 * n + bif b then 1 else 0
-- Nat.bit_decomp
lemma bit_decomp (n : Nat) : bit (bodd n) (div2 n) = n 
Arguments: (n : ℕ)
Goal: Nat.bit n.bodd n.div2 = n
-- Nat.bit_zero
lemma bit_zero : bit false 0 = 0 
Goal: Nat.bit false 0 = 0
-- Nat.shiftLeft'_false
@[simp]
lemma shiftLeft'_false : ∀ n, shiftLeft' false m n = m <<< n
  
Arguments: {m : ℕ} (n : ℕ)
Goal: Nat.shiftLeft' false m n = m <<< n
-- Nat.shiftLeft_eq'
@[simp] lemma shiftLeft_eq' (m n : Nat) : shiftLeft m n = m <<< n 
Arguments: (m n : ℕ)
Goal: m.shiftLeft n = m <<< n
-- Nat.shiftRight_eq
@[simp] lemma shiftRight_eq (m n : Nat) : shiftRight m n = m >>> n 
Arguments: (m n : ℕ)
Goal: m.shiftRight n = m >>> n
-- Nat.binaryRec_decreasing
lemma binaryRec_decreasing (h : n ≠ 0) : div2 n < n 
Arguments: {n : ℕ} (h : n ≠ 0)
Goal: n.div2 < n
-- Nat.binaryRec_zero
@[simp]
lemma binaryRec_zero {C : Nat → Sort u} (z : C 0) (f : ∀ b n, C n → C (bit b n)) :
    binaryRec z f 0 = z 
Arguments: {C : ℕ → Sort u} (z : C 0) (f : (b : Bool) → (n : ℕ) → C n → C (Nat.bit b n))
Goal: Nat.binaryRec z f 0 = z
-- Nat.bodd_bit
lemma bodd_bit (b n) : bodd (bit b n) = b 
Arguments: (b : Bool) (n : ℕ)
Goal: (Nat.bit b n).bodd = b
-- Nat.div2_bit
lemma div2_bit (b n) : div2 (bit b n) = n 
Arguments: (b : Bool) (n : ℕ)
Goal: (Nat.bit b n).div2 = n
-- Nat.shiftLeft'_add
lemma shiftLeft'_add (b m n) : ∀ k, shiftLeft' b m (n + k) = shiftLeft' b (shiftLeft' b m n) k
  
Arguments: (b : Bool) (m n k : ℕ)
Goal: Nat.shiftLeft' b m (n + k) = Nat.shiftLeft' b (Nat.shiftLeft' b m n) k
-- Nat.shiftLeft'_sub
lemma shiftLeft'_sub (b m) : ∀ {n k}, k ≤ n → shiftLeft' b m (n - k) = (shiftLeft' b m n) >>> k
  
Arguments: (b : Bool) (m : ℕ) {n k : ℕ}
Goal: k ≤ n → Nat.shiftLeft' b m (n - k) = Nat.shiftLeft' b m n >>> k
-- Nat.shiftLeft_sub
lemma shiftLeft_sub : ∀ (m : Nat) {n k}, k ≤ n → m <<< (n - k) = (m <<< n) >>> k 
Arguments: (m : ℕ) {n k : ℕ}
Goal: k ≤ n → m <<< (n - k) = m <<< n >>> k
-- Nat.testBit_bit_zero
lemma testBit_bit_zero (b n) : testBit (bit b n) 0 = b 
Arguments: (b : Bool) (n : ℕ)
Goal: (Nat.bit b n).testBit 0 = b
-- Nat.bodd_eq_one_and_ne_zero
lemma bodd_eq_one_and_ne_zero : ∀ n, bodd n = (1 &&& n != 0)
  
Arguments: (n : ℕ)
Goal: n.bodd = (1 &&& n != 0)
-- Nat.testBit_bit_succ
lemma testBit_bit_succ (m b n) : testBit (bit b n) (succ m) = testBit n m 
Arguments: (m : ℕ) (b : Bool) (n : ℕ)
Goal: (Nat.bit b n).testBit m.succ = n.testBit m
-- Nat.binaryRec_eq
lemma binaryRec_eq {C : Nat → Sort u} {z : C 0} {f : ∀ b n, C n → C (bit b n)}
    (h : f false 0 z = z) (b n) : binaryRec z f (bit b n) = f b n (binaryRec z f n) 
Arguments: {C : ℕ → Sort u} {z : C 0} {f : (b : Bool) → (n : ℕ) → C n → C (Nat.bit b n)} (h : f false 0 z = z) (b : Bool) (n : ℕ)
Goal: Nat.binaryRec z f (Nat.bit b n) = f b n (Nat.binaryRec z f n)
-- Nat.boddDiv2_eq
@[simp]
theorem boddDiv2_eq (n : ℕ) : boddDiv2 n = (bodd n, div2 n) 
Arguments: (n : ℕ)
Goal: n.boddDiv2 = (n.bodd, n.div2)
-- Nat.div2_bit0
@[simp]
theorem div2_bit0 (n) : div2 (2 * n) = n 
Arguments: (n : ℕ)
Goal: (2 * n).div2 = n
-- Nat.div2_bit1
theorem div2_bit1 (n) : div2 (2 * n + 1) = n 
Arguments: (n : ℕ)
Goal: (2 * n + 1).div2 = n
-- Nat.bit_add
theorem bit_add : ∀ (b : Bool) (n m : ℕ), bit b (n + m) = bit false n + bit b m
  
Arguments: (b : Bool) (n m : ℕ)
Goal: Nat.bit b (n + m) = Nat.bit false n + Nat.bit b m
-- Nat.bit_add'
theorem bit_add' : ∀ (b : Bool) (n m : ℕ), bit b (n + m) = bit b n + bit false m
  
Arguments: (b : Bool) (n m : ℕ)
Goal: Nat.bit b (n + m) = Nat.bit b n + Nat.bit false m
-- Nat.bit_ne_zero
theorem bit_ne_zero (b) {n} (h : n ≠ 0) : bit b n ≠ 0 
Arguments: (b : Bool) {n : ℕ} (h : n ≠ 0)
Goal: Nat.bit b n ≠ 0
-- Nat.bitCasesOn_bit
@[simp]
theorem bitCasesOn_bit {C : ℕ → Sort u} (H : ∀ b n, C (bit b n)) (b : Bool) (n : ℕ) :
    bitCasesOn (bit b n) H = H b n 
Arguments: {C : ℕ → Sort u} (H : (b : Bool) → (n : ℕ) → C (Nat.bit b n)) (b : Bool) (n : ℕ)
Goal: (Nat.bit b n).bitCasesOn H = H b n
-- Nat.bitCasesOn_bit0
@[simp]
theorem bitCasesOn_bit0 {C : ℕ → Sort u} (H : ∀ b n, C (bit b n)) (n : ℕ) :
    bitCasesOn (2 * n) H = H false n 
Arguments: {C : ℕ → Sort u} (H : (b : Bool) → (n : ℕ) → C (Nat.bit b n)) (n : ℕ)
Goal: (2 * n).bitCasesOn H = H false n
-- Nat.bitCasesOn_bit1
@[simp]
theorem bitCasesOn_bit1 {C : ℕ → Sort u} (H : ∀ b n, C (bit b n)) (n : ℕ) :
    bitCasesOn (2 * n + 1) H = H true n 
Arguments: {C : ℕ → Sort u} (H : (b : Bool) → (n : ℕ) → C (Nat.bit b n)) (n : ℕ)
Goal: (2 * n + 1).bitCasesOn H = H true n
-- Nat.bit_cases_on_injective
theorem bit_cases_on_injective {C : ℕ → Sort u} :
    Function.Injective fun H : ∀ b n, C (bit b n) => fun n => bitCasesOn n H 
Arguments: {C : ℕ → Sort u}
Goal: Function.Injective fun H n => n.bitCasesOn H
-- Nat.bit_cases_on_inj
@[simp]
theorem bit_cases_on_inj {C : ℕ → Sort u} (H₁ H₂ : ∀ b n, C (bit b n)) :
    ((fun n => bitCasesOn n H₁) = fun n => bitCasesOn n H₂) ↔ H₁ = H₂ 
Arguments: {C : ℕ → Sort u} (H₁ H₂ : (b : Bool) → (n : ℕ) → C (Nat.bit b n))
Goal: ((fun n => n.bitCasesOn H₁) = fun n => n.bitCasesOn H₂) ↔ H₁ = H₂
-- Nat.bit_eq_zero_iff
theorem bit_eq_zero_iff {n : ℕ} {b : Bool} : bit b n = 0 ↔ n = 0 ∧ b = false 
Arguments: {n : ℕ} {b : Bool}
Goal: Nat.bit b n = 0 ↔ n = 0 ∧ b = false
-- Nat.bit_le
lemma bit_le : ∀ (b : Bool) {m n : ℕ}, m ≤ n → bit b m ≤ bit b n
  
Arguments: (b : Bool) {m n : ℕ}
Goal: m ≤ n → Nat.bit b m ≤ Nat.bit b n
-- Nat.bit_lt_bit
lemma bit_lt_bit (a b) (h : m < n) : bit a m < bit b n 
Arguments: {m n : ℕ} (a b : Bool) (h : m < n)
Goal: Nat.bit a m < Nat.bit b n
-- Nat.binaryRec_eq'
theorem binaryRec_eq' {C : ℕ → Sort*} {z : C 0} {f : ∀ b n, C n → C (bit b n)} (b n)
    (h : f false 0 z = z ∨ (n = 0 → b = true)) :
    binaryRec z f (bit b n) = f b n (binaryRec z f n) 
Arguments: {C : ℕ → Sort u_1} {z : C 0} {f : (b : Bool) → (n : ℕ) → C n → C (Nat.bit b n)} (b : Bool) (n : ℕ) (h : f false 0 z = z ∨ (n = 0 → b = true))
Goal: Nat.binaryRec z f (Nat.bit b n) = f b n (Nat.binaryRec z f n)
-- Nat.zero_bits
@[simp]
theorem zero_bits : bits 0 = [] 
Goal: Nat.bits 0 = []
-- Nat.bits_append_bit
@[simp]
theorem bits_append_bit (n : ℕ) (b : Bool) (hn : n = 0 → b = true) :
    (bit b n).bits = b :: n.bits 
Arguments: (n : ℕ) (b : Bool) (hn : n = 0 → b = true)
Goal: (Nat.bit b n).bits = b :: n.bits
-- Nat.bit0_bits
@[simp]
theorem bit0_bits (n : ℕ) (hn : n ≠ 0) : (2 * n).bits = false :: n.bits 
Arguments: (n : ℕ) (hn : n ≠ 0)
Goal: (2 * n).bits = false :: n.bits
-- Nat.bit1_bits
@[simp]
theorem bit1_bits (n : ℕ) : (2 * n + 1).bits = true :: n.bits 
Arguments: (n : ℕ)
Goal: (2 * n + 1).bits = true :: n.bits
-- Nat.one_bits
@[simp]
theorem one_bits : Nat.bits 1 = [true] 
Goal: Nat.bits 1 = [true]
-- Nat.bodd_eq_bits_head
theorem bodd_eq_bits_head (n : ℕ) : n.bodd = n.bits.headI 
Arguments: (n : ℕ)
Goal: n.bodd = n.bits.headI
-- Nat.div2_bits_eq_tail
theorem div2_bits_eq_tail (n : ℕ) : n.div2.bits = n.bits.tail 
Arguments: (n : ℕ)
Goal: n.div2.bits = n.bits.tail
-- Nat.floorRoot_def
lemma floorRoot_def :
    floorRoot n a = if n = 0 ∨ a = 0 then 0 else (a.factorization ⌊/⌋ n).prod (· ^ ·) 
Arguments: {a n : ℕ}
Goal: n.floorRoot a = if n = 0 ∨ a = 0 then 0 else (a.factorization ⌊/⌋ n).prod fun x x_1 => x ^ x_1
-- Nat.floorRoot_zero_left
@[simp] lemma floorRoot_zero_left (a : ℕ) : floorRoot 0 a = 0 
Arguments: (a : ℕ)
Goal: Nat.floorRoot 0 a = 0
-- Nat.floorRoot_zero_right
@[simp] lemma floorRoot_zero_right (n : ℕ) : floorRoot n 0 = 0 
Arguments: (n : ℕ)
Goal: n.floorRoot 0 = 0
-- Nat.floorRoot_one_left
@[simp] lemma floorRoot_one_left (a : ℕ) : floorRoot 1 a = a 
Arguments: (a : ℕ)
Goal: Nat.floorRoot 1 a = a
-- Nat.floorRoot_one_right
@[simp] lemma floorRoot_one_right (hn : n ≠ 0) : floorRoot n 1 = 1 
Arguments: {n : ℕ} (hn : n ≠ 0)
Goal: n.floorRoot 1 = 1
-- Nat.floorRoot_pow_self
@[simp] lemma floorRoot_pow_self (hn : n ≠ 0) (a : ℕ) : floorRoot n (a ^ n) = a 
Arguments: {n : ℕ} (hn : n ≠ 0) (a : ℕ)
Goal: n.floorRoot (a ^ n) = a
-- Nat.floorRoot_ne_zero
lemma floorRoot_ne_zero : floorRoot n a ≠ 0 ↔ n ≠ 0 ∧ a ≠ 0 
Arguments: {a n : ℕ}
Goal: n.floorRoot a ≠ 0 ↔ n ≠ 0 ∧ a ≠ 0
-- Nat.floorRoot_eq_zero
@[simp] lemma floorRoot_eq_zero : floorRoot n a = 0 ↔ n = 0 ∨ a = 0 
Arguments: {a n : ℕ}
Goal: n.floorRoot a = 0 ↔ n = 0 ∨ a = 0
-- Nat.factorization_floorRoot
@[simp] lemma factorization_floorRoot (n a : ℕ) :
    (floorRoot n a).factorization = a.factorization ⌊/⌋ n 
Arguments: (n a : ℕ)
Goal: (n.floorRoot a).factorization = a.factorization ⌊/⌋ n
-- Nat.pow_dvd_iff_dvd_floorRoot
lemma pow_dvd_iff_dvd_floorRoot : a ^ n ∣ b ↔ a ∣ floorRoot n b 
Arguments: {a b n : ℕ}
Goal: a ^ n ∣ b ↔ a ∣ n.floorRoot b
-- Nat.floorRoot_pow_dvd
lemma floorRoot_pow_dvd : floorRoot n a ^ n ∣ a 
Arguments: {a n : ℕ}
Goal: n.floorRoot a ^ n ∣ a
-- Nat.ceilRoot_def
lemma ceilRoot_def :
    ceilRoot n a = if n = 0 ∨ a = 0 then 0 else (a.factorization ⌈/⌉ n).prod (· ^ ·) 
Arguments: {a n : ℕ}
Goal: n.ceilRoot a = if n = 0 ∨ a = 0 then 0 else (a.factorization ⌈/⌉ n).prod fun x x_1 => x ^ x_1
-- Nat.ceilRoot_zero_left
@[simp] lemma ceilRoot_zero_left (a : ℕ) : ceilRoot 0 a = 0 
Arguments: (a : ℕ)
Goal: Nat.ceilRoot 0 a = 0
-- Nat.ceilRoot_zero_right
@[simp] lemma ceilRoot_zero_right (n : ℕ) : ceilRoot n 0 = 0 
Arguments: (n : ℕ)
Goal: n.ceilRoot 0 = 0
-- Nat.ceilRoot_one_left
@[simp] lemma ceilRoot_one_left (a : ℕ) : ceilRoot 1 a = a 
Arguments: (a : ℕ)
Goal: Nat.ceilRoot 1 a = a