ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Array.BasicAux.0.List.of_toArrayAux_eq_toArrayAux
private theorem List.of_toArrayAux_eq_toArrayAux {as bs : List α} {cs ds : Array α} (h : as.toArrayAux cs = bs.toArrayAux ds) (hlen : cs.size = ds.size) : as = bs ∧ cs = ds 
Arguments: {α : Type u_1} {as bs : List α} {cs ds : Array α} (h : as.toArrayAux cs = bs.toArrayAux ds) (hlen : cs.size = ds.size)
Goal: as = bs ∧ cs = ds
-- List.toArray_eq_toArray_eq
@[simp] theorem List.toArray_eq_toArray_eq (as bs : List α) : (as.toArray = bs.toArray) = (as = bs) 
Arguments: {α : Type u_1} (as bs : List α)
Goal: (List.toArray as = List.toArray bs) = (as = bs)
-- _private.«.lake».packages.lean4.src.lean.Init.Data.Nat.Basic.0.Nat.rec_eq_recCompiled
@[csimp]
private theorem rec_eq_recCompiled : @Nat.rec = @Nat.recCompiled 
Goal: @Nat.rec = @Nat.recCompiled
-- Nat.zero_eq
@[simp] theorem zero_eq : Nat.zero = 0 
Goal: Nat.zero = 0
-- Nat.add_eq
@[simp] theorem add_eq : Nat.add x y = x + y 
Arguments: {x y : Nat}
Goal: x.add y = x + y
-- Nat.mul_eq
@[simp] theorem mul_eq : Nat.mul x y = x * y 
Arguments: {x y : Nat}
Goal: x.mul y = x * y
-- Nat.sub_eq
@[simp] theorem sub_eq : Nat.sub x y = x - y 
Arguments: {x y : Nat}
Goal: x.sub y = x - y
-- Nat.lt_eq
@[simp] theorem lt_eq : Nat.lt x y = (x < y) 
Arguments: {x y : Nat}
Goal: x.lt y = (x < y)
-- Nat.le_eq
@[simp] theorem le_eq : Nat.le x y = (x ≤ y) 
Arguments: {x y : Nat}
Goal: x.le y = (x ≤ y)
-- Nat.beq_refl
@[simp] theorem beq_refl (a : Nat) : Nat.beq a a = true 
Arguments: (a : Nat)
Goal: a.beq a = true
-- Nat.beq_eq
@[simp] theorem beq_eq : (Nat.beq x y = true) = (x = y) 
Arguments: {x y : Nat}
Goal: (x.beq y = true) = (x = y)
-- Nat.ble_eq
@[simp] theorem ble_eq : (Nat.ble x y = true) = (x ≤ y) 
Arguments: {x y : Nat}
Goal: (x.ble y = true) = (x ≤ y)
-- Nat.blt_eq
@[simp] theorem blt_eq : (Nat.blt x y = true) = (x < y) 
Arguments: {x y : Nat}
Goal: (x.blt y = true) = (x < y)
-- Nat.beq_eq_true_eq
@[simp] theorem beq_eq_true_eq (a b : Nat) : ((a == b) = true) = (a = b) 
Arguments: (a b : Nat)
Goal: ((a == b) = true) = (a = b)
-- Nat.not_beq_eq_true_eq
@[simp] theorem not_beq_eq_true_eq (a b : Nat) : ((!(a == b)) = true) = ¬(a = b) 
Arguments: (a b : Nat)
Goal: ((!a == b) = true) = ¬a = b
-- Nat.zero_add
@[simp] protected theorem zero_add : ∀ (n : Nat), 0 + n = n
  
Arguments: (n : Nat)
Goal: 0 + n = n
-- Nat.succ_add
theorem succ_add : ∀ (n m : Nat), (succ n) + m = succ (n + m)
  
Arguments: (n m : Nat)
Goal: n.succ + m = (n + m).succ
-- Nat.add_succ
theorem add_succ (n m : Nat) : n + succ m = succ (n + m) 
Arguments: (n m : Nat)
Goal: n + m.succ = (n + m).succ
-- Nat.add_one
theorem add_one (n : Nat) : n + 1 = succ n 
Arguments: (n : Nat)
Goal: n + 1 = n.succ
-- Nat.succ_eq_add_one
@[simp] theorem succ_eq_add_one (n : Nat) : succ n = n + 1 
Arguments: (n : Nat)
Goal: n.succ = n + 1
-- Nat.add_one_ne_zero
@[simp] theorem add_one_ne_zero (n : Nat) : n + 1 ≠ 0 
Arguments: (n : Nat)
Goal: n + 1 ≠ 0
-- Nat.zero_ne_add_one
@[simp] theorem zero_ne_add_one (n : Nat) : 0 ≠ n + 1 
Arguments: (n : Nat)
Goal: 0 ≠ n + 1
-- Nat.add_comm
protected theorem add_comm : ∀ (n m : Nat), n + m = m + n
  
