ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Nat.max_eq_max
protected theorem max_eq_max (a : Nat) : Nat.max a b = max a b 
Arguments: {b : Nat} (a : Nat)
Goal: a.max b = max a b
-- Nat.max_comm
protected theorem max_comm (a b : Nat) : max a b = max b a 
Arguments: (a b : Nat)
Goal: max a b = max b a
-- Nat.le_max_left
protected theorem le_max_left ( a b : Nat) : a ≤ max a b 
Arguments: (a b : Nat)
Goal: a ≤ max a b
-- Nat.le_max_right
protected theorem le_max_right (a b : Nat) : b ≤ max a b 
Arguments: (a b : Nat)
Goal: b ≤ max a b
-- Nat.dvd_refl
protected theorem dvd_refl (a : Nat) : a ∣ a 
Arguments: (a : Nat)
Goal: a ∣ a
-- Nat.dvd_zero
protected theorem dvd_zero (a : Nat) : a ∣ 0 
Arguments: (a : Nat)
Goal: a ∣ 0
-- Nat.dvd_mul_left
protected theorem dvd_mul_left (a b : Nat) : a ∣ b * a 
Arguments: (a b : Nat)
Goal: a ∣ b * a
-- Nat.dvd_mul_right
protected theorem dvd_mul_right (a b : Nat) : a ∣ a * b 
Arguments: (a b : Nat)
Goal: a ∣ a * b
-- Nat.dvd_trans
protected theorem dvd_trans {a b c : Nat} (h₁ : a ∣ b) (h₂ : b ∣ c) : a ∣ c 
Arguments: {a b c : Nat} (h₁ : a ∣ b) (h₂ : b ∣ c)
Goal: a ∣ c
-- Nat.eq_zero_of_zero_dvd
protected theorem eq_zero_of_zero_dvd {a : Nat} (h : 0 ∣ a) : a = 0 
Arguments: {a : Nat} (h : 0 ∣ a)
Goal: a = 0
-- Nat.zero_dvd
@[simp] protected theorem zero_dvd {n : Nat} : 0 ∣ n ↔ n = 0 
Arguments: {n : Nat}
Goal: 0 ∣ n ↔ n = 0
-- Nat.dvd_add
protected theorem dvd_add {a b c : Nat} (h₁ : a ∣ b) (h₂ : a ∣ c) : a ∣ b + c 
Arguments: {a b c : Nat} (h₁ : a ∣ b) (h₂ : a ∣ c)
Goal: a ∣ b + c
-- Nat.dvd_add_iff_right
protected theorem dvd_add_iff_right {k m n : Nat} (h : k ∣ m) : k ∣ n ↔ k ∣ m + n 
Arguments: {k m n : Nat} (h : k ∣ m)
Goal: k ∣ n ↔ k ∣ m + n
-- Nat.dvd_add_iff_left
protected theorem dvd_add_iff_left {k m n : Nat} (h : k ∣ n) : k ∣ m ↔ k ∣ m + n 
Arguments: {k m n : Nat} (h : k ∣ n)
Goal: k ∣ m ↔ k ∣ m + n
-- Nat.dvd_mod_iff
theorem dvd_mod_iff {k m n : Nat} (h: k ∣ n) : k ∣ m % n ↔ k ∣ m 
Arguments: {k m n : Nat} (h : k ∣ n)
Goal: k ∣ m % n ↔ k ∣ m
-- Nat.le_of_dvd
theorem le_of_dvd {m n : Nat} (h : 0 < n) : m ∣ n → m ≤ n
  
Arguments: {m n : Nat} (h : 0 < n)
Goal: m ∣ n → m ≤ n
-- Nat.dvd_antisymm
protected theorem dvd_antisymm : ∀ {m n : Nat}, m ∣ n → n ∣ m → m = n
  
