File: .lake/packages/lean4/src/lean/Init/Data/Int/Order.lean

full_name: Int.nonneg_def
code: theorem nonneg_def {a : Int} : NonNeg a ↔ ∃ n : Nat, a = n 
goal: a.NonNeg ↔ ∃ n, a = ↑n

full_name: Int.NonNeg.elim
code: theorem NonNeg.elim {a : Int} : NonNeg a → ∃ n : Nat, a = n 
goal: a.NonNeg → ∃ n, a = ↑n

full_name: Int.nonneg_or_nonneg_neg
code: theorem nonneg_or_nonneg_neg : ∀ (a : Int), NonNeg a ∨ NonNeg (-a)
  
goal: a.NonNeg ∨ (-a).NonNeg

full_name: Int.le_def
code: theorem le_def (a b : Int) : a ≤ b ↔ NonNeg (b - a) 
goal: a ≤ b ↔ (b - a).NonNeg

full_name: Int.lt_iff_add_one_le
code: theorem lt_iff_add_one_le (a b : Int) : a < b ↔ a + 1 ≤ b 
goal: a < b ↔ a + 1 ≤ b

full_name: Int.le.intro_sub
code: theorem le.intro_sub {a b : Int} (n : Nat) (h : b - a = n) : a ≤ b 
goal: a ≤ b

full_name: Int.le.intro
code: theorem le.intro {a b : Int} (n : Nat) (h : a + n = b) : a ≤ b 
goal: a ≤ b

full_name: Int.le.dest_sub
code: theorem le.dest_sub {a b : Int} (h : a ≤ b) : ∃ n : Nat, b - a = n 
goal: ∃ n, b - a = ↑n

full_name: Int.le.dest
code: theorem le.dest {a b : Int} (h : a ≤ b) : ∃ n : Nat, a + n = b 
goal: ∃ n, a + ↑n = b

full_name: Int.le_total
code: protected theorem le_total (a b : Int) : a ≤ b ∨ b ≤ a 
goal: a ≤ b ∨ b ≤ a

full_name: Int.ofNat_le
code: @[simp, norm_cast] theorem ofNat_le {m n : Nat} : (↑m : Int) ≤ ↑n ↔ m ≤ n 
goal: ↑m ≤ ↑n ↔ m ≤ n

full_name: Int.ofNat_zero_le
code: theorem ofNat_zero_le (n : Nat) : 0 ≤ (↑n : Int) 
goal: 0 ≤ ↑n

full_name: Int.eq_ofNat_of_zero_le
code: theorem eq_ofNat_of_zero_le {a : Int} (h : 0 ≤ a) : ∃ n : Nat, a = n 
goal: ∃ n, a = ↑n

full_name: Int.eq_succ_of_zero_lt
code: theorem eq_succ_of_zero_lt {a : Int} (h : 0 < a) : ∃ n : Nat, a = n.succ 
goal: ∃ n, a = ↑n.succ

full_name: Int.lt_add_succ
code: theorem lt_add_succ (a : Int) (n : Nat) : a < a + Nat.succ n 
goal: a < a + ↑n.succ

full_name: Int.lt.intro
code: theorem lt.intro {a b : Int} {n : Nat} (h : a + Nat.succ n = b) : a < b 
goal: a < b

full_name: Int.lt.dest
code: theorem lt.dest {a b : Int} (h : a < b) : ∃ n : Nat, a + Nat.succ n = b 
goal: ∃ n, a + ↑n.succ = b

full_name: Int.ofNat_lt
code: @[simp, norm_cast] theorem ofNat_lt {n m : Nat} : (↑n : Int) < ↑m ↔ n < m 
goal: ↑n < ↑m ↔ n < m

full_name: Int.ofNat_pos
code: @[simp, norm_cast] theorem ofNat_pos {n : Nat} : 0 < (↑n : Int) ↔ 0 < n 
goal: 0 < ↑n ↔ 0 < n

full_name: Int.ofNat_nonneg
code: theorem ofNat_nonneg (n : Nat) : 0 ≤ (n : Int) 
goal: 0 ≤ ↑n

full_name: Int.ofNat_succ_pos
code: theorem ofNat_succ_pos (n : Nat) : 0 < (succ n : Int) 
goal: 0 < ↑n.succ

full_name: Int.le_refl
code: @[simp] protected theorem le_refl (a : Int) : a ≤ a 
goal: a ≤ a

full_name: Int.le_trans
code: protected theorem le_trans {a b c : Int} (h₁ : a ≤ b) (h₂ : b ≤ c) : a ≤ c 
goal: a ≤ c

full_name: Int.le_antisymm
code: protected theorem le_antisymm {a b : Int} (h₁ : a ≤ b) (h₂ : b ≤ a) : a = b 
goal: a = b

full_name: Int.lt_irrefl
code: @[simp] protected theorem lt_irrefl (a : Int) : ¬a < a 
goal: ¬a < a

full_name: Int.ne_of_lt
code: protected theorem ne_of_lt {a b : Int} (h : a < b) : a ≠ b 
goal: a ≠ b

full_name: Int.ne_of_gt
code: protected theorem ne_of_gt {a b : Int} (h : b < a) : a ≠ b 
goal: a ≠ b

full_name: Int.le_of_lt
code: protected theorem le_of_lt {a b : Int} (h : a < b) : a ≤ b 
goal: a ≤ b

full_name: Int.lt_iff_le_and_ne
code: protected theorem lt_iff_le_and_ne {a b : Int} : a < b ↔ a ≤ b ∧ a ≠ b 
goal: a < b ↔ a ≤ b ∧ a ≠ b

full_name: Int.lt_succ
code: theorem lt_succ (a : Int) : a < a + 1 
goal: a < a + 1

full_name: Int.zero_lt_one
code: protected theorem zero_lt_one : (0 : Int) < 1 
goal: 0 < 1

full_name: Int.lt_iff_le_not_le
code: protected theorem lt_iff_le_not_le {a b : Int} : a < b ↔ a ≤ b ∧ ¬b ≤ a 
goal: a < b ↔ a ≤ b ∧ ¬b ≤ a

full_name: Int.lt_of_not_ge
code: protected theorem lt_of_not_ge {a b : Int} (h : ¬a ≤ b) : b < a 
goal: b < a

full_name: Int.not_le_of_gt
code: protected theorem not_le_of_gt {a b : Int} (h : b < a) : ¬a ≤ b 
goal: ¬a ≤ b

full_name: Int.not_le
code: protected theorem not_le {a b : Int} : ¬a ≤ b ↔ b < a 
goal: ¬a ≤ b ↔ b < a

full_name: Int.not_lt
code: protected theorem not_lt {a b : Int} : ¬a < b ↔ b ≤ a 
goal: ¬a < b ↔ b ≤ a

full_name: Int.lt_trichotomy
code: protected theorem lt_trichotomy (a b : Int) : a < b ∨ a = b ∨ b < a 
goal: a < b ∨ a = b ∨ b < a

