File: Mathlib/Data/Int/Defs.lean

full_name: Int.le_rfl
code: protected lemma le_rfl : a ≤ a 
goal: a ≤ a

full_name: Int.lt_or_lt_of_ne
code: protected lemma lt_or_lt_of_ne : a ≠ b → a < b ∨ b < a 
goal: a ≠ b → a < b ∨ b < a

full_name: Int.lt_or_le
code: protected lemma lt_or_le (a b : ℤ) : a < b ∨ b ≤ a 
goal: a < b ∨ b ≤ a

full_name: Int.le_or_lt
code: protected lemma le_or_lt (a b : ℤ) : a ≤ b ∨ b < a 
goal: a ≤ b ∨ b < a

full_name: Int.lt_asymm
code: protected lemma lt_asymm : a < b → ¬ b < a 
goal: a < b → ¬b < a

full_name: Int.le_of_eq
code: protected lemma le_of_eq (hab : a = b) : a ≤ b 
goal: a ≤ b

full_name: Int.ge_of_eq
code: protected lemma ge_of_eq (hab : a = b) : b ≤ a 
goal: b ≤ a

full_name: Int.le_antisymm_iff
code: protected lemma le_antisymm_iff : a = b ↔ a ≤ b ∧ b ≤ a 
goal: a = b ↔ a ≤ b ∧ b ≤ a

full_name: Int.le_iff_eq_or_lt
code: protected lemma le_iff_eq_or_lt : a ≤ b ↔ a = b ∨ a < b 
goal: a ≤ b ↔ a = b ∨ a < b

full_name: Int.le_iff_lt_or_eq
code: protected lemma le_iff_lt_or_eq : a ≤ b ↔ a < b ∨ a = b 
goal: a ≤ b ↔ a < b ∨ a = b

full_name: Int.one_pos
code: protected lemma one_pos : 0 < (1 : Int) 
goal: 0 < 1

full_name: Int.one_ne_zero
code: protected lemma one_ne_zero : (1 : ℤ) ≠ 0 
goal: 1 ≠ 0

full_name: Int.one_nonneg
code: protected lemma one_nonneg : 0 ≤ (1 : ℤ) 
goal: 0 ≤ 1

full_name: Int.zero_le_ofNat
code: lemma zero_le_ofNat (n : ℕ) : 0 ≤ ofNat n 
goal: 0 ≤ Int.ofNat n

full_name: Int.neg_eq_neg
code: protected theorem neg_eq_neg {a b : ℤ} (h : -a = -b) : a = b 
goal: a = b

full_name: Int.neg_pos
code: @[simp, nolint simpNF]
protected lemma neg_pos : 0 < -a ↔ a < 0 
goal: 0 < -a ↔ a < 0

full_name: Int.neg_nonneg
code: @[simp, nolint simpNF]
protected lemma neg_nonneg : 0 ≤ -a ↔ a ≤ 0 
goal: 0 ≤ -a ↔ a ≤ 0

full_name: Int.neg_neg_iff_pos
code: @[simp, nolint simpNF]
protected lemma neg_neg_iff_pos : -a < 0 ↔ 0 < a 
goal: -a < 0 ↔ 0 < a

full_name: Int.neg_nonpos_iff_nonneg
code: @[simp, nolint simpNF]
protected lemma neg_nonpos_iff_nonneg : -a ≤ 0 ↔ 0 ≤ a 
goal: -a ≤ 0 ↔ 0 ≤ a

full_name: Int.sub_pos
code: @[simp, nolint simpNF]
protected lemma sub_pos : 0 < a - b ↔ b < a 
goal: 0 < a - b ↔ b < a

full_name: Int.sub_nonneg
code: @[simp, nolint simpNF]
protected lemma sub_nonneg : 0 ≤ a - b ↔ b ≤ a 
goal: 0 ≤ a - b ↔ b ≤ a

