ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Even.natCast
lemma _root_.Even.natCast [AddMonoidWithOne α] {n : ℕ} (hn : Even n) : Even (n : α) 
Arguments: {α : Type u_1} [AddMonoidWithOne α] {n : ℕ} (hn : Even n)
Goal: Even ↑n
-- Nat.cast_mul
@[simp, norm_cast] lemma cast_mul (m n : ℕ) : ((m * n : ℕ) : α) = m * n 
Arguments: {α : Type u_1} [NonAssocSemiring α] (m n : ℕ)
Goal: ↑(m * n) = ↑m * ↑n
-- Nat.coe_castRingHom
@[simp, norm_cast] lemma coe_castRingHom : (castRingHom α : ℕ → α) = Nat.cast 
Arguments: {α : Type u_1} [NonAssocSemiring α]
Goal: ⇑(Nat.castRingHom α) = Nat.cast
-- nsmul_eq_mul'
lemma _root_.nsmul_eq_mul' (a : α) (n : ℕ) : n • a = a * n 
Arguments: {α : Type u_1} [NonAssocSemiring α] (a : α) (n : ℕ)
Goal: n • a = a * ↑n
-- nsmul_eq_mul
@[simp] lemma _root_.nsmul_eq_mul (n : ℕ) (a : α) : n • a = n * a 
Arguments: {α : Type u_1} [NonAssocSemiring α] (n : ℕ) (a : α)
Goal: n • a = ↑n * a
-- Nat.cast_pow
@[simp, norm_cast]
lemma cast_pow (m : ℕ) : ∀ n : ℕ, ↑(m ^ n) = (m ^ n : α)
  
Arguments: {α : Type u_1} [Semiring α] (m n : ℕ)
Goal: ↑(m ^ n) = ↑m ^ n
-- Nat.cast_dvd_cast
lemma cast_dvd_cast (h : m ∣ n) : (m : α) ∣ (n : α) 
Arguments: {α : Type u_1} [Semiring α] {m n : ℕ} (h : m ∣ n)
Goal: ↑m ∣ ↑n
-- ext_nat'
theorem ext_nat' [AddMonoid A] [AddMonoidHomClass F ℕ A] (f g : F) (h : f 1 = g 1) : f = g 
Arguments: {A : Type u_3} {F : Type u_5} [FunLike F ℕ A] [AddMonoid A] [AddMonoidHomClass F ℕ A] (f g : F) (h : f 1 = g 1)
Goal: f = g
-- AddMonoidHom.ext_nat
@[ext]
theorem AddMonoidHom.ext_nat [AddMonoid A] {f g : ℕ →+ A} : f 1 = g 1 → f = g 
Arguments: {A : Type u_3} [AddMonoid A] {f g : ℕ →+ A}
Goal: f 1 = g 1 → f = g
-- eq_natCast'
theorem eq_natCast' [AddMonoidHomClass F ℕ A] (f : F) (h1 : f 1 = 1) : ∀ n : ℕ, f n = n
  
Arguments: {A : Type u_3} {F : Type u_5} [FunLike F ℕ A] [AddMonoidWithOne A] [AddMonoidHomClass F ℕ A] (f : F) (h1 : f 1 = 1) (n : ℕ)
Goal: f n = ↑n
-- map_natCast'
theorem map_natCast' {A} [AddMonoidWithOne A] [FunLike F A B] [AddMonoidHomClass F A B]
    (f : F) (h : f 1 = 1) :
    ∀ n : ℕ, f n = n
  
Arguments: {B : Type u_4} {F : Type u_5} [AddMonoidWithOne B] {A : Type u_6} [AddMonoidWithOne A] [FunLike F A B] [AddMonoidHomClass F A B] (f : F) (h : f 1 = 1) (n : ℕ)
Goal: f ↑n = ↑n
-- map_ofNat'
theorem map_ofNat' {A} [AddMonoidWithOne A] [FunLike F A B] [AddMonoidHomClass F A B]
    (f : F) (h : f 1 = 1) (n : ℕ) [n.AtLeastTwo] : f (OfNat.ofNat n) = OfNat.ofNat n 
Arguments: {B : Type u_4} {F : Type u_5} [AddMonoidWithOne B] {A : Type u_6} [AddMonoidWithOne A] [FunLike F A B] [AddMonoidHomClass F A B] (f : F) (h : f 1 = 1) (n : ℕ) [n.AtLeastTwo]
Goal: f (OfNat.ofNat n) = OfNat.ofNat n
-- nsmul_one
@[simp] lemma nsmul_one {A} [AddMonoidWithOne A] : ∀ n : ℕ, n • (1 : A) = n 
Arguments: {A : Type u_6} [AddMonoidWithOne A] (n : ℕ)
Goal: n • 1 = ↑n
-- ext_nat''
theorem ext_nat'' [MonoidWithZeroHomClass F ℕ A] (f g : F) (h_pos : ∀ {n : ℕ}, 0 < n → f n = g n) :
    f = g 
