Module docstring
{"# Casts of rational numbers into linear ordered fields. "}
{"# Casts of rational numbers into linear ordered fields. "}
Rat.castHom_rat
theorem
: castHom ℚ = RingHom.id ℚ
@[simp]
theorem castHom_rat : castHom ℚ = RingHom.id ℚ :=
RingHom.ext cast_id
Rat.cast_pos_of_pos
theorem
(hq : 0 < q) : (0 : K) < q
theorem cast_pos_of_pos (hq : 0 < q) : (0 : K) < q := by
rw [Rat.cast_def]
exact div_pos (Int.cast_pos.2 <| num_pos.2 hq) (Nat.cast_pos.2 q.pos)
Rat.cast_strictMono
theorem
: StrictMono ((↑) : ℚ → K)
@[mono]
theorem cast_strictMono : StrictMono ((↑) : ℚ → K) := fun p q => by
simpa only [sub_pos, cast_sub] using cast_pos_of_pos (K := K) (q := q - p)
Rat.cast_mono
theorem
: Monotone ((↑) : ℚ → K)
@[mono]
theorem cast_mono : Monotone ((↑) : ℚ → K) :=
cast_strictMono.monotone
Rat.castOrderEmbedding
definition
: ℚ ↪o K
/-- Coercion from `ℚ` as an order embedding. -/
@[simps!]
def castOrderEmbedding : ℚℚ ↪o K :=
OrderEmbedding.ofStrictMono (↑) cast_strictMono
Rat.cast_le
theorem
: (p : K) ≤ q ↔ p ≤ q
@[simp, norm_cast] lemma cast_le : (p : K) ≤ q ↔ p ≤ q := castOrderEmbedding.le_iff_le
Rat.cast_lt
theorem
: (p : K) < q ↔ p < q
@[simp, norm_cast] lemma cast_lt : (p : K) < q ↔ p < q := cast_strictMono.lt_iff_lt
Rat.cast_nonneg
theorem
: 0 ≤ (q : K) ↔ 0 ≤ q
@[simp] lemma cast_nonneg : 0 ≤ (q : K) ↔ 0 ≤ q := by norm_cast
Rat.cast_nonpos
theorem
: (q : K) ≤ 0 ↔ q ≤ 0
@[simp] lemma cast_nonpos : (q : K) ≤ 0 ↔ q ≤ 0 := by norm_cast
Rat.cast_pos
theorem
: (0 : K) < q ↔ 0 < q
@[simp] lemma cast_pos : (0 : K) < q ↔ 0 < q := by norm_cast
Rat.cast_lt_zero
theorem
: (q : K) < 0 ↔ q < 0
@[simp] lemma cast_lt_zero : (q : K) < 0 ↔ q < 0 := by norm_cast
Rat.cast_le_natCast
theorem
{m : ℚ} {n : ℕ} : (m : K) ≤ n ↔ m ≤ (n : ℚ)
@[simp, norm_cast]
theorem cast_le_natCast {m : ℚ} {n : ℕ} : (m : K) ≤ n ↔ m ≤ (n : ℚ) := by
rw [← cast_le (K := K), cast_natCast]
Rat.natCast_le_cast
theorem
{m : ℕ} {n : ℚ} : (m : K) ≤ n ↔ (m : ℚ) ≤ n
@[simp, norm_cast]
theorem natCast_le_cast {m : ℕ} {n : ℚ} : (m : K) ≤ n ↔ (m : ℚ) ≤ n := by
rw [← cast_le (K := K), cast_natCast]
Rat.cast_le_intCast
theorem
{m : ℚ} {n : ℤ} : (m : K) ≤ n ↔ m ≤ (n : ℚ)
@[simp, norm_cast]
theorem cast_le_intCast {m : ℚ} {n : ℤ} : (m : K) ≤ n ↔ m ≤ (n : ℚ) := by
rw [← cast_le (K := K), cast_intCast]
Rat.intCast_le_cast
theorem
{m : ℤ} {n : ℚ} : (m : K) ≤ n ↔ (m : ℚ) ≤ n
@[simp, norm_cast]
theorem intCast_le_cast {m : ℤ} {n : ℚ} : (m : K) ≤ n ↔ (m : ℚ) ≤ n := by
rw [← cast_le (K := K), cast_intCast]
Rat.cast_lt_natCast
theorem
{m : ℚ} {n : ℕ} : (m : K) < n ↔ m < (n : ℚ)
@[simp, norm_cast]
theorem cast_lt_natCast {m : ℚ} {n : ℕ} : (m : K) < n ↔ m < (n : ℚ) := by
rw [← cast_lt (K := K), cast_natCast]
Rat.natCast_lt_cast
theorem
{m : ℕ} {n : ℚ} : (m : K) < n ↔ (m : ℚ) < n
@[simp, norm_cast]
theorem natCast_lt_cast {m : ℕ} {n : ℚ} : (m : K) < n ↔ (m : ℚ) < n := by
rw [← cast_lt (K := K), cast_natCast]
Rat.cast_lt_intCast
theorem
{m : ℚ} {n : ℤ} : (m : K) < n ↔ m < (n : ℚ)
@[simp, norm_cast]
theorem cast_lt_intCast {m : ℚ} {n : ℤ} : (m : K) < n ↔ m < (n : ℚ) := by
rw [← cast_lt (K := K), cast_intCast]
Rat.intCast_lt_cast
theorem
{m : ℤ} {n : ℚ} : (m : K) < n ↔ (m : ℚ) < n
@[simp, norm_cast]
theorem intCast_lt_cast {m : ℤ} {n : ℚ} : (m : K) < n ↔ (m : ℚ) < n := by
rw [← cast_lt (K := K), cast_intCast]
Rat.cast_min
theorem
(p q : ℚ) : (↑(min p q) : K) = min (p : K) (q : K)
Rat.cast_max
theorem
(p q : ℚ) : (↑(max p q) : K) = max (p : K) (q : K)
Rat.cast_abs
theorem
(q : ℚ) : ((|q| : ℚ) : K) = |(q : K)|
@[simp, norm_cast] lemma cast_abs (q : ℚ) : ((|q| : ℚ) : K) = |(q : K)| := by simp [abs_eq_max_neg]
Rat.preimage_cast_Icc
theorem
(p q : ℚ) : (↑) ⁻¹' Icc (p : K) q = Icc p q
@[simp]
theorem preimage_cast_Icc (p q : ℚ) : (↑) ⁻¹' Icc (p : K) q = Icc p q :=
castOrderEmbedding.preimage_Icc ..
Rat.preimage_cast_Ico
theorem
(p q : ℚ) : (↑) ⁻¹' Ico (p : K) q = Ico p q
@[simp]
theorem preimage_cast_Ico (p q : ℚ) : (↑) ⁻¹' Ico (p : K) q = Ico p q :=
castOrderEmbedding.preimage_Ico ..
Rat.preimage_cast_Ioc
theorem
(p q : ℚ) : (↑) ⁻¹' Ioc (p : K) q = Ioc p q
@[simp]
theorem preimage_cast_Ioc (p q : ℚ) : (↑) ⁻¹' Ioc (p : K) q = Ioc p q :=
castOrderEmbedding.preimage_Ioc p q
Rat.preimage_cast_Ioo
theorem
(p q : ℚ) : (↑) ⁻¹' Ioo (p : K) q = Ioo p q
@[simp]
theorem preimage_cast_Ioo (p q : ℚ) : (↑) ⁻¹' Ioo (p : K) q = Ioo p q :=
castOrderEmbedding.preimage_Ioo p q
Rat.preimage_cast_Ici
theorem
(q : ℚ) : (↑) ⁻¹' Ici (q : K) = Ici q
@[simp]
theorem preimage_cast_Ici (q : ℚ) : (↑) ⁻¹' Ici (q : K) = Ici q :=
castOrderEmbedding.preimage_Ici q
Rat.preimage_cast_Iic
theorem
(q : ℚ) : (↑) ⁻¹' Iic (q : K) = Iic q
@[simp]
theorem preimage_cast_Iic (q : ℚ) : (↑) ⁻¹' Iic (q : K) = Iic q :=
castOrderEmbedding.preimage_Iic q
Rat.preimage_cast_Ioi
theorem
(q : ℚ) : (↑) ⁻¹' Ioi (q : K) = Ioi q
@[simp]
theorem preimage_cast_Ioi (q : ℚ) : (↑) ⁻¹' Ioi (q : K) = Ioi q :=
castOrderEmbedding.preimage_Ioi q
Rat.preimage_cast_Iio
theorem
(q : ℚ) : (↑) ⁻¹' Iio (q : K) = Iio q
@[simp]
theorem preimage_cast_Iio (q : ℚ) : (↑) ⁻¹' Iio (q : K) = Iio q :=
castOrderEmbedding.preimage_Iio q
Rat.preimage_cast_uIcc
theorem
(p q : ℚ) : (↑) ⁻¹' uIcc (p : K) q = uIcc p q
@[simp]
theorem preimage_cast_uIcc (p q : ℚ) : (↑) ⁻¹' uIcc (p : K) q = uIcc p q :=
(castOrderEmbedding (K := K)).preimage_uIcc p q
Rat.preimage_cast_uIoc
theorem
(p q : ℚ) : (↑) ⁻¹' uIoc (p : K) q = uIoc p q
@[simp]
theorem preimage_cast_uIoc (p q : ℚ) : (↑) ⁻¹' uIoc (p : K) q = uIoc p q :=
(castOrderEmbedding (K := K)).preimage_uIoc p q
NNRat.cast_strictMono
theorem
: StrictMono ((↑) : ℚ≥0 → K)
theorem cast_strictMono : StrictMono ((↑) : ℚ≥0 → K) := fun p q h => by
rwa [NNRat.cast_def, NNRat.cast_def, div_lt_div_iff₀, ← Nat.cast_mul, ← Nat.cast_mul,
Nat.cast_lt (α := K), ← NNRat.lt_def]
· simp
· simp
NNRat.cast_mono
theorem
: Monotone ((↑) : ℚ≥0 → K)
@[mono]
theorem cast_mono : Monotone ((↑) : ℚ≥0 → K) :=
cast_strictMono.monotone
NNRat.castOrderEmbedding
definition
: ℚ≥0 ↪o K
/-- Coercion from `ℚ` as an order embedding. -/
@[simps!]
def castOrderEmbedding : ℚ≥0ℚ≥0 ↪o K :=
OrderEmbedding.ofStrictMono (↑) cast_strictMono
NNRat.cast_le
theorem
: (p : K) ≤ q ↔ p ≤ q
@[simp, norm_cast] lemma cast_le : (p : K) ≤ q ↔ p ≤ q := castOrderEmbedding.le_iff_le
NNRat.cast_lt
theorem
: (p : K) < q ↔ p < q
@[simp, norm_cast] lemma cast_lt : (p : K) < q ↔ p < q := cast_strictMono.lt_iff_lt
NNRat.cast_nonpos
theorem
: (q : K) ≤ 0 ↔ q ≤ 0
@[simp] lemma cast_nonpos : (q : K) ≤ 0 ↔ q ≤ 0 := by norm_cast
NNRat.cast_pos
theorem
: (0 : K) < q ↔ 0 < q
@[simp] lemma cast_pos : (0 : K) < q ↔ 0 < q := by norm_cast
NNRat.cast_lt_zero
theorem
: (q : K) < 0 ↔ q < 0
@[norm_cast] lemma cast_lt_zero : (q : K) < 0 ↔ q < 0 := by norm_cast
NNRat.not_cast_lt_zero
theorem
: ¬(q : K) < 0
@[simp] lemma not_cast_lt_zero : ¬(q : K) < 0 := mod_cast not_lt_zero'
NNRat.cast_le_one
theorem
: (p : K) ≤ 1 ↔ p ≤ 1
@[simp] lemma cast_le_one : (p : K) ≤ 1 ↔ p ≤ 1 := by norm_cast
NNRat.one_le_cast
theorem
: 1 ≤ (p : K) ↔ 1 ≤ p
@[simp] lemma one_le_cast : 1 ≤ (p : K) ↔ 1 ≤ p := by norm_cast
NNRat.cast_lt_one
theorem
: (p : K) < 1 ↔ p < 1
@[simp] lemma cast_lt_one : (p : K) < 1 ↔ p < 1 := by norm_cast
NNRat.one_lt_cast
theorem
: 1 < (p : K) ↔ 1 < p
@[simp] lemma one_lt_cast : 1 < (p : K) ↔ 1 < p := by norm_cast
NNRat.cast_le_ofNat
theorem
: (p : K) ≤ ofNat(n) ↔ p ≤ OfNat.ofNat n
@[simp] lemma cast_le_ofNat : (p : K) ≤ ofNat(n) ↔ p ≤ OfNat.ofNat n := by
simp [← cast_le (K := K)]
NNRat.ofNat_le_cast
theorem
: ofNat(n) ≤ (p : K) ↔ OfNat.ofNat n ≤ p
@[simp] lemma ofNat_le_cast : ofNat(n)ofNat(n) ≤ (p : K) ↔ OfNat.ofNat n ≤ p := by
simp [← cast_le (K := K)]
NNRat.cast_lt_ofNat
theorem
: (p : K) < ofNat(n) ↔ p < OfNat.ofNat n
@[simp] lemma cast_lt_ofNat : (p : K) < ofNat(n) ↔ p < OfNat.ofNat n := by
simp [← cast_lt (K := K)]
NNRat.ofNat_lt_cast
theorem
: ofNat(n) < (p : K) ↔ OfNat.ofNat n < p
@[simp] lemma ofNat_lt_cast : ofNat(n)ofNat(n) < (p : K) ↔ OfNat.ofNat n < p := by
simp [← cast_lt (K := K)]
NNRat.cast_le_natCast
theorem
{m : ℚ≥0} {n : ℕ} : (m : K) ≤ n ↔ m ≤ (n : ℚ≥0)
@[simp, norm_cast]
theorem cast_le_natCast {m : ℚ≥0} {n : ℕ} : (m : K) ≤ n ↔ m ≤ (n : ℚ≥0) := by
rw [← cast_le (K := K), cast_natCast]
NNRat.natCast_le_cast
theorem
{m : ℕ} {n : ℚ≥0} : (m : K) ≤ n ↔ (m : ℚ≥0) ≤ n
@[simp, norm_cast]
theorem natCast_le_cast {m : ℕ} {n : ℚ≥0} : (m : K) ≤ n ↔ (m : ℚ≥0) ≤ n := by
rw [← cast_le (K := K), cast_natCast]
NNRat.cast_lt_natCast
theorem
{m : ℚ≥0} {n : ℕ} : (m : K) < n ↔ m < (n : ℚ≥0)
@[simp, norm_cast]
theorem cast_lt_natCast {m : ℚ≥0} {n : ℕ} : (m : K) < n ↔ m < (n : ℚ≥0) := by
rw [← cast_lt (K := K), cast_natCast]
NNRat.natCast_lt_cast
theorem
{m : ℕ} {n : ℚ≥0} : (m : K) < n ↔ (m : ℚ≥0) < n
@[simp, norm_cast]
theorem natCast_lt_cast {m : ℕ} {n : ℚ≥0} : (m : K) < n ↔ (m : ℚ≥0) < n := by
rw [← cast_lt (K := K), cast_natCast]
NNRat.cast_min
theorem
(p q : ℚ≥0) : (↑(min p q) : K) = min (p : K) (q : K)
NNRat.cast_max
theorem
(p q : ℚ≥0) : (↑(max p q) : K) = max (p : K) (q : K)
NNRat.preimage_cast_Icc
theorem
(p q : ℚ≥0) : (↑) ⁻¹' Icc (p : K) q = Icc p q
@[simp]
theorem preimage_cast_Icc (p q : ℚ≥0) : (↑) ⁻¹' Icc (p : K) q = Icc p q :=
castOrderEmbedding.preimage_Icc ..
NNRat.preimage_cast_Ico
theorem
(p q : ℚ≥0) : (↑) ⁻¹' Ico (p : K) q = Ico p q
@[simp]
theorem preimage_cast_Ico (p q : ℚ≥0) : (↑) ⁻¹' Ico (p : K) q = Ico p q :=
castOrderEmbedding.preimage_Ico ..
NNRat.preimage_cast_Ioc
theorem
(p q : ℚ≥0) : (↑) ⁻¹' Ioc (p : K) q = Ioc p q
@[simp]
theorem preimage_cast_Ioc (p q : ℚ≥0) : (↑) ⁻¹' Ioc (p : K) q = Ioc p q :=
castOrderEmbedding.preimage_Ioc p q
NNRat.preimage_cast_Ioo
theorem
(p q : ℚ≥0) : (↑) ⁻¹' Ioo (p : K) q = Ioo p q
@[simp]
theorem preimage_cast_Ioo (p q : ℚ≥0) : (↑) ⁻¹' Ioo (p : K) q = Ioo p q :=
castOrderEmbedding.preimage_Ioo p q
NNRat.preimage_cast_Ici
theorem
(p : ℚ≥0) : (↑) ⁻¹' Ici (p : K) = Ici p
@[simp]
theorem preimage_cast_Ici (p : ℚ≥0) : (↑) ⁻¹' Ici (p : K) = Ici p :=
castOrderEmbedding.preimage_Ici p
NNRat.preimage_cast_Iic
theorem
(p : ℚ≥0) : (↑) ⁻¹' Iic (p : K) = Iic p
@[simp]
theorem preimage_cast_Iic (p : ℚ≥0) : (↑) ⁻¹' Iic (p : K) = Iic p :=
castOrderEmbedding.preimage_Iic p
NNRat.preimage_cast_Ioi
theorem
(p : ℚ≥0) : (↑) ⁻¹' Ioi (p : K) = Ioi p
@[simp]
theorem preimage_cast_Ioi (p : ℚ≥0) : (↑) ⁻¹' Ioi (p : K) = Ioi p :=
castOrderEmbedding.preimage_Ioi p
NNRat.preimage_cast_Iio
theorem
(p : ℚ≥0) : (↑) ⁻¹' Iio (p : K) = Iio p
@[simp]
theorem preimage_cast_Iio (p : ℚ≥0) : (↑) ⁻¹' Iio (p : K) = Iio p :=
castOrderEmbedding.preimage_Iio p
NNRat.preimage_cast_uIcc
theorem
(p q : ℚ≥0) : (↑) ⁻¹' uIcc (p : K) q = uIcc p q
@[simp]
theorem preimage_cast_uIcc (p q : ℚ≥0) : (↑) ⁻¹' uIcc (p : K) q = uIcc p q :=
(castOrderEmbedding (K := K)).preimage_uIcc p q
NNRat.preimage_cast_uIoc
theorem
(p q : ℚ≥0) : (↑) ⁻¹' uIoc (p : K) q = uIoc p q
@[simp]
theorem preimage_cast_uIoc (p q : ℚ≥0) : (↑) ⁻¹' uIoc (p : K) q = uIoc p q :=
(castOrderEmbedding (K := K)).preimage_uIoc p q
Mathlib.Meta.Positivity.evalRatCast
definition
: PositivityExt
/-- Extension for Rat.cast. -/
@[positivity Rat.cast _]
def evalRatCast : PositivityExt where eval {u α} _zα _pα e := do
let ~q(@Rat.cast _ (_) ($a : ℚ)) := e | throwError "not Rat.cast"
match ← core q(inferInstance) q(inferInstance) a with
| .positive pa =>
let _oα ← synthInstanceQ q(Field $α)
let _oα ← synthInstanceQ q(LinearOrder $α)
let _oα ← synthInstanceQ q(IsStrictOrderedRing $α)
assumeInstancesCommute
return .positive q((Rat.cast_pos (K := $α)).mpr $pa)
| .nonnegative pa =>
let _oα ← synthInstanceQ q(Field $α)
let _oα ← synthInstanceQ q(LinearOrder $α)
let _oα ← synthInstanceQ q(IsStrictOrderedRing $α)
assumeInstancesCommute
return .nonnegative q((Rat.cast_nonneg (K := $α)).mpr $pa)
| .nonzero pa =>
let _oα ← synthInstanceQ q(DivisionRing $α)
let _cα ← synthInstanceQ q(CharZero $α)
assumeInstancesCommute
return .nonzero q((Rat.cast_ne_zero (α := $α)).mpr $pa)
| .none => pure .none
Mathlib.Meta.Positivity.evalNNRatCast
definition
: PositivityExt
/-- Extension for NNRat.cast. -/
@[positivity NNRat.cast _]
def evalNNRatCast : PositivityExt where eval {u α} _zα _pα e := do
let ~q(@NNRat.cast _ (_) ($a : ℚ≥0)) := e | throwError "not NNRat.cast"
match ← core q(inferInstance) q(inferInstance) a with
| .positive pa =>
let _oα ← synthInstanceQ q(Semifield $α)
let _oα ← synthInstanceQ q(LinearOrder $α)
let _oα ← synthInstanceQ q(IsStrictOrderedRing $α)
assumeInstancesCommute
return .positive q((NNRat.cast_pos (K := $α)).mpr $pa)
| _ =>
let _oα ← synthInstanceQ q(Semifield $α)
let _oα ← synthInstanceQ q(LinearOrder $α)
let _oα ← synthInstanceQ q(IsStrictOrderedRing $α)
assumeInstancesCommute
return .nonnegative q(NNRat.cast_nonneg _)