full_name: Int.instNontrivial
code: instance instNontrivial : Nontrivial ℤ 
goal: Nontrivial ℤ

full_name: Int.ofNat_add_out
code: protected theorem ofNat_add_out (m n : ℕ) : ↑m + ↑n = (↑(m + n) : ℤ) 
goal: ↑m + ↑n = ↑(m + n)

full_name: Int.ofNat_mul_out
code: protected theorem ofNat_mul_out (m n : ℕ) : ↑m * ↑n = (↑(m * n) : ℤ) 
goal: ↑m * ↑n = ↑(m * n)

full_name: Int.ofNat_add_one_out
code: protected theorem ofNat_add_one_out (n : ℕ) : ↑n + (1 : ℤ) = ↑(succ n) 
goal: ↑n + 1 = ↑n.succ

full_name: Int.ofNat_injective
code: @[simp] lemma ofNat_injective : Function.Injective ofNat 
goal: Function.Injective Int.ofNat

full_name: Int.ofNat_eq_natCast
code: @[simp] lemma ofNat_eq_natCast (n : ℕ) : Int.ofNat n = n 
goal: Int.ofNat n = ↑n

full_name: Int.natCast_eq_ofNat
code: @[deprecated ofNat_eq_natCast (since := "2024-03-24")]
protected lemma natCast_eq_ofNat (n : ℕ) : ↑n = Int.ofNat n 
goal: ↑n = Int.ofNat n

full_name: Int.natCast_inj
code: @[norm_cast] lemma natCast_inj {m n : ℕ} : (m : ℤ) = (n : ℤ) ↔ m = n 
goal: ↑m = ↑n ↔ m = n

full_name: Int.natAbs_cast
code: @[simp, norm_cast] lemma natAbs_cast (n : ℕ) : natAbs ↑n = n 
goal: (↑n).natAbs = n

full_name: Int.natCast_sub
code: @[norm_cast]
protected lemma natCast_sub {n m : ℕ} : n ≤ m → (↑(m - n) : ℤ) = ↑m - ↑n 
goal: n ≤ m → ↑(m - n) = ↑m - ↑n

full_name: Int.natCast_eq_zero
code: @[simp, nolint simpNF] lemma natCast_eq_zero {n : ℕ} : (n : ℤ) = 0 ↔ n = 0 
goal: ↑n = 0 ↔ n = 0

full_name: Int.natCast_ne_zero
code: lemma natCast_ne_zero {n : ℕ} : (n : ℤ) ≠ 0 ↔ n ≠ 0 
goal: ↑n ≠ 0 ↔ n ≠ 0

full_name: Int.natCast_ne_zero_iff_pos
code: lemma natCast_ne_zero_iff_pos {n : ℕ} : (n : ℤ) ≠ 0 ↔ 0 < n 
goal: ↑n ≠ 0 ↔ 0 < n

full_name: Int.natCast_pos
code: @[simp, nolint simpNF] lemma natCast_pos {n : ℕ} : (0 : ℤ) < n ↔ 0 < n 
goal: 0 < ↑n ↔ 0 < n

full_name: Int.natCast_succ_pos
code: lemma natCast_succ_pos (n : ℕ) : 0 < (n.succ : ℤ) 
goal: 0 < ↑n.succ

full_name: Int.natCast_nonpos_iff
code: @[simp] lemma natCast_nonpos_iff {n : ℕ} : (n : ℤ) ≤ 0 ↔ n = 0 
goal: ↑n ≤ 0 ↔ n = 0

full_name: Int.natCast_nonneg
code: lemma natCast_nonneg (n : ℕ) : 0 ≤ (n : ℤ) 
goal: 0 ≤ ↑n

full_name: Int.sign_natCast_add_one
code: @[simp] lemma sign_natCast_add_one (n : ℕ) : sign (n + 1) = 1 
goal: (↑n + 1).sign = 1