Arguments: {A : Type u_3} {F : Type u_4} [MulZeroOneClass A] [FunLike F ℕ A] [MonoidWithZeroHomClass F ℕ A] (f g : F) (h_pos : ∀ {n : ℕ}, 0 < n → f n = g n)
Goal: f = g
-- MonoidWithZeroHom.ext_nat
@[ext]
theorem MonoidWithZeroHom.ext_nat {f g : ℕ →*₀ A} : (∀ {n : ℕ}, 0 < n → f n = g n) → f = g 
Arguments: {A : Type u_3} [MulZeroOneClass A] {f g : ℕ →*₀ A}
Goal: (∀ {n : ℕ}, 0 < n → f n = g n) → f = g
-- eq_natCast
@[simp]
theorem eq_natCast [FunLike F ℕ R] [RingHomClass F ℕ R] (f : F) : ∀ n, f n = n 
Arguments: {R : Type u_3} {F : Type u_5} [NonAssocSemiring R] [FunLike F ℕ R] [RingHomClass F ℕ R] (f : F) (n : ℕ)
Goal: f n = ↑n
-- map_natCast
@[simp]
theorem map_natCast [FunLike F R S] [RingHomClass F R S] (f : F) : ∀ n : ℕ, f (n : R) = n 
Arguments: {R : Type u_3} {S : Type u_4} {F : Type u_5} [NonAssocSemiring R] [NonAssocSemiring S] [FunLike F R S] [RingHomClass F R S] (f : F) (n : ℕ)
Goal: f ↑n = ↑n
-- map_ofNat
@[simp]
theorem map_ofNat [FunLike F R S] [RingHomClass F R S] (f : F) (n : ℕ) [Nat.AtLeastTwo n] :
    (f (no_index (OfNat.ofNat n)) : S) = OfNat.ofNat n 
Arguments: {R : Type u_3} {S : Type u_4} {F : Type u_5} [NonAssocSemiring R] [NonAssocSemiring S] [FunLike F R S] [RingHomClass F R S] (f : F) (n : ℕ) [n.AtLeastTwo]
Goal: f (OfNat.ofNat n) = OfNat.ofNat n
-- ext_nat
theorem ext_nat [FunLike F ℕ R] [RingHomClass F ℕ R] (f g : F) : f = g 
Arguments: {R : Type u_3} {F : Type u_5} [NonAssocSemiring R] [FunLike F ℕ R] [RingHomClass F ℕ R] (f g : F)
Goal: f = g
-- NeZero.nat_of_neZero
theorem NeZero.nat_of_neZero {R S} [Semiring R] [Semiring S]
    {F} [FunLike F R S] [RingHomClass F R S] (f : F)
    {n : ℕ} [hn : NeZero (n : S)] : NeZero (n : R) 
Arguments: {R : Type u_6} {S : Type u_7} [Semiring R] [Semiring S] {F : Type u_8} [FunLike F R S] [RingHomClass F R S] (f : F) {n : ℕ} [hn : NeZero ↑n]
Goal: NeZero ↑n
-- RingHom.eq_natCast'
theorem eq_natCast' {R} [NonAssocSemiring R] (f : ℕ →+* R) : f = Nat.castRingHom R 
Arguments: {R : Type u_3} [NonAssocSemiring R] (f : ℕ →+* R)
Goal: f = Nat.castRingHom R
-- Nat.cast_id
@[simp, norm_cast]
theorem Nat.cast_id (n : ℕ) : n.cast = n 
Arguments: (n : ℕ)
Goal: ↑n = n
-- Nat.castRingHom_nat
@[simp]
theorem Nat.castRingHom_nat : Nat.castRingHom ℕ = RingHom.id ℕ 
Goal: Nat.castRingHom ℕ = RingHom.id ℕ
-- multiplesHom_apply
lemma multiplesHom_apply (x : β) (n : ℕ) : multiplesHom β x n = n • x 
Arguments: (β : Type u_2) [AddMonoid β] (x : β) (n : ℕ)
Goal: ((multiplesHom β) x) n = n • x
-- powersHom_apply
@[to_additive existing (attr := simp)]
lemma powersHom_apply (x : α) (n : Multiplicative ℕ) :
    powersHom α x n = x ^ Multiplicative.toAdd n 
Arguments: {α : Type u_1} [Monoid α] (x : α) (n : Multiplicative ℕ)
Goal: ((powersHom α) x) n = x ^ Multiplicative.toAdd n
-- multiplesHom_symm_apply
lemma multiplesHom_symm_apply (f : ℕ →+ β) : (multiplesHom β).symm f = f 1 
Arguments: (β : Type u_2) [AddMonoid β] (f : ℕ →+ β)
Goal: (multiplesHom β).symm f = f 1
-- powersHom_symm_apply
@[to_additive existing (attr := simp)]
lemma powersHom_symm_apply (f : Multiplicative ℕ →* α) :
    (powersHom α).symm f = f (Multiplicative.ofAdd 1) 