Arguments: (n m : Nat)
Goal: n + m = m + n
-- Nat.add_assoc
protected theorem add_assoc : ∀ (n m k : Nat), (n + m) + k = n + (m + k)
  
Arguments: (n m k : Nat)
Goal: n + m + k = n + (m + k)
-- Nat.add_left_comm
protected theorem add_left_comm (n m k : Nat) : n + (m + k) = m + (n + k) 
Arguments: (n m k : Nat)
Goal: n + (m + k) = m + (n + k)
-- Nat.add_right_comm
protected theorem add_right_comm (n m k : Nat) : (n + m) + k = (n + k) + m 
Arguments: (n m k : Nat)
Goal: n + m + k = n + k + m
-- Nat.add_left_cancel
protected theorem add_left_cancel {n m k : Nat} : n + m = n + k → m = k 
Arguments: {n m k : Nat}
Goal: n + m = n + k → m = k
-- Nat.add_right_cancel
protected theorem add_right_cancel {n m k : Nat} (h : n + m = k + m) : n = k 
Arguments: {n m k : Nat} (h : n + m = k + m)
Goal: n = k
-- Nat.eq_zero_of_add_eq_zero
theorem eq_zero_of_add_eq_zero : ∀ {n m}, n + m = 0 → n = 0 ∧ m = 0
  
Arguments: {n m : Nat}
Goal: n + m = 0 → n = 0 ∧ m = 0
-- Nat.eq_zero_of_add_eq_zero_left
protected theorem eq_zero_of_add_eq_zero_left (h : n + m = 0) : m = 0 
Arguments: {n m : Nat} (h : n + m = 0)
Goal: m = 0
-- Nat.mul_zero
@[simp] protected theorem mul_zero (n : Nat) : n * 0 = 0 
Arguments: (n : Nat)
Goal: n * 0 = 0
-- Nat.mul_succ
theorem mul_succ (n m : Nat) : n * succ m = n * m + n 
Arguments: (n m : Nat)
Goal: n * m.succ = n * m + n
-- Nat.mul_add_one
theorem mul_add_one (n m : Nat) : n * (m + 1) = n * m + n 
Arguments: (n m : Nat)
Goal: n * (m + 1) = n * m + n
-- Nat.zero_mul
@[simp] protected theorem zero_mul : ∀ (n : Nat), 0 * n = 0
  
Arguments: (n : Nat)
Goal: 0 * n = 0
-- Nat.succ_mul
theorem succ_mul (n m : Nat) : (succ n) * m = (n * m) + m 
Arguments: (n m : Nat)
Goal: n.succ * m = n * m + m
-- Nat.add_one_mul
theorem add_one_mul (n m : Nat) : (n + 1) * m = (n * m) + m 
Arguments: (n m : Nat)
Goal: (n + 1) * m = n * m + m
-- Nat.mul_comm
protected theorem mul_comm : ∀ (n m : Nat), n * m = m * n
  
Arguments: (n m : Nat)
Goal: n * m = m * n
-- Nat.mul_one
@[simp] protected theorem mul_one : ∀ (n : Nat), n * 1 = n 
Arguments: (n : Nat)
Goal: n * 1 = n
-- Nat.one_mul
@[simp] protected theorem one_mul (n : Nat) : 1 * n = n 
Arguments: (n : Nat)
Goal: 1 * n = n
-- Nat.left_distrib
protected theorem left_distrib (n m k : Nat) : n * (m + k) = n * m + n * k 
Arguments: (n m k : Nat)
Goal: n * (m + k) = n * m + n * k
-- Nat.right_distrib
protected theorem right_distrib (n m k : Nat) : (n + m) * k = n * k + m * k 
Arguments: (n m k : Nat)
Goal: (n + m) * k = n * k + m * k
-- Nat.mul_add
protected theorem mul_add (n m k : Nat) : n * (m + k) = n * m + n * k 
Arguments: (n m k : Nat)
Goal: n * (m + k) = n * m + n * k
-- Nat.add_mul
protected theorem add_mul (n m k : Nat) : (n + m) * k = n * k + m * k 
Arguments: (n m k : Nat)
Goal: (n + m) * k = n * k + m * k
-- Nat.mul_assoc
protected theorem mul_assoc : ∀ (n m k : Nat), (n * m) * k = n * (m * k)
  