full_name: Int.cast_id
code: @[simp, norm_cast] lemma cast_id {n : ℤ} : Int.cast n = n 
goal: ↑n = n

full_name: Int.two_mul
code: protected lemma two_mul : ∀ n : ℤ, 2 * n = n + n
  
goal: 2 * n = n + n

full_name: Int.mul_le_mul_iff_of_pos_right
code: protected lemma mul_le_mul_iff_of_pos_right (ha : 0 < a) : b * a ≤ c * a ↔ b ≤ c 
goal: b * a ≤ c * a ↔ b ≤ c

full_name: Int.mul_nonneg_iff_of_pos_right
code: protected lemma mul_nonneg_iff_of_pos_right (hb : 0 < b) : 0 ≤ a * b ↔ 0 ≤ a 
goal: 0 ≤ a * b ↔ 0 ≤ a

full_name: Int.succ
code: /-- Immediate successor of an integer: `succ n = n + 1` -/
def succ (a : ℤ) 
goal: ℤ

full_name: Int.pred
code: /-- Immediate predecessor of an integer: `pred n = n - 1` -/
def pred (a : ℤ) 
goal: ℤ

full_name: Int.natCast_succ
code: lemma natCast_succ (n : ℕ) : (Nat.succ n : ℤ) = Int.succ n 
goal: ↑n.succ = (↑n).succ

full_name: Int.pred_succ
code: lemma pred_succ (a : ℤ) : pred (succ a) = a 
goal: a.succ.pred = a

full_name: Int.succ_pred
code: lemma succ_pred (a : ℤ) : succ (pred a) = a 
goal: a.pred.succ = a

full_name: Int.neg_succ
code: lemma neg_succ (a : ℤ) : -succ a = pred (-a) 
goal: -a.succ = (-a).pred

full_name: Int.succ_neg_succ
code: lemma succ_neg_succ (a : ℤ) : succ (-succ a) = -a 
goal: (-a.succ).succ = -a

full_name: Int.neg_pred
code: lemma neg_pred (a : ℤ) : -pred a = succ (-a) 
goal: -a.pred = (-a).succ

full_name: Int.pred_neg_pred
code: lemma pred_neg_pred (a : ℤ) : pred (-pred a) = -a 
goal: (-a.pred).pred = -a

full_name: Int.pred_nat_succ
code: lemma pred_nat_succ (n : ℕ) : pred (Nat.succ n) = n 
goal: (↑n.succ).pred = ↑n

full_name: Int.neg_nat_succ
code: lemma neg_nat_succ (n : ℕ) : -(Nat.succ n : ℤ) = pred (-n) 
goal: -↑n.succ = (-↑n).pred

full_name: Int.succ_neg_natCast_succ
code: lemma succ_neg_natCast_succ (n : ℕ) : succ (-Nat.succ n) = -n 
goal: (-↑n.succ).succ = -↑n

full_name: Int.natCast_pred_of_pos
code: @[norm_cast] lemma natCast_pred_of_pos {n : ℕ} (h : 0 < n) : ((n - 1 : ℕ) : ℤ) = (n : ℤ) - 1 
goal: ↑(n - 1) = ↑n - 1

full_name: Int.lt_succ_self
code: lemma lt_succ_self (a : ℤ) : a < succ a 
goal: a < a.succ

full_name: Int.pred_self_lt
code: lemma pred_self_lt (a : ℤ) : pred a < a 
goal: a.pred < a

full_name: Int.le_add_one_iff
code: lemma le_add_one_iff : m ≤ n + 1 ↔ m ≤ n ∨ m = n + 1 
goal: m ≤ n + 1 ↔ m ≤ n ∨ m = n + 1

full_name: Int.sub_one_lt_iff
code: lemma sub_one_lt_iff : m - 1 < n ↔ m ≤ n 
goal: m - 1 < n ↔ m ≤ n

