ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- MonoidHom.apply_mint
lemma MonoidHom.apply_mint (f : Multiplicative ℤ →* α) (n : Multiplicative ℤ) :
    f n = f (ofAdd 1) ^ (toAdd n) 
Arguments: (α : Type u_3) [Group α] (f : Multiplicative ℤ →* α) (n : Multiplicative ℤ)
Goal: f n = f (Multiplicative.ofAdd 1) ^ Multiplicative.toAdd n
-- AddMonoidHom.apply_int
lemma AddMonoidHom.apply_int (f : ℤ →+ β) (n : ℤ) : f n = n • f 1 
Arguments: (β : Type u_4) [AddGroup β] (f : ℤ →+ β) (n : ℤ)
Goal: f n = n • f 1
-- zpowersMulHom_apply
@[simp]
lemma zpowersMulHom_apply (x : α) (n : Multiplicative ℤ) : zpowersMulHom α x n = x ^ toAdd n 
Arguments: {α : Type u_3} [CommGroup α] (x : α) (n : Multiplicative ℤ)
Goal: ((zpowersMulHom α) x) n = x ^ Multiplicative.toAdd n
-- zpowersMulHom_symm_apply
@[simp]
lemma zpowersMulHom_symm_apply (f : Multiplicative ℤ →* α) :
    (zpowersMulHom α).symm f = f (ofAdd 1) 
Arguments: {α : Type u_3} [CommGroup α] (f : Multiplicative ℤ →* α)
Goal: (zpowersMulHom α).symm f = f (Multiplicative.ofAdd 1)
-- zmultiplesAddHom_apply
@[simp] lemma zmultiplesAddHom_apply (x : β) (n : ℤ) : zmultiplesAddHom β x n = n • x 
Arguments: (β : Type u_4) [AddCommGroup β] (x : β) (n : ℤ)
Goal: ((zmultiplesAddHom β) x) n = n • x
-- zmultiplesAddHom_symm_apply
@[simp] lemma zmultiplesAddHom_symm_apply (f : ℤ →+ β) : (zmultiplesAddHom β).symm f = f 1 
Arguments: (β : Type u_4) [AddCommGroup β] (f : ℤ →+ β)
Goal: (zmultiplesAddHom β).symm f = f 1
-- eq_intCast
@[simp]
theorem eq_intCast [FunLike F ℤ α] [RingHomClass F ℤ α] (f : F) (n : ℤ) : f n = n 
Arguments: {F : Type u_1} {α : Type u_3} [NonAssocRing α] [FunLike F ℤ α] [RingHomClass F ℤ α] (f : F) (n : ℤ)
Goal: f n = ↑n
-- map_intCast
@[simp]
theorem map_intCast [FunLike F α β] [RingHomClass F α β] (f : F) (n : ℤ) : f n = n 
Arguments: {F : Type u_1} {α : Type u_3} {β : Type u_4} [NonAssocRing α] [NonAssocRing β] [FunLike F α β] [RingHomClass F α β] (f : F) (n : ℤ)
Goal: f ↑n = ↑n
-- RingHom.eq_intCast'
theorem eq_intCast' (f : ℤ →+* α) : f = Int.castRingHom α 
Arguments: {α : Type u_3} [NonAssocRing α] (f : ℤ →+* α)
Goal: f = Int.castRingHom α
-- RingHom.ext_int
theorem ext_int {R : Type*} [NonAssocSemiring R] (f g : ℤ →+* R) : f = g 
Arguments: {R : Type u_5} [NonAssocSemiring R] (f g : ℤ →+* R)
Goal: f = g
-- Int.castRingHom_int
@[simp]
theorem Int.castRingHom_int : Int.castRingHom ℤ = RingHom.id ℤ 
Goal: Int.castRingHom ℤ = RingHom.id ℤ
-- Pi.intCast_apply
theorem intCast_apply (n : ℤ) (i : ι) : (n : ∀ i, π i) i = n 
Arguments: {ι : Type u_2} {π : ι → Type u_5} [(i : ι) → IntCast (π i)] (n : ℤ) (i : ι)
Goal: ↑n i = ↑n
-- Pi.intCast_def
@[simp]
theorem intCast_def (n : ℤ) : (n : ∀ i, π i) = fun _ => ↑n 
Arguments: {ι : Type u_2} {π : ι → Type u_5} [(i : ι) → IntCast (π i)] (n : ℤ)
Goal: ↑n = fun x => ↑n
-- Sum.elim_intCast_intCast
theorem Sum.elim_intCast_intCast {α β γ : Type*} [IntCast γ] (n : ℤ) :
    Sum.elim (n : α → γ) (n : β → γ) = n 
