Module docstring
{"# Cast of natural numbers: lemmas about bundled ordered semirings
"}
{"# Cast of natural numbers: lemmas about bundled ordered semirings
"}
Nat.cast_nonneg
theorem
{α} [Semiring α] [PartialOrder α] [IsOrderedRing α] (n : ℕ) : 0 ≤ (n : α)
/-- Specialisation of `Nat.cast_nonneg'`, which seems to be easier for Lean to use. -/
@[simp]
theorem cast_nonneg {α} [Semiring α] [PartialOrder α] [IsOrderedRing α] (n : ℕ) : 0 ≤ (n : α) :=
cast_nonneg' n
Nat.ofNat_nonneg
theorem
{α} [Semiring α] [PartialOrder α] [IsOrderedRing α] (n : ℕ) [n.AtLeastTwo] : 0 ≤ (ofNat(n) : α)
/-- Specialisation of `Nat.ofNat_nonneg'`, which seems to be easier for Lean to use. -/
@[simp]
theorem ofNat_nonneg {α} [Semiring α] [PartialOrder α] [IsOrderedRing α] (n : ℕ) [n.AtLeastTwo] :
0 ≤ (ofNat(n) : α) :=
ofNat_nonneg' n
Nat.cast_min
theorem
{α} [Semiring α] [LinearOrder α] [IsStrictOrderedRing α] (m n : ℕ) : (↑(min m n : ℕ) : α) = min (m : α) n
@[simp, norm_cast]
theorem cast_min {α} [Semiring α] [LinearOrder α] [IsStrictOrderedRing α] (m n : ℕ) :
(↑(min m n : ℕ) : α) = min (m : α) n :=
(@mono_cast α _).map_min
Nat.cast_max
theorem
{α} [Semiring α] [LinearOrder α] [IsStrictOrderedRing α] (m n : ℕ) : (↑(max m n : ℕ) : α) = max (m : α) n
@[simp, norm_cast]
theorem cast_max {α} [Semiring α] [LinearOrder α] [IsStrictOrderedRing α] (m n : ℕ) :
(↑(max m n : ℕ) : α) = max (m : α) n :=
(@mono_cast α _).map_max
Nat.cast_pos
theorem
{α} [Semiring α] [PartialOrder α] [IsOrderedRing α] [Nontrivial α] {n : ℕ} : (0 : α) < n ↔ 0 < n
/-- Specialisation of `Nat.cast_pos'`, which seems to be easier for Lean to use. -/
@[simp]
theorem cast_pos {α} [Semiring α] [PartialOrder α] [IsOrderedRing α] [Nontrivial α] {n : ℕ} :
(0 : α) < n ↔ 0 < n := cast_pos'
Nat.ofNat_pos'
theorem
{n : ℕ} [n.AtLeastTwo] : 0 < (ofNat(n) : α)
/-- See also `Nat.ofNat_pos`, specialised for an `OrderedSemiring`. -/
@[simp low]
theorem ofNat_pos' {n : ℕ} [n.AtLeastTwo] : 0 < (ofNat(n) : α) :=
cast_pos'.mpr (NeZero.pos n)
Nat.ofNat_pos
theorem
{α} [Semiring α] [PartialOrder α] [IsOrderedRing α] [Nontrivial α] {n : ℕ} [n.AtLeastTwo] : 0 < (ofNat(n) : α)
/-- Specialisation of `Nat.ofNat_pos'`, which seems to be easier for Lean to use. -/
@[simp]
theorem ofNat_pos {α} [Semiring α] [PartialOrder α] [IsOrderedRing α] [Nontrivial α]
{n : ℕ} [n.AtLeastTwo] :
0 < (ofNat(n) : α) :=
ofNat_pos'
Nat.cast_tsub
theorem
[CommSemiring α] [PartialOrder α] [IsOrderedRing α] [CanonicallyOrderedAdd α] [Sub α] [OrderedSub α]
[AddLeftReflectLE α] (m n : ℕ) : ↑(m - n) = (m - n : α)
/-- A version of `Nat.cast_sub` that works for `ℝ≥0` and `ℚ≥0`. Note that this proof doesn't work
for `ℕ∞` and `ℝ≥0∞`, so we use type-specific lemmas for these types. -/
@[simp, norm_cast]
theorem cast_tsub [CommSemiring α] [PartialOrder α] [IsOrderedRing α] [CanonicallyOrderedAdd α]
[Sub α] [OrderedSub α] [AddLeftReflectLE α] (m n : ℕ) : ↑(m - n) = (m - n : α) := by
rcases le_total m n with h | h
· rw [Nat.sub_eq_zero_of_le h, cast_zero, tsub_eq_zero_of_le]
exact mono_cast h
· rcases le_iff_exists_add'.mp h with ⟨m, rfl⟩
rw [add_tsub_cancel_right, cast_add, add_tsub_cancel_right]
Nat.abs_cast
theorem
(n : ℕ) : |(n : R)| = n
@[simp, norm_cast]
theorem abs_cast (n : ℕ) : |(n : R)| = n := abs_of_nonneg n.cast_nonneg
Nat.abs_ofNat
theorem
(n : ℕ) [n.AtLeastTwo] : |(ofNat(n) : R)| = ofNat(n)
@[simp]
theorem abs_ofNat (n : ℕ) [n.AtLeastTwo] : |(ofNat(n) : R)| = ofNat(n) := abs_cast n
Nat.neg_cast_eq_cast
theorem
: (-m : R) = n ↔ m = 0 ∧ n = 0
@[simp, norm_cast] lemma neg_cast_eq_cast : (-m : R) = n ↔ m = 0 ∧ n = 0 := by
simp [neg_eq_iff_add_eq_zero, ← cast_add]
Nat.cast_eq_neg_cast
theorem
: (m : R) = -n ↔ m = 0 ∧ n = 0
@[simp, norm_cast] lemma cast_eq_neg_cast : (m : R) = -n ↔ m = 0 ∧ n = 0 := by
simp [eq_neg_iff_add_eq_zero, ← cast_add]
Nat.mul_le_pow
theorem
{a : ℕ} (ha : a ≠ 1) (b : ℕ) : a * b ≤ a ^ b
lemma mul_le_pow {a : ℕ} (ha : a ≠ 1) (b : ℕ) :
a * b ≤ a ^ b := by
induction b generalizing a with
| zero => simp
| succ b hb =>
rw [mul_add_one, pow_succ]
rcases a with (_|_|a)
· simp
· simp at ha
· rw [mul_add_one, mul_add_one, add_comm (_ * a), add_assoc _ (_ * a)]
rcases b with (_|b)
· simp [add_assoc, add_comm]
refine add_le_add (hb (by simp)) ?_
rw [pow_succ']
refine (le_add_left ?_ ?_).trans' ?_
exact le_mul_of_one_le_right' (one_le_pow _ _ (by simp))
Nat.two_mul_sq_add_one_le_two_pow_two_mul
theorem
(k : ℕ) : 2 * k ^ 2 + 1 ≤ 2 ^ (2 * k)
lemma two_mul_sq_add_one_le_two_pow_two_mul (k : ℕ) : 2 * k ^ 2 + 1 ≤ 2 ^ (2 * k) := by
induction k with
| zero => simp
| succ k hk =>
rw [add_pow_two, one_pow, mul_one, add_assoc, mul_add, add_right_comm]
refine (add_le_add_right hk _).trans ?_
rw [mul_add 2 k, pow_add, mul_one, pow_two, ← mul_assoc, mul_two, mul_two, add_assoc]
gcongr
rw [← two_mul, ← pow_succ']
exact le_add_of_le_right (mul_le_pow (by simp) _)