full_name: Int.le_sub_one_iff
code: lemma le_sub_one_iff : m ≤ n - 1 ↔ m < n 
goal: m ≤ n - 1 ↔ m < n

full_name: Int.add_le_iff_le_sub
code: protected lemma add_le_iff_le_sub : a + b ≤ c ↔ a ≤ c - b 
goal: a + b ≤ c ↔ a ≤ c - b

full_name: Int.le_add_iff_sub_le
code: protected lemma le_add_iff_sub_le : a ≤ b + c ↔ a - c ≤ b 
goal: a ≤ b + c ↔ a - c ≤ b

full_name: Int.add_le_zero_iff_le_neg
code: protected lemma add_le_zero_iff_le_neg : a + b ≤ 0 ↔ a ≤ - b 
goal: a + b ≤ 0 ↔ a ≤ -b

full_name: Int.add_le_zero_iff_le_neg'
code: protected lemma add_le_zero_iff_le_neg' : a + b ≤ 0 ↔ b ≤ -a 
goal: a + b ≤ 0 ↔ b ≤ -a

full_name: Int.add_nonnneg_iff_neg_le
code: protected lemma add_nonnneg_iff_neg_le : 0 ≤ a + b ↔ -b ≤ a 
goal: 0 ≤ a + b ↔ -b ≤ a

full_name: Int.add_nonnneg_iff_neg_le'
code: protected lemma add_nonnneg_iff_neg_le' : 0 ≤ a + b ↔ -a ≤ b 
goal: 0 ≤ a + b ↔ -a ≤ b

full_name: Int.induction_on
code: @[elab_as_elim] protected lemma induction_on {p : ℤ → Prop} (i : ℤ)
    (hz : p 0) (hp : ∀ i : ℕ, p i → p (i + 1)) (hn : ∀ i : ℕ, p (-i) → p (-i - 1)) : p i 
goal: p i

full_name: Int.inductionOn'.pos
code: /-- Inductively define a function on `ℤ` by defining it at `b`, for the `succ` of a number greater
than `b`, and the `pred` of a number less than `b`. -/
@[elab_as_elim] protected def inductionOn' : C z 
goal: C (b + ↑n)

full_name: Int.inductionOn'
code: /-- Inductively define a function on `ℤ` by defining it at `b`, for the `succ` of a number greater
than `b`, and the `pred` of a number less than `b`. -/
@[elab_as_elim] protected def inductionOn' : C z 
goal: C z

full_name: Int.inductionOn'.neg
code: /-- Inductively define a function on `ℤ` by defining it at `b`, for the `succ` of a number greater
than `b`, and the `pred` of a number less than `b`. -/
@[elab_as_elim] protected def inductionOn' : C z 
goal: C (b + -[n+1])

full_name: Int.inductionOn'_self
code: lemma inductionOn'_self : b.inductionOn' b H0 Hs Hp = H0 
goal: b.inductionOn' b H0 Hs Hp = H0

full_name: Int.inductionOn'_add_one
code: lemma inductionOn'_add_one (hz : b ≤ z) :
    (z + 1).inductionOn' b H0 Hs Hp = Hs z hz (z.inductionOn' b H0 Hs Hp) 
goal: (z + 1).inductionOn' b H0 Hs Hp = Hs z hz (z.inductionOn' b H0 Hs Hp)

full_name: Int.inductionOn'_sub_one
code: lemma inductionOn'_sub_one (hz : z ≤ b) :
    (z - 1).inductionOn' b H0 Hs Hp = Hp z hz (z.inductionOn' b H0 Hs Hp) 
goal: (z - 1).inductionOn' b H0 Hs Hp = Hp z hz (z.inductionOn' b H0 Hs Hp)

full_name: Int.negInduction
code: /-- Inductively define a function on `ℤ` by defining it on `ℕ` and extending it from `n` to `-n`. -/
@[elab_as_elim] protected def negInduction {C : ℤ → Sort*} (nat : ∀ n : ℕ, C n)
    (neg : ∀ n : ℕ, C n → C (-n)) : ∀ n : ℤ, C n
  
