ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Int.neg_nonneg_of_nonpos
protected theorem neg_nonneg_of_nonpos {a : Int} (h : a ≤ 0) : 0 ≤ -a 
Arguments: {a : Int} (h : a ≤ 0)
Goal: 0 ≤ -a
-- Int.neg_lt_neg
protected theorem neg_lt_neg {a b : Int} (h : a < b) : -b < -a 
Arguments: {a b : Int} (h : a < b)
Goal: -b < -a
-- Int.neg_neg_of_pos
protected theorem neg_neg_of_pos {a : Int} (h : 0 < a) : -a < 0 
Arguments: {a : Int} (h : 0 < a)
Goal: -a < 0
-- Int.neg_pos_of_neg
protected theorem neg_pos_of_neg {a : Int} (h : a < 0) : 0 < -a 
Arguments: {a : Int} (h : a < 0)
Goal: 0 < -a
-- Int.sub_nonneg_of_le
protected theorem sub_nonneg_of_le {a b : Int} (h : b ≤ a) : 0 ≤ a - b 
Arguments: {a b : Int} (h : b ≤ a)
Goal: 0 ≤ a - b
-- Int.le_of_sub_nonneg
protected theorem le_of_sub_nonneg {a b : Int} (h : 0 ≤ a - b) : b ≤ a 
Arguments: {a b : Int} (h : 0 ≤ a - b)
Goal: b ≤ a
-- Int.sub_pos_of_lt
protected theorem sub_pos_of_lt {a b : Int} (h : b < a) : 0 < a - b 
Arguments: {a b : Int} (h : b < a)
Goal: 0 < a - b
-- Int.lt_of_sub_pos
protected theorem lt_of_sub_pos {a b : Int} (h : 0 < a - b) : b < a 
Arguments: {a b : Int} (h : 0 < a - b)
Goal: b < a
-- Int.sub_left_le_of_le_add
protected theorem sub_left_le_of_le_add {a b c : Int} (h : a ≤ b + c) : a - b ≤ c 
Arguments: {a b c : Int} (h : a ≤ b + c)
Goal: a - b ≤ c
-- Int.sub_le_self
protected theorem sub_le_self (a : Int) {b : Int} (h : 0 ≤ b) : a - b ≤ a 
Arguments: (a : Int) {b : Int} (h : 0 ≤ b)
Goal: a - b ≤ a
-- Int.sub_lt_self
protected theorem sub_lt_self (a : Int) {b : Int} (h : 0 < b) : a - b < a 
Arguments: (a : Int) {b : Int} (h : 0 < b)
Goal: a - b < a
-- Int.add_one_le_of_lt
theorem add_one_le_of_lt {a b : Int} (H : a < b) : a + 1 ≤ b 
Arguments: {a b : Int} (H : a < b)
Goal: a + 1 ≤ b
-- Int.mul_nonneg
protected theorem mul_nonneg {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b 
Arguments: {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b)
Goal: 0 ≤ a * b
-- Int.mul_pos
protected theorem mul_pos {a b : Int} (ha : 0 < a) (hb : 0 < b) : 0 < a * b 
Arguments: {a b : Int} (ha : 0 < a) (hb : 0 < b)
Goal: 0 < a * b
-- Int.mul_lt_mul_of_pos_left
protected theorem mul_lt_mul_of_pos_left {a b c : Int}
  (h₁ : a < b) (h₂ : 0 < c) : c * a < c * b 
Arguments: {a b c : Int} (h₁ : a < b) (h₂ : 0 < c)
Goal: c * a < c * b
-- Int.mul_lt_mul_of_pos_right
protected theorem mul_lt_mul_of_pos_right {a b c : Int}
  (h₁ : a < b) (h₂ : 0 < c) : a * c < b * c 
Arguments: {a b c : Int} (h₁ : a < b) (h₂ : 0 < c)
Goal: a * c < b * c
-- Int.mul_le_mul_of_nonneg_left
protected theorem mul_le_mul_of_nonneg_left {a b c : Int}
    (h₁ : a ≤ b) (h₂ : 0 ≤ c) : c * a ≤ c * b 
Arguments: {a b c : Int} (h₁ : a ≤ b) (h₂ : 0 ≤ c)
Goal: c * a ≤ c * b
-- Int.mul_le_mul_of_nonneg_right
protected theorem mul_le_mul_of_nonneg_right {a b c : Int}
    (h₁ : a ≤ b) (h₂ : 0 ≤ c) : a * c ≤ b * c 
Arguments: {a b c : Int} (h₁ : a ≤ b) (h₂ : 0 ≤ c)
Goal: a * c ≤ b * c
-- Int.mul_le_mul
protected theorem mul_le_mul {a b c d : Int}
    (hac : a ≤ c) (hbd : b ≤ d) (nn_b : 0 ≤ b) (nn_c : 0 ≤ c) : a * b ≤ c * d 
Arguments: {a b c d : Int} (hac : a ≤ c) (hbd : b ≤ d) (nn_b : 0 ≤ b) (nn_c : 0 ≤ c)
Goal: a * b ≤ c * d
-- Int.mul_nonpos_of_nonneg_of_nonpos
protected theorem mul_nonpos_of_nonneg_of_nonpos {a b : Int}
  (ha : 0 ≤ a) (hb : b ≤ 0) : a * b ≤ 0 
Arguments: {a b : Int} (ha : 0 ≤ a) (hb : b ≤ 0)
Goal: a * b ≤ 0
-- Int.mul_nonpos_of_nonpos_of_nonneg
protected theorem mul_nonpos_of_nonpos_of_nonneg {a b : Int}
  (ha : a ≤ 0) (hb : 0 ≤ b) : a * b ≤ 0 
Arguments: {a b : Int} (ha : a ≤ 0) (hb : 0 ≤ b)
Goal: a * b ≤ 0
-- Int.mul_le_mul_of_nonpos_right
protected theorem mul_le_mul_of_nonpos_right {a b c : Int}
    (h : b ≤ a) (hc : c ≤ 0) : a * c ≤ b * c 
Arguments: {a b c : Int} (h : b ≤ a) (hc : c ≤ 0)
Goal: a * c ≤ b * c
-- Int.mul_le_mul_of_nonpos_left
protected theorem mul_le_mul_of_nonpos_left {a b c : Int}
    (ha : a ≤ 0) (h : c ≤ b) : a * b ≤ a * c 
Arguments: {a b c : Int} (ha : a ≤ 0) (h : c ≤ b)
Goal: a * b ≤ a * c
-- Int.natAbs_ofNat
@[simp] theorem natAbs_ofNat (n : Nat) : natAbs ↑n = n 
Arguments: (n : Nat)
Goal: (↑n).natAbs = n
-- Int.natAbs_negSucc
@[simp] theorem natAbs_negSucc (n : Nat) : natAbs -[n+1] = n.succ 
Arguments: (n : Nat)
Goal: (Int.negSucc n).natAbs = n.succ
-- Int.natAbs_zero
@[simp] theorem natAbs_zero : natAbs (0 : Int) = (0 : Nat) 
Goal: Int.natAbs 0 = 0
-- Int.natAbs_one
@[simp] theorem natAbs_one : natAbs (1 : Int) = (1 : Nat) 
Goal: Int.natAbs 1 = 1
-- Int.natAbs_eq_zero
@[simp] theorem natAbs_eq_zero : natAbs a = 0 ↔ a = 0 
Arguments: {a : Int}
Goal: a.natAbs = 0 ↔ a = 0
-- Int.natAbs_pos
theorem natAbs_pos : 0 < natAbs a ↔ a ≠ 0 
Arguments: {a : Int}
Goal: 0 < a.natAbs ↔ a ≠ 0
-- Int.natAbs_neg
@[simp] theorem natAbs_neg : ∀ (a : Int), natAbs (-a) = natAbs a
  
Arguments: (a : Int)
Goal: (-a).natAbs = a.natAbs
-- Int.natAbs_eq
theorem natAbs_eq : ∀ (a : Int), a = natAbs a ∨ a = -↑(natAbs a)
  
Arguments: (a : Int)
Goal: a = ↑a.natAbs ∨ a = -↑a.natAbs
-- Int.natAbs_negOfNat
theorem natAbs_negOfNat (n : Nat) : natAbs (negOfNat n) = n 
Arguments: (n : Nat)
Goal: (Int.negOfNat n).natAbs = n
-- Int.natAbs_mul
theorem natAbs_mul (a b : Int) : natAbs (a * b) = natAbs a * natAbs b 
Arguments: (a b : Int)
Goal: (a * b).natAbs = a.natAbs * b.natAbs
-- Int.natAbs_eq_natAbs_iff
theorem natAbs_eq_natAbs_iff {a b : Int} : a.natAbs = b.natAbs ↔ a = b ∨ a = -b 
Arguments: {a b : Int}
Goal: a.natAbs = b.natAbs ↔ a = b ∨ a = -b
-- Int.natAbs_of_nonneg
theorem natAbs_of_nonneg {a : Int} (H : 0 ≤ a) : (natAbs a : Int) = a 
Arguments: {a : Int} (H : 0 ≤ a)
Goal: ↑a.natAbs = a
-- Int.ofNat_natAbs_of_nonpos
theorem ofNat_natAbs_of_nonpos {a : Int} (H : a ≤ 0) : (natAbs a : Int) = -a 
Arguments: {a : Int} (H : a ≤ 0)
Goal: ↑a.natAbs = -a
-- Int.toNat_eq_max
theorem toNat_eq_max : ∀ a : Int, (toNat a : Int) = max a 0
  
Arguments: (a : Int)
Goal: ↑a.toNat = max a 0
-- Int.toNat_zero
@[simp] theorem toNat_zero : (0 : Int).toNat = 0 
Goal: Int.toNat 0 = 0
-- Int.toNat_one
@[simp] theorem toNat_one : (1 : Int).toNat = 1 
Goal: Int.toNat 1 = 1
-- Int.toNat_of_nonneg
@[simp] theorem toNat_of_nonneg {a : Int} (h : 0 ≤ a) : (toNat a : Int) = a 
Arguments: {a : Int} (h : 0 ≤ a)
Goal: ↑a.toNat = a
-- Int.toNat_ofNat
@[simp] theorem toNat_ofNat (n : Nat) : toNat ↑n = n 
Arguments: (n : Nat)
Goal: (↑n).toNat = n
-- Int.toNat_ofNat_add_one
@[simp] theorem toNat_ofNat_add_one {n : Nat} : ((n : Int) + 1).toNat = n + 1 
Arguments: {n : Nat}
Goal: (↑n + 1).toNat = n + 1
-- Int.self_le_toNat
theorem self_le_toNat (a : Int) : a ≤ toNat a 
Arguments: (a : Int)
Goal: a ≤ ↑a.toNat
-- Int.le_toNat
@[simp] theorem le_toNat {n : Nat} {z : Int} (h : 0 ≤ z) : n ≤ z.toNat ↔ (n : Int) ≤ z 
Arguments: {n : Nat} {z : Int} (h : 0 ≤ z)
Goal: n ≤ z.toNat ↔ ↑n ≤ z
-- Int.toNat_lt
@[simp] theorem toNat_lt {n : Nat} {z : Int} (h : 0 ≤ z) : z.toNat < n ↔ z < (n : Int) 
Arguments: {n : Nat} {z : Int} (h : 0 ≤ z)
Goal: z.toNat < n ↔ z < ↑n
-- Int.toNat_add
theorem toNat_add {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : (a + b).toNat = a.toNat + b.toNat 
Arguments: {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b)
Goal: (a + b).toNat = a.toNat + b.toNat
-- Int.toNat_add_nat
theorem toNat_add_nat {a : Int} (ha : 0 ≤ a) (n : Nat) : (a + n).toNat = a.toNat + n 
Arguments: {a : Int} (ha : 0 ≤ a) (n : Nat)
Goal: (a + ↑n).toNat = a.toNat + n
-- Int.pred_toNat
@[simp] theorem pred_toNat : ∀ i : Int, (i - 1).toNat = i.toNat - 1
  
Arguments: (i : Int)
Goal: (i - 1).toNat = i.toNat - 1
-- Int.toNat_sub_toNat_neg
@[simp] theorem toNat_sub_toNat_neg : ∀ n : Int, ↑n.toNat - ↑(-n).toNat = n
  
Arguments: (n : Int)
Goal: ↑n.toNat - ↑(-n).toNat = n
-- Int.toNat_add_toNat_neg_eq_natAbs
@[simp] theorem toNat_add_toNat_neg_eq_natAbs : ∀ n : Int, n.toNat + (-n).toNat = n.natAbs
  
Arguments: (n : Int)
Goal: n.toNat + (-n).toNat = n.natAbs
-- Int.toNat_neg_nat
@[simp] theorem toNat_neg_nat : ∀ n : Nat, (-(n : Int)).toNat = 0
  
Arguments: (n : Nat)
Goal: (-↑n).toNat = 0
-- Int.mem_toNat'
theorem mem_toNat' : ∀ (a : Int) (n : Nat), toNat' a = some n ↔ a = n
  
Arguments: (a : Int) (n : Nat)
Goal: a.toNat' = some n ↔ a = ↑n
-- Int.le_of_not_le
protected theorem le_of_not_le {a b : Int} : ¬ a ≤ b → b ≤ a 
Arguments: {a b : Int}
Goal: ¬a ≤ b → b ≤ a
-- Int.negSucc_not_pos
@[simp] theorem negSucc_not_pos (n : Nat) : 0 < -[n+1] ↔ False 
Arguments: (n : Nat)
Goal: 0 < Int.negSucc n ↔ False
-- Int.eq_negSucc_of_lt_zero
theorem eq_negSucc_of_lt_zero : ∀ {a : Int}, a < 0 → ∃ n : Nat, a = -[n+1]
  
Arguments: {a : Int}
Goal: a < 0 → ∃ n, a = Int.negSucc n
-- Int.lt_of_add_lt_add_left
protected theorem lt_of_add_lt_add_left {a b c : Int} (h : a + b < a + c) : b < c 
Arguments: {a b c : Int} (h : a + b < a + c)
Goal: b < c
-- Int.lt_of_add_lt_add_right
protected theorem lt_of_add_lt_add_right {a b c : Int} (h : a + b < c + b) : a < c 
Arguments: {a b c : Int} (h : a + b < c + b)
Goal: a < c
-- Int.add_lt_add_iff_left
protected theorem add_lt_add_iff_left (a : Int) : a + b < a + c ↔ b < c 
Arguments: {b c : Int} (a : Int)
Goal: a + b < a + c ↔ b < c
-- Int.add_lt_add_iff_right
protected theorem add_lt_add_iff_right (c : Int) : a + c < b + c ↔ a < b 
Arguments: {a b : Int} (c : Int)
Goal: a + c < b + c ↔ a < b
-- Int.add_lt_add
protected theorem add_lt_add {a b c d : Int} (h₁ : a < b) (h₂ : c < d) : a + c < b + d 
Arguments: {a b c d : Int} (h₁ : a < b) (h₂ : c < d)
Goal: a + c < b + d
-- Int.add_lt_add_of_le_of_lt
protected theorem add_lt_add_of_le_of_lt {a b c d : Int} (h₁ : a ≤ b) (h₂ : c < d) :
    a + c < b + d 
Arguments: {a b c d : Int} (h₁ : a ≤ b) (h₂ : c < d)
Goal: a + c < b + d
-- Int.add_lt_add_of_lt_of_le
protected theorem add_lt_add_of_lt_of_le {a b c d : Int} (h₁ : a < b) (h₂ : c ≤ d) :
    a + c < b + d 
Arguments: {a b c d : Int} (h₁ : a < b) (h₂ : c ≤ d)
Goal: a + c < b + d
-- Int.lt_add_of_pos_right
protected theorem lt_add_of_pos_right (a : Int) {b : Int} (h : 0 < b) : a < a + b 
Arguments: (a : Int) {b : Int} (h : 0 < b)
Goal: a < a + b
-- Int.lt_add_of_pos_left
protected theorem lt_add_of_pos_left (a : Int) {b : Int} (h : 0 < b) : a < b + a 
Arguments: (a : Int) {b : Int} (h : 0 < b)
Goal: a < b + a
-- Int.add_nonneg
protected theorem add_nonneg {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a + b 
Arguments: {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b)
Goal: 0 ≤ a + b
-- Int.add_pos
protected theorem add_pos {a b : Int} (ha : 0 < a) (hb : 0 < b) : 0 < a + b 
Arguments: {a b : Int} (ha : 0 < a) (hb : 0 < b)
Goal: 0 < a + b
-- Int.add_pos_of_pos_of_nonneg
protected theorem add_pos_of_pos_of_nonneg {a b : Int} (ha : 0 < a) (hb : 0 ≤ b) : 0 < a + b 
Arguments: {a b : Int} (ha : 0 < a) (hb : 0 ≤ b)
Goal: 0 < a + b
-- Int.add_pos_of_nonneg_of_pos
protected theorem add_pos_of_nonneg_of_pos {a b : Int} (ha : 0 ≤ a) (hb : 0 < b) : 0 < a + b 
Arguments: {a b : Int} (ha : 0 ≤ a) (hb : 0 < b)
Goal: 0 < a + b
-- Int.add_nonpos
protected theorem add_nonpos {a b : Int} (ha : a ≤ 0) (hb : b ≤ 0) : a + b ≤ 0 
Arguments: {a b : Int} (ha : a ≤ 0) (hb : b ≤ 0)
Goal: a + b ≤ 0
-- Int.add_neg
protected theorem add_neg {a b : Int} (ha : a < 0) (hb : b < 0) : a + b < 0 
Arguments: {a b : Int} (ha : a < 0) (hb : b < 0)
Goal: a + b < 0
-- Int.add_neg_of_neg_of_nonpos
protected theorem add_neg_of_neg_of_nonpos {a b : Int} (ha : a < 0) (hb : b ≤ 0) : a + b < 0 
Arguments: {a b : Int} (ha : a < 0) (hb : b ≤ 0)
Goal: a + b < 0
-- Int.add_neg_of_nonpos_of_neg
protected theorem add_neg_of_nonpos_of_neg {a b : Int} (ha : a ≤ 0) (hb : b < 0) : a + b < 0 
Arguments: {a b : Int} (ha : a ≤ 0) (hb : b < 0)
Goal: a + b < 0
-- Int.lt_add_of_le_of_pos
protected theorem lt_add_of_le_of_pos {a b c : Int} (hbc : b ≤ c) (ha : 0 < a) : b < c + a 
Arguments: {a b c : Int} (hbc : b ≤ c) (ha : 0 < a)
Goal: b < c + a
-- Int.add_one_le_iff
theorem add_one_le_iff {a b : Int} : a + 1 ≤ b ↔ a < b 
Arguments: {a b : Int}
Goal: a + 1 ≤ b ↔ a < b
-- Int.lt_add_one_iff
theorem lt_add_one_iff {a b : Int} : a < b + 1 ↔ a ≤ b 
Arguments: {a b : Int}
Goal: a < b + 1 ↔ a ≤ b
-- Int.succ_ofNat_pos
@[simp] theorem succ_ofNat_pos (n : Nat) : 0 < (n : Int) + 1 
Arguments: (n : Nat)
Goal: 0 < ↑n + 1
-- Int.not_ofNat_neg
theorem not_ofNat_neg (n : Nat) : ¬((n : Int) < 0) 
Arguments: (n : Nat)
Goal: ¬↑n < 0
-- Int.le_add_one
theorem le_add_one {a b : Int} (h : a ≤ b) : a ≤ b + 1 
Arguments: {a b : Int} (h : a ≤ b)
Goal: a ≤ b + 1
-- Int.nonneg_of_neg_nonpos
protected theorem nonneg_of_neg_nonpos {a : Int} (h : -a ≤ 0) : 0 ≤ a 
Arguments: {a : Int} (h : -a ≤ 0)
Goal: 0 ≤ a
-- Int.nonpos_of_neg_nonneg
protected theorem nonpos_of_neg_nonneg {a : Int} (h : 0 ≤ -a) : a ≤ 0 
Arguments: {a : Int} (h : 0 ≤ -a)
Goal: a ≤ 0
-- Int.lt_of_neg_lt_neg
protected theorem lt_of_neg_lt_neg {a b : Int} (h : -b < -a) : a < b 
Arguments: {a b : Int} (h : -b < -a)
Goal: a < b
-- Int.pos_of_neg_neg
protected theorem pos_of_neg_neg {a : Int} (h : -a < 0) : 0 < a 
Arguments: {a : Int} (h : -a < 0)
Goal: 0 < a
-- Int.neg_of_neg_pos
protected theorem neg_of_neg_pos {a : Int} (h : 0 < -a) : a < 0 
Arguments: {a : Int} (h : 0 < -a)
Goal: a < 0
-- Int.le_neg_of_le_neg
protected theorem le_neg_of_le_neg {a b : Int} (h : a ≤ -b) : b ≤ -a 
Arguments: {a b : Int} (h : a ≤ -b)
Goal: b ≤ -a
-- Int.neg_le_of_neg_le
protected theorem neg_le_of_neg_le {a b : Int} (h : -a ≤ b) : -b ≤ a 
Arguments: {a b : Int} (h : -a ≤ b)
Goal: -b ≤ a
-- Int.lt_neg_of_lt_neg
protected theorem lt_neg_of_lt_neg {a b : Int} (h : a < -b) : b < -a 
Arguments: {a b : Int} (h : a < -b)
Goal: b < -a
-- Int.neg_lt_of_neg_lt
protected theorem neg_lt_of_neg_lt {a b : Int} (h : -a < b) : -b < a 
Arguments: {a b : Int} (h : -a < b)
Goal: -b < a
-- Int.sub_nonpos_of_le
protected theorem sub_nonpos_of_le {a b : Int} (h : a ≤ b) : a - b ≤ 0 
Arguments: {a b : Int} (h : a ≤ b)
Goal: a - b ≤ 0
-- Int.le_of_sub_nonpos
protected theorem le_of_sub_nonpos {a b : Int} (h : a - b ≤ 0) : a ≤ b 
Arguments: {a b : Int} (h : a - b ≤ 0)
Goal: a ≤ b
-- Int.sub_neg_of_lt
protected theorem sub_neg_of_lt {a b : Int} (h : a < b) : a - b < 0 
Arguments: {a b : Int} (h : a < b)
Goal: a - b < 0
-- Int.lt_of_sub_neg
protected theorem lt_of_sub_neg {a b : Int} (h : a - b < 0) : a < b 
Arguments: {a b : Int} (h : a - b < 0)
Goal: a < b
-- Int.add_le_of_le_neg_add
protected theorem add_le_of_le_neg_add {a b c : Int} (h : b ≤ -a + c) : a + b ≤ c 
Arguments: {a b c : Int} (h : b ≤ -a + c)
Goal: a + b ≤ c
-- Int.le_neg_add_of_add_le
protected theorem le_neg_add_of_add_le {a b c : Int} (h : a + b ≤ c) : b ≤ -a + c 
Arguments: {a b c : Int} (h : a + b ≤ c)
Goal: b ≤ -a + c
-- Int.add_le_of_le_sub_left
protected theorem add_le_of_le_sub_left {a b c : Int} (h : b ≤ c - a) : a + b ≤ c 
Arguments: {a b c : Int} (h : b ≤ c - a)
Goal: a + b ≤ c
-- Int.le_sub_left_of_add_le
protected theorem le_sub_left_of_add_le {a b c : Int} (h : a + b ≤ c) : b ≤ c - a 
Arguments: {a b c : Int} (h : a + b ≤ c)
Goal: b ≤ c - a
-- Int.add_le_of_le_sub_right
protected theorem add_le_of_le_sub_right {a b c : Int} (h : a ≤ c - b) : a + b ≤ c 
Arguments: {a b c : Int} (h : a ≤ c - b)
Goal: a + b ≤ c
-- Int.le_sub_right_of_add_le
protected theorem le_sub_right_of_add_le {a b c : Int} (h : a + b ≤ c) : a ≤ c - b 
Arguments: {a b c : Int} (h : a + b ≤ c)
Goal: a ≤ c - b
-- Int.le_add_of_neg_add_le
protected theorem le_add_of_neg_add_le {a b c : Int} (h : -b + a ≤ c) : a ≤ b + c 
Arguments: {a b c : Int} (h : -b + a ≤ c)
Goal: a ≤ b + c
-- Int.neg_add_le_of_le_add
protected theorem neg_add_le_of_le_add {a b c : Int} (h : a ≤ b + c) : -b + a ≤ c 
Arguments: {a b c : Int} (h : a ≤ b + c)
Goal: -b + a ≤ c
-- Int.le_add_of_sub_left_le
protected theorem le_add_of_sub_left_le {a b c : Int} (h : a - b ≤ c) : a ≤ b + c 
Arguments: {a b c : Int} (h : a - b ≤ c)
Goal: a ≤ b + c
-- Int.le_add_of_sub_right_le
protected theorem le_add_of_sub_right_le {a b c : Int} (h : a - c ≤ b) : a ≤ b + c 
Arguments: {a b c : Int} (h : a - c ≤ b)
Goal: a ≤ b + c
-- Int.sub_right_le_of_le_add
protected theorem sub_right_le_of_le_add {a b c : Int} (h : a ≤ b + c) : a - c ≤ b 
Arguments: {a b c : Int} (h : a ≤ b + c)
Goal: a - c ≤ b
-- Int.le_add_of_neg_add_le_left
protected theorem le_add_of_neg_add_le_left {a b c : Int} (h : -b + a ≤ c) : a ≤ b + c 
Arguments: {a b c : Int} (h : -b + a ≤ c)
Goal: a ≤ b + c
-- Int.neg_add_le_left_of_le_add
protected theorem neg_add_le_left_of_le_add {a b c : Int} (h : a ≤ b + c) : -b + a ≤ c 
Arguments: {a b c : Int} (h : a ≤ b + c)
Goal: -b + a ≤ c
-- Int.le_add_of_neg_add_le_right
protected theorem le_add_of_neg_add_le_right {a b c : Int} (h : -c + a ≤ b) : a ≤ b + c 
Arguments: {a b c : Int} (h : -c + a ≤ b)
Goal: a ≤ b + c
-- Int.neg_add_le_right_of_le_add
protected theorem neg_add_le_right_of_le_add {a b c : Int} (h : a ≤ b + c) : -c + a ≤ b 
Arguments: {a b c : Int} (h : a ≤ b + c)
Goal: -c + a ≤ b
-- Int.le_add_of_neg_le_sub_left
protected theorem le_add_of_neg_le_sub_left {a b c : Int} (h : -a ≤ b - c) : c ≤ a + b 
Arguments: {a b c : Int} (h : -a ≤ b - c)
Goal: c ≤ a + b
-- Int.neg_le_sub_left_of_le_add
protected theorem neg_le_sub_left_of_le_add {a b c : Int} (h : c ≤ a + b) : -a ≤ b - c 
Arguments: {a b c : Int} (h : c ≤ a + b)
Goal: -a ≤ b - c
-- Int.le_add_of_neg_le_sub_right
protected theorem le_add_of_neg_le_sub_right {a b c : Int} (h : -b ≤ a - c) : c ≤ a + b 
Arguments: {a b c : Int} (h : -b ≤ a - c)
Goal: c ≤ a + b
-- Int.neg_le_sub_right_of_le_add
protected theorem neg_le_sub_right_of_le_add {a b c : Int} (h : c ≤ a + b) : -b ≤ a - c 
Arguments: {a b c : Int} (h : c ≤ a + b)
Goal: -b ≤ a - c
-- Int.sub_le_of_sub_le
protected theorem sub_le_of_sub_le {a b c : Int} (h : a - b ≤ c) : a - c ≤ b 
Arguments: {a b c : Int} (h : a - b ≤ c)
Goal: a - c ≤ b
-- Int.sub_le_sub_left
protected theorem sub_le_sub_left {a b : Int} (h : a ≤ b) (c : Int) : c - b ≤ c - a 
Arguments: {a b : Int} (h : a ≤ b) (c : Int)
Goal: c - b ≤ c - a
-- Int.sub_le_sub_right
protected theorem sub_le_sub_right {a b : Int} (h : a ≤ b) (c : Int) : a - c ≤ b - c 
Arguments: {a b : Int} (h : a ≤ b) (c : Int)
Goal: a - c ≤ b - c
-- Int.sub_le_sub
protected theorem sub_le_sub {a b c d : Int} (hab : a ≤ b) (hcd : c ≤ d) : a - d ≤ b - c 
Arguments: {a b c d : Int} (hab : a ≤ b) (hcd : c ≤ d)
Goal: a - d ≤ b - c
-- Int.add_lt_of_lt_neg_add
protected theorem add_lt_of_lt_neg_add {a b c : Int} (h : b < -a + c) : a + b < c 
Arguments: {a b c : Int} (h : b < -a + c)
Goal: a + b < c
-- Int.lt_neg_add_of_add_lt
protected theorem lt_neg_add_of_add_lt {a b c : Int} (h : a + b < c) : b < -a + c 
Arguments: {a b c : Int} (h : a + b < c)
Goal: b < -a + c
-- Int.add_lt_of_lt_sub_left
protected theorem add_lt_of_lt_sub_left {a b c : Int} (h : b < c - a) : a + b < c 
Arguments: {a b c : Int} (h : b < c - a)
Goal: a + b < c
-- Int.lt_sub_left_of_add_lt
protected theorem lt_sub_left_of_add_lt {a b c : Int} (h : a + b < c) : b < c - a 
Arguments: {a b c : Int} (h : a + b < c)
Goal: b < c - a
-- Int.add_lt_of_lt_sub_right
protected theorem add_lt_of_lt_sub_right {a b c : Int} (h : a < c - b) : a + b < c 
Arguments: {a b c : Int} (h : a < c - b)
Goal: a + b < c
-- Int.lt_sub_right_of_add_lt
protected theorem lt_sub_right_of_add_lt {a b c : Int} (h : a + b < c) : a < c - b 
Arguments: {a b c : Int} (h : a + b < c)
Goal: a < c - b
-- Int.lt_add_of_neg_add_lt
protected theorem lt_add_of_neg_add_lt {a b c : Int} (h : -b + a < c) : a < b + c 
Arguments: {a b c : Int} (h : -b + a < c)
Goal: a < b + c
-- Int.neg_add_lt_of_lt_add
protected theorem neg_add_lt_of_lt_add {a b c : Int} (h : a < b + c) : -b + a < c 
Arguments: {a b c : Int} (h : a < b + c)
Goal: -b + a < c
-- Int.lt_add_of_sub_left_lt
protected theorem lt_add_of_sub_left_lt {a b c : Int} (h : a - b < c) : a < b + c 
Arguments: {a b c : Int} (h : a - b < c)
Goal: a < b + c
-- Int.sub_left_lt_of_lt_add
protected theorem sub_left_lt_of_lt_add {a b c : Int} (h : a < b + c) : a - b < c 
Arguments: {a b c : Int} (h : a < b + c)
Goal: a - b < c
-- Int.lt_add_of_sub_right_lt
protected theorem lt_add_of_sub_right_lt {a b c : Int} (h : a - c < b) : a < b + c 
Arguments: {a b c : Int} (h : a - c < b)
Goal: a < b + c
-- Int.sub_right_lt_of_lt_add
protected theorem sub_right_lt_of_lt_add {a b c : Int} (h : a < b + c) : a - c < b 
Arguments: {a b c : Int} (h : a < b + c)
Goal: a - c < b
-- Int.lt_add_of_neg_add_lt_left
protected theorem lt_add_of_neg_add_lt_left {a b c : Int} (h : -b + a < c) : a < b + c 
Arguments: {a b c : Int} (h : -b + a < c)
Goal: a < b + c
-- Int.neg_add_lt_left_of_lt_add
protected theorem neg_add_lt_left_of_lt_add {a b c : Int} (h : a < b + c) : -b + a < c 
Arguments: {a b c : Int} (h : a < b + c)
Goal: -b + a < c
-- Int.lt_add_of_neg_add_lt_right
protected theorem lt_add_of_neg_add_lt_right {a b c : Int} (h : -c + a < b) : a < b + c 
Arguments: {a b c : Int} (h : -c + a < b)
Goal: a < b + c
-- Int.neg_add_lt_right_of_lt_add
protected theorem neg_add_lt_right_of_lt_add {a b c : Int} (h : a < b + c) : -c + a < b 
Arguments: {a b c : Int} (h : a < b + c)
Goal: -c + a < b
-- Int.lt_add_of_neg_lt_sub_left
protected theorem lt_add_of_neg_lt_sub_left {a b c : Int} (h : -a < b - c) : c < a + b 
Arguments: {a b c : Int} (h : -a < b - c)
Goal: c < a + b
-- Int.neg_lt_sub_left_of_lt_add
protected theorem neg_lt_sub_left_of_lt_add {a b c : Int} (h : c < a + b) : -a < b - c 
Arguments: {a b c : Int} (h : c < a + b)
Goal: -a < b - c
-- Int.lt_add_of_neg_lt_sub_right
protected theorem lt_add_of_neg_lt_sub_right {a b c : Int} (h : -b < a - c) : c < a + b 
Arguments: {a b c : Int} (h : -b < a - c)
Goal: c < a + b
-- Int.neg_lt_sub_right_of_lt_add
protected theorem neg_lt_sub_right_of_lt_add {a b c : Int} (h : c < a + b) : -b < a - c 
Arguments: {a b c : Int} (h : c < a + b)
Goal: -b < a - c
-- Int.add_lt_iff
protected theorem add_lt_iff (a b c : Int) : a + b < c ↔ a < -b + c 
Arguments: (a b c : Int)
Goal: a + b < c ↔ a < -b + c
-- Int.sub_lt_iff
protected theorem sub_lt_iff (a b c : Int) : a - b < c ↔ a < c + b 
Arguments: (a b c : Int)
Goal: a - b < c ↔ a < c + b
-- Int.sub_lt_of_sub_lt
protected theorem sub_lt_of_sub_lt {a b c : Int} (h : a - b < c) : a - c < b 
Arguments: {a b c : Int} (h : a - b < c)
Goal: a - c < b
-- Int.sub_lt_sub_left
protected theorem sub_lt_sub_left {a b : Int} (h : a < b) (c : Int) : c - b < c - a 
Arguments: {a b : Int} (h : a < b) (c : Int)
Goal: c - b < c - a
-- Int.sub_lt_sub_right
protected theorem sub_lt_sub_right {a b : Int} (h : a < b) (c : Int) : a - c < b - c 
Arguments: {a b : Int} (h : a < b) (c : Int)
Goal: a - c < b - c
-- Int.sub_lt_sub
protected theorem sub_lt_sub {a b c d : Int} (hab : a < b) (hcd : c < d) : a - d < b - c 
Arguments: {a b c d : Int} (hab : a < b) (hcd : c < d)
Goal: a - d < b - c
-- Int.lt_of_sub_lt_sub_left
protected theorem lt_of_sub_lt_sub_left {a b c : Int} (h : c - a < c - b) : b < a 
Arguments: {a b c : Int} (h : c - a < c - b)
Goal: b < a
-- Int.lt_of_sub_lt_sub_right
protected theorem lt_of_sub_lt_sub_right {a b c : Int} (h : a - c < b - c) : a < b 
Arguments: {a b c : Int} (h : a - c < b - c)
Goal: a < b
-- Int.sub_lt_sub_left_iff
@[simp] protected theorem sub_lt_sub_left_iff (a b c : Int) :
    c - a < c - b ↔ b < a 
Arguments: (a b c : Int)
Goal: c - a < c - b ↔ b < a
-- Int.sub_lt_sub_right_iff
@[simp] protected theorem sub_lt_sub_right_iff (a b c : Int) :
    a - c < b - c ↔ a < b 
Arguments: (a b c : Int)
Goal: a - c < b - c ↔ a < b
-- Int.sub_lt_sub_of_le_of_lt
protected theorem sub_lt_sub_of_le_of_lt {a b c d : Int}
  (hab : a ≤ b) (hcd : c < d) : a - d < b - c 
Arguments: {a b c d : Int} (hab : a ≤ b) (hcd : c < d)
Goal: a - d < b - c
-- Int.sub_lt_sub_of_lt_of_le
protected theorem sub_lt_sub_of_lt_of_le {a b c d : Int}
  (hab : a < b) (hcd : c ≤ d) : a - d < b - c 
Arguments: {a b c d : Int} (hab : a < b) (hcd : c ≤ d)
Goal: a - d < b - c
-- Int.add_le_add_three
protected theorem add_le_add_three {a b c d e f : Int}
    (h₁ : a ≤ d) (h₂ : b ≤ e) (h₃ : c ≤ f) : a + b + c ≤ d + e + f 
Arguments: {a b c d e f : Int} (h₁ : a ≤ d) (h₂ : b ≤ e) (h₃ : c ≤ f)
Goal: a + b + c ≤ d + e + f
-- Int.exists_eq_neg_ofNat
theorem exists_eq_neg_ofNat {a : Int} (H : a ≤ 0) : ∃ n : Nat, a = -(n : Int) 
Arguments: {a : Int} (H : a ≤ 0)
Goal: ∃ n, a = -↑n
-- Int.lt_of_add_one_le
theorem lt_of_add_one_le {a b : Int} (H : a + 1 ≤ b) : a < b 
Arguments: {a b : Int} (H : a + 1 ≤ b)
Goal: a < b
-- Int.lt_add_one_of_le
theorem lt_add_one_of_le {a b : Int} (H : a ≤ b) : a < b + 1 
Arguments: {a b : Int} (H : a ≤ b)
Goal: a < b + 1