full_name: Int.ne_iff_lt_or_gt
code: protected theorem ne_iff_lt_or_gt {a b : Int} : a ≠ b ↔ a < b ∨ b < a 
goal: a ≠ b ↔ a < b ∨ b < a

full_name: Int.lt_or_gt_of_ne
code: protected theorem lt_or_gt_of_ne {a b : Int} : a ≠ b →  a < b ∨ b < a
goal: a ≠ b → a < b ∨ b < a

full_name: Int.eq_iff_le_and_ge
code: protected theorem eq_iff_le_and_ge {x y : Int} : x = y ↔ x ≤ y ∧ y ≤ x 
goal: x = y ↔ x ≤ y ∧ y ≤ x

full_name: Int.lt_of_le_of_lt
code: protected theorem lt_of_le_of_lt {a b c : Int} (h₁ : a ≤ b) (h₂ : b < c) : a < c 
goal: a < c

full_name: Int.lt_of_lt_of_le
code: protected theorem lt_of_lt_of_le {a b c : Int} (h₁ : a < b) (h₂ : b ≤ c) : a < c 
goal: a < c

full_name: Int.lt_trans
code: protected theorem lt_trans {a b c : Int} (h₁ : a < b) (h₂ : b < c) : a < c 
goal: a < c

full_name: Int.«instTransLe_.lake»
code: instance : Trans (α := Int) (· ≤ ·) (· ≤ ·) (· ≤ ·) 
goal: Trans (fun x x_1 => x ≤ x_1) (fun x x_1 => x ≤ x_1) fun x x_1 => x ≤ x_1

full_name: Int.«instTransLtLe_.lake»
code: instance : Trans (α := Int) (· < ·) (· ≤ ·) (· < ·) 
goal: Trans (fun x x_1 => x < x_1) (fun x x_1 => x ≤ x_1) fun x x_1 => x < x_1

full_name: Int.«instTransLeLt_.lake»
code: instance : Trans (α := Int) (· ≤ ·) (· < ·) (· < ·) 
goal: Trans (fun x x_1 => x ≤ x_1) (fun x x_1 => x < x_1) fun x x_1 => x < x_1

full_name: Int.«instTransLt_.lake»
code: instance : Trans (α := Int) (· < ·) (· < ·) (· < ·) 
goal: Trans (fun x x_1 => x < x_1) (fun x x_1 => x < x_1) fun x x_1 => x < x_1

full_name: Int.min_def
code: protected theorem min_def (n m : Int) : min n m = if n ≤ m then n else m 
goal: min n m = if n ≤ m then n else m

full_name: Int.max_def
code: protected theorem max_def (n m : Int) : max n m = if n ≤ m then m else n 
goal: max n m = if n ≤ m then m else n

full_name: Int.min_comm
code: protected theorem min_comm (a b : Int) : min a b = min b a 
goal: min a b = min b a

full_name: Int.«instCommutativeMin_.lake»
code: instance : Std.Commutative (α := Int) min 
goal: Std.Commutative min

full_name: Int.min_le_right
code: protected theorem min_le_right (a b : Int) : min a b ≤ b 
goal: min a b ≤ b

full_name: Int.min_le_left
code: protected theorem min_le_left (a b : Int) : min a b ≤ a 
goal: min a b ≤ a

full_name: Int.min_eq_left
code: protected theorem min_eq_left {a b : Int} (h : a ≤ b) : min a b = a 
goal: min a b = a

full_name: Int.min_eq_right
code: protected theorem min_eq_right {a b : Int} (h : b ≤ a) : min a b = b 
goal: min a b = b

full_name: Int.le_min
code: protected theorem le_min {a b c : Int} : a ≤ min b c ↔ a ≤ b ∧ a ≤ c 
goal: a ≤ min b c ↔ a ≤ b ∧ a ≤ c

full_name: Int.max_comm
code: protected theorem max_comm (a b : Int) : max a b = max b a 
goal: max a b = max b a

full_name: Int.«instCommutativeMax_.lake»
code: instance : Std.Commutative (α := Int) max 
goal: Std.Commutative max

full_name: Int.le_max_left
code: protected theorem le_max_left (a b : Int) : a ≤ max a b 
goal: a ≤ max a b

full_name: Int.le_max_right
code: protected theorem le_max_right (a b : Int) : b ≤ max a b 
goal: b ≤ max a b

full_name: Int.max_le
code: protected theorem max_le {a b c : Int} : max a b ≤ c ↔ a ≤ c ∧ b ≤ c 
goal: max a b ≤ c ↔ a ≤ c ∧ b ≤ c

full_name: Int.max_eq_right
code: protected theorem max_eq_right {a b : Int} (h : a ≤ b) : max a b = b 
goal: max a b = b

full_name: Int.max_eq_left
code: protected theorem max_eq_left {a b : Int} (h : b ≤ a) : max a b = a 
goal: max a b = a

full_name: Int.eq_natAbs_of_zero_le
code: theorem eq_natAbs_of_zero_le {a : Int} (h : 0 ≤ a) : a = natAbs a 
goal: a = ↑a.natAbs

full_name: Int.le_natAbs
code: theorem le_natAbs {a : Int} : a ≤ natAbs a 
goal: a ≤ ↑a.natAbs

full_name: Int.negSucc_lt_zero
code: theorem negSucc_lt_zero (n : Nat) : -[n+1] < 0 
goal: Int.negSucc n < 0

full_name: Int.negSucc_not_nonneg
code: @[simp] theorem negSucc_not_nonneg (n : Nat) : 0 ≤ -[n+1] ↔ False 
goal: 0 ≤ Int.negSucc n ↔ False

full_name: Int.add_le_add_left
code: protected theorem add_le_add_left {a b : Int} (h : a ≤ b) (c : Int) : c + a ≤ c + b 
goal: c + a ≤ c + b

full_name: Int.add_lt_add_left
code: protected theorem add_lt_add_left {a b : Int} (h : a < b) (c : Int) : c + a < c + b 
goal: c + a < c + b

full_name: Int.add_le_add_right
code: protected theorem add_le_add_right {a b : Int} (h : a ≤ b) (c : Int) : a + c ≤ b + c 
goal: a + c ≤ b + c

full_name: Int.add_lt_add_right
code: protected theorem add_lt_add_right {a b : Int} (h : a < b) (c : Int) : a + c < b + c 
goal: a + c < b + c

full_name: Int.le_of_add_le_add_left
code: protected theorem le_of_add_le_add_left {a b c : Int} (h : a + b ≤ a + c) : b ≤ c 
goal: b ≤ c

full_name: Int.le_of_add_le_add_right
code: protected theorem le_of_add_le_add_right {a b c : Int} (h : a + b ≤ c + b) : a ≤ c 
goal: a ≤ c

full_name: Int.add_le_add_iff_left
code: protected theorem add_le_add_iff_left (a : Int) : a + b ≤ a + c ↔ b ≤ c 
goal: a + b ≤ a + c ↔ b ≤ c