goal: C n

full_name: Int.le_induction
code: /-- See `Int.inductionOn'` for an induction in both directions. -/
protected lemma le_induction {P : ℤ → Prop} {m : ℤ} (h0 : P m)
    (h1 : ∀ n : ℤ, m ≤ n → P n → P (n + 1)) (n : ℤ) : m ≤ n → P n 
goal: m ≤ n → P n

full_name: Int.le_induction_down
code: /-- See `Int.inductionOn'` for an induction in both directions. -/
protected theorem le_induction_down {P : ℤ → Prop} {m : ℤ} (h0 : P m)
    (h1 : ∀ n : ℤ, n ≤ m → P n → P (n - 1)) (n : ℤ) : n ≤ m → P n 
goal: n ≤ m → P n

full_name: Int.strongRec
code: /-- A strong recursor for `Int` that specifies explicit values for integers below a threshold,
and is analogous to `Nat.strongRec` for integers on or above the threshold. -/
@[elab_as_elim] protected def strongRec (n : ℤ) : P n 
goal: P n

full_name: Int.strongRec_of_lt
code: lemma strongRec_of_lt (hn : n < m) : m.strongRec lt ge n = lt n hn 
goal: Int.strongRec lt ge n = lt n hn

full_name: Int.strongRec_of_ge
code: lemma strongRec_of_ge :
    ∀ hn : m ≤ n, m.strongRec lt ge n = ge n hn fun k _ ↦ m.strongRec lt ge k 
goal: Int.strongRec lt ge n = ge n hn fun k x => Int.strongRec lt ge k

full_name: Int.natAbs_ofNat'
code: @[simp] lemma natAbs_ofNat' (n : ℕ) : natAbs (ofNat n) = n 
goal: (Int.ofNat n).natAbs = n

full_name: Int.natAbs_add_of_nonneg
code: lemma natAbs_add_of_nonneg : ∀ {a b : Int}, 0 ≤ a → 0 ≤ b → natAbs (a + b) = natAbs a + natAbs b
  
goal: 0 ≤ a → 0 ≤ b → (a + b).natAbs = a.natAbs + b.natAbs

full_name: Int.natAbs_add_of_nonpos
code: lemma natAbs_add_of_nonpos {a b : Int} (ha : a ≤ 0) (hb : b ≤ 0) :
    natAbs (a + b) = natAbs a + natAbs b 
goal: (a + b).natAbs = a.natAbs + b.natAbs

full_name: Int.natAbs_surjective
code: lemma natAbs_surjective : natAbs.Surjective 
goal: Function.Surjective Int.natAbs

full_name: Int.natAbs_pow
code: lemma natAbs_pow (n : ℤ) (k : ℕ) : Int.natAbs (n ^ k) = Int.natAbs n ^ k 
goal: (n ^ k).natAbs = n.natAbs ^ k

full_name: Int.pow_right_injective
code: lemma pow_right_injective (h : 1 < a.natAbs) : ((a ^ ·) : ℕ → ℤ).Injective 
goal: Function.Injective fun x => a ^ x

full_name: Int.natAbs_sq
code: lemma natAbs_sq (x : ℤ) : (x.natAbs : ℤ) ^ 2 = x ^ 2 
goal: ↑x.natAbs ^ 2 = x ^ 2

full_name: Int.natCast_div
code: @[simp, norm_cast] lemma natCast_div (m n : ℕ) : ((m / n : ℕ) : ℤ) = m / n 
goal: ↑(m / n) = ↑m / ↑n

full_name: Int.natCast_ediv
code: lemma natCast_ediv (m n : ℕ) : ((m / n : ℕ) : ℤ) = ediv m n 
goal: ↑(m / n) = (↑m).ediv ↑n