Arguments: (n m k : Nat)
Goal: n * m * k = n * (m * k)
-- Nat.mul_left_comm
protected theorem mul_left_comm (n m k : Nat) : n * (m * k) = m * (n * k) 
Arguments: (n m k : Nat)
Goal: n * (m * k) = m * (n * k)
-- Nat.mul_two
protected theorem mul_two (n) : n * 2 = n + n 
Arguments: (n : Nat)
Goal: n * 2 = n + n
-- Nat.two_mul
protected theorem two_mul (n) : 2 * n = n + n 
Arguments: (n : Nat)
Goal: 2 * n = n + n
-- Nat.succ_lt_succ
theorem succ_lt_succ {n m : Nat} : n < m → succ n < succ m 
Arguments: {n m : Nat}
Goal: n < m → n.succ < m.succ
-- Nat.lt_succ_of_le
theorem lt_succ_of_le {n m : Nat} : n ≤ m → n < succ m 
Arguments: {n m : Nat}
Goal: n ≤ m → n < m.succ
-- Nat.le_of_lt_add_one
theorem le_of_lt_add_one {n m : Nat} : n < m + 1 → n ≤ m 
Arguments: {n m : Nat}
Goal: n < m + 1 → n ≤ m
-- Nat.lt_add_one_of_le
theorem lt_add_one_of_le {n m : Nat} : n ≤ m → n < m + 1 
Arguments: {n m : Nat}
Goal: n ≤ m → n < m + 1
-- Nat.sub_zero
@[simp] protected theorem sub_zero (n : Nat) : n - 0 = n 
Arguments: (n : Nat)
Goal: n - 0 = n
-- Nat.not_add_one_le_zero
theorem not_add_one_le_zero (n : Nat) : ¬ n + 1 ≤ 0 
Arguments: (n : Nat)
Goal: ¬n + 1 ≤ 0
-- Nat.not_add_one_le_self
theorem not_add_one_le_self : (n : Nat) → ¬ n + 1 ≤ n 
Arguments: (n : Nat)
Goal: ¬n + 1 ≤ n
-- Nat.add_one_pos
theorem add_one_pos (n : Nat) : 0 < n + 1 
Arguments: (n : Nat)
Goal: 0 < n + 1
-- Nat.succ_sub_succ_eq_sub
theorem succ_sub_succ_eq_sub (n m : Nat) : succ n - succ m = n - m 
Arguments: (n m : Nat)
Goal: n.succ - m.succ = n - m
-- Nat.pred_le
theorem pred_le : ∀ (n : Nat), pred n ≤ n
  
Arguments: (n : Nat)
Goal: n.pred ≤ n
-- Nat.pred_lt
theorem pred_lt : ∀ {n : Nat}, n ≠ 0 → pred n < n
  
Arguments: {n : Nat}
Goal: n ≠ 0 → n.pred < n
-- Nat.sub_one_lt
theorem sub_one_lt : ∀ {n : Nat}, n ≠ 0 → n - 1 < n 
Arguments: {n : Nat}
Goal: n ≠ 0 → n - 1 < n
-- Nat.sub_le
@[simp] theorem sub_le (n m : Nat) : n - m ≤ n 
Arguments: (n m : Nat)
Goal: n - m ≤ n
-- Nat.sub_lt
theorem sub_lt : ∀ {n m : Nat}, 0 < n → 0 < m → n - m < n
  
Arguments: {n m : Nat}
Goal: 0 < n → 0 < m → n - m < n
-- Nat.sub_succ
theorem sub_succ (n m : Nat) : n - succ m = pred (n - m) 
Arguments: (n m : Nat)
Goal: n - m.succ = (n - m).pred
-- Nat.succ_sub_succ
theorem succ_sub_succ (n m : Nat) : succ n - succ m = n - m 
Arguments: (n m : Nat)
Goal: n.succ - m.succ = n - m
-- Nat.sub_self
@[simp] protected theorem sub_self : ∀ (n : Nat), n - n = 0
  
Arguments: (n : Nat)
Goal: n - n = 0
-- Nat.sub_add_eq
theorem sub_add_eq (a b c : Nat) : a - (b + c) = a - b - c 
Arguments: (a b c : Nat)
Goal: a - (b + c) = a - b - c
-- Nat.lt_of_lt_of_le
protected theorem lt_of_lt_of_le {n m k : Nat} : n < m → m ≤ k → n < k 
Arguments: {n m k : Nat}
Goal: n < m → m ≤ k → n < k
-- Nat.lt_of_lt_of_eq
protected theorem lt_of_lt_of_eq {n m k : Nat} : n < m → m = k → n < k 
Arguments: {n m k : Nat}
Goal: n < m → m = k → n < k
-- Nat.le_of_eq
protected theorem le_of_eq {n m : Nat} (p : n = m) : n ≤ m 
Arguments: {n m : Nat} (p : n = m)
Goal: n ≤ m
-- Nat.lt.step
theorem lt.step {n m : Nat} : n < m → n < succ m 
Arguments: {n m : Nat}
Goal: n < m → n < m.succ
-- Nat.le_of_succ_le
theorem le_of_succ_le {n m : Nat} (h : succ n ≤ m) : n ≤ m 
Arguments: {n m : Nat} (h : n.succ ≤ m)
Goal: n ≤ m
-- Nat.lt_of_succ_lt
theorem lt_of_succ_lt      {n m : Nat} : succ n < m → n < m 
Arguments: {n m : Nat}
Goal: n.succ < m → n < m
-- Nat.le_of_lt
protected theorem le_of_lt {n m : Nat} : n < m → n ≤ m 
Arguments: {n m : Nat}
Goal: n < m → n ≤ m
-- Nat.lt_of_succ_lt_succ
theorem lt_of_succ_lt_succ {n m : Nat} : succ n < succ m → n < m 
Arguments: {n m : Nat}
Goal: n.succ < m.succ → n < m
-- Nat.lt_of_succ_le
theorem lt_of_succ_le {n m : Nat} (h : succ n ≤ m) : n < m 
Arguments: {n m : Nat} (h : n.succ ≤ m)
Goal: n < m
-- Nat.succ_le_of_lt
theorem succ_le_of_lt {n m : Nat} (h : n < m) : succ n ≤ m 
Arguments: {n m : Nat} (h : n < m)
Goal: n.succ ≤ m
-- Nat.eq_zero_or_pos
theorem eq_zero_or_pos : ∀ (n : Nat), n = 0 ∨ n > 0
  