Arguments: {m n : Nat}
Goal: m ∣ n → n ∣ m → m = n
-- Nat.pos_of_dvd_of_pos
theorem pos_of_dvd_of_pos {m n : Nat} (H1 : m ∣ n) (H2 : 0 < n) : 0 < m 
Arguments: {m n : Nat} (H1 : m ∣ n) (H2 : 0 < n)
Goal: 0 < m
-- Nat.one_dvd
@[simp] protected theorem one_dvd (n : Nat) : 1 ∣ n 
Arguments: (n : Nat)
Goal: 1 ∣ n
-- Nat.eq_one_of_dvd_one
theorem eq_one_of_dvd_one {n : Nat} (H : n ∣ 1) : n = 1 
Arguments: {n : Nat} (H : n ∣ 1)
Goal: n = 1
-- Nat.mod_eq_zero_of_dvd
theorem mod_eq_zero_of_dvd {m n : Nat} (H : m ∣ n) : n % m = 0 
Arguments: {m n : Nat} (H : m ∣ n)
Goal: n % m = 0
-- Nat.dvd_of_mod_eq_zero
theorem dvd_of_mod_eq_zero {m n : Nat} (H : n % m = 0) : m ∣ n 
Arguments: {m n : Nat} (H : n % m = 0)
Goal: m ∣ n
-- Nat.dvd_iff_mod_eq_zero
theorem dvd_iff_mod_eq_zero (m n : Nat) : m ∣ n ↔ n % m = 0 
Arguments: (m n : Nat)
Goal: m ∣ n ↔ n % m = 0
-- Nat.emod_pos_of_not_dvd
theorem emod_pos_of_not_dvd {a b : Nat} (h : ¬ a ∣ b) : 0 < b % a 
Arguments: {a b : Nat} (h : ¬a ∣ b)
Goal: 0 < b % a
-- Nat.mul_div_cancel'
protected theorem mul_div_cancel' {n m : Nat} (H : n ∣ m) : n * (m / n) = m 
Arguments: {n m : Nat} (H : n ∣ m)
Goal: n * (m / n) = m
-- Nat.div_mul_cancel
protected theorem div_mul_cancel {n m : Nat} (H : n ∣ m) : m / n * n = m 
Arguments: {n m : Nat} (H : n ∣ m)
Goal: m / n * n = m
-- Nat.mod_mod_of_dvd
@[simp] theorem mod_mod_of_dvd (a : Nat) (h : c ∣ b) : a % b % c = a % c 
Arguments: {c b : Nat} (a : Nat) (h : c ∣ b)
Goal: a % b % c = a % c
-- Nat.dvd_of_mul_dvd_mul_left
protected theorem dvd_of_mul_dvd_mul_left
    (kpos : 0 < k) (H : k * m ∣ k * n) : m ∣ n 
Arguments: {k m n : Nat} (kpos : 0 < k) (H : k * m ∣ k * n)
Goal: m ∣ n
-- Nat.dvd_of_mul_dvd_mul_right
protected theorem dvd_of_mul_dvd_mul_right (kpos : 0 < k) (H : m * k ∣ n * k) : m ∣ n 
Arguments: {k m n : Nat} (kpos : 0 < k) (H : m * k ∣ n * k)
Goal: m ∣ n
-- Nat.dvd_sub
theorem dvd_sub {k m n : Nat} (H : n ≤ m) (h₁ : k ∣ m) (h₂ : k ∣ n) : k ∣ m - n 
Arguments: {k m n : Nat} (H : n ≤ m) (h₁ : k ∣ m) (h₂ : k ∣ n)
Goal: k ∣ m - n
-- Nat.mul_dvd_mul
protected theorem mul_dvd_mul {a b c d : Nat} : a ∣ b → c ∣ d → a * c ∣ b * d
  
Arguments: {a b c d : Nat}
Goal: a ∣ b → c ∣ d → a * c ∣ b * d
-- Nat.mul_dvd_mul_left
protected theorem mul_dvd_mul_left (a : Nat) (h : b ∣ c) : a * b ∣ a * c 
Arguments: {b c : Nat} (a : Nat) (h : b ∣ c)
Goal: a * b ∣ a * c
-- Nat.mul_dvd_mul_right
protected theorem mul_dvd_mul_right (h: a ∣ b) (c : Nat) : a * c ∣ b * c 
Arguments: {a b : Nat} (h : a ∣ b) (c : Nat)
Goal: a * c ∣ b * c
-- Nat.dvd_one
@[simp] theorem dvd_one {n : Nat} : n ∣ 1 ↔ n = 1 
Arguments: {n : Nat}
Goal: n ∣ 1 ↔ n = 1
-- Nat.mul_div_assoc
protected theorem mul_div_assoc (m : Nat) (H : k ∣ n) : m * n / k = m * (n / k) 
Arguments: {k n : Nat} (m : Nat) (H : k ∣ n)
Goal: m * n / k = m * (n / k)
-- Nat.log2_terminates
theorem log2_terminates : ∀ n, n ≥ 2 → n / 2 < n
  