full_name: Int.ediv_of_neg_of_pos
code: lemma ediv_of_neg_of_pos {a b : ℤ} (Ha : a < 0) (Hb : 0 < b) : ediv a b = -((-a - 1) / b + 1) 
goal: a.ediv b = -((-a - 1) / b + 1)

full_name: Int.natCast_mod
code: @[simp, norm_cast] lemma natCast_mod (m n : ℕ) : (↑(m % n) : ℤ) = ↑m % ↑n 
goal: ↑(m % n) = ↑m % ↑n

full_name: Int.add_emod_eq_add_mod_right
code: lemma add_emod_eq_add_mod_right {m n k : ℤ} (i : ℤ) (H : m % n = k % n) :
    (m + i) % n = (k + i) % n 
goal: (m + i) % n = (k + i) % n

full_name: Int.neg_emod_two
code: @[simp] lemma neg_emod_two (i : ℤ) : -i % 2 = i % 2 
goal: -i % 2 = i % 2

full_name: Int.emod_two_eq_zero_or_one
code: lemma emod_two_eq_zero_or_one (n : ℤ) : n % 2 = 0 ∨ n % 2 = 1 
goal: n % 2 = 0 ∨ n % 2 = 1

full_name: Int.mul_dvd_mul
code: protected lemma mul_dvd_mul : a ∣ b → c ∣ d → a * c ∣ b * d
  
goal: a ∣ b → c ∣ d → a * c ∣ b * d

full_name: Int.mul_dvd_mul_left
code: protected lemma mul_dvd_mul_left (a : ℤ) (h : b ∣ c) : a * b ∣ a * c 
goal: a * b ∣ a * c

full_name: Int.mul_dvd_mul_right
code: protected lemma mul_dvd_mul_right (a : ℤ) (h : b ∣ c) : b * a ∣ c * a 
goal: b * a ∣ c * a

full_name: Int.dvd_mul_of_div_dvd
code: lemma dvd_mul_of_div_dvd (h : b ∣ a) (hdiv : a / b ∣ c) : a ∣ b * c 
goal: a ∣ b * c

full_name: Int.div_dvd_iff_dvd_mul
code: @[simp] lemma div_dvd_iff_dvd_mul (h : b ∣ a) (hb : b ≠ 0) : a / b ∣ c ↔ a ∣ b * c 
goal: a / b ∣ c ↔ a ∣ b * c

full_name: Int.mul_dvd_of_dvd_div
code: lemma mul_dvd_of_dvd_div (hcb : c ∣ b) (h : a ∣ b / c) : c * a ∣ b 
goal: c * a ∣ b

full_name: Int.dvd_div_of_mul_dvd
code: lemma dvd_div_of_mul_dvd (h : a * b ∣ c) : b ∣ c / a 
goal: b ∣ c / a

full_name: Int.dvd_div_iff_mul_dvd
code: @[simp] lemma dvd_div_iff_mul_dvd (hbc : c ∣ b) : a ∣ b / c ↔ c * a ∣ b 
goal: a ∣ b / c ↔ c * a ∣ b

full_name: Int.ediv_dvd_ediv
code: lemma ediv_dvd_ediv : ∀ {a b c : ℤ}, a ∣ b → b ∣ c → b / a ∣ c / a
  
goal: a ∣ b → b ∣ c → b / a ∣ c / a

full_name: Int.exists_lt_and_lt_iff_not_dvd
code: /-- If `n > 0` then `m` is not divisible by `n` iff it is between `n * k` and `n * (k + 1)`
  for some `k`. -/
lemma exists_lt_and_lt_iff_not_dvd (m : ℤ) (hn : 0 < n) :
    (∃ k, n * k < m ∧ m < n * (k + 1)) ↔ ¬n ∣ m 
goal: (∃ k, n * k < m ∧ m < n * (k + 1)) ↔ ¬n ∣ m