Arguments: (n : Nat)
Goal: n = 0 ∨ n > 0
-- Nat.pos_of_ne_zero
protected theorem pos_of_ne_zero {n : Nat} : n ≠ 0 → 0 < n 
Arguments: {n : Nat}
Goal: n ≠ 0 → 0 < n
-- Nat.lt.base
theorem lt.base (n : Nat) : n < succ n 
Arguments: (n : Nat)
Goal: n < n.succ
-- Nat.lt_succ_self
@[simp] theorem lt_succ_self (n : Nat) : n < succ n 
Arguments: (n : Nat)
Goal: n < n.succ
-- Nat.lt_add_one
@[simp] protected theorem lt_add_one (n : Nat) : n < n + 1 
Arguments: (n : Nat)
Goal: n < n + 1
-- Nat.le_total
protected theorem le_total (m n : Nat) : m ≤ n ∨ n ≤ m 
Arguments: (m n : Nat)
Goal: m ≤ n ∨ n ≤ m
-- Nat.eq_zero_of_le_zero
theorem eq_zero_of_le_zero {n : Nat} (h : n ≤ 0) : n = 0 
Arguments: {n : Nat} (h : n ≤ 0)
Goal: n = 0
-- Nat.zero_lt_of_lt
theorem zero_lt_of_lt : {a b : Nat} → a < b → 0 < b
  
Arguments: {a b : Nat}
Goal: a < b → 0 < b
-- Nat.zero_lt_of_ne_zero
theorem zero_lt_of_ne_zero {a : Nat} (h : a ≠ 0) : 0 < a 
Arguments: {a : Nat} (h : a ≠ 0)
Goal: 0 < a
-- Nat.ne_of_lt
theorem ne_of_lt {a b : Nat} (h : a < b) : a ≠ b 
Arguments: {a b : Nat} (h : a < b)
Goal: a ≠ b
-- Nat.le_or_eq_of_le_succ
theorem le_or_eq_of_le_succ {m n : Nat} (h : m ≤ succ n) : m ≤ n ∨ m = succ n 
Arguments: {m n : Nat} (h : m ≤ n.succ)
Goal: m ≤ n ∨ m = n.succ
-- Nat.le_or_eq_of_le_add_one
theorem le_or_eq_of_le_add_one {m n : Nat} (h : m ≤ n + 1) : m ≤ n ∨ m = n + 1 
Arguments: {m n : Nat} (h : m ≤ n + 1)
Goal: m ≤ n ∨ m = n + 1
-- Nat.le_add_right
theorem le_add_right : ∀ (n k : Nat), n ≤ n + k
  
Arguments: (n k : Nat)
Goal: n ≤ n + k
-- Nat.le_add_left
theorem le_add_left (n m : Nat): n ≤ m + n 
Arguments: (n m : Nat)
Goal: n ≤ m + n
-- Nat.le_of_add_right_le
theorem le_of_add_right_le {n m k : Nat} (h : n + k ≤ m) : n ≤ m 
Arguments: {n m k : Nat} (h : n + k ≤ m)
Goal: n ≤ m
-- Nat.le_add_right_of_le
theorem le_add_right_of_le {n m k : Nat} (h : n ≤ m) : n ≤ m + k 
Arguments: {n m k : Nat} (h : n ≤ m)
Goal: n ≤ m + k
-- Nat.lt_of_add_one_le
theorem lt_of_add_one_le {n m : Nat} (h : n + 1 ≤ m) : n < m 
Arguments: {n m : Nat} (h : n + 1 ≤ m)
Goal: n < m
-- Nat.add_one_le_of_lt
theorem add_one_le_of_lt {n m : Nat} (h : n < m) : n + 1 ≤ m 
Arguments: {n m : Nat} (h : n < m)
Goal: n + 1 ≤ m
-- Nat.lt_add_left
protected theorem lt_add_left (c : Nat) (h : a < b) : a < c + b 
Arguments: {a b : Nat} (c : Nat) (h : a < b)
Goal: a < c + b
-- Nat.lt_add_right
protected theorem lt_add_right (c : Nat) (h : a < b) : a < b + c 
Arguments: {a b : Nat} (c : Nat) (h : a < b)
Goal: a < b + c
-- Nat.lt_of_add_right_lt
theorem lt_of_add_right_lt {n m k : Nat} (h : n + k < m) : n < m 
Arguments: {n m k : Nat} (h : n + k < m)
Goal: n < m
-- Nat.le.dest
theorem le.dest : ∀ {n m : Nat}, n ≤ m → Exists (fun k => n + k = m)
  
