| import OAI.Computability.RandomMean.ControlCorrectness |
|
|
| namespace OAI |
|
|
| section |
| namespace MeanPayoff.TreeDevice.Certified |
| open BinaryData Code |
| local infixl:80 " ≫ₚ " => Code.comp |
|
|
| namespace Word |
| end Word |
| namespace Array |
| end Array |
| end MeanPayoff.TreeDevice.Certified |
|
|
| end |
|
|
| section |
| namespace MeanPayoff.TreeDevice.Certified |
| open BinaryData Code |
| namespace Array |
| end Array |
| namespace RawBudget |
| end RawBudget |
| namespace RawBox |
| end RawBox |
| end MeanPayoff.TreeDevice.Certified |
|
|
| end |
|
|
| section |
| namespace MeanPayoff.TreeDevice.Certified |
| open BinaryData Code |
| namespace RawBasic |
| theorem fold_digits {g : Arena} {b : RawBox.Data} {E M : ℕ} (hg : ArenaBounded g E) |
| (ha : Array.Bounded b.2.1 M) (hb : Array.Bounded b.2.2 M) (xs : List W) (cs : Count) |
| (hx : Array.Bounded xs M) : Array.Bounded (Fold.fold advance.eval ((g,b),xs) cs).2 (M+cs.length*(E+1)) := by |
| induction cs generalizing M xs with |
| | nil => simpa only [Fold.fold,List.foldl_nil,List.length_nil,Nat.zero_mul,Nat.add_zero] using hx |
| | cons u cs ih => |
| have hn : Array.Bounded (next ((g,b),xs)) (M+(E+1)) := |
| clip_bound (ha.mono (by omega)) (hb.mono (by omega)) (by change Array.Bounded (graph (xs,g)) (M+(E+1)); simpa only [Nat.add_assoc] using graph_bound hx hg) |
| have h := ih (ha.mono (by omega : M≤M+(E+1))) (hb.mono (by omega : M≤M+(E+1))) (next ((g,b),xs)) hn |
| change Array.Bounded (Fold.fold advance.eval ((g,b),next ((g,b),xs)) cs).2 _ |
| convert h using 1 ; simp only [List.length_cons,Nat.add_mul,Nat.one_mul] ; omega |
| theorem solve_small {g : Arena} {b : RawBox.Data} {n E M : ℕ} (hg : ArenaBounded g E) |
| (hb : RawBox.Small n M b) (cs : Count) : Array.Small n (M+cs.length*(E+1)) (solve ((g,b),cs)) := by |
| refine ⟨?_,fold_digits hg hb.lower.digits hb.upper.digits b.2.1 cs hb.lower.digits⟩ |
| change (Fold.fold advance.eval ((g,b),b.2.1) cs).2.length≤n |
| rw [(fold_layout (g,b) b.2.1 cs).2] |
| split <;> first | exact hb.lower.length | exact hb.upper.length |
| end RawBasic |
| namespace Array |
| theorem Small.foldMin {n M : ℕ} {xs : List W} {xss : List (List W)} (hx : Small n M xs) (hs : ∀ ys∈xss, Small n M ys) : |
| Small n M (foldMin (xs,xss)) := |
| ⟨(fold_select_bound Word.min EdgeScan.low_mem hx.digits (fun ys hy => (hs ys hy).digits)).2.le.trans hx.length, |
| (fold_select_bound Word.min EdgeScan.low_mem hx.digits (fun ys hy => (hs ys hy).digits)).1⟩ |
| theorem Small.foldMax {n M : ℕ} {xs : List W} {xss : List (List W)} (hx : Small n M xs) (hs : ∀ ys∈xss, Small n M ys) : |
| Small n M (foldMax (xs,xss)) := |
| ⟨(fold_select_bound Word.max EdgeScan.high_mem hx.digits (fun ys hy => (hs ys hy).digits)).2.le.trans hx.length, |
| (fold_select_bound Word.max EdgeScan.high_mem hx.digits (fun ys hy => (hs ys hy).digits)).1⟩ |
| end Array |
| namespace RawBox |
| theorem Small.smallVector {n M : ℕ} {b : Data} (hb : Small n M b) {p : RawBudget.Data} (hp : RawBudget.Small n M p) : |
| Array.Small n M (smallVector (p,b)) := by |
| apply Array.choose_small hb.upper hb.lower |
| change (Zip.zip _ _ _ _).length≤n |
| rw [Array.zip_length] |
| change (p.2.2.2.map _).length≤n |
| simpa only [List.length_map] using hp.beta.length |
| end RawBox |
| end MeanPayoff.TreeDevice.Certified |
|
|
| end |
|
|
| section |
| namespace MeanPayoff.TreeDevice.Certified |
| open BinaryData Code |
| namespace Array |
| theorem Bounded.nth {M : ℕ} {xs : List W} (h : Bounded xs M) (i : ℕ) : (xs.getD i zero).digits.length≤M := by |
| induction xs generalizing i with |
| | nil => exact Nat.zero_le _ |
| | cons x xs ih => cases i with |
| | zero => exact h x (by simp) |
| | succ i => exact ih (fun y hy => h y (by simp [hy])) i |
| end Array |
| namespace RawMedian |
| theorem scalar_bound {M : ℕ} {xs : List W} (h : Array.Bounded xs M) : (scalar xs).digits.length≤M := by |
| apply Array.Bounded.headD |
| intro w hw |
| exact h w ((Sort.sort_perm xs).mem_iff.mp (List.mem_of_mem_drop hw)) |
| theorem column_bound {M : ℕ} {xs : List (List W)} (h : ∀ ys∈xs, Array.Bounded ys M) (c : Count) : |
| (column (xs,c)).digits.length≤M := by |
| apply scalar_bound |
| intro w hw |
| obtain ⟨ys,hy,rfl⟩ := List.mem_map.mp hw |
| change (Code.nth Array.zero (ys,c)).digits.length≤M |
| rw [Code.nth_eval] |
| exact (h ys hy).nth _ |
| theorem coordinates_small {M n : ℕ} {xs : List (List W)} (h : ∀ ys∈xs, Array.Bounded ys M) (c : Count) (hc : c.length≤n) : |
| Array.Small n M (coordinates (c,xs)) := by |
| refine ⟨?_,?_⟩ |
| · change ((Counter.enum c).map _).length≤n |
| rw [List.length_map,Counter.enum_eq,List.length_map,List.length_range] |
| exact hc |
| · intro w hw |
| obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hw |
| exact column_bound h i |
| theorem boxed_small {n M : ℕ} {b : RawBox.Data} (hb : RawBox.Small n M b) {xs : List (List W)} (h : ∀ ys∈xs, Array.Small n M ys) : |
| Array.Small n M (boxed (b,xs)) := by |
| simp only [boxed,branch_eval,comp_eval,pair_eval,fst_eval,snd_eval,empty_eval] |
| split |
| · exact hb.lower |
| · apply coordinates_small (fun ys hy => (h ys hy).digits) |
| change (b.2.1.map (fun _ => ())).length≤n |
| simpa only [List.length_map] using hb.lower.length |
| end RawMedian |
| namespace RawOrientation |
| def Small (n : ℕ) (o : Data) : Prop := ∀ hs∈o.2, hs.length≤n |
| theorem positives_length (b : RawBox.Data) (s : W) (xs : List W) : (positives (b,s,xs)).length=xs.length := by |
| change ((_ : List W).map _).length=xs.length |
| rw [List.length_map] |
| change ((_ : List W).map _).length=xs.length |
| rw [List.length_map] |
| exact Array.zip_length _ _ _ _ |
| theorem negatives_length (b : RawBox.Data) (s : W) (xs : List W) : (negatives (b,s,xs)).length=xs.length := by |
| change ((_ : List W).map _).length=xs.length |
| rw [List.length_map] |
| change ((_ : List W).map _).length=xs.length |
| rw [List.length_map] |
| exact Array.zip_length _ _ _ _ |
| theorem trueComplement_small {n : ℕ} {bs : List Bool} (h : bs.length≤n) : Small n (trueComplement bs) := by |
| intro cs hc |
| change cs∈[bs.map Bool.not] at hc |
| rcases List.mem_singleton.mp hc with rfl |
| simpa only [List.length_map] using h |
| theorem falseComplement_small {n : ℕ} {bs : List Bool} (h : bs.length≤n) : Small n (falseComplement bs) := by |
| intro cs hc |
| change cs∈[bs.map Bool.not] at hc |
| rcases List.mem_singleton.mp hc with rfl |
| simpa only [List.length_map] using h |
| theorem base_small {n M : ℕ} (p : RawBudget.Data) (b : RawBox.Data) {xs : List W} (h : Array.Small n M xs) : Small n (base (p,b,xs)) := by |
| have hl : (baseMask (b,xs)).length≤n := by |
| change ((_ : List W).map _).length≤n |
| rw [List.length_map] |
| change ((_ : List W).map _).length≤n |
| rw [List.length_map] |
| change (Array.sub (xs,b.2.1)).length≤n |
| exact (Array.zip_length _ _ _ _).le.trans h.length |
| change Small n (if RawBudget.measureLarge (p,baseMask (b,xs)) then _ else _) |
| split |
| · exact trueComplement_small hl |
| · intro cs hc |
| change cs∈[baseMask (b,xs)] at hc |
| rcases List.mem_singleton.mp hc with rfl |
| exact hl |
| theorem extend_small {n : ℕ} {o : Data} (ho : Small n o) {hs ns : List Bool} (hh : hs.length≤n) (hn : ns.length≤n) : |
| Small n (extend (o,hs,ns)) := by |
| intro cs hc |
| change cs∈Code.append (o.2,[hs,ns]) at hc |
| rw [Code.append_eval] at hc |
| rcases List.mem_append.mp hc with hc | hc |
| · exact ho cs hc |
| · simp only [List.mem_cons,List.not_mem_nil,or_false] at hc |
| rcases hc with rfl | rfl <;> assumption |
| theorem combine_small {n : ℕ} {os : List Data} (h : ∀ o∈os, Small n o) : Small n (combine os) := by |
| intro cs hc |
| change cs∈Code.flatten (os.map Prod.snd) at hc |
| rw [Code.flatten_eval] at hc |
| obtain ⟨ss,hs,hcs⟩ := List.mem_flatten.mp hc |
| obtain ⟨o,ho,rfl⟩ := List.mem_map.mp hs |
| exact h o ho cs hcs |
| end RawOrientation |
| end MeanPayoff.TreeDevice.Certified |
|
|
| end |
|
|
| end OAI |
|
|