Arguments: {α : Type u_5} {β : Type u_6} {γ : Type u_7} [IntCast γ] (n : ℤ)
Goal: Sum.elim ↑n ↑n = ↑n
-- Nat.xgcd_zero_left
@[simp]
theorem xgcd_zero_left {s t r' s' t'} : xgcdAux 0 s t r' s' t' = (r', s', t') 
Arguments: {s t : ℤ} {r' : ℕ} {s' t' : ℤ}
Goal: Nat.xgcdAux 0 s t r' s' t' = (r', s', t')
-- Nat.xgcdAux_rec
theorem xgcdAux_rec {r s t r' s' t'} (h : 0 < r) :
    xgcdAux r s t r' s' t' = xgcdAux (r' % r) (s' - r' / r * s) (t' - r' / r * t) r s t 
Arguments: {r : ℕ} {s t : ℤ} {r' : ℕ} {s' t' : ℤ} (h : 0 < r)
Goal: r.xgcdAux s t r' s' t' = (r' % r).xgcdAux (s' - ↑r' / ↑r * s) (t' - ↑r' / ↑r * t) r s t
-- Nat.gcdA_zero_left
@[simp]
theorem gcdA_zero_left {s : ℕ} : gcdA 0 s = 0 
Arguments: {s : ℕ}
Goal: Nat.gcdA 0 s = 0
-- Nat.gcdB_zero_left
@[simp]
theorem gcdB_zero_left {s : ℕ} : gcdB 0 s = 1 
Arguments: {s : ℕ}
Goal: Nat.gcdB 0 s = 1
-- Nat.gcdA_zero_right
@[simp]
theorem gcdA_zero_right {s : ℕ} (h : s ≠ 0) : gcdA s 0 = 1 
Arguments: {s : ℕ} (h : s ≠ 0)
Goal: s.gcdA 0 = 1
-- Nat.gcdB_zero_right
@[simp]
theorem gcdB_zero_right {s : ℕ} (h : s ≠ 0) : gcdB s 0 = 0 
Arguments: {s : ℕ} (h : s ≠ 0)
Goal: s.gcdB 0 = 0
-- Nat.xgcdAux_fst
@[simp]
theorem xgcdAux_fst (x y) : ∀ s t s' t', (xgcdAux x s t y s' t').1 = gcd x y 
Arguments: (x y : ℕ) (s t s' t' : ℤ)
Goal: (x.xgcdAux s t y s' t').1 = x.gcd y
-- Nat.xgcdAux_val
theorem xgcdAux_val (x y) : xgcdAux x 1 0 y 0 1 = (gcd x y, xgcd x y) 
Arguments: (x y : ℕ)
Goal: x.xgcdAux 1 0 y 0 1 = (x.gcd y, x.xgcd y)
-- Nat.xgcd_val
theorem xgcd_val (x y) : xgcd x y = (gcdA x y, gcdB x y) 
Arguments: (x y : ℕ)
Goal: x.xgcd y = (x.gcdA y, x.gcdB y)
-- Nat.xgcdAux_P
theorem xgcdAux_P {r r'} :
    ∀ {s t s' t'}, P x y (r, s, t) → P x y (r', s', t') → P x y (xgcdAux r s t r' s' t') 
Arguments: (x y : ℕ) {r r' : ℕ} {s t s' t' : ℤ}
Goal: Nat.P x y (r, s, t) → Nat.P x y (r', s', t') → Nat.P x y (r.xgcdAux s t r' s' t')
-- Nat.gcd_eq_gcd_ab
theorem gcd_eq_gcd_ab : (gcd x y : ℤ) = x * gcdA x y + y * gcdB x y 
Arguments: (x y : ℕ)
Goal: ↑(x.gcd y) = ↑x * x.gcdA y + ↑y * x.gcdB y
-- Nat.exists_mul_emod_eq_gcd
theorem exists_mul_emod_eq_gcd {k n : ℕ} (hk : gcd n k < k) : ∃ m, n * m % k = gcd n k 
Arguments: {k n : ℕ} (hk : n.gcd k < k)
Goal: ∃ m, n * m % k = n.gcd k
-- Nat.exists_mul_emod_eq_one_of_coprime
theorem exists_mul_emod_eq_one_of_coprime {k n : ℕ} (hkn : Coprime n k) (hk : 1 < k) :
    ∃ m, n * m % k = 1 
Arguments: {k n : ℕ} (hkn : n.Coprime k) (hk : 1 < k)
Goal: ∃ m, n * m % k = 1
-- Int.gcd_def
theorem gcd_def (i j : ℤ) : gcd i j = Nat.gcd i.natAbs j.natAbs 
Arguments: (i j : ℤ)
Goal: i.gcd j = i.natAbs.gcd j.natAbs
-- Int.gcd_natCast_natCast
@[simp, norm_cast] protected lemma gcd_natCast_natCast (m n : ℕ) : gcd ↑m ↑n = m.gcd n 
Arguments: (m n : ℕ)
Goal: (↑m).gcd ↑n = m.gcd n
-- Int.gcd_eq_gcd_ab
theorem gcd_eq_gcd_ab : ∀ x y : ℤ, (gcd x y : ℤ) = x * gcdA x y + y * gcdB x y
  
Arguments: (x y : ℤ)
Goal: ↑(x.gcd y) = x * x.gcdA y + y * x.gcdB y
-- Int.lcm_def
theorem lcm_def (i j : ℤ) : lcm i j = Nat.lcm (natAbs i) (natAbs j) 
Arguments: (i j : ℤ)
Goal: i.lcm j = i.natAbs.lcm j.natAbs
-- Int.coe_nat_lcm
protected theorem coe_nat_lcm (m n : ℕ) : Int.lcm ↑m ↑n = Nat.lcm m n 
Arguments: (m n : ℕ)
Goal: (↑m).lcm ↑n = m.lcm n
-- Int.dvd_gcd
theorem dvd_gcd {i j k : ℤ} (h1 : k ∣ i) (h2 : k ∣ j) : k ∣ gcd i j 
Arguments: {i j k : ℤ} (h1 : k ∣ i) (h2 : k ∣ j)
Goal: k ∣ ↑(i.gcd j)
-- Int.gcd_mul_lcm
theorem gcd_mul_lcm (i j : ℤ) : gcd i j * lcm i j = natAbs (i * j) 
Arguments: (i j : ℤ)
Goal: i.gcd j * i.lcm j = (i * j).natAbs
-- Int.gcd_comm
theorem gcd_comm (i j : ℤ) : gcd i j = gcd j i 
Arguments: (i j : ℤ)
Goal: i.gcd j = j.gcd i
-- Int.gcd_assoc
theorem gcd_assoc (i j k : ℤ) : gcd (gcd i j) k = gcd i (gcd j k) 
Arguments: (i j k : ℤ)
Goal: (↑(i.gcd j)).gcd k = i.gcd ↑(j.gcd k)
-- Int.gcd_self
@[simp]
theorem gcd_self (i : ℤ) : gcd i i = natAbs i 
Arguments: (i : ℤ)
Goal: i.gcd i = i.natAbs
-- Int.gcd_zero_left
@[simp]
theorem gcd_zero_left (i : ℤ) : gcd 0 i = natAbs i 
Arguments: (i : ℤ)
Goal: Int.gcd 0 i = i.natAbs
-- Int.gcd_zero_right
@[simp]
theorem gcd_zero_right (i : ℤ) : gcd i 0 = natAbs i 
Arguments: (i : ℤ)
Goal: i.gcd 0 = i.natAbs
-- Int.gcd_mul_left
theorem gcd_mul_left (i j k : ℤ) : gcd (i * j) (i * k) = natAbs i * gcd j k 
Arguments: (i j k : ℤ)
Goal: (i * j).gcd (i * k) = i.natAbs * j.gcd k
-- Int.gcd_mul_right
theorem gcd_mul_right (i j k : ℤ) : gcd (i * j) (k * j) = gcd i k * natAbs j 
Arguments: (i j k : ℤ)
Goal: (i * j).gcd (k * j) = i.gcd k * j.natAbs
-- Int.gcd_pos_of_ne_zero_left
theorem gcd_pos_of_ne_zero_left {i : ℤ} (j : ℤ) (hi : i ≠ 0) : 0 < gcd i j 
Arguments: {i : ℤ} (j : ℤ) (hi : i ≠ 0)
Goal: 0 < i.gcd j
-- Int.gcd_pos_of_ne_zero_right
theorem gcd_pos_of_ne_zero_right (i : ℤ) {j : ℤ} (hj : j ≠ 0) : 0 < gcd i j 
Arguments: (i : ℤ) {j : ℤ} (hj : j ≠ 0)
Goal: 0 < i.gcd j
-- Int.gcd_eq_zero_iff
theorem gcd_eq_zero_iff {i j : ℤ} : gcd i j = 0 ↔ i = 0 ∧ j = 0 
Arguments: {i j : ℤ}
Goal: i.gcd j = 0 ↔ i = 0 ∧ j = 0
-- Int.gcd_pos_iff
theorem gcd_pos_iff {i j : ℤ} : 0 < gcd i j ↔ i ≠ 0 ∨ j ≠ 0 
Arguments: {i j : ℤ}
Goal: 0 < i.gcd j ↔ i ≠ 0 ∨ j ≠ 0
-- Int.gcd_div
theorem gcd_div {i j k : ℤ} (H1 : k ∣ i) (H2 : k ∣ j) :
    gcd (i / k) (j / k) = gcd i j / natAbs k 
Arguments: {i j k : ℤ} (H1 : k ∣ i) (H2 : k ∣ j)
Goal: (i / k).gcd (j / k) = i.gcd j / k.natAbs
-- Int.gcd_div_gcd_div_gcd
theorem gcd_div_gcd_div_gcd {i j : ℤ} (H : 0 < gcd i j) : gcd (i / gcd i j) (j / gcd i j) = 1 
Arguments: {i j : ℤ} (H : 0 < i.gcd j)
Goal: (i / ↑(i.gcd j)).gcd (j / ↑(i.gcd j)) = 1
-- Int.gcd_dvd_gcd_of_dvd_left
theorem gcd_dvd_gcd_of_dvd_left {i k : ℤ} (j : ℤ) (H : i ∣ k) : gcd i j ∣ gcd k j 
Arguments: {i k : ℤ} (j : ℤ) (H : i ∣ k)
Goal: i.gcd j ∣ k.gcd j
-- Int.gcd_dvd_gcd_of_dvd_right
theorem gcd_dvd_gcd_of_dvd_right {i k : ℤ} (j : ℤ) (H : i ∣ k) : gcd j i ∣ gcd j k 
Arguments: {i k : ℤ} (j : ℤ) (H : i ∣ k)
Goal: j.gcd i ∣ j.gcd k
-- Int.gcd_dvd_gcd_mul_left
theorem gcd_dvd_gcd_mul_left (i j k : ℤ) : gcd i j ∣ gcd (k * i) j 
Arguments: (i j k : ℤ)
Goal: i.gcd j ∣ (k * i).gcd j
-- Int.gcd_dvd_gcd_mul_right
theorem gcd_dvd_gcd_mul_right (i j k : ℤ) : gcd i j ∣ gcd (i * k) j 
Arguments: (i j k : ℤ)
Goal: i.gcd j ∣ (i * k).gcd j
-- Int.gcd_dvd_gcd_mul_left_right
theorem gcd_dvd_gcd_mul_left_right (i j k : ℤ) : gcd i j ∣ gcd i (k * j) 
Arguments: (i j k : ℤ)
Goal: i.gcd j ∣ i.gcd (k * j)
-- Int.gcd_dvd_gcd_mul_right_right
theorem gcd_dvd_gcd_mul_right_right (i j k : ℤ) : gcd i j ∣ gcd i (j * k) 
Arguments: (i j k : ℤ)
Goal: i.gcd j ∣ i.gcd (j * k)
-- Int.gcd_eq_one_of_gcd_mul_right_eq_one_left
theorem gcd_eq_one_of_gcd_mul_right_eq_one_left {a : ℤ} {m n : ℕ} (h : a.gcd (m * n) = 1) :
    a.gcd m = 1 
Arguments: {a : ℤ} {m n : ℕ} (h : a.gcd (↑m * ↑n) = 1)
Goal: a.gcd ↑m = 1
-- Int.gcd_eq_one_of_gcd_mul_right_eq_one_right
theorem gcd_eq_one_of_gcd_mul_right_eq_one_right {a : ℤ} {m n : ℕ} (h : a.gcd (m * n) = 1) :
    a.gcd n = 1 
Arguments: {a : ℤ} {m n : ℕ} (h : a.gcd (↑m * ↑n) = 1)
Goal: a.gcd ↑n = 1
-- Int.gcd_eq_left
theorem gcd_eq_left {i j : ℤ} (H : i ∣ j) : gcd i j = natAbs i 
Arguments: {i j : ℤ} (H : i ∣ j)
Goal: i.gcd j = i.natAbs
-- Int.gcd_eq_right
theorem gcd_eq_right {i j : ℤ} (H : j ∣ i) : gcd i j = natAbs j 
Arguments: {i j : ℤ} (H : j ∣ i)
Goal: i.gcd j = j.natAbs
-- Int.ne_zero_of_gcd
theorem ne_zero_of_gcd {x y : ℤ} (hc : gcd x y ≠ 0) : x ≠ 0 ∨ y ≠ 0 
Arguments: {x y : ℤ} (hc : x.gcd y ≠ 0)
Goal: x ≠ 0 ∨ y ≠ 0
-- Int.exists_gcd_one
theorem exists_gcd_one {m n : ℤ} (H : 0 < gcd m n) :
    ∃ m' n' : ℤ, gcd m' n' = 1 ∧ m = m' * gcd m n ∧ n = n' * gcd m n 
Arguments: {m n : ℤ} (H : 0 < m.gcd n)
Goal: ∃ m' n', m'.gcd n' = 1 ∧ m = m' * ↑(m.gcd n) ∧ n = n' * ↑(m.gcd n)
-- Int.exists_gcd_one'
theorem exists_gcd_one' {m n : ℤ} (H : 0 < gcd m n) :
    ∃ (g : ℕ) (m' n' : ℤ), 0 < g ∧ gcd m' n' = 1 ∧ m = m' * g ∧ n = n' * g 
Arguments: {m n : ℤ} (H : 0 < m.gcd n)
Goal: ∃ g m' n', 0 < g ∧ m'.gcd n' = 1 ∧ m = m' * ↑g ∧ n = n' * ↑g
-- Int.pow_dvd_pow_iff
theorem pow_dvd_pow_iff {m n : ℤ} {k : ℕ} (k0 : k ≠ 0) : m ^ k ∣ n ^ k ↔ m ∣ n 
Arguments: {m n : ℤ} {k : ℕ} (k0 : k ≠ 0)
Goal: m ^ k ∣ n ^ k ↔ m ∣ n
-- Int.gcd_dvd_iff
theorem gcd_dvd_iff {a b : ℤ} {n : ℕ} : gcd a b ∣ n ↔ ∃ x y : ℤ, ↑n = a * x + b * y 
Arguments: {a b : ℤ} {n : ℕ}
Goal: a.gcd b ∣ n ↔ ∃ x y, ↑n = a * x + b * y
-- Int.gcd_greatest
theorem gcd_greatest {a b d : ℤ} (hd_pos : 0 ≤ d) (hda : d ∣ a) (hdb : d ∣ b)
    (hd : ∀ e : ℤ, e ∣ a → e ∣ b → e ∣ d) : d = gcd a b 
Arguments: {a b d : ℤ} (hd_pos : 0 ≤ d) (hda : d ∣ a) (hdb : d ∣ b) (hd : ∀ (e : ℤ), e ∣ a → e ∣ b → e ∣ d)
Goal: d = ↑(a.gcd b)
-- Int.dvd_of_dvd_mul_left_of_gcd_one
theorem dvd_of_dvd_mul_left_of_gcd_one {a b c : ℤ} (habc : a ∣ b * c) (hab : gcd a c = 1) :
    a ∣ b 
Arguments: {a b c : ℤ} (habc : a ∣ b * c) (hab : a.gcd c = 1)
Goal: a ∣ b
-- Int.dvd_of_dvd_mul_right_of_gcd_one
theorem dvd_of_dvd_mul_right_of_gcd_one {a b c : ℤ} (habc : a ∣ b * c) (hab : gcd a b = 1) :
    a ∣ c 
Arguments: {a b c : ℤ} (habc : a ∣ b * c) (hab : a.gcd b = 1)
Goal: a ∣ c
-- Int.gcd_least_linear
theorem gcd_least_linear {a b : ℤ} (ha : a ≠ 0) :
    IsLeast { n : ℕ | 0 < n ∧ ∃ x y : ℤ, ↑n = a * x + b * y } (a.gcd b) 
Arguments: {a b : ℤ} (ha : a ≠ 0)
Goal: IsLeast {n | 0 < n ∧ ∃ x y, ↑n = a * x + b * y} (a.gcd b)
-- Int.lcm_comm
theorem lcm_comm (i j : ℤ) : lcm i j = lcm j i 
Arguments: (i j : ℤ)
Goal: i.lcm j = j.lcm i
-- Int.lcm_assoc
theorem lcm_assoc (i j k : ℤ) : lcm (lcm i j) k = lcm i (lcm j k) 
Arguments: (i j k : ℤ)
Goal: (↑(i.lcm j)).lcm k = i.lcm ↑(j.lcm k)
-- Int.lcm_zero_left
@[simp]
theorem lcm_zero_left (i : ℤ) : lcm 0 i = 0 
Arguments: (i : ℤ)
Goal: Int.lcm 0 i = 0
-- Int.lcm_zero_right
@[simp]
theorem lcm_zero_right (i : ℤ) : lcm i 0 = 0 
Arguments: (i : ℤ)
Goal: i.lcm 0 = 0
-- Int.lcm_one_left
@[simp]
theorem lcm_one_left (i : ℤ) : lcm 1 i = natAbs i 
Arguments: (i : ℤ)
Goal: Int.lcm 1 i = i.natAbs
-- Int.lcm_one_right
@[simp]
theorem lcm_one_right (i : ℤ) : lcm i 1 = natAbs i 
Arguments: (i : ℤ)
Goal: i.lcm 1 = i.natAbs
-- Int.lcm_dvd
theorem lcm_dvd {i j k : ℤ} : i ∣ k → j ∣ k → (lcm i j : ℤ) ∣ k 
Arguments: {i j k : ℤ}
Goal: i ∣ k → j ∣ k → ↑(i.lcm j) ∣ k
-- Int.lcm_mul_left
theorem lcm_mul_left {m n k : ℤ} : (m * n).lcm (m * k) = natAbs m * n.lcm k 
Arguments: {m n k : ℤ}
Goal: (m * n).lcm (m * k) = m.natAbs * n.lcm k
-- Int.lcm_mul_right
theorem lcm_mul_right {m n k : ℤ} : (m * n).lcm (k * n) = m.lcm k * natAbs n 
Arguments: {m n k : ℤ}
Goal: (m * n).lcm (k * n) = m.lcm k * n.natAbs
-- pow_gcd_eq_one
@[to_additive gcd_nsmul_eq_zero]
theorem pow_gcd_eq_one {M : Type*} [Monoid M] (x : M) {m n : ℕ} (hm : x ^ m = 1) (hn : x ^ n = 1) :
    x ^ m.gcd n = 1 
Arguments: {M : Type u_1} [Monoid M] (x : M) {m n : ℕ} (hm : x ^ m = 1) (hn : x ^ n = 1)
Goal: x ^ m.gcd n = 1
-- gcd_nsmul_eq_zero
@[to_additive gcd_nsmul_eq_zero]
theorem pow_gcd_eq_one {M : Type*} [Monoid M] (x : M) {m n : ℕ} (hm : x ^ m = 1) (hn : x ^ n = 1) :
    x ^ m.gcd n = 1 
Arguments: {M : Type u_1} [AddMonoid M] (x : M) {m n : ℕ} (hm : m • x = 0) (hn : n • x = 0)
Goal: m.gcd n • x = 0
-- Commute.pow_eq_pow_iff_of_coprime
protected lemma Commute.pow_eq_pow_iff_of_coprime (hab : Commute a b) (hmn : m.Coprime n) :
    a ^ m = b ^ n ↔ ∃ c, a = c ^ n ∧ b = c ^ m 
Arguments: {α : Type u_1} [GroupWithZero α] {a b : α} {m n : ℕ} (hab : Commute a b) (hmn : m.Coprime n)
Goal: a ^ m = b ^ n ↔ ∃ c, a = c ^ n ∧ b = c ^ m
-- pow_eq_pow_iff_of_coprime
lemma pow_eq_pow_iff_of_coprime (hmn : m.Coprime n) : a ^ m = b ^ n ↔ ∃ c, a = c ^ n ∧ b = c ^ m 
Arguments: {α : Type u_1} [CommGroupWithZero α] {a b : α} {m n : ℕ} (hmn : m.Coprime n)
Goal: a ^ m = b ^ n ↔ ∃ c, a = c ^ n ∧ b = c ^ m
-- pow_mem_range_pow_of_coprime
lemma pow_mem_range_pow_of_coprime (hmn : m.Coprime n) (a : α) :
    a ^ m ∈ Set.range (· ^ n : α → α) ↔ a ∈ Set.range (· ^ n : α → α) 
Arguments: {α : Type u_1} [CommGroupWithZero α] {m n : ℕ} (hmn : m.Coprime n) (a : α)
Goal: (a ^ m ∈ Set.range fun x => x ^ n) ↔ a ∈ Set.range fun x => x ^ n
-- Int.succ_eq_succ
@[simp]
theorem succ_eq_succ : Order.succ = succ 
Goal: Order.succ = Int.succ
-- Int.pred_eq_pred
@[simp]
theorem pred_eq_pred : Order.pred = pred 
Goal: Order.pred = Int.pred
-- Int.pos_iff_one_le
theorem pos_iff_one_le {a : ℤ} : 0 < a ↔ 1 ≤ a 
Arguments: {a : ℤ}
Goal: 0 < a ↔ 1 ≤ a
-- Int.succ_iterate
theorem succ_iterate (a : ℤ) : ∀ n, succ^[n] a = a + n
  
Arguments: (a : ℤ) (n : ℕ)
Goal: Int.succ^[n] a = a + ↑n
-- Int.pred_iterate
theorem pred_iterate (a : ℤ) : ∀ n, pred^[n] a = a - n
  
Arguments: (a : ℤ) (n : ℕ)
Goal: Int.pred^[n] a = a - ↑n
-- Int.covBy_iff_succ_eq
protected theorem covBy_iff_succ_eq {m n : ℤ} : m ⋖ n ↔ m + 1 = n 
Arguments: {m n : ℤ}
Goal: m ⋖ n ↔ m + 1 = n
-- Int.sub_one_covBy
@[simp]
theorem sub_one_covBy (z : ℤ) : z - 1 ⋖ z 
Arguments: (z : ℤ)
Goal: z - 1 ⋖ z
-- Int.covBy_add_one
@[simp]
theorem covBy_add_one (z : ℤ) : z ⋖ z + 1 
Arguments: (z : ℤ)
Goal: z ⋖ z + 1
-- Int.natCast_covBy
@[simp, norm_cast]
theorem natCast_covBy {a b : ℕ} : (a : ℤ) ⋖ b ↔ a ⋖ b 
Arguments: {a b : ℕ}
Goal: ↑a ⋖ ↑b ↔ a ⋖ b
-- Int.natAbs_eq_iff_associated
theorem Int.natAbs_eq_iff_associated {a b : ℤ} : a.natAbs = b.natAbs ↔ Associated a b 
Arguments: {a b : ℤ}
Goal: a.natAbs = b.natAbs ↔ Associated a b
-- Int.exists_least_of_bdd
theorem exists_least_of_bdd
    {P : ℤ → Prop}
    (Hbdd : ∃ b : ℤ , ∀ z : ℤ , P z → b ≤ z)
    (Hinh : ∃ z : ℤ , P z) : ∃ lb : ℤ , P lb ∧ ∀ z : ℤ , P z → lb ≤ z 
Arguments: {P : ℤ → Prop} (Hbdd : ∃ b, ∀ (z : ℤ), P z → b ≤ z) (Hinh : ∃ z, P z)
Goal: ∃ lb, P lb ∧ ∀ (z : ℤ), P z → lb ≤ z
-- Int.coe_leastOfBdd_eq
theorem coe_leastOfBdd_eq {P : ℤ → Prop} [DecidablePred P] {b b' : ℤ} (Hb : ∀ z : ℤ, P z → b ≤ z)
    (Hb' : ∀ z : ℤ, P z → b' ≤ z) (Hinh : ∃ z : ℤ, P z) :
    (leastOfBdd b Hb Hinh : ℤ) = leastOfBdd b' Hb' Hinh 
Arguments: {P : ℤ → Prop} [DecidablePred P] {b b' : ℤ} (Hb : ∀ (z : ℤ), P z → b ≤ z) (Hb' : ∀ (z : ℤ), P z → b' ≤ z) (Hinh : ∃ z, P z)
Goal: ↑(b.leastOfBdd Hb Hinh) = ↑(b'.leastOfBdd Hb' Hinh)
-- Int.exists_greatest_of_bdd
theorem exists_greatest_of_bdd
    {P : ℤ → Prop}
    (Hbdd : ∃ b : ℤ , ∀ z : ℤ , P z → z ≤ b)
    (Hinh : ∃ z : ℤ , P z) : ∃ ub : ℤ , P ub ∧ ∀ z : ℤ , P z → z ≤ ub 
Arguments: {P : ℤ → Prop} (Hbdd : ∃ b, ∀ (z : ℤ), P z → z ≤ b) (Hinh : ∃ z, P z)
Goal: ∃ ub, P ub ∧ ∀ (z : ℤ), P z → z ≤ ub
-- Int.coe_greatestOfBdd_eq
theorem coe_greatestOfBdd_eq {P : ℤ → Prop} [DecidablePred P] {b b' : ℤ}
    (Hb : ∀ z : ℤ, P z → z ≤ b) (Hb' : ∀ z : ℤ, P z → z ≤ b') (Hinh : ∃ z : ℤ, P z) :
    (greatestOfBdd b Hb Hinh : ℤ) = greatestOfBdd b' Hb' Hinh 
Arguments: {P : ℤ → Prop} [DecidablePred P] {b b' : ℤ} (Hb : ∀ (z : ℤ), P z → z ≤ b) (Hb' : ∀ (z : ℤ), P z → z ≤ b') (Hinh : ∃ z, P z)
Goal: ↑(b.greatestOfBdd Hb Hinh) = ↑(b'.greatestOfBdd Hb' Hinh)
-- Int.log_of_one_le_right
theorem log_of_one_le_right (b : ℕ) {r : R} (hr : 1 ≤ r) : log b r = Nat.log b ⌊r⌋₊ 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ) {r : R} (hr : 1 ≤ r)
Goal: Int.log b r = ↑(Nat.log b ⌊r⌋₊)
-- Int.log_of_right_le_one
theorem log_of_right_le_one (b : ℕ) {r : R} (hr : r ≤ 1) : log b r = -Nat.clog b ⌈r⁻¹⌉₊ 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ) {r : R} (hr : r ≤ 1)
Goal: Int.log b r = -↑(Nat.clog b ⌈r⁻¹⌉₊)
-- Int.log_natCast
@[simp, norm_cast]
theorem log_natCast (b : ℕ) (n : ℕ) : log b (n : R) = Nat.log b n 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b n : ℕ)
Goal: Int.log b ↑n = ↑(Nat.log b n)
-- Int.log_ofNat
@[simp]
theorem log_ofNat (b : ℕ) (n : ℕ) [n.AtLeastTwo] :
    log b (no_index (OfNat.ofNat n : R)) = Nat.log b (OfNat.ofNat n) 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b n : ℕ) [n.AtLeastTwo]
Goal: Int.log b (OfNat.ofNat n) = ↑(Nat.log b (OfNat.ofNat n))
-- Int.log_of_left_le_one
theorem log_of_left_le_one {b : ℕ} (hb : b ≤ 1) (r : R) : log b r = 0 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] {b : ℕ} (hb : b ≤ 1) (r : R)
Goal: Int.log b r = 0
-- Int.log_of_right_le_zero
theorem log_of_right_le_zero (b : ℕ) {r : R} (hr : r ≤ 0) : log b r = 0 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ) {r : R} (hr : r ≤ 0)
Goal: Int.log b r = 0
-- Int.zpow_log_le_self
theorem zpow_log_le_self {b : ℕ} {r : R} (hb : 1 < b) (hr : 0 < r) : (b : R) ^ log b r ≤ r 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] {b : ℕ} {r : R} (hb : 1 < b) (hr : 0 < r)
Goal: ↑b ^ Int.log b r ≤ r
-- Int.lt_zpow_succ_log_self
theorem lt_zpow_succ_log_self {b : ℕ} (hb : 1 < b) (r : R) : r < (b : R) ^ (log b r + 1) 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] {b : ℕ} (hb : 1 < b) (r : R)
Goal: r < ↑b ^ (Int.log b r + 1)
-- Int.log_zero_right
@[simp]
theorem log_zero_right (b : ℕ) : log b (0 : R) = 0 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ)
Goal: Int.log b 0 = 0
-- Int.log_one_right
@[simp]
theorem log_one_right (b : ℕ) : log b (1 : R) = 0 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ)
Goal: Int.log b 1 = 0
-- Int.log_zpow
theorem log_zpow {b : ℕ} (hb : 1 < b) (z : ℤ) : log b ((b : R) ^ z : R) = z 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] {b : ℕ} (hb : 1 < b) (z : ℤ)
Goal: Int.log b (↑b ^ z) = z
-- Int.log_mono_right
@[mono]
theorem log_mono_right {b : ℕ} {r₁ r₂ : R} (h₀ : 0 < r₁) (h : r₁ ≤ r₂) : log b r₁ ≤ log b r₂ 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] {b : ℕ} {r₁ r₂ : R} (h₀ : 0 < r₁) (h : r₁ ≤ r₂)
Goal: Int.log b r₁ ≤ Int.log b r₂
-- Int.lt_zpow_iff_log_lt
theorem lt_zpow_iff_log_lt {b : ℕ} (hb : 1 < b) {x : ℤ} {r : R} (hr : 0 < r) :
    r < (b : R) ^ x ↔ log b r < x 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] {b : ℕ} (hb : 1 < b) {x : ℤ} {r : R} (hr : 0 < r)