full_name: Int.natCast_dvd_natCast
code: @[norm_cast] lemma natCast_dvd_natCast {m n : ℕ} : (↑m : ℤ) ∣ ↑n ↔ m ∣ n 
goal: ↑m ∣ ↑n ↔ m ∣ n

full_name: Int.natCast_dvd
code: lemma natCast_dvd {m : ℕ} : (m : ℤ) ∣ n ↔ m ∣ n.natAbs 
goal: ↑m ∣ n ↔ m ∣ n.natAbs

full_name: Int.dvd_natCast
code: lemma dvd_natCast {n : ℕ} : m ∣ (n : ℤ) ↔ m.natAbs ∣ n 
goal: m ∣ ↑n ↔ m.natAbs ∣ n

full_name: Int.natAbs_ediv
code: lemma natAbs_ediv (a b : ℤ) (H : b ∣ a) : natAbs (a / b) = natAbs a / natAbs b 
goal: (a / b).natAbs = a.natAbs / b.natAbs

full_name: Int.dvd_of_mul_dvd_mul_left
code: lemma dvd_of_mul_dvd_mul_left (ha : a ≠ 0) (h : a * m ∣ a * n) : m ∣ n 
goal: m ∣ n

full_name: Int.dvd_of_mul_dvd_mul_right
code: lemma dvd_of_mul_dvd_mul_right (ha : a ≠ 0) (h : m * a ∣ n * a) : m ∣ n 
goal: m ∣ n

full_name: Int.eq_mul_div_of_mul_eq_mul_of_dvd_left
code: lemma eq_mul_div_of_mul_eq_mul_of_dvd_left (hb : b ≠ 0) (hbc : b ∣ c) (h : b * a = c * d) :
    a = c / b * d 
goal: a = c / b * d

full_name: Int.eq_zero_of_dvd_of_natAbs_lt_natAbs
code: /-- If an integer with larger absolute value divides an integer, it is zero. -/
lemma eq_zero_of_dvd_of_natAbs_lt_natAbs (hmn : m ∣ n) (hnm : natAbs n < natAbs m) : n = 0 
goal: n = 0

full_name: Int.eq_zero_of_dvd_of_nonneg_of_lt
code: lemma eq_zero_of_dvd_of_nonneg_of_lt (hm : 0 ≤ m) (hmn : m < n) (hnm : n ∣ m) : m = 0 
goal: m = 0

full_name: Int.eq_of_mod_eq_of_natAbs_sub_lt_natAbs
code: /-- If two integers are congruent to a sufficiently large modulus, they are equal. -/
lemma eq_of_mod_eq_of_natAbs_sub_lt_natAbs {a b c : ℤ} (h1 : a % b = c)
    (h2 : natAbs (a - c) < natAbs b) : a = c 
goal: a = c

full_name: Int.ofNat_add_negSucc_of_ge
code: lemma ofNat_add_negSucc_of_ge {m n : ℕ} (h : n.succ ≤ m) :
    ofNat m + -[n+1] = ofNat (m - n.succ) 
goal: Int.ofNat m + -[n+1] = Int.ofNat (m - n.succ)

full_name: Int.natAbs_le_of_dvd_ne_zero
code: lemma natAbs_le_of_dvd_ne_zero (hmn : m ∣ n) (hn : n ≠ 0) : natAbs m ≤ natAbs n 
goal: m.natAbs ≤ n.natAbs

full_name: Int.natAbs_eq_of_dvd_dvd
code: lemma natAbs_eq_of_dvd_dvd (hmn : m ∣ n) (hnm : n ∣ m) : natAbs m = natAbs n 
goal: m.natAbs = n.natAbs

full_name: Int.ediv_dvd_of_dvd
code: lemma ediv_dvd_of_dvd (hmn : m ∣ n) : n / m ∣ n 
goal: n / m ∣ n