Arguments: {n m : Nat}
Goal: n ≤ m → Exists fun k => n + k = m
-- Nat.le.intro
theorem le.intro {n m k : Nat} (h : n + k = m) : n ≤ m 
Arguments: {n m k : Nat} (h : n + k = m)
Goal: n ≤ m
-- Nat.not_le_of_gt
protected theorem not_le_of_gt {n m : Nat} (h : n > m) : ¬ n ≤ m 
Arguments: {n m : Nat} (h : n > m)
Goal: ¬n ≤ m
-- Nat.not_le_of_lt
protected theorem not_le_of_lt : ∀{a b : Nat}, a < b → ¬(b ≤ a) 
Arguments: {a b : Nat}
Goal: a < b → ¬b ≤ a
-- Nat.not_lt_of_ge
protected theorem not_lt_of_ge : ∀{a b : Nat}, b ≥ a → ¬(b < a) 
Arguments: {a b : Nat}
Goal: b ≥ a → ¬b < a
-- Nat.not_lt_of_le
protected theorem not_lt_of_le : ∀{a b : Nat}, a ≤ b → ¬(b < a) 
Arguments: {a b : Nat}
Goal: a ≤ b → ¬b < a
-- Nat.lt_le_asymm
protected theorem lt_le_asymm : ∀{a b : Nat}, a < b → ¬(b ≤ a) 
Arguments: {a b : Nat}
Goal: a < b → ¬b ≤ a
-- Nat.le_lt_asymm
protected theorem le_lt_asymm : ∀{a b : Nat}, a ≤ b → ¬(b < a) 
Arguments: {a b : Nat}
Goal: a ≤ b → ¬b < a
-- Nat.gt_of_not_le
theorem gt_of_not_le {n m : Nat} (h : ¬ n ≤ m) : n > m 
Arguments: {n m : Nat} (h : ¬n ≤ m)
Goal: n > m
-- Nat.lt_of_not_ge
protected theorem lt_of_not_ge : ∀{a b : Nat}, ¬(b ≥ a) → b < a 
Arguments: {a b : Nat}
Goal: ¬b ≥ a → b < a
-- Nat.lt_of_not_le
protected theorem lt_of_not_le : ∀{a b : Nat}, ¬(a ≤ b) → b < a 
Arguments: {a b : Nat}
Goal: ¬a ≤ b → b < a
-- Nat.ge_of_not_lt
theorem ge_of_not_lt {n m : Nat} (h : ¬ n < m) : n ≥ m 
Arguments: {n m : Nat} (h : ¬n < m)
Goal: n ≥ m
-- Nat.le_of_not_gt
protected theorem le_of_not_gt : ∀{a b : Nat}, ¬(b > a) → b ≤ a 
Arguments: {a b : Nat}
Goal: ¬b > a → b ≤ a
-- Nat.le_of_not_lt
protected theorem le_of_not_lt : ∀{a b : Nat}, ¬(a < b) → b ≤ a 
Arguments: {a b : Nat}
Goal: ¬a < b → b ≤ a
-- Nat.ne_of_gt
theorem ne_of_gt {a b : Nat} (h : b < a) : a ≠ b 
Arguments: {a b : Nat} (h : b < a)
Goal: a ≠ b
-- Nat.ne_of_lt'
protected theorem ne_of_lt' : ∀{a b : Nat}, a < b → b ≠ a 
Arguments: {a b : Nat}
Goal: a < b → b ≠ a
-- Nat.not_le
@[simp] protected theorem not_le {a b : Nat} : ¬ a ≤ b ↔ b < a 
Arguments: {a b : Nat}
Goal: ¬a ≤ b ↔ b < a
-- Nat.not_lt
@[simp] protected theorem not_lt {a b : Nat} : ¬ a < b ↔ b ≤ a 
Arguments: {a b : Nat}
Goal: ¬a < b ↔ b ≤ a
-- Nat.le_of_not_le
protected theorem le_of_not_le {a b : Nat} (h : ¬ b ≤ a) : a ≤ b 
Arguments: {a b : Nat} (h : ¬b ≤ a)
Goal: a ≤ b
-- Nat.le_of_not_ge
protected theorem le_of_not_ge : ∀{a b : Nat}, ¬(a ≥ b) → a ≤ b
Arguments: {a b : Nat}
Goal: ¬a ≥ b → a ≤ b
-- Nat.lt_trichotomy
protected theorem lt_trichotomy (a b : Nat) : a < b ∨ a = b ∨ b < a 
Arguments: (a b : Nat)
Goal: a < b ∨ a = b ∨ b < a
-- Nat.lt_or_gt_of_ne
protected theorem lt_or_gt_of_ne {a b : Nat} (ne : a ≠ b) : a < b ∨ a > b 
Arguments: {a b : Nat} (ne : a ≠ b)
Goal: a < b ∨ a > b
-- Nat.lt_or_lt_of_ne
protected theorem lt_or_lt_of_ne : ∀{a b : Nat}, a ≠ b → a < b ∨ b < a 
Arguments: {a b : Nat}
Goal: a ≠ b → a < b ∨ b < a
-- Nat.le_antisymm_iff
protected theorem le_antisymm_iff {a b : Nat} : a = b ↔ a ≤ b ∧ b ≤ a 
Arguments: {a b : Nat}
Goal: a = b ↔ a ≤ b ∧ b ≤ a
-- Nat.eq_iff_le_and_ge
protected theorem eq_iff_le_and_ge : ∀{a b : Nat}, a = b ↔ a ≤ b ∧ b ≤ a 
Arguments: {a b : Nat}
Goal: a = b ↔ a ≤ b ∧ b ≤ a
-- Nat.add_le_add_left
protected theorem add_le_add_left {n m : Nat} (h : n ≤ m) (k : Nat) : k + n ≤ k + m 
Arguments: {n m : Nat} (h : n ≤ m) (k : Nat)
Goal: k + n ≤ k + m
-- Nat.add_le_add_right
protected theorem add_le_add_right {n m : Nat} (h : n ≤ m) (k : Nat) : n + k ≤ m + k 
Arguments: {n m : Nat} (h : n ≤ m) (k : Nat)
Goal: n + k ≤ m + k
-- Nat.add_lt_add_left
protected theorem add_lt_add_left {n m : Nat} (h : n < m) (k : Nat) : k + n < k + m 
Arguments: {n m : Nat} (h : n < m) (k : Nat)
Goal: k + n < k + m
-- Nat.add_lt_add_right
protected theorem add_lt_add_right {n m : Nat} (h : n < m) (k : Nat) : n + k < m + k 
Arguments: {n m : Nat} (h : n < m) (k : Nat)
Goal: n + k < m + k
-- Nat.lt_add_of_pos_right
protected theorem lt_add_of_pos_right (h : 0 < k) : n < n + k 
Arguments: {k n : Nat} (h : 0 < k)
Goal: n < n + k
-- Nat.zero_lt_one
protected theorem zero_lt_one : 0 < (1:Nat) 
Goal: 0 < 1
-- Nat.pos_iff_ne_zero
protected theorem pos_iff_ne_zero : 0 < n ↔ n ≠ 0 
Arguments: {n : Nat}
Goal: 0 < n ↔ n ≠ 0
-- Nat.add_le_add
theorem add_le_add {a b c d : Nat} (h₁ : a ≤ b) (h₂ : c ≤ d) : a + c ≤ b + d 
Arguments: {a b c d : Nat} (h₁ : a ≤ b) (h₂ : c ≤ d)
Goal: a + c ≤ b + d
-- Nat.add_lt_add
theorem add_lt_add {a b c d : Nat} (h₁ : a < b) (h₂ : c < d) : a + c < b + d 
Arguments: {a b c d : Nat} (h₁ : a < b) (h₂ : c < d)
Goal: a + c < b + d
-- Nat.le_of_add_le_add_left
protected theorem le_of_add_le_add_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.le_of_add_le_add_right
protected theorem le_of_add_le_add_right {a b c : Nat} : a + b ≤ c + b → a ≤ c 
Arguments: {a b c : Nat}
Goal: a + b ≤ c + b → a ≤ c
-- Nat.add_le_add_iff_right
protected theorem add_le_add_iff_right {n : Nat} : m + n ≤ k + n ↔ m ≤ k 
Arguments: {m k n : Nat}
Goal: m + n ≤ k + n ↔ m ≤ k
-- Nat.lt_asymm
protected theorem lt_asymm {a b : Nat} (h : a < b) : ¬ b < a 
Arguments: {a b : Nat} (h : a < b)
Goal: ¬b < a
-- Nat.lt_iff_le_not_le
protected theorem lt_iff_le_not_le {m n : Nat} : m < n ↔ m ≤ n ∧ ¬ n ≤ m 
Arguments: {m n : Nat}
Goal: m < n ↔ m ≤ n ∧ ¬n ≤ m
-- Nat.lt_iff_le_and_ne
protected theorem lt_iff_le_and_ne {m n : Nat} : m < n ↔ m ≤ n ∧ m ≠ n 
Arguments: {m n : Nat}
Goal: m < n ↔ m ≤ n ∧ m ≠ n
-- Nat.ne_iff_lt_or_gt
protected theorem ne_iff_lt_or_gt {a b : Nat} : a ≠ b ↔ a < b ∨ b < a 
Arguments: {a b : Nat}
Goal: a ≠ b ↔ a < b ∨ b < a
-- Nat.eq_or_lt_of_not_lt
protected theorem eq_or_lt_of_not_lt {a b : Nat} (hnlt : ¬ a < b) : a = b ∨ b < a 
Arguments: {a b : Nat} (hnlt : ¬a < b)
Goal: a = b ∨ b < a
-- Nat.lt_or_eq_of_le
protected theorem lt_or_eq_of_le {n m : Nat} (h : n ≤ m) : n < m ∨ n = m 
Arguments: {n m : Nat} (h : n ≤ m)
Goal: n < m ∨ n = m
-- Nat.le_iff_lt_or_eq
protected theorem le_iff_lt_or_eq {n m : Nat} : n ≤ m ↔ n < m ∨ n = m 
Arguments: {n m : Nat}
Goal: n ≤ m ↔ n < m ∨ n = m
-- Nat.lt_succ_iff
protected theorem lt_succ_iff : m < succ n ↔ m ≤ n 
Arguments: {m n : Nat}
Goal: m < n.succ ↔ m ≤ n
-- Nat.lt_add_one_iff
protected theorem lt_add_one_iff : m < n + 1 ↔ m ≤ n 
Arguments: {m n : Nat}
Goal: m < n + 1 ↔ m ≤ n
-- Nat.lt_succ_iff_lt_or_eq
protected theorem lt_succ_iff_lt_or_eq : m < succ n ↔ m < n ∨ m = n 
Arguments: {m n : Nat}
Goal: m < n.succ ↔ m < n ∨ m = n
-- Nat.lt_add_one_iff_lt_or_eq
protected theorem lt_add_one_iff_lt_or_eq : m < n + 1 ↔ m < n ∨ m = n 
Arguments: {m n : Nat}
Goal: m < n + 1 ↔ m < n ∨ m = n
-- Nat.eq_of_lt_succ_of_not_lt
protected theorem eq_of_lt_succ_of_not_lt (hmn : m < n + 1) (h : ¬ m < n) : m = n 
Arguments: {m n : Nat} (hmn : m < n + 1) (h : ¬m < n)
Goal: m = n
-- Nat.eq_of_le_of_lt_succ
protected theorem eq_of_le_of_lt_succ (h₁ : n ≤ m) (h₂ : m < n + 1) : m = n 
Arguments: {n m : Nat} (h₁ : n ≤ m) (h₂ : m < n + 1)
Goal: m = n
-- Nat.le_zero
theorem le_zero : i ≤ 0 ↔ i = 0 
Arguments: {i : Nat}
Goal: i ≤ 0 ↔ i = 0
-- Nat.two_pos
protected theorem two_pos : 0 < 2 
Goal: 0 < 2
-- Nat.ne_zero_iff_zero_lt
protected theorem ne_zero_iff_zero_lt : n ≠ 0 ↔ 0 < n 
Arguments: {n : Nat}
Goal: n ≠ 0 ↔ 0 < n
-- Nat.zero_lt_two
protected theorem zero_lt_two : 0 < 2 
Goal: 0 < 2
-- Nat.one_lt_two
protected theorem one_lt_two : 1 < 2 
Goal: 1 < 2
-- Nat.eq_zero_of_not_pos
protected theorem eq_zero_of_not_pos (h : ¬0 < n) : n = 0 
Arguments: {n : Nat} (h : ¬0 < n)
Goal: n = 0
-- Nat.succ_ne_self
theorem succ_ne_self (n) : succ n ≠ n 
Arguments: (n : Nat)
Goal: n.succ ≠ n
-- Nat.add_one_ne_self
theorem add_one_ne_self (n) : n + 1 ≠ n 
Arguments: (n : Nat)
Goal: n + 1 ≠ n
-- Nat.succ_le
theorem succ_le : succ n ≤ m ↔ n < m 
Arguments: {n m : Nat}
Goal: n.succ ≤ m ↔ n < m
-- Nat.add_one_le_iff
theorem add_one_le_iff : n + 1 ≤ m ↔ n < m 
Arguments: {n m : Nat}
Goal: n + 1 ≤ m ↔ n < m
-- Nat.lt_succ
theorem lt_succ : m < succ n ↔ m ≤ n 
Arguments: {m n : Nat}
Goal: m < n.succ ↔ m ≤ n
-- Nat.lt_succ_of_lt
theorem lt_succ_of_lt (h : a < b) : a < succ b 
Arguments: {a b : Nat} (h : a < b)
Goal: a < b.succ
-- Nat.lt_add_one_of_lt
theorem lt_add_one_of_lt (h : a < b) : a < b + 1 
Arguments: {a b : Nat} (h : a < b)
Goal: a < b + 1
-- Nat.succ_pred_eq_of_ne_zero
theorem succ_pred_eq_of_ne_zero : ∀ {n}, n ≠ 0 → succ (pred n) = n
  
