File size: 4,439 Bytes
d5b7741 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 | import OAI.Combinatorics.ContingencyTables.Transport.RationalRootBisection
import OAI.Combinatorics.MatchingCount.Arithmetic.TreeFraction
namespace OAI
/-! # Integer implementation of the correction-root bisection
The two interval endpoints share one dyadic denominator. Every comparison
is an inequality between natural powers and products. This is the literal
integer algorithm to which the rational correction analysis is applied.
-/
namespace ContingencyTables.DyadicRootBisection
open MatchingFPRAS
abbrev State := (ℕ×ℕ)×ℕ
def value (z : State) : ℚ×ℚ := ((z.1.1:ℚ)/z.2,(z.1.2:ℚ)/z.2)
def advance (c : TreeFraction.Fraction) (s : ℕ) (z : State) : State :=
if (z.1.1+z.1.2)^s*c.2 ≤ c.1*(2*z.2)^s
then ((z.1.1+z.1.2,2*z.1.2),2*z.2)
else ((2*z.1.1,z.1.1+z.1.2),2*z.2)
def run (c : TreeFraction.Fraction) (s : ℕ) : ℕ→State
| 0=>((0,8),1)
| n+1=>advance c s (run c s n)
def output (c : TreeFraction.Fraction) (s n : ℕ) : TreeFraction.Fraction :=
let z:=run c s n
TreeFraction.normalize (z.1.1+z.1.2,2*z.2)
lemma compare_iff (a d p q s : ℕ) (hd : 0<d) (hq : 0<q) :
((a:ℚ)/d)^s ≤ (p:ℚ)/q ↔ a^s*q≤p*d^s := by
rw [div_pow,div_le_div_iff₀ (pow_pos (by exact_mod_cast hd) _)
(by exact_mod_cast hq)]
norm_cast
lemma advance_denominator (c : TreeFraction.Fraction) (s : ℕ) (z : State) :
(advance c s z).2=2*z.2 := by
unfold advance
split_ifs <;> rfl
lemma run_denominator (c : TreeFraction.Fraction) (s n : ℕ) :
(run c s n).2=2^n := by
induction n with
| zero=>rfl
| succ n ih=>simp only [run,advance_denominator,ih,pow_succ,mul_comm]
lemma advance_bounds (c : TreeFraction.Fraction) (s : ℕ) (z : State)
(ha : z.1.1≤8*z.2) (hb : z.1.2≤8*z.2) :
(advance c s z).1.1≤8*(advance c s z).2 ∧
(advance c s z).1.2≤8*(advance c s z).2 := by
unfold advance
split_ifs <;> dsimp only <;> omega
lemma run_bounds (c : TreeFraction.Fraction) (s n : ℕ) :
(run c s n).1.1≤8*2^n ∧ (run c s n).1.2≤8*2^n := by
induction n with
| zero=>norm_num [run]
| succ n ih=>
have h:=advance_bounds c s (run c s n)
(by simpa only [run_denominator] using ih.1)
(by simpa only [run_denominator] using ih.2)
change (run c s (n+1)).1.1≤8*(run c s (n+1)).2 ∧
(run c s (n+1)).1.2≤8*(run c s (n+1)).2 at h
simpa only [run_denominator] using h
lemma value_advance (c : TreeFraction.Fraction) (hc : 0<c.2)
(s : ℕ) (z : State) (hz : 0<z.2) :
value (advance c s z)=
let ab:=value z
let mid:=(ab.1+ab.2)/2
if mid^s≤TreeFraction.val c then (mid,ab.2) else (ab.1,mid) := by
have hD : (z.2:ℚ)≠0 := by exact_mod_cast hz.ne'
have hm : (((z.1.1:ℚ)/z.2)+((z.1.2:ℚ)/z.2))/2=
((z.1.1+z.1.2:ℕ):ℚ)/((2*z.2:ℕ):ℚ) := by
push_cast
field_simp [hD]
have hleft : ((2*z.1.1:ℕ):ℚ)/((2*z.2:ℕ):ℚ)=(z.1.1:ℚ)/z.2 := by
push_cast
field_simp [hD]
have hright : ((2*z.1.2:ℕ):ℚ)/((2*z.2:ℕ):ℚ)=(z.1.2:ℚ)/z.2 := by
push_cast
field_simp [hD]
have ht:=compare_iff (z.1.1+z.1.2) (2*z.2) c.1 c.2 s (by omega) hc
dsimp only [value,TreeFraction.val]
rw [hm]
by_cases h : (z.1.1+z.1.2)^s*c.2≤c.1*(2*z.2)^s
· simp only [advance,h,ite_true,ht.mpr h,hright]
· have hr := mt ht.mp h
simp only [advance,h,ite_false,hr,hleft]
/-- Every integer execution is the rational bisection used by the
already proved relative-error estimate. -/
theorem run_value (c : TreeFraction.Fraction) (hc : 0<c.2) (s n : ℕ) :
value (run c s n)=RationalRootBisection.interval (TreeFraction.val c) s n := by
induction n with
| zero=>norm_num [run,value,RationalRootBisection.interval]
| succ n ih=>
rw [run,value_advance c hc s _ (by rw [run_denominator]; positivity),ih]
rfl
theorem output_value (c : TreeFraction.Fraction) (hc : 0<c.2) (s n : ℕ) :
TreeFraction.val (output c s n)=
RationalRootBisection.midpoint (TreeFraction.val c) s n := by
have he:=run_value c hc s n
unfold output
rw [TreeFraction.normalize_val]
unfold RationalRootBisection.midpoint
rw [←he]
dsimp only [value,TreeFraction.val]
have hD : ((run c s n).2:ℚ)≠0 := by rw [run_denominator]; positivity
push_cast
field_simp [hD]
theorem output_denominator_pos (c : TreeFraction.Fraction) (s n : ℕ) :
0<(output c s n).2 := TreeFraction.normalize_den_pos _
end ContingencyTables.DyadicRootBisection
end OAI
|