Arguments: (n : Nat)
Goal: n ≥ 2 → n / 2 < n
-- Nat.log2_le_self
theorem log2_le_self (n : Nat) : Nat.log2 n ≤ n 
Arguments: (n : Nat)
Goal: n.log2 ≤ n
-- Nat.Simproc.sub_add_eq_comm
theorem sub_add_eq_comm (a b c : Nat) : a - (b + c) = a - c - b 
Arguments: (a b c : Nat)
Goal: a - (b + c) = a - c - b
-- Nat.Simproc.add_sub_add_le
theorem add_sub_add_le (a c : Nat) {b d : Nat} (h : b ≤ d) : a + b - (c + d) = a - (c + (d-b)) 
Arguments: (a c : Nat) {b d : Nat} (h : b ≤ d)
Goal: a + b - (c + d) = a - (c + (d - b))
-- Nat.Simproc.add_sub_add_ge
theorem add_sub_add_ge (a c : Nat) {b d : Nat} (h : b ≥ d) : a + b - (c + d) = a + (b - d) - c 
Arguments: (a c : Nat) {b d : Nat} (h : b ≥ d)
Goal: a + b - (c + d) = a + (b - d) - c
-- Nat.Simproc.add_sub_le
theorem add_sub_le (a : Nat) {b c : Nat} (h : b ≤ c) : a + b - c = a - (c - b) 
Arguments: (a : Nat) {b c : Nat} (h : b ≤ c)
Goal: a + b - c = a - (c - b)
-- Nat.Simproc.add_eq_gt
theorem add_eq_gt (a : Nat) {b c : Nat} (h : b > c) : (a + b = c) = False 
Arguments: (a : Nat) {b c : Nat} (h : b > c)
Goal: (a + b = c) = False
-- Nat.Simproc.eq_add_gt
theorem eq_add_gt (a : Nat) {b c : Nat} (h : c > a) : (a = b + c) = False 
Arguments: (a : Nat) {b c : Nat} (h : c > a)
Goal: (a = b + c) = False
-- Nat.Simproc.add_eq_add_le
theorem add_eq_add_le (a c : Nat) {b d : Nat} (h : b ≤ d) : (a + b = c + d) = (a = c + (d - b)) 
Arguments: (a c : Nat) {b d : Nat} (h : b ≤ d)
Goal: (a + b = c + d) = (a = c + (d - b))
-- Nat.Simproc.add_eq_add_ge
theorem add_eq_add_ge (a c : Nat) {b d : Nat} (h : b ≥ d) : (a + b = c + d) = (a + (b - d) = c) 
Arguments: (a c : Nat) {b d : Nat} (h : b ≥ d)
Goal: (a + b = c + d) = (a + (b - d) = c)
-- Nat.Simproc.add_eq_le
theorem add_eq_le (a : Nat) {b c : Nat} (h : b ≤ c) : (a + b = c) = (a = c - b) 
Arguments: (a : Nat) {b c : Nat} (h : b ≤ c)
Goal: (a + b = c) = (a = c - b)
-- Nat.Simproc.eq_add_le
theorem eq_add_le {a : Nat} (b : Nat) {c : Nat} (h : c ≤ a) : (a = b + c) = (b = a - c) 
Arguments: {a : Nat} (b : Nat) {c : Nat} (h : c ≤ a)
Goal: (a = b + c) = (b = a - c)
-- Nat.Simproc.beqEqOfEqEq
theorem beqEqOfEqEq {a b c d : Nat} (p : (a = b) = (c = d)) : (a == b) = (c == d) 
Arguments: {a b c d : Nat} (p : (a = b) = (c = d))
Goal: (a == b) = (c == d)
-- Nat.Simproc.beqFalseOfEqFalse
theorem beqFalseOfEqFalse {a b : Nat} (p : (a = b) = False) : (a == b) = false 
Arguments: {a b : Nat} (p : (a = b) = False)
Goal: (a == b) = false
-- Nat.Simproc.bneEqOfEqEq
theorem bneEqOfEqEq {a b c d : Nat} (p : (a = b) = (c = d)) : (a != b) = (c != d) 
Arguments: {a b c d : Nat} (p : (a = b) = (c = d))
Goal: (a != b) = (c != d)
-- Nat.Simproc.bneTrueOfEqFalse
theorem bneTrueOfEqFalse {a b : Nat} (p : (a = b) = False) : (a != b) = true 
Arguments: {a b : Nat} (p : (a = b) = False)
Goal: (a != b) = true
-- Nat.Simproc.add_le_add_le
theorem add_le_add_le (a c : Nat) {b d : Nat} (h : b ≤ d) : (a + b ≤ c + d) = (a ≤ c + (d - b)) 
Arguments: (a c : Nat) {b d : Nat} (h : b ≤ d)
Goal: (a + b ≤ c + d) = (a ≤ c + (d - b))
-- Nat.Simproc.add_le_add_ge
theorem add_le_add_ge (a c : Nat) {b d : Nat} (h : b ≥ d) : (a + b ≤ c + d) = (a + (b - d) ≤ c) 
Arguments: (a c : Nat) {b d : Nat} (h : b ≥ d)
Goal: (a + b ≤ c + d) = (a + (b - d) ≤ c)
-- Nat.Simproc.add_le_le
theorem add_le_le (a : Nat) {b c : Nat} (h : b ≤ c) : (a + b ≤ c) = (a ≤ c - b) 
Arguments: (a : Nat) {b c : Nat} (h : b ≤ c)
Goal: (a + b ≤ c) = (a ≤ c - b)
-- Nat.Simproc.add_le_gt
theorem add_le_gt (a : Nat) {b c : Nat} (h : b > c) : (a + b ≤ c) = False 
Arguments: (a : Nat) {b c : Nat} (h : b > c)
Goal: (a + b ≤ c) = False
-- Nat.Simproc.le_add_le
theorem le_add_le (a : Nat) {b c : Nat} (h : a ≤ c) : (a ≤ b + c) = True 
Arguments: (a : Nat) {b c : Nat} (h : a ≤ c)
Goal: (a ≤ b + c) = True
-- Nat.Simproc.le_add_ge
theorem le_add_ge (a : Nat) {b c : Nat} (h : a ≥ c) : (a ≤ b + c) = (a - c ≤ b) 
Arguments: (a : Nat) {b c : Nat} (h : a ≥ c)
Goal: (a ≤ b + c) = (a - c ≤ b)
-- Nat.mul_lt_mul_left
@[simp] protected theorem mul_lt_mul_left (a0 : 0 < a) : a * b < a * c ↔ b < c 
Arguments: {a b c : Nat} (a0 : 0 < a)
Goal: a * b < a * c ↔ b < c
-- Nat.mul_lt_mul_right
@[simp] protected theorem mul_lt_mul_right (a0 : 0 < a) : b * a < c * a ↔ b < c 
Arguments: {a b c : Nat} (a0 : 0 < a)
Goal: b * a < c * a ↔ b < c
-- Nat.lt_of_mul_lt_mul_left
protected theorem lt_of_mul_lt_mul_left {a b c : Nat} (h : a * b < a * c) : b < c 
Arguments: {a b c : Nat} (h : a * b < a * c)
Goal: b < c
-- Nat.lt_of_mul_lt_mul_right
protected theorem lt_of_mul_lt_mul_right {a b c : Nat} (h : b * a < c * a) : b < c 
Arguments: {a b c : Nat} (h : b * a < c * a)
Goal: b < c
-- Nat.div_lt_of_lt_mul
protected theorem div_lt_of_lt_mul {m n k : Nat} (h : m < n * k) : m / n < k 
Arguments: {m n k : Nat} (h : m < n * k)
Goal: m / n < k
-- Nat.mod_mul_right_div_self
theorem mod_mul_right_div_self (m n k : Nat) : m % (n * k) / n = m / n % k 
Arguments: (m n k : Nat)
Goal: m % (n * k) / n = m / n % k
-- Nat.mod_mul_left_div_self
theorem mod_mul_left_div_self (m n k : Nat) : m % (k * n) / n = m / n % k 
Arguments: (m n k : Nat)
Goal: m % (k * n) / n = m / n % k
-- Nat.mod_mul_right_mod
@[simp 1100]
theorem mod_mul_right_mod (a b c : Nat) : a % (b * c) % b = a % b 
Arguments: (a b c : Nat)
Goal: a % (b * c) % b = a % b
-- Nat.mod_mul_left_mod
@[simp 1100]
theorem mod_mul_left_mod (a b c : Nat) : a % (b * c) % c = a % c 
Arguments: (a b c : Nat)
Goal: a % (b * c) % c = a % c
-- Nat.mod_mul
theorem mod_mul {a b x : Nat} : x % (a * b) = x % a + a * (x / a % b) 
Arguments: {a b x : Nat}
Goal: x % (a * b) = x % a + a * (x / a % b)
-- Nat.mod_pow_succ
theorem mod_pow_succ {x b k : Nat} :
    x % b ^ (k + 1) = x % b ^ k + b ^ k * ((x / b ^ k) % b) 