Arguments: {α : Type u_1} [Monoid α] (f : Multiplicative ℕ →* α)
Goal: (powersHom α).symm f = f (Multiplicative.ofAdd 1)
-- MonoidHom.apply_mnat
lemma MonoidHom.apply_mnat (f : Multiplicative ℕ →* α) (n : Multiplicative ℕ) :
    f n = f (Multiplicative.ofAdd 1) ^ (Multiplicative.toAdd n) 
Arguments: {α : Type u_1} [Monoid α] (f : Multiplicative ℕ →* α) (n : Multiplicative ℕ)
Goal: f n = f (Multiplicative.ofAdd 1) ^ Multiplicative.toAdd n
-- MonoidHom.ext_mnat
@[ext]
lemma MonoidHom.ext_mnat ⦃f g : Multiplicative ℕ →* α⦄
    (h : f (Multiplicative.ofAdd 1) = g (Multiplicative.ofAdd 1)) : f = g 
Arguments: {α : Type u_1} [Monoid α] ⦃f g : Multiplicative ℕ →* α⦄ (h : f (Multiplicative.ofAdd 1) = g (Multiplicative.ofAdd 1))
Goal: f = g
-- AddMonoidHom.apply_nat
lemma AddMonoidHom.apply_nat (f : ℕ →+ β) (n : ℕ) : f n = n • f 1 
Arguments: (β : Type u_2) [AddMonoid β] (f : ℕ →+ β) (n : ℕ)
Goal: f n = n • f 1
-- multiplesAddHom_apply
@[simp] lemma multiplesAddHom_apply (x : β) (n : ℕ) : multiplesAddHom β x n = n • x 
Arguments: (β : Type u_2) [AddCommMonoid β] (x : β) (n : ℕ)
Goal: ((multiplesAddHom β) x) n = n • x
-- powersMulHom_apply
@[simp]
lemma powersMulHom_apply (x : α) (n : Multiplicative ℕ) : powersMulHom α x n = x ^ toAdd n 
Arguments: (α : Type u_1) [CommMonoid α] (x : α) (n : Multiplicative ℕ)
Goal: ((powersMulHom α) x) n = x ^ Multiplicative.toAdd n
-- multiplesAddHom_symm_apply
@[simp] lemma multiplesAddHom_symm_apply (f : ℕ →+ β) : (multiplesAddHom β).symm f = f 1 
Arguments: (β : Type u_2) [AddCommMonoid β] (f : ℕ →+ β)
Goal: (multiplesAddHom β).symm f = f 1
-- powersMulHom_symm_apply
@[simp] lemma powersMulHom_symm_apply (f : Multiplicative ℕ →* α) :
    (powersMulHom α).symm f = f (ofAdd 1) 
Arguments: (α : Type u_1) [CommMonoid α] (f : Multiplicative ℕ →* α)
Goal: (powersMulHom α).symm f = f (Multiplicative.ofAdd 1)
-- Pi.natCast_apply
theorem natCast_apply (n : ℕ) (a : α) : (n : ∀ a, π a) a = n 
Arguments: {α : Type u_1} {π : α → Type u_3} [(a : α) → NatCast (π a)] (n : ℕ) (a : α)
Goal: ↑n a = ↑n
-- Pi.natCast_def
@[simp]
theorem natCast_def (n : ℕ) : (n : ∀ a, π a) = fun _ ↦ ↑n 
Arguments: {α : Type u_1} {π : α → Type u_3} [(a : α) → NatCast (π a)] (n : ℕ)
Goal: ↑n = fun x => ↑n
-- Pi.ofNat_apply
@[simp]
theorem ofNat_apply (n : ℕ) [n.AtLeastTwo] (a : α) : (OfNat.ofNat n : ∀ a, π a) a = n 
Arguments: {α : Type u_1} {π : α → Type u_3} [(a : α) → NatCast (π a)] (n : ℕ) [n.AtLeastTwo] (a : α)
Goal: OfNat.ofNat n a = ↑n
-- Sum.elim_natCast_natCast
theorem Sum.elim_natCast_natCast {α β γ : Type*} [NatCast γ] (n : ℕ) :
    Sum.elim (n : α → γ) (n : β → γ) = n 