full_name: Int.add_le_add_iff_right
code: protected theorem add_le_add_iff_right (c : Int) : a + c ≤ b + c ↔ a ≤ b 
goal: a + c ≤ b + c ↔ a ≤ b

full_name: Int.add_le_add
code: protected theorem add_le_add {a b c d : Int} (h₁ : a ≤ b) (h₂ : c ≤ d) : a + c ≤ b + d 
goal: a + c ≤ b + d

full_name: Int.le_add_of_nonneg_right
code: protected theorem le_add_of_nonneg_right {a b : Int} (h : 0 ≤ b) : a ≤ a + b 
goal: a ≤ a + b

full_name: Int.le_add_of_nonneg_left
code: protected theorem le_add_of_nonneg_left {a b : Int} (h : 0 ≤ b) : a ≤ b + a 
goal: a ≤ b + a

full_name: Int.neg_le_neg
code: protected theorem neg_le_neg {a b : Int} (h : a ≤ b) : -b ≤ -a 
goal: -b ≤ -a

full_name: Int.le_of_neg_le_neg
code: protected theorem le_of_neg_le_neg {a b : Int} (h : -b ≤ -a) : a ≤ b 
goal: a ≤ b

full_name: Int.neg_nonpos_of_nonneg
code: protected theorem neg_nonpos_of_nonneg {a : Int} (h : 0 ≤ a) : -a ≤ 0 
goal: -a ≤ 0

full_name: Int.neg_nonneg_of_nonpos
code: protected theorem neg_nonneg_of_nonpos {a : Int} (h : a ≤ 0) : 0 ≤ -a 
goal: 0 ≤ -a

full_name: Int.neg_lt_neg
code: protected theorem neg_lt_neg {a b : Int} (h : a < b) : -b < -a 
goal: -b < -a

full_name: Int.neg_neg_of_pos
code: protected theorem neg_neg_of_pos {a : Int} (h : 0 < a) : -a < 0 
goal: -a < 0

full_name: Int.neg_pos_of_neg
code: protected theorem neg_pos_of_neg {a : Int} (h : a < 0) : 0 < -a 
goal: 0 < -a

full_name: Int.sub_nonneg_of_le
code: protected theorem sub_nonneg_of_le {a b : Int} (h : b ≤ a) : 0 ≤ a - b 
goal: 0 ≤ a - b

full_name: Int.le_of_sub_nonneg
code: protected theorem le_of_sub_nonneg {a b : Int} (h : 0 ≤ a - b) : b ≤ a 
goal: b ≤ a

full_name: Int.sub_pos_of_lt
code: protected theorem sub_pos_of_lt {a b : Int} (h : b < a) : 0 < a - b 
goal: 0 < a - b

full_name: Int.lt_of_sub_pos
code: protected theorem lt_of_sub_pos {a b : Int} (h : 0 < a - b) : b < a 
goal: b < a

full_name: Int.sub_left_le_of_le_add
code: protected theorem sub_left_le_of_le_add {a b c : Int} (h : a ≤ b + c) : a - b ≤ c 
goal: a - b ≤ c

full_name: Int.sub_le_self
code: protected theorem sub_le_self (a : Int) {b : Int} (h : 0 ≤ b) : a - b ≤ a 
goal: a - b ≤ a

full_name: Int.sub_lt_self
code: protected theorem sub_lt_self (a : Int) {b : Int} (h : 0 < b) : a - b < a 
goal: a - b < a

full_name: Int.add_one_le_of_lt
code: theorem add_one_le_of_lt {a b : Int} (H : a < b) : a + 1 ≤ b 
goal: a + 1 ≤ b