Arguments: {x b k : Nat}
Goal: x % b ^ (k + 1) = x % b ^ k + b ^ k * (x / b ^ k % b)
-- Nat.compare_def_lt
theorem compare_def_lt (a b : Nat) :
    compare a b = if a < b then .lt else if b < a then .gt else .eq 
Arguments: (a b : Nat)
Goal: compare a b = if a < b then Ordering.lt else if b < a then Ordering.gt else Ordering.eq
-- Nat.compare_def_le
theorem compare_def_le (a b : Nat) :
    compare a b = if a ≤ b then if b ≤ a then .eq else .lt else .gt 
Arguments: (a b : Nat)
Goal: compare a b = if a ≤ b then if b ≤ a then Ordering.eq else Ordering.lt else Ordering.gt
-- Nat.compare_swap
protected theorem compare_swap (a b : Nat) : (compare a b).swap = compare b a 
Arguments: (a b : Nat)
Goal: (compare a b).swap = compare b a
-- Nat.compare_eq_eq
protected theorem compare_eq_eq {a b : Nat} : compare a b = .eq ↔ a = b 
Arguments: {a b : Nat}
Goal: compare a b = Ordering.eq ↔ a = b
-- Nat.compare_eq_lt
protected theorem compare_eq_lt {a b : Nat} : compare a b = .lt ↔ a < b 
Arguments: {a b : Nat}
Goal: compare a b = Ordering.lt ↔ a < b
-- Nat.compare_eq_gt
protected theorem compare_eq_gt {a b : Nat} : compare a b = .gt ↔ b < a 
Arguments: {a b : Nat}
Goal: compare a b = Ordering.gt ↔ b < a
-- Nat.compare_ne_gt
protected theorem compare_ne_gt {a b : Nat} : compare a b ≠ .gt ↔ a ≤ b 
Arguments: {a b : Nat}
Goal: compare a b ≠ Ordering.gt ↔ a ≤ b
-- Nat.compare_ne_lt
protected theorem compare_ne_lt {a b : Nat} : compare a b ≠ .lt ↔ b ≤ a 
Arguments: {a b : Nat}
Goal: compare a b ≠ Ordering.lt ↔ b ≤ a
-- Nat.lcm_comm
theorem lcm_comm (m n : Nat) : lcm m n = lcm n m 
Arguments: (m n : Nat)
Goal: m.lcm n = n.lcm m
-- Nat.lcm_zero_left
@[simp] theorem lcm_zero_left (m : Nat) : lcm 0 m = 0 
Arguments: (m : Nat)
Goal: Nat.lcm 0 m = 0
-- Nat.lcm_zero_right
@[simp] theorem lcm_zero_right (m : Nat) : lcm m 0 = 0 
Arguments: (m : Nat)
Goal: m.lcm 0 = 0
-- Nat.lcm_one_left
@[simp] theorem lcm_one_left (m : Nat) : lcm 1 m = m 
Arguments: (m : Nat)
Goal: Nat.lcm 1 m = m
-- Nat.lcm_one_right
@[simp] theorem lcm_one_right (m : Nat) : lcm m 1 = m 
Arguments: (m : Nat)
Goal: m.lcm 1 = m
-- Nat.lcm_self
@[simp] theorem lcm_self (m : Nat) : lcm m m = m 
Arguments: (m : Nat)
Goal: m.lcm m = m
-- Nat.dvd_lcm_left
theorem dvd_lcm_left (m n : Nat) : m ∣ lcm m n 
Arguments: (m n : Nat)
Goal: m ∣ m.lcm n
-- Nat.dvd_lcm_right
theorem dvd_lcm_right (m n : Nat) : n ∣ lcm m n 
Arguments: (m n : Nat)
Goal: n ∣ m.lcm n
-- Nat.gcd_mul_lcm
theorem gcd_mul_lcm (m n : Nat) : gcd m n * lcm m n = m * n 
Arguments: (m n : Nat)
Goal: m.gcd n * m.lcm n = m * n
-- Nat.lcm_dvd
theorem lcm_dvd {m n k : Nat} (H1 : m ∣ k) (H2 : n ∣ k) : lcm m n ∣ k 
Arguments: {m n k : Nat} (H1 : m ∣ k) (H2 : n ∣ k)
Goal: m.lcm n ∣ k
-- Nat.lcm_assoc
theorem lcm_assoc (m n k : Nat) : lcm (lcm m n) k = lcm m (lcm n k) 
Arguments: (m n k : Nat)
Goal: (m.lcm n).lcm k = m.lcm (n.lcm k)
-- Nat.lcm_ne_zero
theorem lcm_ne_zero (hm : m ≠ 0) (hn : n ≠ 0) : lcm m n ≠ 0 
Arguments: {m n : Nat} (hm : m ≠ 0) (hn : n ≠ 0)
Goal: m.lcm n ≠ 0
-- Nat.two_pow_pos
protected theorem two_pow_pos (w : Nat) : 0 < 2^w 
Arguments: (w : Nat)
Goal: 0 < 2 ^ w
-- Nat.nextPowerOfTwo_dec
theorem nextPowerOfTwo_dec {n power : Nat} (h₁ : power > 0) (h₂ : power < n) : n - power * 2 < n - power 
Arguments: {n power : Nat} (h₁ : power > 0) (h₂ : power < n)
Goal: n - power * 2 < n - power
-- Nat.one_isPowerOfTwo
theorem one_isPowerOfTwo : isPowerOfTwo 1 
Goal: Nat.isPowerOfTwo 1
-- Nat.mul2_isPowerOfTwo_of_isPowerOfTwo
theorem mul2_isPowerOfTwo_of_isPowerOfTwo (h : isPowerOfTwo n) : isPowerOfTwo (n * 2) 
Arguments: {n : Nat} (h : n.isPowerOfTwo)
Goal: (n * 2).isPowerOfTwo
-- Nat.pos_of_isPowerOfTwo
theorem pos_of_isPowerOfTwo (h : isPowerOfTwo n) : n > 0 
Arguments: {n : Nat} (h : n.isPowerOfTwo)
Goal: n > 0
-- Nat.isPowerOfTwo_nextPowerOfTwo.isPowerOfTwo_go
theorem isPowerOfTwo_nextPowerOfTwo (n : Nat) : n.nextPowerOfTwo.isPowerOfTwo 
Arguments: (n power : Nat) (h₁ : power > 0) (h₂ : power.isPowerOfTwo)
Goal: (Nat.nextPowerOfTwo.go n power h₁).isPowerOfTwo
-- Nat.isPowerOfTwo_nextPowerOfTwo
theorem isPowerOfTwo_nextPowerOfTwo (n : Nat) : n.nextPowerOfTwo.isPowerOfTwo 
Arguments: (n : Nat)
Goal: n.nextPowerOfTwo.isPowerOfTwo
-- Array.eq_of_isEqvAux
theorem eq_of_isEqvAux [DecidableEq α] (a b : Array α) (hsz : a.size = b.size) (i : Nat) (hi : i ≤ a.size) (heqv : Array.isEqvAux a b hsz (fun x y => x = y) i) (j : Nat) (low : i ≤ j) (high : j < a.size) : a[j] = b[j]'(hsz ▸ high) 
Arguments: {α : Type u_1} [DecidableEq α] (a b : Array α) (hsz : a.size = b.size) (i : Nat) (hi : i ≤ a.size) (heqv : a.isEqvAux b hsz (fun x y => decide (x = y)) i = true) (j : Nat) (low : i ≤ j) (high : j < a.size)
Goal: a[j] = b[j]
-- Array.eq_of_isEqv
theorem eq_of_isEqv [DecidableEq α] (a b : Array α) : Array.isEqv a b (fun x y => x = y) → a = b 
Arguments: {α : Type u_1} [DecidableEq α] (a b : Array α)
Goal: (a.isEqv b fun x y => decide (x = y)) = true → a = b
-- Array.isEqvAux_self
theorem isEqvAux_self [DecidableEq α] (a : Array α) (i : Nat) : Array.isEqvAux a a rfl (fun x y => x = y) i = true 
Arguments: {α : Type u_1} [DecidableEq α] (a : Array α) (i : Nat)
Goal: a.isEqvAux a ⋯ (fun x y => decide (x = y)) i = true
-- Array.isEqv_self
theorem isEqv_self [DecidableEq α] (a : Array α) : Array.isEqv a a (fun x y => x = y) = true 
Arguments: {α : Type u_1} [DecidableEq α] (a : Array α)
Goal: (a.isEqv a fun x y => decide (x = y)) = true
-- Nat.gcd_zero_left
@[simp] theorem gcd_zero_left (y : Nat) : gcd 0 y = y 
Arguments: (y : Nat)
Goal: Nat.gcd 0 y = y
-- Nat.gcd_succ
theorem gcd_succ (x y : Nat) : gcd (succ x) y = gcd (y % succ x) (succ x) 
Arguments: (x y : Nat)
Goal: x.succ.gcd y = (y % x.succ).gcd x.succ
-- Nat.gcd_add_one
theorem gcd_add_one (x y : Nat) : gcd (x + 1) y = gcd (y % (x + 1)) (x + 1) 
Arguments: (x y : Nat)
Goal: (x + 1).gcd y = (y % (x + 1)).gcd (x + 1)
-- Nat.gcd_one_left
@[simp] theorem gcd_one_left (n : Nat) : gcd 1 n = 1 
Arguments: (n : Nat)
Goal: Nat.gcd 1 n = 1
-- Nat.gcd_zero_right
@[simp] theorem gcd_zero_right (n : Nat) : gcd n 0 = n 
Arguments: (n : Nat)
Goal: n.gcd 0 = n
-- Nat.gcd_self
@[simp] theorem gcd_self (n : Nat) : gcd n n = n 
Arguments: (n : Nat)
Goal: n.gcd n = n
-- Nat.gcd_rec
theorem gcd_rec (m n : Nat) : gcd m n = gcd (n % m) m 
Arguments: (m n : Nat)
Goal: m.gcd n = (n % m).gcd m
-- Nat.gcd.induction
@[elab_as_elim] theorem gcd.induction {P : Nat → Nat → Prop} (m n : Nat)
    (H0 : ∀n, P 0 n) (H1 : ∀ m n, 0 < m → P (n % m) m → P m n) : P m n 
