| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Arithmetic.TreeGCD |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.TreeFraction |
| open TreeTyped |
|
|
| abbrev Fraction := ℕ×ℕ |
| def val (x : Fraction) : ℚ := (x.1:ℚ)/x.2 |
| def repr (q : ℚ) : Fraction := (q.num.natAbs,q.den) |
|
|
| def normalize (x : Fraction) : Fraction := |
| if x.2=0 then (0,1) else (x.1/(x.1.gcd x.2),x.2/(x.1.gcd x.2)) |
|
|
| def normalizeRealizer : Realizer normalize := by |
| let G := gcd |
| let Q := pair (composition (pair first G) quotient) (composition (pair second G) quotient) |
| exact (choose (composition (pair second (constant 0)) natEqual) (constant (0,1)) Q).congr |
| (fun x=>by simp only [normalize,Function.comp_apply,decide_eq_true_eq]) |
|
|
| lemma normalize_repr (x : Fraction) : normalize x=repr (val x) := by |
| by_cases hd : x.2=0 |
| · simp [normalize,repr,val,hd] |
| · have he : val x=mkRat (x.1:Int) x.2 := by simp [val,Rat.mkRat_eq_div] |
| simp only [normalize,hd,↓reduceIte,he,repr,Rat.num_mkRat,Rat.den_mkRat] |
| simp [Nat.gcd_comm,←Int.natCast_ediv] |
|
|
| lemma val_nonneg (x : Fraction) : 0≤val x := by unfold val; positivity |
| lemma val_repr {q : ℚ} (h : 0≤q) : val (repr q)=q := by |
| have hn : 0≤q.num := by exact Rat.num_nonneg.mpr h |
| have he : (q.num.natAbs : ℤ)=q.num := Int.natAbs_of_nonneg hn |
| change (q.num.natAbs:ℚ)/(q.den:ℚ)=q |
| rw [←Int.cast_natCast q.num.natAbs,he] |
| exact Rat.num_div_den q |
|
|
| lemma normalize_val (x : Fraction) : val (normalize x)=val x := by |
| rw [normalize_repr] |
| exact val_repr (val_nonneg x) |
|
|
| lemma normalize_den_pos (x : Fraction) : 0<(normalize x).2 := by |
| rw [normalize_repr]; exact (val x).pos |
|
|
| lemma normalize_size_num (x : Fraction) : (normalize x).1.size≤x.1.size := by |
| unfold normalize; split_ifs |
| · simp |
| · exact Nat.size_le_size (Nat.div_le_self _ _) |
| lemma normalize_size_den (x : Fraction) : (normalize x).2.size≤x.2.size+1 := by |
| unfold normalize; split_ifs |
| · simp |
| · exact (Nat.size_le_size (Nat.div_le_self _ _)).trans (Nat.le_succ _) |
|
|
| def mul (x : Fraction×Fraction) : Fraction := normalize (x.1.1*x.2.1,x.1.2*x.2.2) |
| def mulRealizer : Realizer mul := |
| composition (pair (composition (pair (composition first first) (composition second first)) multiply) |
| (composition (pair (composition first second) (composition second second)) multiply)) normalizeRealizer |
| lemma mul_val (x y : Fraction) : val (mul (x,y))=val x*val y := by |
| rw [mul,normalize_val] |
| simp only [val,Nat.cast_mul] |
| exact (div_mul_div_comm _ _ _ _).symm |
|
|
| def add (x : Fraction×Fraction) : Fraction := |
| normalize (x.1.1*x.2.2+x.2.1*x.1.2,x.1.2*x.2.2) |
| def addRealizer : Realizer add := |
| composition (pair (composition (pair |
| (composition (pair (composition first first) (composition second second)) multiply) |
| (composition (pair (composition second first) (composition first second)) multiply)) TreeTyped.add) |
| (composition (pair (composition first second) (composition second second)) multiply)) normalizeRealizer |
| lemma add_val (x y : Fraction) (hx : x.2≠0) (hy : y.2≠0) : |
| val (add (x,y))=val x+val y := by |
| rw [add,normalize_val] |
| simp only [val,Nat.cast_add,Nat.cast_mul] |
| rw [div_add_div (x.1:ℚ) (y.1:ℚ) (b:=(x.2:ℚ)) (d:=(y.2:ℚ)) |
| (by exact_mod_cast hx) (by exact_mod_cast hy)] |
| ring |
|
|
| def div (x : Fraction×Fraction) : Fraction := normalize (x.1.1*x.2.2,x.1.2*x.2.1) |
| def divRealizer : Realizer div := |
| composition (pair (composition (pair (composition first first) (composition second second)) multiply) |
| (composition (pair (composition first second) (composition second first)) multiply)) normalizeRealizer |
| lemma div_val (x y : Fraction) : val (div (x,y))=val x/val y := by |
| rw [div,normalize_val] |
| simp only [val,Nat.cast_mul] |
| simp only [div_eq_mul_inv,mul_inv_rev,inv_inv] |
| ring |
|
|
| def less (x : Fraction×Fraction) : Bool := decide (x.1.1*x.2.2<x.2.1*x.1.2) |
| def lessRealizer : Realizer less := |
| composition (pair (composition (pair (composition first first) (composition second second)) multiply) |
| (composition (pair (composition second first) (composition first second)) multiply)) TreeTyped.less |
| lemma less_val (x y : Fraction) (hx : 0<x.2) (hy : 0<y.2) : |
| less (x,y)=decide (val x<val y) := by |
| unfold less |
| apply Bool.eq_iff_iff.mpr |
| simp only [decide_eq_true_eq] |
| rw [val,val,div_lt_div_iff₀ (by exact_mod_cast hx) (by exact_mod_cast hy)] |
| norm_cast |
|
|
| end MatchingFPRAS.TreeFraction |
|
|
| end OAI |
|
|