Arguments: {α : Type u_3} {β : Type u_4} {γ : Type u_5} [NatCast γ] (n : ℕ)
Goal: Sum.elim ↑n ↑n = ↑n
-- Nat.log_eq_zero_iff
@[simp]
theorem log_eq_zero_iff {b n : ℕ} : log b n = 0 ↔ n < b ∨ b ≤ 1 
Arguments: {b n : ℕ}
Goal: Nat.log b n = 0 ↔ n < b ∨ b ≤ 1
-- Nat.log_of_lt
theorem log_of_lt {b n : ℕ} (hb : n < b) : log b n = 0 
Arguments: {b n : ℕ} (hb : n < b)
Goal: Nat.log b n = 0
-- Nat.log_of_left_le_one
theorem log_of_left_le_one {b : ℕ} (hb : b ≤ 1) (n) : log b n = 0 
Arguments: {b : ℕ} (hb : b ≤ 1) (n : ℕ)
Goal: Nat.log b n = 0
-- Nat.log_pos_iff
@[simp]
theorem log_pos_iff {b n : ℕ} : 0 < log b n ↔ b ≤ n ∧ 1 < b 
Arguments: {b n : ℕ}
Goal: 0 < Nat.log b n ↔ b ≤ n ∧ 1 < b
-- Nat.log_pos
theorem log_pos {b n : ℕ} (hb : 1 < b) (hbn : b ≤ n) : 0 < log b n 
Arguments: {b n : ℕ} (hb : 1 < b) (hbn : b ≤ n)
Goal: 0 < Nat.log b n
-- Nat.log_of_one_lt_of_le
theorem log_of_one_lt_of_le {b n : ℕ} (h : 1 < b) (hn : b ≤ n) : log b n = log b (n / b) + 1 
Arguments: {b n : ℕ} (h : 1 < b) (hn : b ≤ n)
Goal: Nat.log b n = Nat.log b (n / b) + 1
-- Nat.log_zero_left
@[simp] lemma log_zero_left : ∀ n, log 0 n = 0 
Arguments: (n : ℕ)
Goal: Nat.log 0 n = 0
-- Nat.log_zero_right
@[simp]
theorem log_zero_right (b : ℕ) : log b 0 = 0 
Arguments: (b : ℕ)
Goal: Nat.log b 0 = 0
-- Nat.log_one_left
@[simp]
theorem log_one_left : ∀ n, log 1 n = 0 
Arguments: (n : ℕ)
Goal: Nat.log 1 n = 0
-- Nat.log_one_right
@[simp]
theorem log_one_right (b : ℕ) : log b 1 = 0 
Arguments: (b : ℕ)
Goal: Nat.log b 1 = 0
-- Nat.pow_le_iff_le_log
theorem pow_le_iff_le_log {b : ℕ} (hb : 1 < b) {x y : ℕ} (hy : y ≠ 0) :
    b ^ x ≤ y ↔ x ≤ log b y 
Arguments: {b : ℕ} (hb : 1 < b) {x y : ℕ} (hy : y ≠ 0)
Goal: b ^ x ≤ y ↔ x ≤ Nat.log b y
-- Nat.lt_pow_iff_log_lt
theorem lt_pow_iff_log_lt {b : ℕ} (hb : 1 < b) {x y : ℕ} (hy : y ≠ 0) : y < b ^ x ↔ log b y < x 
Arguments: {b : ℕ} (hb : 1 < b) {x y : ℕ} (hy : y ≠ 0)
Goal: y < b ^ x ↔ Nat.log b y < x
-- Nat.pow_le_of_le_log
theorem pow_le_of_le_log {b x y : ℕ} (hy : y ≠ 0) (h : x ≤ log b y) : b ^ x ≤ y 
Arguments: {b x y : ℕ} (hy : y ≠ 0) (h : x ≤ Nat.log b y)
Goal: b ^ x ≤ y
-- Nat.le_log_of_pow_le
theorem le_log_of_pow_le {b x y : ℕ} (hb : 1 < b) (h : b ^ x ≤ y) : x ≤ log b y 
Arguments: {b x y : ℕ} (hb : 1 < b) (h : b ^ x ≤ y)
Goal: x ≤ Nat.log b y
-- Nat.pow_log_le_self
theorem pow_log_le_self (b : ℕ) {x : ℕ} (hx : x ≠ 0) : b ^ log b x ≤ x 
Arguments: (b : ℕ) {x : ℕ} (hx : x ≠ 0)
Goal: b ^ Nat.log b x ≤ x
-- Nat.log_lt_of_lt_pow
theorem log_lt_of_lt_pow {b x y : ℕ} (hy : y ≠ 0) : y < b ^ x → log b y < x 
Arguments: {b x y : ℕ} (hy : y ≠ 0)
Goal: y < b ^ x → Nat.log b y < x
-- Nat.lt_pow_of_log_lt
theorem lt_pow_of_log_lt {b x y : ℕ} (hb : 1 < b) : log b y < x → y < b ^ x 
Arguments: {b x y : ℕ} (hb : 1 < b)
Goal: Nat.log b y < x → y < b ^ x
-- Nat.lt_pow_succ_log_self
theorem lt_pow_succ_log_self {b : ℕ} (hb : 1 < b) (x : ℕ) : x < b ^ (log b x).succ 
Arguments: {b : ℕ} (hb : 1 < b) (x : ℕ)
Goal: x < b ^ (Nat.log b x).succ
-- Nat.log_eq_iff
theorem log_eq_iff {b m n : ℕ} (h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0) :
    log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1) 
Arguments: {b m n : ℕ} (h : m ≠ 0 ∨ 1 < b ∧ n ≠ 0)
Goal: Nat.log b n = m ↔ b ^ m ≤ n ∧ n < b ^ (m + 1)
-- Nat.log_eq_of_pow_le_of_lt_pow
theorem log_eq_of_pow_le_of_lt_pow {b m n : ℕ} (h₁ : b ^ m ≤ n) (h₂ : n < b ^ (m + 1)) :
    log b n = m 