Arguments: {n : Nat}
Goal: n ≠ 0 → n.pred.succ = n
-- Nat.eq_zero_or_eq_succ_pred
theorem eq_zero_or_eq_succ_pred : ∀ n, n = 0 ∨ n = succ (pred n)
  
Arguments: (n : Nat)
Goal: n = 0 ∨ n = n.pred.succ
-- Nat.succ_inj'
theorem succ_inj' : succ a = succ b ↔ a = b 
Arguments: {a b : Nat}
Goal: a.succ = b.succ ↔ a = b
-- Nat.succ_le_succ_iff
theorem succ_le_succ_iff : succ a ≤ succ b ↔ a ≤ b 
Arguments: {a b : Nat}
Goal: a.succ ≤ b.succ ↔ a ≤ b
-- Nat.succ_lt_succ_iff
theorem succ_lt_succ_iff : succ a < succ b ↔ a < b 
Arguments: {a b : Nat}
Goal: a.succ < b.succ ↔ a < b
-- Nat.add_one_inj
theorem add_one_inj : a + 1 = b + 1 ↔ a = b 
Arguments: {a b : Nat}
Goal: a + 1 = b + 1 ↔ a = b
-- Nat.add_one_le_add_one_iff
theorem add_one_le_add_one_iff : a + 1 ≤ b + 1 ↔ a ≤ b 
Arguments: {a b : Nat}
Goal: a + 1 ≤ b + 1 ↔ a ≤ b
-- Nat.add_one_lt_add_one_iff
theorem add_one_lt_add_one_iff : a + 1 < b + 1 ↔ a < b 
Arguments: {a b : Nat}
Goal: a + 1 < b + 1 ↔ a < b
-- Nat.pred_inj
theorem pred_inj : ∀ {a b}, 0 < a → 0 < b → pred a = pred b → a = b
  