full_name: Int.le_iff_pos_of_dvd
code: lemma le_iff_pos_of_dvd (ha : 0 < a) (hab : a ∣ b) : a ≤ b ↔ 0 < b 
goal: a ≤ b ↔ 0 < b

full_name: Int.le_add_iff_lt_of_dvd_sub
code: lemma le_add_iff_lt_of_dvd_sub (ha : 0 < a) (hab : a ∣ c - b) : a + b ≤ c ↔ b < c 
goal: a + b ≤ c ↔ b < c

full_name: Int.sign_natCast_of_ne_zero
code: lemma sign_natCast_of_ne_zero {n : ℕ} (hn : n ≠ 0) : Int.sign n = 1 
goal: (↑n).sign = 1

full_name: Int.sign_add_eq_of_sign_eq
code: lemma sign_add_eq_of_sign_eq : ∀ {m n : ℤ}, m.sign = n.sign → (m + n).sign = n.sign 
goal: m.sign = n.sign → (m + n).sign = n.sign

full_name: Int.toNat_natCast
code: @[simp] lemma toNat_natCast (n : ℕ) : toNat ↑n = n 
goal: (↑n).toNat = n

full_name: Int.toNat_natCast_add_one
code: @[simp] lemma toNat_natCast_add_one {n : ℕ} : ((n : ℤ) + 1).toNat = n + 1 
goal: (↑n + 1).toNat = n + 1

full_name: Int.toNat_le
code: @[simp] lemma toNat_le {n : ℕ} : toNat m ≤ n ↔ m ≤ n 
goal: m.toNat ≤ n ↔ m ≤ ↑n

full_name: Int.lt_toNat
code: @[simp]
lemma lt_toNat {m : ℕ} : m < toNat n ↔ (m : ℤ) < n 
goal: m < n.toNat ↔ ↑m < n

full_name: Int.toNat_le_toNat
code: lemma toNat_le_toNat {a b : ℤ} (h : a ≤ b) : toNat a ≤ toNat b 
goal: a.toNat ≤ b.toNat

full_name: Int.toNat_lt_toNat
code: lemma toNat_lt_toNat {a b : ℤ} (hb : 0 < b) : toNat a < toNat b ↔ a < b 
goal: a.toNat < b.toNat ↔ a < b

full_name: Int.lt_of_toNat_lt
code: lemma lt_of_toNat_lt {a b : ℤ} (h : toNat a < toNat b) : a < b 
goal: a < b

full_name: Int.toNat_pred_coe_of_pos
code: @[simp] lemma toNat_pred_coe_of_pos {i : ℤ} (h : 0 < i) : ((i.toNat - 1 : ℕ) : ℤ) = i - 1 
goal: ↑(i.toNat - 1) = i - 1

full_name: Int.toNat_eq_zero
code: @[simp] lemma toNat_eq_zero : ∀ {n : ℤ}, n.toNat = 0 ↔ n ≤ 0
  
goal: n.toNat = 0 ↔ n ≤ 0

full_name: Int.toNat_sub_of_le
code: @[simp]
theorem toNat_sub_of_le {a b : ℤ} (h : b ≤ a) : (toNat (a - b) : ℤ) = a - b 
goal: ↑(a - b).toNat = a - b

full_name: Int.toNat_lt'
code: lemma toNat_lt' {n : ℕ} (hn : n ≠ 0) : m.toNat < n ↔ m < n 
goal: m.toNat < n ↔ m < ↑n

full_name: Int.natMod
code: /-- The modulus of an integer by another as a natural. Uses the E-rounding convention. -/
def natMod (m n : ℤ) : ℕ 
goal: ℕ

full_name: Int.natMod_lt
code: lemma natMod_lt {n : ℕ} (hn : n ≠ 0) : m.natMod n < n 
goal: m.natMod ↑n < n

full_name: Int.pow_eq
code: @[simp] lemma pow_eq (m : ℤ) (n : ℕ) : m.pow n = m ^ n 
goal: m.pow n = m ^ n