Arguments: {b m n : ℕ} (h₁ : b ^ m ≤ n) (h₂ : n < b ^ (m + 1))
Goal: Nat.log b n = m
-- Nat.log_pow
theorem log_pow {b : ℕ} (hb : 1 < b) (x : ℕ) : log b (b ^ x) = x 
Arguments: {b : ℕ} (hb : 1 < b) (x : ℕ)
Goal: Nat.log b (b ^ x) = x
-- Nat.log_eq_one_iff'
theorem log_eq_one_iff' {b n : ℕ} : log b n = 1 ↔ b ≤ n ∧ n < b * b 
Arguments: {b n : ℕ}
Goal: Nat.log b n = 1 ↔ b ≤ n ∧ n < b * b
-- Nat.log_eq_one_iff
theorem log_eq_one_iff {b n : ℕ} : log b n = 1 ↔ n < b * b ∧ 1 < b ∧ b ≤ n 
Arguments: {b n : ℕ}
Goal: Nat.log b n = 1 ↔ n < b * b ∧ 1 < b ∧ b ≤ n
-- Nat.log_mul_base
theorem log_mul_base {b n : ℕ} (hb : 1 < b) (hn : n ≠ 0) : log b (n * b) = log b n + 1 
Arguments: {b n : ℕ} (hb : 1 < b) (hn : n ≠ 0)
Goal: Nat.log b (n * b) = Nat.log b n + 1
-- Nat.pow_log_le_add_one
theorem pow_log_le_add_one (b : ℕ) : ∀ x, b ^ log b x ≤ x + 1
  
Arguments: (b x : ℕ)
Goal: b ^ Nat.log b x ≤ x + 1
-- Nat.log_monotone
theorem log_monotone {b : ℕ} : Monotone (log b) 
Arguments: {b : ℕ}
Goal: Monotone (Nat.log b)
-- Nat.log_mono_right
@[mono]
theorem log_mono_right {b n m : ℕ} (h : n ≤ m) : log b n ≤ log b m 
Arguments: {b n m : ℕ} (h : n ≤ m)
Goal: Nat.log b n ≤ Nat.log b m
-- Nat.log_anti_left
@[mono]
theorem log_anti_left {b c n : ℕ} (hc : 1 < c) (hb : c ≤ b) : log b n ≤ log c n 
Arguments: {b c n : ℕ} (hc : 1 < c) (hb : c ≤ b)
Goal: Nat.log b n ≤ Nat.log c n
-- Nat.log_antitone_left
theorem log_antitone_left {n : ℕ} : AntitoneOn (fun b => log b n) (Set.Ioi 1) 
Arguments: {n : ℕ}
Goal: AntitoneOn (fun b => Nat.log b n) (Set.Ioi 1)
-- Nat.log_div_base
@[simp]
theorem log_div_base (b n : ℕ) : log b (n / b) = log b n - 1 
Arguments: (b n : ℕ)
Goal: Nat.log b (n / b) = Nat.log b n - 1
-- Nat.log_div_mul_self
@[simp]
theorem log_div_mul_self (b n : ℕ) : log b (n / b * b) = log b n 
Arguments: (b n : ℕ)
Goal: Nat.log b (n / b * b) = Nat.log b n
-- Nat.add_pred_div_lt
theorem add_pred_div_lt {b n : ℕ} (hb : 1 < b) (hn : 2 ≤ n) : (n + b - 1) / b < n 
Arguments: {b n : ℕ} (hb : 1 < b) (hn : 2 ≤ n)
Goal: (n + b - 1) / b < n
-- Nat.clog_of_left_le_one
theorem clog_of_left_le_one {b : ℕ} (hb : b ≤ 1) (n : ℕ) : clog b n = 0 
Arguments: {b : ℕ} (hb : b ≤ 1) (n : ℕ)
Goal: Nat.clog b n = 0
-- Nat.clog_of_right_le_one
theorem clog_of_right_le_one {n : ℕ} (hn : n ≤ 1) (b : ℕ) : clog b n = 0 
Arguments: {n : ℕ} (hn : n ≤ 1) (b : ℕ)
Goal: Nat.clog b n = 0
-- Nat.clog_zero_left
@[simp] lemma clog_zero_left (n : ℕ) : clog 0 n = 0 
Arguments: (n : ℕ)
Goal: Nat.clog 0 n = 0
-- Nat.clog_zero_right
@[simp] lemma clog_zero_right (b : ℕ) : clog b 0 = 0 
Arguments: (b : ℕ)
Goal: Nat.clog b 0 = 0
-- Nat.clog_one_left
@[simp]
theorem clog_one_left (n : ℕ) : clog 1 n = 0 
Arguments: (n : ℕ)
Goal: Nat.clog 1 n = 0
-- Nat.clog_one_right
@[simp]
theorem clog_one_right (b : ℕ) : clog b 1 = 0 
Arguments: (b : ℕ)
Goal: Nat.clog b 1 = 0
-- Nat.clog_of_two_le
theorem clog_of_two_le {b n : ℕ} (hb : 1 < b) (hn : 2 ≤ n) :
    clog b n = clog b ((n + b - 1) / b) + 1 