Arguments: {a b : Nat}
Goal: 0 < a → 0 < b → a.pred = b.pred → a = b
-- Nat.pred_ne_self
theorem pred_ne_self : ∀ {a}, a ≠ 0 → pred a ≠ a
  
Arguments: {a : Nat}
Goal: a ≠ 0 → a.pred ≠ a
-- Nat.sub_one_ne_self
theorem sub_one_ne_self : ∀ {a}, a ≠ 0 → a - 1 ≠ a
  
Arguments: {a : Nat}
Goal: a ≠ 0 → a - 1 ≠ a
-- Nat.pred_lt_self
theorem pred_lt_self : ∀ {a}, 0 < a → pred a < a
  
Arguments: {a : Nat}
Goal: 0 < a → a.pred < a
-- Nat.pred_lt_pred
theorem pred_lt_pred : ∀ {n m}, n ≠ 0 → n < m → pred n < pred m
  
Arguments: {n m : Nat}
Goal: n ≠ 0 → n < m → n.pred < m.pred
-- Nat.pred_le_iff_le_succ
theorem pred_le_iff_le_succ : ∀ {n m}, pred n ≤ m ↔ n ≤ succ m
  
Arguments: {n : Nat} {m : Nat}
Goal: n.pred ≤ m ↔ n ≤ m.succ
-- Nat.le_succ_of_pred_le
theorem le_succ_of_pred_le : pred n ≤ m → n ≤ succ m 
Arguments: {n : Nat} {m : Nat}
Goal: n.pred ≤ m → n ≤ m.succ
-- Nat.pred_le_of_le_succ
theorem pred_le_of_le_succ : n ≤ succ m → pred n ≤ m 
Arguments: {n m : Nat}
Goal: n ≤ m.succ → n.pred ≤ m
-- Nat.lt_pred_iff_succ_lt
theorem lt_pred_iff_succ_lt : ∀ {n m}, n < pred m ↔ succ n < m
  