Arguments: {P : Nat → Nat → Prop} (m n : Nat) (H0 : ∀ (n : Nat), P 0 n) (H1 : ∀ (m n : Nat), 0 < m → P (n % m) m → P m n)
Goal: P m n
-- Nat.gcd_dvd
theorem gcd_dvd (m n : Nat) : (gcd m n ∣ m) ∧ (gcd m n ∣ n) 
Arguments: (m n : Nat)
Goal: m.gcd n ∣ m ∧ m.gcd n ∣ n
-- Nat.gcd_dvd_left
theorem gcd_dvd_left (m n : Nat) : gcd m n ∣ m 
Arguments: (m n : Nat)
Goal: m.gcd n ∣ m
-- Nat.gcd_dvd_right
theorem gcd_dvd_right (m n : Nat) : gcd m n ∣ n 
Arguments: (m n : Nat)
Goal: m.gcd n ∣ n
-- Nat.gcd_le_left
theorem gcd_le_left (n) (h : 0 < m) : gcd m n ≤ m 
Arguments: {m : Nat} (n : Nat) (h : 0 < m)
Goal: m.gcd n ≤ m
-- Nat.gcd_le_right
theorem gcd_le_right (n) (h : 0 < n) : gcd m n ≤ n 
Arguments: {m : Nat} (n : Nat) (h : 0 < n)
Goal: m.gcd n ≤ n
-- Nat.dvd_gcd
theorem dvd_gcd : k ∣ m → k ∣ n → k ∣ gcd m n 
Arguments: {k m n : Nat}
Goal: k ∣ m → k ∣ n → k ∣ m.gcd n
-- Nat.dvd_gcd_iff
theorem dvd_gcd_iff : k ∣ gcd m n ↔ k ∣ m ∧ k ∣ n 
Arguments: {k : Nat} {m n : Nat}
Goal: k ∣ m.gcd n ↔ k ∣ m ∧ k ∣ n
-- Nat.gcd_comm
theorem gcd_comm (m n : Nat) : gcd m n = gcd n m 
Arguments: (m n : Nat)
Goal: m.gcd n = n.gcd m
-- Nat.gcd_eq_left_iff_dvd
theorem gcd_eq_left_iff_dvd : m ∣ n ↔ gcd m n = m 
Arguments: {m n : Nat}
Goal: m ∣ n ↔ m.gcd n = m
-- Nat.gcd_eq_right_iff_dvd
theorem gcd_eq_right_iff_dvd : m ∣ n ↔ gcd n m = m 
Arguments: {m n : Nat}
Goal: m ∣ n ↔ n.gcd m = m
-- Nat.gcd_assoc
theorem gcd_assoc (m n k : Nat) : gcd (gcd m n) k = gcd m (gcd n k) 
Arguments: (m n k : Nat)
Goal: (m.gcd n).gcd k = m.gcd (n.gcd k)
-- Nat.gcd_one_right
@[simp] theorem gcd_one_right (n : Nat) : gcd n 1 = 1 
Arguments: (n : Nat)
Goal: n.gcd 1 = 1
-- Nat.gcd_mul_left
theorem gcd_mul_left (m n k : Nat) : gcd (m * n) (m * k) = m * gcd n k 
Arguments: (m n k : Nat)
Goal: (m * n).gcd (m * k) = m * n.gcd k
-- Nat.gcd_mul_right
theorem gcd_mul_right (m n k : Nat) : gcd (m * n) (k * n) = gcd m k * n 
Arguments: (m n k : Nat)
Goal: (m * n).gcd (k * n) = m.gcd k * n
-- Nat.gcd_pos_of_pos_left
theorem gcd_pos_of_pos_left {m : Nat} (n : Nat) (mpos : 0 < m) : 0 < gcd m n 
Arguments: {m : Nat} (n : Nat) (mpos : 0 < m)
Goal: 0 < m.gcd n
-- Nat.gcd_pos_of_pos_right
theorem gcd_pos_of_pos_right (m : Nat) {n : Nat} (npos : 0 < n) : 0 < gcd m n 
Arguments: (m : Nat) {n : Nat} (npos : 0 < n)
Goal: 0 < m.gcd n
-- Nat.div_gcd_pos_of_pos_left
theorem div_gcd_pos_of_pos_left (b : Nat) (h : 0 < a) : 0 < a / a.gcd b 
Arguments: {a : Nat} (b : Nat) (h : 0 < a)
Goal: 0 < a / a.gcd b
-- Nat.div_gcd_pos_of_pos_right
theorem div_gcd_pos_of_pos_right (a : Nat) (h : 0 < b) : 0 < b / a.gcd b 
Arguments: {b : Nat} (a : Nat) (h : 0 < b)
Goal: 0 < b / a.gcd b
-- Nat.eq_zero_of_gcd_eq_zero_left
theorem eq_zero_of_gcd_eq_zero_left {m n : Nat} (H : gcd m n = 0) : m = 0 
Arguments: {m n : Nat} (H : m.gcd n = 0)
Goal: m = 0
-- Nat.eq_zero_of_gcd_eq_zero_right
theorem eq_zero_of_gcd_eq_zero_right {m n : Nat} (H : gcd m n = 0) : n = 0 
Arguments: {m n : Nat} (H : m.gcd n = 0)
Goal: n = 0
-- Nat.gcd_ne_zero_left
theorem gcd_ne_zero_left : m ≠ 0 → gcd m n ≠ 0 
Arguments: {m n : Nat}
Goal: m ≠ 0 → m.gcd n ≠ 0
-- Nat.gcd_ne_zero_right
theorem gcd_ne_zero_right : n ≠ 0 → gcd m n ≠ 0 
Arguments: {n m : Nat}
Goal: n ≠ 0 → m.gcd n ≠ 0
-- Nat.gcd_div
theorem gcd_div {m n k : Nat} (H1 : k ∣ m) (H2 : k ∣ n) :
    gcd (m / k) (n / k) = gcd m n / k 