Arguments: {b n : ℕ} (hb : 1 < b) (hn : 2 ≤ n)
Goal: Nat.clog b n = Nat.clog b ((n + b - 1) / b) + 1
-- Nat.clog_pos
theorem clog_pos {b n : ℕ} (hb : 1 < b) (hn : 2 ≤ n) : 0 < clog b n 
Arguments: {b n : ℕ} (hb : 1 < b) (hn : 2 ≤ n)
Goal: 0 < Nat.clog b n
-- Nat.clog_eq_one
theorem clog_eq_one {b n : ℕ} (hn : 2 ≤ n) (h : n ≤ b) : clog b n = 1 
Arguments: {b n : ℕ} (hn : 2 ≤ n) (h : n ≤ b)
Goal: Nat.clog b n = 1
-- Nat.le_pow_iff_clog_le
theorem le_pow_iff_clog_le {b : ℕ} (hb : 1 < b) {x y : ℕ} : x ≤ b ^ y ↔ clog b x ≤ y 
Arguments: {b : ℕ} (hb : 1 < b) {x y : ℕ}
Goal: x ≤ b ^ y ↔ Nat.clog b x ≤ y
-- Nat.pow_lt_iff_lt_clog
theorem pow_lt_iff_lt_clog {b : ℕ} (hb : 1 < b) {x y : ℕ} : b ^ y < x ↔ y < clog b x 
Arguments: {b : ℕ} (hb : 1 < b) {x y : ℕ}
Goal: b ^ y < x ↔ y < Nat.clog b x
-- Nat.clog_pow
theorem clog_pow (b x : ℕ) (hb : 1 < b) : clog b (b ^ x) = x 
Arguments: (b x : ℕ) (hb : 1 < b)
Goal: Nat.clog b (b ^ x) = x
-- Nat.pow_pred_clog_lt_self
theorem pow_pred_clog_lt_self {b : ℕ} (hb : 1 < b) {x : ℕ} (hx : 1 < x) :
    b ^ (clog b x).pred < x 