Arguments: {n : Nat} {m : Nat}
Goal: n < m.pred ↔ n.succ < m
-- Nat.succ_lt_of_lt_pred
theorem succ_lt_of_lt_pred : n < pred m → succ n < m 
Arguments: {n : Nat} {m : Nat}
Goal: n < m.pred → n.succ < m
-- Nat.lt_pred_of_succ_lt
theorem lt_pred_of_succ_lt : succ n < m → n < pred m 
Arguments: {n m : Nat}
Goal: n.succ < m → n < m.pred
-- Nat.le_pred_iff_lt
theorem le_pred_iff_lt : ∀ {n m}, 0 < m → (n ≤ pred m ↔ n < m)
  
Arguments: {n : Nat} {m : Nat}
Goal: 0 < m → (n ≤ m.pred ↔ n < m)
-- Nat.le_pred_of_lt
theorem le_pred_of_lt (h : n < m) : n ≤ pred m 
Arguments: {n m : Nat} (h : n < m)
Goal: n ≤ m.pred
-- Nat.le_sub_one_of_lt
theorem le_sub_one_of_lt : a < b → a ≤ b - 1 
Arguments: {a b : Nat}
Goal: a < b → a ≤ b - 1
-- Nat.lt_of_le_pred
theorem lt_of_le_pred (h : 0 < m) : n ≤ pred m → n < m 
Arguments: {m : Nat} {n : Nat} (h : 0 < m)
Goal: n ≤ m.pred → n < m
-- Nat.lt_of_le_sub_one
theorem lt_of_le_sub_one (h : 0 < m) : n ≤ m - 1 → n < m 
Arguments: {m n : Nat} (h : 0 < m)
Goal: n ≤ m - 1 → n < m