Goal: r < ↑b ^ x ↔ Int.log b r < x
-- Int.zpow_le_iff_le_log
theorem zpow_le_iff_le_log {b : ℕ} (hb : 1 < b) {x : ℤ} {r : R} (hr : 0 < r) :
    (b : R) ^ x ≤ r ↔ x ≤ log b r 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] {b : ℕ} (hb : 1 < b) {x : ℤ} {r : R} (hr : 0 < r)
Goal: ↑b ^ x ≤ r ↔ x ≤ Int.log b r
-- Int.clog_of_one_le_right
theorem clog_of_one_le_right (b : ℕ) {r : R} (hr : 1 ≤ r) : clog b r = Nat.clog b ⌈r⌉₊ 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ) {r : R} (hr : 1 ≤ r)
Goal: Int.clog b r = ↑(Nat.clog b ⌈r⌉₊)
-- Int.clog_of_right_le_one
theorem clog_of_right_le_one (b : ℕ) {r : R} (hr : r ≤ 1) : clog b r = -Nat.log b ⌊r⁻¹⌋₊ 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ) {r : R} (hr : r ≤ 1)
Goal: Int.clog b r = -↑(Nat.log b ⌊r⁻¹⌋₊)
-- Int.clog_of_right_le_zero
theorem clog_of_right_le_zero (b : ℕ) {r : R} (hr : r ≤ 0) : clog b r = 0 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ) {r : R} (hr : r ≤ 0)
Goal: Int.clog b r = 0
-- Int.clog_inv
@[simp]
theorem clog_inv (b : ℕ) (r : R) : clog b r⁻¹ = -log b r 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ) (r : R)
Goal: Int.clog b r⁻¹ = -Int.log b r
-- Int.log_inv
@[simp]
theorem log_inv (b : ℕ) (r : R) : log b r⁻¹ = -clog b r 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ) (r : R)
Goal: Int.log b r⁻¹ = -Int.clog b r
-- Int.neg_log_inv_eq_clog
theorem neg_log_inv_eq_clog (b : ℕ) (r : R) : -log b r⁻¹ = clog b r 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ) (r : R)
Goal: -Int.log b r⁻¹ = Int.clog b r
-- Int.neg_clog_inv_eq_log
theorem neg_clog_inv_eq_log (b : ℕ) (r : R) : -clog b r⁻¹ = log b r 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ) (r : R)
Goal: -Int.clog b r⁻¹ = Int.log b r
-- Int.clog_natCast
@[simp, norm_cast]
theorem clog_natCast (b : ℕ) (n : ℕ) : clog b (n : R) = Nat.clog b n 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b n : ℕ)
Goal: Int.clog b ↑n = ↑(Nat.clog b n)
-- Int.clog_ofNat
@[simp]
theorem clog_ofNat (b : ℕ) (n : ℕ) [n.AtLeastTwo] :
    clog b (no_index (OfNat.ofNat n : R)) = Nat.clog b (OfNat.ofNat n) 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b n : ℕ) [n.AtLeastTwo]