Arguments: {b : ℕ} (hb : 1 < b) {x : ℕ} (hx : 1 < x)
Goal: b ^ (Nat.clog b x).pred < x
-- Nat.le_pow_clog
theorem le_pow_clog {b : ℕ} (hb : 1 < b) (x : ℕ) : x ≤ b ^ clog b x 
Arguments: {b : ℕ} (hb : 1 < b) (x : ℕ)
Goal: x ≤ b ^ Nat.clog b x
-- Nat.clog_mono_right
@[mono]
theorem clog_mono_right (b : ℕ) {n m : ℕ} (h : n ≤ m) : clog b n ≤ clog b m 
Arguments: (b : ℕ) {n m : ℕ} (h : n ≤ m)
Goal: Nat.clog b n ≤ Nat.clog b m
-- Nat.clog_anti_left
@[mono]
theorem clog_anti_left {b c n : ℕ} (hc : 1 < c) (hb : c ≤ b) : clog b n ≤ clog c n 
Arguments: {b c n : ℕ} (hc : 1 < c) (hb : c ≤ b)
Goal: Nat.clog b n ≤ Nat.clog c n
-- Nat.clog_monotone
theorem clog_monotone (b : ℕ) : Monotone (clog b) 
Arguments: (b : ℕ)
Goal: Monotone (Nat.clog b)
-- Nat.clog_antitone_left
theorem clog_antitone_left {n : ℕ} : AntitoneOn (fun b : ℕ => clog b n) (Set.Ioi 1) 
Arguments: {n : ℕ}
Goal: AntitoneOn (fun b => Nat.clog b n) (Set.Ioi 1)
-- Nat.log_le_clog
theorem log_le_clog (b n : ℕ) : log b n ≤ clog b n 
Arguments: (b n : ℕ)
Goal: Nat.log b n ≤ Nat.clog b n
-- Nat.range_cast_int
@[simp]
theorem range_cast_int : range ((↑) : ℕ → ℤ) = Ici 0 
Goal: Set.range Nat.cast = Set.Ici 0
-- Nat.image_cast_int_Icc
theorem image_cast_int_Icc (a b : ℕ) : (↑) '' Icc a b = Icc (a : ℤ) b 
Arguments: (a b : ℕ)
Goal: Nat.cast '' Set.Icc a b = Set.Icc ↑a ↑b
-- Nat.image_cast_int_Ico
theorem image_cast_int_Ico (a b : ℕ) : (↑) '' Ico a b = Ico (a : ℤ) b 
Arguments: (a b : ℕ)
Goal: Nat.cast '' Set.Ico a b = Set.Ico ↑a ↑b
-- Nat.image_cast_int_Ioc
theorem image_cast_int_Ioc (a b : ℕ) : (↑) '' Ioc a b = Ioc (a : ℤ) b 
Arguments: (a b : ℕ)
Goal: Nat.cast '' Set.Ioc a b = Set.Ioc ↑a ↑b
-- Nat.image_cast_int_Ioo
theorem image_cast_int_Ioo (a b : ℕ) : (↑) '' Ioo a b = Ioo (a : ℤ) b 
Arguments: (a b : ℕ)
Goal: Nat.cast '' Set.Ioo a b = Set.Ioo ↑a ↑b
-- Nat.image_cast_int_Iic
theorem image_cast_int_Iic (a : ℕ) : (↑) '' Iic a = Icc (0 : ℤ) a 
Arguments: (a : ℕ)
Goal: Nat.cast '' Set.Iic a = Set.Icc 0 ↑a
-- Nat.image_cast_int_Iio
theorem image_cast_int_Iio (a : ℕ) : (↑) '' Iio a = Ico (0 : ℤ) a 
Arguments: (a : ℕ)
Goal: Nat.cast '' Set.Iio a = Set.Ico 0 ↑a
-- Nat.image_cast_int_Ici
theorem image_cast_int_Ici (a : ℕ) : (↑) '' Ici a = Ici (a : ℤ) 
Arguments: (a : ℕ)
Goal: Nat.cast '' Set.Ici a = Set.Ici ↑a
-- Nat.image_cast_int_Ioi
theorem image_cast_int_Ioi (a : ℕ) : (↑) '' Ioi a = Ioi (a : ℤ) 
Arguments: (a : ℕ)
Goal: Nat.cast '' Set.Ioi a = Set.Ioi ↑a
-- NeZero.one_le
theorem one_le {n : ℕ} [NeZero n] : 1 ≤ n 
Arguments: {n : ℕ} [NeZero n]
Goal: 1 ≤ n
-- NeZero.natCast_ne
lemma natCast_ne (n : ℕ) (R) [AddMonoidWithOne R] [h : NeZero (n : R)] : (n : R) ≠ 0 
Arguments: (n : ℕ) (R : Type u_1) [AddMonoidWithOne R] [h : NeZero ↑n]
Goal: ↑n ≠ 0
-- NeZero.of_neZero_natCast
lemma of_neZero_natCast (R) [AddMonoidWithOne R] {n : ℕ} [h : NeZero (n : R)] : NeZero n 
Arguments: (R : Type u_1) [AddMonoidWithOne R] {n : ℕ} [h : NeZero ↑n]
Goal: NeZero n
-- NeZero.pos_of_neZero_natCast
lemma pos_of_neZero_natCast (R) [AddMonoidWithOne R] {n : ℕ} [NeZero (n : R)] : 0 < n 
Arguments: (R : Type u_1) [AddMonoidWithOne R] {n : ℕ} [NeZero ↑n]
Goal: 0 < n
-- PNat.XgcdType.v_eq_succ_vp
theorem v_eq_succ_vp : u.v = succ₂ u.vp 
Arguments: (u : PNat.XgcdType)
Goal: u.v = PNat.XgcdType.succ₂ u.vp
-- PNat.XgcdType.isSpecial_iff
theorem isSpecial_iff : u.IsSpecial ↔ u.IsSpecial' 
Arguments: (u : PNat.XgcdType)
Goal: u.IsSpecial ↔ u.IsSpecial'
-- PNat.XgcdType.isReduced_iff
theorem isReduced_iff : u.IsReduced ↔ u.IsReduced' 
Arguments: (u : PNat.XgcdType)
Goal: u.IsReduced ↔ u.IsReduced'
-- PNat.XgcdType.flip_w
@[simp]
theorem flip_w : (flip u).w = u.z 
Arguments: (u : PNat.XgcdType)
Goal: u.flip.w = u.z
-- PNat.XgcdType.flip_x
@[simp]
theorem flip_x : (flip u).x = u.y 
Arguments: (u : PNat.XgcdType)
Goal: u.flip.x = u.y
-- PNat.XgcdType.flip_y
@[simp]
theorem flip_y : (flip u).y = u.x 
Arguments: (u : PNat.XgcdType)
Goal: u.flip.y = u.x
-- PNat.XgcdType.flip_z
@[simp]
theorem flip_z : (flip u).z = u.w 
Arguments: (u : PNat.XgcdType)
Goal: u.flip.z = u.w
-- PNat.XgcdType.flip_a
@[simp]
theorem flip_a : (flip u).a = u.b 
Arguments: (u : PNat.XgcdType)
Goal: u.flip.a = u.b
-- PNat.XgcdType.flip_b
@[simp]
theorem flip_b : (flip u).b = u.a 
Arguments: (u : PNat.XgcdType)
Goal: u.flip.b = u.a
-- PNat.XgcdType.flip_isReduced
theorem flip_isReduced : (flip u).IsReduced ↔ u.IsReduced 
Arguments: (u : PNat.XgcdType)
Goal: u.flip.IsReduced ↔ u.IsReduced
-- PNat.XgcdType.flip_isSpecial
theorem flip_isSpecial : (flip u).IsSpecial ↔ u.IsSpecial 
Arguments: (u : PNat.XgcdType)
Goal: u.flip.IsSpecial ↔ u.IsSpecial
-- PNat.XgcdType.flip_v
theorem flip_v : (flip u).v = u.v.swap 
Arguments: (u : PNat.XgcdType)
Goal: u.flip.v = u.v.swap
-- PNat.XgcdType.rq_eq
theorem rq_eq : u.r + (u.bp + 1) * u.q = u.ap + 1 
Arguments: (u : PNat.XgcdType)
Goal: u.r + (u.bp + 1) * u.q = u.ap + 1
-- PNat.XgcdType.qp_eq
theorem qp_eq (hr : u.r = 0) : u.q = u.qp + 1 
Arguments: (u : PNat.XgcdType) (hr : u.r = 0)
Goal: u.q = u.qp + 1
-- PNat.XgcdType.start_isSpecial
theorem start_isSpecial (a b : ℕ+) : (start a b).IsSpecial 
Arguments: (a b : ℕ+)
Goal: (PNat.XgcdType.start a b).IsSpecial
-- PNat.XgcdType.start_v
theorem start_v (a b : ℕ+) : (start a b).v = ⟨a, b⟩ 
Arguments: (a b : ℕ+)
Goal: (PNat.XgcdType.start a b).v = (↑a, ↑b)
-- PNat.XgcdType.finish_isReduced
theorem finish_isReduced : u.finish.IsReduced 
Arguments: (u : PNat.XgcdType)
Goal: u.finish.IsReduced
-- PNat.XgcdType.finish_isSpecial
theorem finish_isSpecial (hs : u.IsSpecial) : u.finish.IsSpecial 
Arguments: (u : PNat.XgcdType) (hs : u.IsSpecial)
Goal: u.finish.IsSpecial
-- PNat.XgcdType.finish_v
theorem finish_v (hr : u.r = 0) : u.finish.v = u.v 
Arguments: (u : PNat.XgcdType) (hr : u.r = 0)
Goal: u.finish.v = u.v
-- PNat.XgcdType.step_wf
theorem step_wf (hr : u.r ≠ 0) : SizeOf.sizeOf u.step < SizeOf.sizeOf u 
Arguments: (u : PNat.XgcdType) (hr : u.r ≠ 0)
Goal: sizeOf u.step < sizeOf u
-- PNat.XgcdType.step_isSpecial
theorem step_isSpecial (hs : u.IsSpecial) : u.step.IsSpecial 
Arguments: (u : PNat.XgcdType) (hs : u.IsSpecial)
Goal: u.step.IsSpecial
-- PNat.XgcdType.step_v
theorem step_v (hr : u.r ≠ 0) : u.step.v = u.v.swap 
Arguments: (u : PNat.XgcdType) (hr : u.r ≠ 0)
Goal: u.step.v = u.v.swap
-- PNat.XgcdType.reduce_a
theorem reduce_a {u : XgcdType} (h : u.r = 0) : u.reduce = u.finish 
Arguments: {u : PNat.XgcdType} (h : u.r = 0)
Goal: u.reduce = u.finish
-- PNat.XgcdType.reduce_b
theorem reduce_b {u : XgcdType} (h : u.r ≠ 0) : u.reduce = u.step.reduce.flip 
Arguments: {u : PNat.XgcdType} (h : u.r ≠ 0)
Goal: u.reduce = u.step.reduce.flip
-- PNat.XgcdType.reduce_isReduced
theorem reduce_isReduced : ∀ u : XgcdType, u.reduce.IsReduced
  
