mathlib documentation

data.​rat.​basic

data.​rat.​basic

Basics for the Rational Numbers

Summary

We define a rational number q as a structure { num, denom, pos, cop }, where

We then define the expected (discrete) field structure on and prove basic lemmas about it. Moreoever, we provide the expected casts from and into , i.e. (↑n : ℚ) = n / 1.

Main Definitions

Notations

Tags

rat, rationals, field, ℚ, numerator, denominator, num, denom

structure rat  :
Type

rat, or , is the type of rational numbers. It is defined as the set of pairs ⟨n, d⟩ of integers such that d is positive and n and d are coprime. This representation is preferred to the quotient because without periodic reduction, the numerator and denominator can grow exponentially (for example, adding 1/2 to itself repeatedly).

def rat.​repr  :

Equations
@[instance]

Equations
@[instance]

@[instance]

Equations
def rat.​of_int  :

Embed an integer as a rational number

Equations
@[instance]

Equations
@[instance]

Equations
@[instance]

Equations
def rat.​mk_pnat  :
ℕ+

Form the quotient n / d where n:ℤ and d:ℕ+ (not necessarily coprime)

Equations
def rat.​mk_nat  :

Form the quotient n / d where n:ℤ and d:ℕ. In the case d = 0, we define n / 0 = 0 by convention.

Equations
def rat.​mk  :

Form the quotient n / d where n d : ℤ.

Equations
theorem rat.​mk_pnat_eq (n : ) (d : ) (h : 0 < d) :
rat.mk_pnat n d, h⟩ = rat.mk n d

theorem rat.​mk_nat_eq (n : ) (d : ) :

@[simp]
theorem rat.​mk_zero (n : ) :
rat.mk n 0 = 0

@[simp]
theorem rat.​zero_mk_pnat (n : ℕ+) :

@[simp]
theorem rat.​zero_mk_nat (n : ) :

@[simp]
theorem rat.​zero_mk (n : ) :
rat.mk 0 n = 0

@[simp]
theorem rat.​mk_eq_zero {a b : } :
b 0(rat.mk a b = 0 a = 0)

theorem rat.​mk_eq {a b c d : } :
b 0d 0(rat.mk a b = rat.mk c d a * d = c * b)

@[simp]
theorem rat.​div_mk_div_cancel_left {a b c : } :
c 0rat.mk (a * c) (b * c) = rat.mk a b

@[simp]
theorem rat.​num_denom {a : } :

theorem rat.​num_denom' {n : } {d : } {h : 0 < d} {c : n.nat_abs.coprime d} :
{num := n, denom := d, pos := h, cop := c} = rat.mk n d

theorem rat.​of_int_eq_mk (z : ) :

def rat.​num_denom_cases_on {C : Sort u} (a : ) :
(Π (n : ) (d : ), 0 < dn.nat_abs.coprime dC (rat.mk n d))C a

Equations
def rat.​num_denom_cases_on' {C : Sort u} (a : ) :
(Π (n : ) (d : ), d 0C (rat.mk n d))C a

Equations
theorem rat.​num_dvd (a : ) {b : } :
b 0(rat.mk a b).num a

theorem rat.​denom_dvd (a b : ) :
((rat.mk a b).denom) b

def rat.​add  :

Equations
@[instance]

Equations
theorem rat.​lift_binop_eq (f : ) (f₁ f₂ : ) (fv : ∀ {n₁ : } {d₁ : } {h₁ : 0 < d₁} {c₁ : n₁.nat_abs.coprime d₁} {n₂ : } {d₂ : } {h₂ : 0 < d₂} {c₂ : n₂.nat_abs.coprime d₂}, f {num := n₁, denom := d₁, pos := h₁, cop := c₁} {num := n₂, denom := d₂, pos := h₂, cop := c₂} = rat.mk (f₁ n₁ d₁ n₂ d₂) (f₂ n₁ d₁ n₂ d₂)) (f0 : ∀ {n₁ d₁ n₂ d₂ : }, d₁ 0d₂ 0f₂ n₁ d₁ n₂ d₂ 0) (a b c d : ) :
b 0d 0(∀ {n₁ d₁ n₂ d₂ : }, a * d₁ = n₁ * bc * d₂ = n₂ * df₁ n₁ d₁ n₂ d₂ * f₂ a b c d = f₁ a b c d * f₂ n₁ d₁ n₂ d₂)f (rat.mk a b) (rat.mk c d) = rat.mk (f₁ a b c d) (f₂ a b c d)

@[simp]
theorem rat.​add_def {a b c d : } :
b 0d 0rat.mk a b + rat.mk c d = rat.mk (a * d + c * b) (b * d)

def rat.​neg  :

Equations
@[instance]

Equations
@[simp]
theorem rat.​neg_def {a b : } :
-rat.mk a b = rat.mk (-a) b

def rat.​mul  :

Equations
@[instance]

Equations
@[simp]
theorem rat.​mul_def {a b c d : } :
b 0d 0rat.mk a b * rat.mk c d = rat.mk (a * c) (b * d)

def rat.​inv  :

Equations
@[instance]

Equations
@[simp]
theorem rat.​inv_def {a b : } :
(rat.mk a b)⁻¹ = rat.mk b a

theorem rat.​add_zero (a : ) :
a + 0 = a

theorem rat.​zero_add (a : ) :
0 + a = a