Arguments: {m n k : Nat} (H1 : k ∣ m) (H2 : k ∣ n)
Goal: (m / k).gcd (n / k) = m.gcd n / k
-- Nat.gcd_dvd_gcd_of_dvd_left
theorem gcd_dvd_gcd_of_dvd_left {m k : Nat} (n : Nat) (H : m ∣ k) : gcd m n ∣ gcd k n 
Arguments: {m k : Nat} (n : Nat) (H : m ∣ k)
Goal: m.gcd n ∣ k.gcd n
-- Nat.gcd_dvd_gcd_of_dvd_right
theorem gcd_dvd_gcd_of_dvd_right {m k : Nat} (n : Nat) (H : m ∣ k) : gcd n m ∣ gcd n k 
Arguments: {m k : Nat} (n : Nat) (H : m ∣ k)
Goal: n.gcd m ∣ n.gcd k
-- Nat.gcd_dvd_gcd_mul_left
theorem gcd_dvd_gcd_mul_left (m n k : Nat) : gcd m n ∣ gcd (k * m) n 
Arguments: (m n k : Nat)
Goal: m.gcd n ∣ (k * m).gcd n
-- Nat.gcd_dvd_gcd_mul_right
theorem gcd_dvd_gcd_mul_right (m n k : Nat) : gcd m n ∣ gcd (m * k) n 
Arguments: (m n k : Nat)
Goal: m.gcd n ∣ (m * k).gcd n
-- Nat.gcd_dvd_gcd_mul_left_right
theorem gcd_dvd_gcd_mul_left_right (m n k : Nat) : gcd m n ∣ gcd m (k * n) 
Arguments: (m n k : Nat)
Goal: m.gcd n ∣ m.gcd (k * n)
-- Nat.gcd_dvd_gcd_mul_right_right
theorem gcd_dvd_gcd_mul_right_right (m n k : Nat) : gcd m n ∣ gcd m (n * k) 
Arguments: (m n k : Nat)
Goal: m.gcd n ∣ m.gcd (n * k)
-- Nat.gcd_eq_left
theorem gcd_eq_left {m n : Nat} (H : m ∣ n) : gcd m n = m 
Arguments: {m n : Nat} (H : m ∣ n)
Goal: m.gcd n = m
-- Nat.gcd_eq_right
theorem gcd_eq_right {m n : Nat} (H : n ∣ m) : gcd m n = n 
Arguments: {m n : Nat} (H : n ∣ m)
Goal: m.gcd n = n
-- Nat.gcd_mul_left_left
@[simp] theorem gcd_mul_left_left (m n : Nat) : gcd (m * n) n = n 
Arguments: (m n : Nat)
Goal: (m * n).gcd n = n
-- Nat.gcd_mul_left_right
@[simp] theorem gcd_mul_left_right (m n : Nat) : gcd n (m * n) = n 
Arguments: (m n : Nat)
Goal: n.gcd (m * n) = n
-- Nat.gcd_mul_right_left
@[simp] theorem gcd_mul_right_left (m n : Nat) : gcd (n * m) n = n 
Arguments: (m n : Nat)
Goal: (n * m).gcd n = n
-- Nat.gcd_mul_right_right
@[simp] theorem gcd_mul_right_right (m n : Nat) : gcd n (n * m) = n 
Arguments: (m n : Nat)
Goal: n.gcd (n * m) = n
-- Nat.gcd_gcd_self_right_left
@[simp] theorem gcd_gcd_self_right_left (m n : Nat) : gcd m (gcd m n) = gcd m n 
Arguments: (m n : Nat)
Goal: m.gcd (m.gcd n) = m.gcd n
-- Nat.gcd_gcd_self_right_right
@[simp] theorem gcd_gcd_self_right_right (m n : Nat) : gcd m (gcd n m) = gcd n m 
Arguments: (m n : Nat)
Goal: m.gcd (n.gcd m) = n.gcd m
-- Nat.gcd_gcd_self_left_right
@[simp] theorem gcd_gcd_self_left_right (m n : Nat) : gcd (gcd n m) m = gcd n m 
Arguments: (m n : Nat)
Goal: (n.gcd m).gcd m = n.gcd m
-- Nat.gcd_gcd_self_left_left
@[simp] theorem gcd_gcd_self_left_left (m n : Nat) : gcd (gcd m n) m = gcd m n 
Arguments: (m n : Nat)
Goal: (m.gcd n).gcd m = m.gcd n
-- Nat.gcd_add_mul_self
theorem gcd_add_mul_self (m n k : Nat) : gcd m (n + k * m) = gcd m n 
Arguments: (m n k : Nat)
Goal: m.gcd (n + k * m) = m.gcd n
-- Nat.gcd_eq_zero_iff
theorem gcd_eq_zero_iff {i j : Nat} : gcd i j = 0 ↔ i = 0 ∧ j = 0 
Arguments: {i j : Nat}
Goal: i.gcd j = 0 ↔ i = 0 ∧ j = 0
-- Nat.gcd_eq_iff
theorem gcd_eq_iff (a b : Nat) :
    gcd a b = g ↔ g ∣ a ∧ g ∣ b ∧ (∀ c, c ∣ a → c ∣ b → c ∣ g) 
Arguments: {g : Nat} (a b : Nat)
Goal: a.gcd b = g ↔ g ∣ a ∧ g ∣ b ∧ ∀ (c : Nat), c ∣ a → c ∣ b → c ∣ g
-- Nat.gcd_mul_dvd_mul_gcd
theorem gcd_mul_dvd_mul_gcd (k m n : Nat) : gcd k (m * n) ∣ gcd k m * gcd k n 
Arguments: (k m n : Nat)
Goal: k.gcd (m * n) ∣ k.gcd m * k.gcd n
-- Array.of_push_eq_push
theorem Array.of_push_eq_push {as bs : Array α} (h : as.push a = bs.push b) : as = bs ∧ a = b 
Arguments: {α : Type u_1} {a b : α} {as bs : Array α} (h : as.push a = bs.push b)
Goal: as = bs ∧ a = b
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Array.BasicAux.0.List.size_toArrayAux
private theorem List.size_toArrayAux (as : List α) (bs : Array α) : (as.toArrayAux bs).size = as.length + bs.size 
Arguments: {α : Type u_1} (as : List α) (bs : Array α)
Goal: (as.toArrayAux bs).size = as.length + bs.size