full_name: Int.mul_nonneg
code: protected theorem mul_nonneg {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b 
goal: 0 ≤ a * b

full_name: Int.mul_pos
code: protected theorem mul_pos {a b : Int} (ha : 0 < a) (hb : 0 < b) : 0 < a * b 
goal: 0 < a * b

full_name: Int.mul_lt_mul_of_pos_left
code: protected theorem mul_lt_mul_of_pos_left {a b c : Int}
  (h₁ : a < b) (h₂ : 0 < c) : c * a < c * b 
goal: c * a < c * b

full_name: Int.mul_lt_mul_of_pos_right
code: protected theorem mul_lt_mul_of_pos_right {a b c : Int}
  (h₁ : a < b) (h₂ : 0 < c) : a * c < b * c 
goal: a * c < b * c

full_name: Int.mul_le_mul_of_nonneg_left
code: protected theorem mul_le_mul_of_nonneg_left {a b c : Int}
    (h₁ : a ≤ b) (h₂ : 0 ≤ c) : c * a ≤ c * b 
goal: c * a ≤ c * b

full_name: Int.mul_le_mul_of_nonneg_right
code: protected theorem mul_le_mul_of_nonneg_right {a b c : Int}
    (h₁ : a ≤ b) (h₂ : 0 ≤ c) : a * c ≤ b * c 
goal: a * c ≤ b * c

full_name: Int.mul_le_mul
code: 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 
goal: a * b ≤ c * d

full_name: Int.mul_nonpos_of_nonneg_of_nonpos
code: protected theorem mul_nonpos_of_nonneg_of_nonpos {a b : Int}
  (ha : 0 ≤ a) (hb : b ≤ 0) : a * b ≤ 0 
goal: a * b ≤ 0

full_name: Int.mul_nonpos_of_nonpos_of_nonneg
code: protected theorem mul_nonpos_of_nonpos_of_nonneg {a b : Int}
  (ha : a ≤ 0) (hb : 0 ≤ b) : a * b ≤ 0 
goal: a * b ≤ 0

full_name: Int.mul_le_mul_of_nonpos_right
code: protected theorem mul_le_mul_of_nonpos_right {a b c : Int}
    (h : b ≤ a) (hc : c ≤ 0) : a * c ≤ b * c 
goal: a * c ≤ b * c

full_name: Int.mul_le_mul_of_nonpos_left
code: protected theorem mul_le_mul_of_nonpos_left {a b c : Int}
    (ha : a ≤ 0) (h : c ≤ b) : a * b ≤ a * c 
goal: a * b ≤ a * c

full_name: Int.natAbs_ofNat
code: @[simp] theorem natAbs_ofNat (n : Nat) : natAbs ↑n = n 
goal: (↑n).natAbs = n

full_name: Int.natAbs_negSucc
code: @[simp] theorem natAbs_negSucc (n : Nat) : natAbs -[n+1] = n.succ 
goal: (Int.negSucc n).natAbs = n.succ

full_name: Int.natAbs_zero
code: @[simp] theorem natAbs_zero : natAbs (0 : Int) = (0 : Nat) 
goal: Int.natAbs 0 = 0

full_name: Int.natAbs_one
code: @[simp] theorem natAbs_one : natAbs (1 : Int) = (1 : Nat) 
goal: Int.natAbs 1 = 1

full_name: Int.natAbs_eq_zero
code: @[simp] theorem natAbs_eq_zero : natAbs a = 0 ↔ a = 0 
goal: a.natAbs = 0 ↔ a = 0

full_name: Int.natAbs_pos
code: theorem natAbs_pos : 0 < natAbs a ↔ a ≠ 0 
goal: 0 < a.natAbs ↔ a ≠ 0

full_name: Int.natAbs_neg
code: @[simp] theorem natAbs_neg : ∀ (a : Int), natAbs (-a) = natAbs a
  
goal: (-a).natAbs = a.natAbs

full_name: Int.natAbs_eq
code: theorem natAbs_eq : ∀ (a : Int), a = natAbs a ∨ a = -↑(natAbs a)
  
goal: a = ↑a.natAbs ∨ a = -↑a.natAbs

full_name: Int.natAbs_negOfNat
code: theorem natAbs_negOfNat (n : Nat) : natAbs (negOfNat n) = n 
goal: (Int.negOfNat n).natAbs = n

full_name: Int.natAbs_mul
code: theorem natAbs_mul (a b : Int) : natAbs (a * b) = natAbs a * natAbs b 
goal: (a * b).natAbs = a.natAbs * b.natAbs

full_name: Int.natAbs_eq_natAbs_iff
code: theorem natAbs_eq_natAbs_iff {a b : Int} : a.natAbs = b.natAbs ↔ a = b ∨ a = -b 
goal: a.natAbs = b.natAbs ↔ a = b ∨ a = -b

full_name: Int.natAbs_of_nonneg
code: theorem natAbs_of_nonneg {a : Int} (H : 0 ≤ a) : (natAbs a : Int) = a 
goal: ↑a.natAbs = a

full_name: Int.ofNat_natAbs_of_nonpos
code: theorem ofNat_natAbs_of_nonpos {a : Int} (H : a ≤ 0) : (natAbs a : Int) = -a 
goal: ↑a.natAbs = -a

full_name: Int.toNat_eq_max
code: theorem toNat_eq_max : ∀ a : Int, (toNat a : Int) = max a 0
  
goal: ↑a.toNat = max a 0

full_name: Int.toNat_zero
code: @[simp] theorem toNat_zero : (0 : Int).toNat = 0 
goal: Int.toNat 0 = 0

full_name: Int.toNat_one
code: @[simp] theorem toNat_one : (1 : Int).toNat = 1 
goal: Int.toNat 1 = 1

full_name: Int.toNat_of_nonneg
code: @[simp] theorem toNat_of_nonneg {a : Int} (h : 0 ≤ a) : (toNat a : Int) = a 
goal: ↑a.toNat = a

full_name: Int.toNat_ofNat
code: @[simp] theorem toNat_ofNat (n : Nat) : toNat ↑n = n 
goal: (↑n).toNat = n

full_name: Int.toNat_ofNat_add_one
code: @[simp] theorem toNat_ofNat_add_one {n : Nat} : ((n : Int) + 1).toNat = n + 1 
goal: (↑n + 1).toNat = n + 1

full_name: Int.self_le_toNat
code: theorem self_le_toNat (a : Int) : a ≤ toNat a 
goal: a ≤ ↑a.toNat

full_name: Int.le_toNat
code: @[simp] theorem le_toNat {n : Nat} {z : Int} (h : 0 ≤ z) : n ≤ z.toNat ↔ (n : Int) ≤ z 
goal: n ≤ z.toNat ↔ ↑n ≤ z

full_name: Int.toNat_lt
code: @[simp] theorem toNat_lt {n : Nat} {z : Int} (h : 0 ≤ z) : z.toNat < n ↔ z < (n : Int) 
goal: z.toNat < n ↔ z < ↑n

full_name: Int.toNat_add
code: theorem toNat_add {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : (a + b).toNat = a.toNat + b.toNat 
goal: (a + b).toNat = a.toNat + b.toNat

full_name: Int.toNat_add_nat
code: theorem toNat_add_nat {a : Int} (ha : 0 ≤ a) (n : Nat) : (a + n).toNat = a.toNat + n 
goal: (a + ↑n).toNat = a.toNat + n

full_name: Int.pred_toNat
code: @[simp] theorem pred_toNat : ∀ i : Int, (i - 1).toNat = i.toNat - 1
  
goal: (i - 1).toNat = i.toNat - 1

full_name: Int.toNat_sub_toNat_neg
code: @[simp] theorem toNat_sub_toNat_neg : ∀ n : Int, ↑n.toNat - ↑(-n).toNat = n
  
goal: ↑n.toNat - ↑(-n).toNat = n

full_name: Int.toNat_add_toNat_neg_eq_natAbs
code: @[simp] theorem toNat_add_toNat_neg_eq_natAbs : ∀ n : Int, n.toNat + (-n).toNat = n.natAbs
  
goal: n.toNat + (-n).toNat = n.natAbs

full_name: Int.toNat_neg_nat
code: @[simp] theorem toNat_neg_nat : ∀ n : Nat, (-(n : Int)).toNat = 0
  
goal: (-↑n).toNat = 0

full_name: Int.mem_toNat'
code: theorem mem_toNat' : ∀ (a : Int) (n : Nat), toNat' a = some n ↔ a = n
  
goal: a.toNat' = some n ↔ a = ↑n

full_name: Int.le_of_not_le
code: protected theorem le_of_not_le {a b : Int} : ¬ a ≤ b → b ≤ a 
goal: ¬a ≤ b → b ≤ a

full_name: Int.negSucc_not_pos
code: @[simp] theorem negSucc_not_pos (n : Nat) : 0 < -[n+1] ↔ False 
goal: 0 < Int.negSucc n ↔ False

full_name: Int.eq_negSucc_of_lt_zero
code: theorem eq_negSucc_of_lt_zero : ∀ {a : Int}, a < 0 → ∃ n : Nat, a = -[n+1]
  
goal: a < 0 → ∃ n, a = Int.negSucc n

full_name: Int.lt_of_add_lt_add_left
code: protected theorem lt_of_add_lt_add_left {a b c : Int} (h : a + b < a + c) : b < c 
goal: b < c

full_name: Int.lt_of_add_lt_add_right
code: protected theorem lt_of_add_lt_add_right {a b c : Int} (h : a + b < c + b) : a < c 
goal: a < c

full_name: Int.add_lt_add_iff_left
code: protected theorem add_lt_add_iff_left (a : Int) : a + b < a + c ↔ b < c 
goal: a + b < a + c ↔ b < c

full_name: Int.add_lt_add_iff_right
code: protected theorem add_lt_add_iff_right (c : Int) : a + c < b + c ↔ a < b 
goal: a + c < b + c ↔ a < b

full_name: Int.add_lt_add
code: protected theorem add_lt_add {a b c d : Int} (h₁ : a < b) (h₂ : c < d) : a + c < b + d 
goal: a + c < b + d

full_name: Int.add_lt_add_of_le_of_lt
code: protected theorem add_lt_add_of_le_of_lt {a b c d : Int} (h₁ : a ≤ b) (h₂ : c < d) :
    a + c < b + d 
goal: a + c < b + d

full_name: Int.add_lt_add_of_lt_of_le
code: protected theorem add_lt_add_of_lt_of_le {a b c d : Int} (h₁ : a < b) (h₂ : c ≤ d) :
    a + c < b + d 
goal: a + c < b + d

full_name: Int.lt_add_of_pos_right
code: protected theorem lt_add_of_pos_right (a : Int) {b : Int} (h : 0 < b) : a < a + b 
goal: a < a + b

full_name: Int.lt_add_of_pos_left
code: protected theorem lt_add_of_pos_left (a : Int) {b : Int} (h : 0 < b) : a < b + a 
goal: a < b + a

full_name: Int.add_nonneg
code: protected theorem add_nonneg {a b : Int} (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a + b 
goal: 0 ≤ a + b

full_name: Int.add_pos
code: protected theorem add_pos {a b : Int} (ha : 0 < a) (hb : 0 < b) : 0 < a + b 
goal: 0 < a + b

full_name: Int.add_pos_of_pos_of_nonneg
code: protected theorem add_pos_of_pos_of_nonneg {a b : Int} (ha : 0 < a) (hb : 0 ≤ b) : 0 < a + b 
goal: 0 < a + b

full_name: Int.add_pos_of_nonneg_of_pos
code: protected theorem add_pos_of_nonneg_of_pos {a b : Int} (ha : 0 ≤ a) (hb : 0 < b) : 0 < a + b 
goal: 0 < a + b

full_name: Int.add_nonpos
code: protected theorem add_nonpos {a b : Int} (ha : a ≤ 0) (hb : b ≤ 0) : a + b ≤ 0 
goal: a + b ≤ 0

full_name: Int.add_neg
code: protected theorem add_neg {a b : Int} (ha : a < 0) (hb : b < 0) : a + b < 0 
goal: a + b < 0

full_name: Int.add_neg_of_neg_of_nonpos
code: protected theorem add_neg_of_neg_of_nonpos {a b : Int} (ha : a < 0) (hb : b ≤ 0) : a + b < 0 
goal: a + b < 0

full_name: Int.add_neg_of_nonpos_of_neg
code: protected theorem add_neg_of_nonpos_of_neg {a b : Int} (ha : a ≤ 0) (hb : b < 0) : a + b < 0 
goal: a + b < 0

full_name: Int.lt_add_of_le_of_pos
code: protected theorem lt_add_of_le_of_pos {a b c : Int} (hbc : b ≤ c) (ha : 0 < a) : b < c + a 
goal: b < c + a

full_name: Int.add_one_le_iff
code: theorem add_one_le_iff {a b : Int} : a + 1 ≤ b ↔ a < b 
goal: a + 1 ≤ b ↔ a < b

full_name: Int.lt_add_one_iff
code: theorem lt_add_one_iff {a b : Int} : a < b + 1 ↔ a ≤ b 
goal: a < b + 1 ↔ a ≤ b

full_name: Int.succ_ofNat_pos
code: @[simp] theorem succ_ofNat_pos (n : Nat) : 0 < (n : Int) + 1 
goal: 0 < ↑n + 1

full_name: Int.not_ofNat_neg
code: theorem not_ofNat_neg (n : Nat) : ¬((n : Int) < 0) 
goal: ¬↑n < 0

full_name: Int.le_add_one
code: theorem le_add_one {a b : Int} (h : a ≤ b) : a ≤ b + 1 
goal: a ≤ b + 1

full_name: Int.nonneg_of_neg_nonpos
code: protected theorem nonneg_of_neg_nonpos {a : Int} (h : -a ≤ 0) : 0 ≤ a 
goal: 0 ≤ a

full_name: Int.nonpos_of_neg_nonneg
code: protected theorem nonpos_of_neg_nonneg {a : Int} (h : 0 ≤ -a) : a ≤ 0 
goal: a ≤ 0

full_name: Int.lt_of_neg_lt_neg
code: protected theorem lt_of_neg_lt_neg {a b : Int} (h : -b < -a) : a < b 
goal: a < b

full_name: Int.pos_of_neg_neg
code: protected theorem pos_of_neg_neg {a : Int} (h : -a < 0) : 0 < a 
goal: 0 < a

full_name: Int.neg_of_neg_pos
code: protected theorem neg_of_neg_pos {a : Int} (h : 0 < -a) : a < 0 
goal: a < 0

full_name: Int.le_neg_of_le_neg
code: protected theorem le_neg_of_le_neg {a b : Int} (h : a ≤ -b) : b ≤ -a 
goal: b ≤ -a

full_name: Int.neg_le_of_neg_le
code: protected theorem neg_le_of_neg_le {a b : Int} (h : -a ≤ b) : -b ≤ a 
goal: -b ≤ a

full_name: Int.lt_neg_of_lt_neg
code: protected theorem lt_neg_of_lt_neg {a b : Int} (h : a < -b) : b < -a 
goal: b < -a

full_name: Int.neg_lt_of_neg_lt
code: protected theorem neg_lt_of_neg_lt {a b : Int} (h : -a < b) : -b < a 
goal: -b < a

full_name: Int.sub_nonpos_of_le
code: protected theorem sub_nonpos_of_le {a b : Int} (h : a ≤ b) : a - b ≤ 0 
goal: a - b ≤ 0

full_name: Int.le_of_sub_nonpos
code: protected theorem le_of_sub_nonpos {a b : Int} (h : a - b ≤ 0) : a ≤ b 
goal: a ≤ b

full_name: Int.sub_neg_of_lt
code: protected theorem sub_neg_of_lt {a b : Int} (h : a < b) : a - b < 0 
goal: a - b < 0

full_name: Int.lt_of_sub_neg
code: protected theorem lt_of_sub_neg {a b : Int} (h : a - b < 0) : a < b 
goal: a < b

full_name: Int.add_le_of_le_neg_add
code: protected theorem add_le_of_le_neg_add {a b c : Int} (h : b ≤ -a + c) : a + b ≤ c 
goal: a + b ≤ c

full_name: Int.le_neg_add_of_add_le
code: protected theorem le_neg_add_of_add_le {a b c : Int} (h : a + b ≤ c) : b ≤ -a + c 
goal: b ≤ -a + c

full_name: Int.add_le_of_le_sub_left
code: protected theorem add_le_of_le_sub_left {a b c : Int} (h : b ≤ c - a) : a + b ≤ c 
goal: a + b ≤ c

full_name: Int.le_sub_left_of_add_le
code: protected theorem le_sub_left_of_add_le {a b c : Int} (h : a + b ≤ c) : b ≤ c - a 
goal: b ≤ c - a

full_name: Int.add_le_of_le_sub_right
code: protected theorem add_le_of_le_sub_right {a b c : Int} (h : a ≤ c - b) : a + b ≤ c 
goal: a + b ≤ c

full_name: Int.le_sub_right_of_add_le
code: protected theorem le_sub_right_of_add_le {a b c : Int} (h : a + b ≤ c) : a ≤ c - b 
goal: a ≤ c - b

full_name: Int.le_add_of_neg_add_le
code: protected theorem le_add_of_neg_add_le {a b c : Int} (h : -b + a ≤ c) : a ≤ b + c 
goal: a ≤ b + c

full_name: Int.neg_add_le_of_le_add
code: protected theorem neg_add_le_of_le_add {a b c : Int} (h : a ≤ b + c) : -b + a ≤ c 
goal: -b + a ≤ c

full_name: Int.le_add_of_sub_left_le
code: protected theorem le_add_of_sub_left_le {a b c : Int} (h : a - b ≤ c) : a ≤ b + c 
goal: a ≤ b + c

full_name: Int.le_add_of_sub_right_le
code: protected theorem le_add_of_sub_right_le {a b c : Int} (h : a - c ≤ b) : a ≤ b + c 
goal: a ≤ b + c

full_name: Int.sub_right_le_of_le_add
code: protected theorem sub_right_le_of_le_add {a b c : Int} (h : a ≤ b + c) : a - c ≤ b 
goal: a - c ≤ b

full_name: Int.le_add_of_neg_add_le_left
code: protected theorem le_add_of_neg_add_le_left {a b c : Int} (h : -b + a ≤ c) : a ≤ b + c 
goal: a ≤ b + c

full_name: Int.neg_add_le_left_of_le_add
code: protected theorem neg_add_le_left_of_le_add {a b c : Int} (h : a ≤ b + c) : -b + a ≤ c 
goal: -b + a ≤ c

full_name: Int.le_add_of_neg_add_le_right
code: protected theorem le_add_of_neg_add_le_right {a b c : Int} (h : -c + a ≤ b) : a ≤ b + c 
goal: a ≤ b + c

full_name: Int.neg_add_le_right_of_le_add
code: protected theorem neg_add_le_right_of_le_add {a b c : Int} (h : a ≤ b + c) : -c + a ≤ b 
goal: -c + a ≤ b

full_name: Int.le_add_of_neg_le_sub_left
code: protected theorem le_add_of_neg_le_sub_left {a b c : Int} (h : -a ≤ b - c) : c ≤ a + b 
goal: c ≤ a + b

full_name: Int.neg_le_sub_left_of_le_add
code: protected theorem neg_le_sub_left_of_le_add {a b c : Int} (h : c ≤ a + b) : -a ≤ b - c 
goal: -a ≤ b - c

full_name: Int.le_add_of_neg_le_sub_right
code: protected theorem le_add_of_neg_le_sub_right {a b c : Int} (h : -b ≤ a - c) : c ≤ a + b 
goal: c ≤ a + b

full_name: Int.neg_le_sub_right_of_le_add
code: protected theorem neg_le_sub_right_of_le_add {a b c : Int} (h : c ≤ a + b) : -b ≤ a - c 
goal: -b ≤ a - c

full_name: Int.sub_le_of_sub_le
code: protected theorem sub_le_of_sub_le {a b c : Int} (h : a - b ≤ c) : a - c ≤ b 
goal: a - c ≤ b

full_name: Int.sub_le_sub_left
code: protected theorem sub_le_sub_left {a b : Int} (h : a ≤ b) (c : Int) : c - b ≤ c - a 
goal: c - b ≤ c - a

full_name: Int.sub_le_sub_right
code: protected theorem sub_le_sub_right {a b : Int} (h : a ≤ b) (c : Int) : a - c ≤ b - c 
goal: a - c ≤ b - c

full_name: Int.sub_le_sub
code: protected theorem sub_le_sub {a b c d : Int} (hab : a ≤ b) (hcd : c ≤ d) : a - d ≤ b - c 
goal: a - d ≤ b - c

full_name: Int.add_lt_of_lt_neg_add
code: protected theorem add_lt_of_lt_neg_add {a b c : Int} (h : b < -a + c) : a + b < c 
goal: a + b < c

full_name: Int.lt_neg_add_of_add_lt
code: protected theorem lt_neg_add_of_add_lt {a b c : Int} (h : a + b < c) : b < -a + c 
goal: b < -a + c

full_name: Int.add_lt_of_lt_sub_left
code: protected theorem add_lt_of_lt_sub_left {a b c : Int} (h : b < c - a) : a + b < c 
goal: a + b < c

full_name: Int.lt_sub_left_of_add_lt
code: protected theorem lt_sub_left_of_add_lt {a b c : Int} (h : a + b < c) : b < c - a 
goal: b < c - a

full_name: Int.add_lt_of_lt_sub_right
code: protected theorem add_lt_of_lt_sub_right {a b c : Int} (h : a < c - b) : a + b < c 
goal: a + b < c

full_name: Int.lt_sub_right_of_add_lt
code: protected theorem lt_sub_right_of_add_lt {a b c : Int} (h : a + b < c) : a < c - b 
goal: a < c - b

full_name: Int.lt_add_of_neg_add_lt
code: protected theorem lt_add_of_neg_add_lt {a b c : Int} (h : -b + a < c) : a < b + c 
goal: a < b + c

full_name: Int.neg_add_lt_of_lt_add
code: protected theorem neg_add_lt_of_lt_add {a b c : Int} (h : a < b + c) : -b + a < c 
goal: -b + a < c

full_name: Int.lt_add_of_sub_left_lt
code: protected theorem lt_add_of_sub_left_lt {a b c : Int} (h : a - b < c) : a < b + c 
goal: a < b + c

full_name: Int.sub_left_lt_of_lt_add
code: protected theorem sub_left_lt_of_lt_add {a b c : Int} (h : a < b + c) : a - b < c 
goal: a - b < c

full_name: Int.lt_add_of_sub_right_lt
code: protected theorem lt_add_of_sub_right_lt {a b c : Int} (h : a - c < b) : a < b + c 
goal: a < b + c

full_name: Int.sub_right_lt_of_lt_add
code: protected theorem sub_right_lt_of_lt_add {a b c : Int} (h : a < b + c) : a - c < b 
goal: a - c < b

full_name: Int.lt_add_of_neg_add_lt_left
code: protected theorem lt_add_of_neg_add_lt_left {a b c : Int} (h : -b + a < c) : a < b + c 
goal: a < b + c

full_name: Int.neg_add_lt_left_of_lt_add
code: protected theorem neg_add_lt_left_of_lt_add {a b c : Int} (h : a < b + c) : -b + a < c 
goal: -b + a < c

full_name: Int.lt_add_of_neg_add_lt_right
code: protected theorem lt_add_of_neg_add_lt_right {a b c : Int} (h : -c + a < b) : a < b + c 
goal: a < b + c

full_name: Int.neg_add_lt_right_of_lt_add
code: protected theorem neg_add_lt_right_of_lt_add {a b c : Int} (h : a < b + c) : -c + a < b 
goal: -c + a < b

full_name: Int.lt_add_of_neg_lt_sub_left
code: protected theorem lt_add_of_neg_lt_sub_left {a b c : Int} (h : -a < b - c) : c < a + b 
goal: c < a + b

full_name: Int.neg_lt_sub_left_of_lt_add
code: protected theorem neg_lt_sub_left_of_lt_add {a b c : Int} (h : c < a + b) : -a < b - c 
goal: -a < b - c

full_name: Int.lt_add_of_neg_lt_sub_right
code: protected theorem lt_add_of_neg_lt_sub_right {a b c : Int} (h : -b < a - c) : c < a + b 
goal: c < a + b

full_name: Int.neg_lt_sub_right_of_lt_add
code: protected theorem neg_lt_sub_right_of_lt_add {a b c : Int} (h : c < a + b) : -b < a - c 
goal: -b < a - c

full_name: Int.add_lt_iff
code: protected theorem add_lt_iff (a b c : Int) : a + b < c ↔ a < -b + c 
goal: a + b < c ↔ a < -b + c

full_name: Int.sub_lt_iff
code: protected theorem sub_lt_iff (a b c : Int) : a - b < c ↔ a < c + b 
goal: a - b < c ↔ a < c + b

full_name: Int.sub_lt_of_sub_lt
code: protected theorem sub_lt_of_sub_lt {a b c : Int} (h : a - b < c) : a - c < b 
goal: a - c < b

full_name: Int.sub_lt_sub_left
code: protected theorem sub_lt_sub_left {a b : Int} (h : a < b) (c : Int) : c - b < c - a 
goal: c - b < c - a

full_name: Int.sub_lt_sub_right
code: protected theorem sub_lt_sub_right {a b : Int} (h : a < b) (c : Int) : a - c < b - c 
goal: a - c < b - c

full_name: Int.sub_lt_sub
code: protected theorem sub_lt_sub {a b c d : Int} (hab : a < b) (hcd : c < d) : a - d < b - c 
goal: a - d < b - c

full_name: Int.lt_of_sub_lt_sub_left
code: protected theorem lt_of_sub_lt_sub_left {a b c : Int} (h : c - a < c - b) : b < a 
goal: b < a

full_name: Int.lt_of_sub_lt_sub_right
code: protected theorem lt_of_sub_lt_sub_right {a b c : Int} (h : a - c < b - c) : a < b 
goal: a < b

full_name: Int.sub_lt_sub_left_iff
code: @[simp] protected theorem sub_lt_sub_left_iff (a b c : Int) :
    c - a < c - b ↔ b < a 
goal: c - a < c - b ↔ b < a

full_name: Int.sub_lt_sub_right_iff
code: @[simp] protected theorem sub_lt_sub_right_iff (a b c : Int) :
    a - c < b - c ↔ a < b 
goal: a - c < b - c ↔ a < b

full_name: Int.sub_lt_sub_of_le_of_lt
code: protected theorem sub_lt_sub_of_le_of_lt {a b c d : Int}
  (hab : a ≤ b) (hcd : c < d) : a - d < b - c 
goal: a - d < b - c

full_name: Int.sub_lt_sub_of_lt_of_le
code: protected theorem sub_lt_sub_of_lt_of_le {a b c d : Int}
  (hab : a < b) (hcd : c ≤ d) : a - d < b - c 
goal: a - d < b - c

full_name: Int.add_le_add_three
code: 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 
goal: a + b + c ≤ d + e + f

full_name: Int.exists_eq_neg_ofNat
code: theorem exists_eq_neg_ofNat {a : Int} (H : a ≤ 0) : ∃ n : Nat, a = -(n : Int) 
goal: ∃ n, a = -↑n

full_name: Int.lt_of_add_one_le
code: theorem lt_of_add_one_le {a b : Int} (H : a + 1 ≤ b) : a < b 
goal: a < b

full_name: Int.lt_add_one_of_le
code: theorem lt_add_one_of_le {a b : Int} (H : a ≤ b) : a < b + 1 
goal: a < b + 1

full_name: Int.le_of_lt_add_one
code: theorem le_of_lt_add_one {a b : Int} (H : a < b + 1) : a ≤ b 
goal: a ≤ b

full_name: Int.sub_one_lt_of_le
code: theorem sub_one_lt_of_le {a b : Int} (H : a ≤ b) : a - 1 < b 
goal: a - 1 < b

full_name: Int.le_of_sub_one_lt
code: theorem le_of_sub_one_lt {a b : Int} (H : a - 1 < b) : a ≤ b 
goal: a ≤ b

full_name: Int.le_sub_one_of_lt
code: theorem le_sub_one_of_lt {a b : Int} (H : a < b) : a ≤ b - 1 
goal: a ≤ b - 1

full_name: Int.lt_of_le_sub_one
code: theorem lt_of_le_sub_one {a b : Int} (H : a ≤ b - 1) : a < b 
goal: a < b

full_name: Int.mul_lt_mul
code: protected theorem mul_lt_mul {a b c d : Int}
    (h₁ : a < c) (h₂ : b ≤ d) (h₃ : 0 < b) (h₄ : 0 ≤ c) : a * b < c * d 
goal: a * b < c * d

full_name: Int.mul_lt_mul'
code: protected theorem mul_lt_mul' {a b c d : Int}
    (h₁ : a ≤ c) (h₂ : b < d) (h₃ : 0 ≤ b) (h₄ : 0 < c) : a * b < c * d 
goal: a * b < c * d

full_name: Int.mul_neg_of_pos_of_neg
code: protected theorem mul_neg_of_pos_of_neg {a b : Int} (ha : 0 < a) (hb : b < 0) : a * b < 0 
goal: a * b < 0

full_name: Int.mul_neg_of_neg_of_pos
code: protected theorem mul_neg_of_neg_of_pos {a b : Int} (ha : a < 0) (hb : 0 < b) : a * b < 0 
goal: a * b < 0

full_name: Int.mul_nonneg_of_nonpos_of_nonpos
code: protected theorem mul_nonneg_of_nonpos_of_nonpos {a b : Int}
  (ha : a ≤ 0) (hb : b ≤ 0) : 0 ≤ a * b 
goal: 0 ≤ a * b

full_name: Int.mul_lt_mul_of_neg_left
code: protected theorem mul_lt_mul_of_neg_left {a b c : Int} (h : b < a) (hc : c < 0) : c * a < c * b 
goal: c * a < c * b

full_name: Int.mul_lt_mul_of_neg_right
code: protected theorem mul_lt_mul_of_neg_right {a b c : Int} (h : b < a) (hc : c < 0) : a * c < b * c 
goal: a * c < b * c

full_name: Int.mul_pos_of_neg_of_neg
code: protected theorem mul_pos_of_neg_of_neg {a b : Int} (ha : a < 0) (hb : b < 0) : 0 < a * b 
goal: 0 < a * b

full_name: Int.mul_self_le_mul_self
code: protected theorem mul_self_le_mul_self {a b : Int} (h1 : 0 ≤ a) (h2 : a ≤ b) : a * a ≤ b * b 
goal: a * a ≤ b * b

full_name: Int.mul_self_lt_mul_self
code: protected theorem mul_self_lt_mul_self {a b : Int} (h1 : 0 ≤ a) (h2 : a < b) : a * a < b * b 
goal: a * a < b * b

full_name: Int.sign_zero
code: @[simp] theorem sign_zero : sign 0 = 0 
goal: Int.sign 0 = 0

full_name: Int.sign_one
code: @[simp] theorem sign_one : sign 1 = 1 
goal: Int.sign 1 = 1

full_name: Int.sign_neg_one
code: theorem sign_neg_one : sign (-1) = -1 
goal: (-1).sign = -1

full_name: Int.sign_of_add_one
code: @[simp] theorem sign_of_add_one (x : Nat) : Int.sign (x + 1) = 1 
goal: (↑x + 1).sign = 1

full_name: Int.sign_negSucc
code: @[simp] theorem sign_negSucc (x : Nat) : Int.sign (Int.negSucc x) = -1 
goal: (Int.negSucc x).sign = -1

full_name: Int.natAbs_sign
code: theorem natAbs_sign (z : Int) : z.sign.natAbs = if z = 0 then 0 else 1 
goal: z.sign.natAbs = if z = 0 then 0 else 1

full_name: Int.natAbs_sign_of_nonzero
code: theorem natAbs_sign_of_nonzero {z : Int} (hz : z ≠ 0) : z.sign.natAbs = 1 
goal: z.sign.natAbs = 1

full_name: Int.sign_ofNat_of_nonzero
code: theorem sign_ofNat_of_nonzero {n : Nat} (hn : n ≠ 0) : Int.sign n = 1 
goal: (↑n).sign = 1

full_name: Int.sign_neg
code: @[simp] theorem sign_neg (z : Int) : Int.sign (-z) = -Int.sign z 
goal: (-z).sign = -z.sign

full_name: Int.sign_mul_natAbs
code: theorem sign_mul_natAbs : ∀ a : Int, sign a * natAbs a = a
  
goal: a.sign * ↑a.natAbs = a

full_name: Int.sign_mul
code: @[simp] theorem sign_mul : ∀ a b, sign (a * b) = sign a * sign b
  
goal: (a * b).sign = a.sign * b.sign

full_name: Int.sign_eq_one_of_pos
code: theorem sign_eq_one_of_pos {a : Int} (h : 0 < a) : sign a = 1 
goal: a.sign = 1

full_name: Int.sign_eq_neg_one_of_neg
code: theorem sign_eq_neg_one_of_neg {a : Int} (h : a < 0) : sign a = -1 
goal: a.sign = -1

full_name: Int.eq_zero_of_sign_eq_zero
code: theorem eq_zero_of_sign_eq_zero : ∀ {a : Int}, sign a = 0 → a = 0
  
goal: a.sign = 0 → a = 0

full_name: Int.pos_of_sign_eq_one
code: theorem pos_of_sign_eq_one : ∀ {a : Int}, sign a = 1 → 0 < a
  
goal: a.sign = 1 → 0 < a

full_name: Int.neg_of_sign_eq_neg_one
code: theorem neg_of_sign_eq_neg_one : ∀ {a : Int}, sign a = -1 → a < 0
  
goal: a.sign = -1 → a < 0

full_name: Int.sign_eq_one_iff_pos
code: theorem sign_eq_one_iff_pos (a : Int) : sign a = 1 ↔ 0 < a 
goal: a.sign = 1 ↔ 0 < a

full_name: Int.sign_eq_neg_one_iff_neg
code: theorem sign_eq_neg_one_iff_neg (a : Int) : sign a = -1 ↔ a < 0 
goal: a.sign = -1 ↔ a < 0

full_name: Int.sign_eq_zero_iff_zero
code: @[simp] theorem sign_eq_zero_iff_zero (a : Int) : sign a = 0 ↔ a = 0 
goal: a.sign = 0 ↔ a = 0

full_name: Int.sign_sign
code: @[simp] theorem sign_sign : sign (sign x) = sign x 
goal: x.sign.sign = x.sign

full_name: Int.sign_nonneg
code: @[simp] theorem sign_nonneg : 0 ≤ sign x ↔ 0 ≤ x 
goal: 0 ≤ x.sign ↔ 0 ≤ x

full_name: Int.mul_sign
code: theorem mul_sign : ∀ i : Int, i * sign i = natAbs i
  
goal: i * i.sign = ↑i.natAbs

full_name: Int.natAbs_ne_zero
code: theorem natAbs_ne_zero {a : Int} : a.natAbs ≠ 0 ↔ a ≠ 0 
goal: a.natAbs ≠ 0 ↔ a ≠ 0

full_name: Int.natAbs_mul_self
code: theorem natAbs_mul_self : ∀ {a : Int}, ↑(natAbs a * natAbs a) = a * a
  
goal: ↑(a.natAbs * a.natAbs) = a * a

full_name: Int.eq_nat_or_neg
code: theorem eq_nat_or_neg (a : Int) : ∃ n : Nat, a = n ∨ a = -↑n 
goal: ∃ n, a = ↑n ∨ a = -↑n

full_name: Int.natAbs_mul_natAbs_eq
code: theorem natAbs_mul_natAbs_eq {a b : Int} {c : Nat}
    (h : a * b = (c : Int)) : a.natAbs * b.natAbs = c 
goal: a.natAbs * b.natAbs = c

full_name: Int.natAbs_mul_self'
code: @[simp] theorem natAbs_mul_self' (a : Int) : (natAbs a * natAbs a : Int) = a * a 
goal: ↑a.natAbs * ↑a.natAbs = a * a

full_name: Int.natAbs_eq_iff
code: theorem natAbs_eq_iff {a : Int} {n : Nat} : a.natAbs = n ↔ a = n ∨ a = -↑n 
goal: a.natAbs = n ↔ a = ↑n ∨ a = -↑n

full_name: Int.natAbs_add_le
code: theorem natAbs_add_le (a b : Int) : natAbs (a + b) ≤ natAbs a + natAbs b 
goal: (a + b).natAbs ≤ a.natAbs + b.natAbs

full_name: Int.natAbs_sub_le
code: theorem natAbs_sub_le (a b : Int) : natAbs (a - b) ≤ natAbs a + natAbs b 
goal: (a - b).natAbs ≤ a.natAbs + b.natAbs

full_name: Int.negSucc_eq'
code: theorem negSucc_eq' (m : Nat) : -[m+1] = -m - 1 
goal: Int.negSucc m = -↑m - 1

full_name: Int.natAbs_lt_natAbs_of_nonneg_of_lt
code: theorem natAbs_lt_natAbs_of_nonneg_of_lt {a b : Int}
    (w₁ : 0 ≤ a) (w₂ : a < b) : a.natAbs < b.natAbs 
goal: a.natAbs < b.natAbs

full_name: Int.eq_natAbs_iff_mul_eq_zero
code: theorem eq_natAbs_iff_mul_eq_zero : natAbs a = n ↔ (a - n) * (a + n) = 0 
goal: a.natAbs = n ↔ (a - ↑n) * (a + ↑n) = 0