theorem rat.​add_comm (a b : ) :
a + b = b + a

theorem rat.​add_assoc (a b c : ) :
a + b + c = a + (b + c)

theorem rat.​add_left_neg (a : ) :
-a + a = 0

theorem rat.​mul_one (a : ) :
a * 1 = a

theorem rat.​one_mul (a : ) :
1 * a = a

theorem rat.​mul_comm (a b : ) :
a * b = b * a

theorem rat.​mul_assoc (a b c : ) :
a * b * c = a * (b * c)

theorem rat.​add_mul (a b c : ) :
(a + b) * c = a * c + b * c

theorem rat.​mul_add (a b c : ) :
a * (b + c) = a * b + a * c

theorem rat.​zero_ne_one  :
0 1

theorem rat.​mul_inv_cancel (a : ) :
a 0a * a⁻¹ = 1

theorem rat.​inv_mul_cancel (a : ) :
a 0a⁻¹ * a = 1

@[instance]

Equations
@[instance]

Equations
@[instance]

Equations
theorem rat.​sub_def {a b c d : } :
b 0d 0rat.mk a b - rat.mk c d = rat.mk (a * d - c * b) (b * d)

@[simp]
theorem rat.​denom_neg_eq_denom (q : ) :
(-q).denom = q.denom

@[simp]
theorem rat.​num_neg_eq_neg_num (q : ) :
(-q).num = -q.num

@[simp]
theorem rat.​num_zero  :
0.num = 0

theorem rat.​zero_of_num_zero {q : } :
q.num = 0q = 0

theorem rat.​zero_iff_num_zero {q : } :
q = 0 q.num = 0

theorem rat.​num_ne_zero_of_ne_zero {q : } :
q 0q.num 0

@[simp]
theorem rat.​num_one  :
1.num = 1

@[simp]
theorem rat.​denom_one  :
1.denom = 1

theorem rat.​denom_ne_zero (q : ) :

theorem rat.​eq_iff_mul_eq_mul {p q : } :
p = q p.num * (q.denom) = q.num * (p.denom)

theorem rat.​mk_num_ne_zero_of_ne_zero {q : } {n d : } :
q 0q = rat.mk n dn 0

theorem rat.​mk_denom_ne_zero_of_ne_zero {q : } {n d : } :
q 0q = rat.mk n dd 0

theorem rat.​mk_ne_zero_of_ne_zero {n d : } :
n 0d 0rat.mk n d 0

theorem rat.​mul_num_denom (q r : ) :
q * r = rat.mk (q.num * r.num) (q.denom * r.denom)

theorem rat.​div_num_denom (q r : ) :
q / r = rat.mk (q.num * (r.denom)) ((q.denom) * r.num)

theorem rat.​num_denom_mk {q : } {n d : } :
n 0d 0q = rat.mk n d(∃ (c : ), n = c * q.num d = c * (q.denom))

theorem rat.​mk_pnat_num (n : ) (d : ℕ+) :

theorem rat.​mk_pnat_denom (n : ) (d : ℕ+) :

theorem rat.​mul_num (q₁ q₂ : ) :
(q₁ * q₂).num = q₁.num * q₂.num / ((q₁.num * q₂.num).nat_abs.gcd (q₁.denom * q₂.denom))

theorem rat.​mul_denom (q₁ q₂ : ) :
(q₁ * q₂).denom = q₁.denom * q₂.denom / (q₁.num * q₂.num).nat_abs.gcd (q₁.denom * q₂.denom)

theorem rat.​mul_self_num (q : ) :
(q * q).num = q.num * q.num

theorem rat.​mul_self_denom (q : ) :
(q * q).denom = q.denom * q.denom

theorem rat.​add_num_denom (q r : ) :
q + r = rat.mk (q.num * (r.denom) + (q.denom) * r.num) ((q.denom) * (r.denom))

theorem rat.​coe_int_eq_mk (z : ) :
z = rat.mk z 1

theorem rat.​mk_eq_div (n d : ) :
rat.mk n d = n / d

@[simp]
theorem rat.​coe_int_num (n : ) :
n.num = n

@[simp]
theorem rat.​coe_int_denom (n : ) :

theorem rat.​coe_int_num_of_denom_eq_one {q : } :
q.denom = 1(q.num) = q

@[instance]

Equations
theorem rat.​coe_nat_eq_mk (n : ) :

@[simp]
theorem rat.​coe_nat_num (n : ) :

@[simp]
theorem rat.​coe_nat_denom (n : ) :

theorem rat.​coe_int_inj (m n : ) :
m = n m = n

theorem rat.​inv_def' {q : } :

@[simp]
theorem rat.​mul_denom_eq_num {q : } :
q * (q.denom) = (q.num)

theorem rat.​denom_div_cast_eq_one_iff (m n : ) :
n 0((m / n).denom = 1 n m)

theorem rat.​num_div_eq_of_coprime {a b : } :
0 < ba.nat_abs.coprime b.nat_abs(a / b).num = a

theorem rat.​denom_div_eq_of_coprime {a b : } :
0 < ba.nat_abs.coprime b.nat_abs((a / b).denom) = b

theorem rat.​div_int_inj {a b c d : } :
0 < b0 < da.nat_abs.coprime b.nat_absc.nat_abs.coprime d.nat_absa / b = c / da = c b = d