File size: 9,603 Bytes
e63eb7f | 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 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 | import OAI.Combinatorics.EditApproximation.Coarse.CoarseLevelMagnitude
namespace OAI
namespace EditApproximation
namespace BinaryFraction
/-- Actual Boolean work of the complete pruning-stopped evaluator. The
hypotheses bound input registers and the common grid, not execution cost. -/
theorem coarseBinaryEval_bitWork {B d : ℕ} {α : Type*} [DecidableEq α]
(k q L N R D A : ℕ) (frame : List (Option α)) (two : BinaryFraction)
(tree : CoarseSourceTree B α d) (draws : CoarseThresholdDraws B d)
(hB : 0 < B) (hq : 0 < q) (hL : 0 < L) (htwo : two.value = 2)
(htw : two.width ≤ A) (hd : Nat.size two.representation.den ≤ D)
(hroot : two.representation.den = coarseCommonDenominator 1 q L B R)
(hBbits : Nat.size B + 2 ≤ A) (hqbits : Nat.size q + 2 ≤ A)
(hLbits : Nat.size L + 2 ≤ A) (hNbits : Nat.size N + 2 ≤ A)
(hbound : Nat.size (coarseLevelMagnitude N k B R + 2) + 2 * D + 1 ≤ A)
(j : ℕ) (hdepth : j + d = R) (allowance : BinaryFraction) (start : ℕ)
(ha : CoarseGridCell two allowance k D A)
(hpath : allowance.value.den ∣ (L * B * q) ^ j)
(hstart : start + tree.word.length ≤ N) :
CoarseBinaryBox two (2 * k + 1) (coarseLevelMagnitude N k B d) D A
(coarseBinaryEval k q L frame two tree draws allowance start).1 ∧
(coarseBinaryEval k q L frame two tree draws allowance start).2 ≤
(100000000 * (A + 1) ^ 2) * coarseBinaryWeight k q L tree draws allowance := by
have hkbound : Nat.size k + 2 * D + 1 ≤ A :=
(Nat.add_le_add_right (Nat.add_le_add_right (Nat.size_le_size
((coarseLevelMagnitude_ge N k B R).trans (by omega))) _) _).trans hbound
induction tree generalizing j allowance start with
| leaf letter =>
have hnat : (nat (CoarseSourceTree.leaf (B := B) letter).word.length).width ≤ A :=
(nat_width_le _).trans ((Nat.add_le_add_right (Nat.size_le_size (by omega)) 2).trans hNbits)
have hp := leWithWork_cost (nat (CoarseSourceTree.leaf (B := B) letter).word.length) allowance A hnat ha.2.2.2.2
have hs : Nat.size (CoarseSourceTree.leaf (B := B) letter).word.length ≤ A :=
(Nat.size_le_size (show (CoarseSourceTree.leaf (B := B) letter).word.length ≤ N by omega)).trans (by omega)
rw [coarseBinaryEval, coarseBinaryWeight]
split_ifs
· exact ⟨coarseBinaryBox_none _ _ _ _ _, by dsimp only; nlinarith only [hp, hs, Nat.zero_le A]⟩
· have hvbound : Nat.size (coarseLevelMagnitude N k B 0) + 2 * D + 1 ≤ A :=
(Nat.add_le_add_right (Nat.add_le_add_right (Nat.size_le_size
((coarseLevelMagnitude_mono N k B 0 R (by omega)).trans (by omega))) _) _).trans hbound
have hcell (shift : Fin (2 * k + 1)) :
CoarseGridCell two (coarseGridNatWithWork allowance.denominator allowance.denominator_pos
(coarseShiftCost k frame (.leaf (B := B) letter) start shift)).1
(coarseLevelMagnitude N k B 0) D A := by
apply coarseGridNatWithWork_bounds two _ _ _ _ _ _ ha.1 ha.2.1 _ hvbound
have hcost : coarseShiftCost k frame (.leaf (B := B) letter) start shift ≤ 1 := by
cases letter <;> simp only [coarseShiftCost] <;> (try split_ifs) <;> omega
exact hcost.trans (coarseLevelMagnitude_pos N k B 0)
constructor
· intro cells hc
have heq : (arithmeticMapWithWork (fun shift : Fin (2 * k + 1) =>
coarseGridNatWithWork allowance.denominator allowance.denominator_pos
(coarseShiftCost k frame (.leaf (B := B) letter) start shift))
(List.finRange (2 * k + 1))).1 = cells := Option.some.inj hc
rw [← heq, arithmeticMapWithWork_value]
refine ⟨by simp, ?_⟩
intro a hamem
obtain ⟨shift, _, rfl⟩ := List.mem_map.mp hamem
exact hcell shift
· have hc := arithmeticMapWithWork_cost (fun shift : Fin (2 * k + 1) =>
coarseGridNatWithWork allowance.denominator allowance.denominator_pos
(coarseShiftCost k frame (.leaf (B := B) letter) start shift))
(List.finRange (2 * k + 1)) (100 * (A + 1) ^ 2) (by
intro shift _
apply coarseGridNatWithWork_cost _ _ _ A _ ((le_max_right _ _).trans ha.2.2.2.2)
have hcost : coarseShiftCost k frame (.leaf (B := B) letter) start shift ≤ 1 := by
cases letter <;> simp only [coarseShiftCost] <;> (try split_ifs) <;> omega
exact (Nat.size_le_size hcost).trans (by norm_num; omega))
simp only [List.length_finRange] at hc
have hBn : 2 * k + 1 ≤ B * (2 * k + 1) := by nlinarith
have hbudget := Nat.mul_le_mul_left ((A + 1) ^ 2) hBn
have hunit : 1 ≤ (A + 1) ^ 2 := by
have hz : 0 < (A + 1) ^ 2 := by positivity
omega
have hnscale := Nat.mul_le_mul_right (2 * k + 1) hunit
dsimp only
nlinarith only [hp, hs, hc, hbudget, hnscale, Nat.zero_le A, Nat.zero_le k]
| @branch d children ih =>
obtain ⟨draws, below⟩ := draws
have hnat : (nat (CoarseSourceTree.branch children).word.length).width ≤ A :=
(nat_width_le _).trans ((Nat.add_le_add_right (Nat.size_le_size (by omega)) 2).trans hNbits)
have hp := leWithWork_cost (nat (CoarseSourceTree.branch children).word.length) allowance A hnat ha.2.2.2.2
have hslen : Nat.size (CoarseSourceTree.branch children).word.length ≤ A :=
(Nat.size_le_size (show (CoarseSourceTree.branch children).word.length ≤ N by omega)).trans (by omega)
rw [coarseBinaryEval, coarseBinaryWeight]
split_ifs
· exact ⟨coarseBinaryBox_none _ _ _ _ _, by dsimp only; nlinarith only [hp, hslen, Nat.zero_le A]⟩
· have htval (draw : Fin B) : (coarseChildThresholdWithWork B q allowance draw).1.value =
coarseChildThreshold B q allowance.value draw := by
apply coarseChildThresholdWithWork_value
rw [ha.1, hroot, ← hdepth]
exact coarseThreshold_root_grid B q L j d allowance.value draw hB hq hpath
have htgrid (draw : Fin B) : CoarseGridCell two
(coarseChildThresholdWithWork B q allowance draw).1 k D A := by
apply coarseChildThresholdWithWork_bounds two allowance B q k D A draw hq ha hd _ hkbound
rw [ha.1, hroot, ← hdepth]
exact coarseThreshold_root_grid B q L j d allowance.value draw hB hq hpath
have hscale : CoarseGridCell two (coarseChildAllowanceWithWork q allowance).1 k D A := by
apply coarseChildAllowanceWithWork_bounds two allowance q k D A hq ha hd _ hkbound
rw [ha.1, hroot, ← hdepth]
exact coarseScale_root_grid B q L j (d + 1) allowance.value hq hpath
have hstep (draw : Fin B) :
CoarseGridCell two (coarseChildAllowanceWithWork L
(coarseChildThresholdWithWork B q allowance draw).1).1 k D A ∧
(coarseChildAllowanceWithWork L (coarseChildThresholdWithWork B q allowance draw).1).1.value.den ∣
(L * B * q) ^ (j + 1) := by
let threshold := (coarseChildThresholdWithWork B q allowance draw).1
have hden : (threshold.value / L).den ∣ threshold.representation.den := by
rw [htval draw, (htgrid draw).1, hroot, ← hdepth]
rw [show coarseChildThreshold B q allowance.value draw / (L : ℚ) =
(1 / (L : ℚ)) * coarseChildThreshold B q allowance.value draw by ring]
exact coarseChildAllowance_root_grid B q L j d allowance.value draw hB hq hL hpath
refine ⟨coarseChildAllowanceWithWork_bounds two threshold L k D A hL (htgrid draw) hd hden hkbound, ?_⟩
rw [coarseChildAllowanceWithWork_value L threshold hden, htval draw]
convert coarseChildAllowance_grid B q L j allowance.value draw hB hq hL hpath using 1
congr 1
ring
have hchildbound : Nat.size (B * (coarseLevelMagnitude N k B d + k) + 2) + 2 * D + 1 ≤ A := by
apply le_trans _ hbound
apply Nat.add_le_add_right
apply Nat.add_le_add_right
apply Nat.size_le_size
exact (coarseLevelMagnitude_succ N k B d).trans
((coarseLevelMagnitude_mono N k B (d + 1) R (by omega)).trans (by omega))
have hc := coarseBinaryChildren_bounds k q L N (coarseLevelMagnitude N k B d) D A two allowance
(fun child => coarseBinaryEval k q L frame two child)
(fun child => coarseBinaryWeight k q L child)
(List.ofFn fun i => (children i, draws i, below i)) hB (by simp) htwo htw ha.2.2.2.2
hBbits hqbits hLbits (by omega) (fun draw => (htgrid draw).2.2.2.2) hscale hchildbound (by
intro child draw childBelow hmem s hs
obtain ⟨i, hi⟩ := List.mem_ofFn.mp hmem
cases hi
exact ih i (below i) (j + 1) (by omega) _ s (hstep (draws i)).1 (hstep (draws i)).2 hs)
start (by rwa [coarseChildrenSpan_ofFn])
constructor
· have hm : (List.ofFn fun i => (children i, draws i, below i)).length *
(coarseLevelMagnitude N k B d + k) ≤ coarseLevelMagnitude N k B (d + 1) := by
simp only [List.length_ofFn]
exact (Nat.le_add_right _ 2).trans (coarseLevelMagnitude_succ N k B d)
exact coarseBinaryBox_mono two (2 * k + 1) _ _ D A _ hc.1 hm
· have hcost := hc.2
simp only [List.length_ofFn] at hcost
have hprune : (leWithWork (nat (CoarseSourceTree.branch children).word.length) allowance).2 +
Nat.size (CoarseSourceTree.branch children).word.length + 1 ≤ 100000000 * (A + 1) ^ 2 := by
nlinarith only [hp, hslen, Nat.zero_le A]
dsimp only
nlinarith only [hcost, hprune]
end BinaryFraction
end EditApproximation
end OAI
|