Arguments: (u : PNat.XgcdType)
Goal: u.reduce.IsReduced
-- PNat.XgcdType.reduce_isReduced'
theorem reduce_isReduced' (u : XgcdType) : u.reduce.IsReduced' 
Arguments: (u : PNat.XgcdType)
Goal: u.reduce.IsReduced'
-- PNat.XgcdType.reduce_isSpecial
theorem reduce_isSpecial : ∀ u : XgcdType, u.IsSpecial → u.reduce.IsSpecial
  
Arguments: (u : PNat.XgcdType)
Goal: u.IsSpecial → u.reduce.IsSpecial
-- PNat.XgcdType.reduce_isSpecial'
theorem reduce_isSpecial' (u : XgcdType) (hs : u.IsSpecial) : u.reduce.IsSpecial' 
Arguments: (u : PNat.XgcdType) (hs : u.IsSpecial)
Goal: u.reduce.IsSpecial'
-- PNat.XgcdType.reduce_v
theorem reduce_v : ∀ u : XgcdType, u.reduce.v = u.v
  
Arguments: (u : PNat.XgcdType)
Goal: u.reduce.v = u.v
-- PNat.gcdA'_coe
theorem gcdA'_coe : (gcdA' a b : ℕ) = gcdW a b + gcdX a b 
Arguments: (a b : ℕ+)
Goal: ↑(a.gcdA' b) = ↑(a.gcdW b) + a.gcdX b
-- PNat.gcdB'_coe
theorem gcdB'_coe : (gcdB' a b : ℕ) = gcdY a b + gcdZ a b 
Arguments: (a b : ℕ+)
Goal: ↑(a.gcdB' b) = a.gcdY b + ↑(a.gcdZ b)