Goal: Int.clog b (OfNat.ofNat n) = ↑(Nat.clog b (OfNat.ofNat n))
-- Int.clog_of_left_le_one
theorem clog_of_left_le_one {b : ℕ} (hb : b ≤ 1) (r : R) : clog b r = 0 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] {b : ℕ} (hb : b ≤ 1) (r : R)
Goal: Int.clog b r = 0
-- Int.self_le_zpow_clog
theorem self_le_zpow_clog {b : ℕ} (hb : 1 < b) (r : R) : r ≤ (b : R) ^ clog b r 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] {b : ℕ} (hb : 1 < b) (r : R)
Goal: r ≤ ↑b ^ Int.clog b r
-- Int.zpow_pred_clog_lt_self
theorem zpow_pred_clog_lt_self {b : ℕ} {r : R} (hb : 1 < b) (hr : 0 < r) :
    (b : R) ^ (clog b r - 1) < r 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] {b : ℕ} {r : R} (hb : 1 < b) (hr : 0 < r)
Goal: ↑b ^ (Int.clog b r - 1) < r
-- Int.clog_zero_right
@[simp]
theorem clog_zero_right (b : ℕ) : clog b (0 : R) = 0 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ)
Goal: Int.clog b 0 = 0
-- Int.clog_one_right
@[simp]
theorem clog_one_right (b : ℕ) : clog b (1 : R) = 0 
Arguments: {R : Type u_1} [LinearOrderedSemifield R] [FloorSemiring R] (b : ℕ)
Goal: Int.clog b 1 = 0