| import OAI.Computability.RandomMean.Orientation |
|
|
| namespace OAI |
|
|
| section |
| namespace MeanPayoff.TreeDevice.Certified |
| open BinaryData Code |
| local infixl:80 " ≫ₚ " => Code.comp |
| local infixr:70 " ⋏ₚ " => Code.pair |
|
|
| namespace Code |
| variable {α β : Type} [Encoding α] [Encoding β] |
| end Code |
|
|
| namespace RawControl |
| abbrev Orient := RawOrientation.Data |
| abbrev Tuple := RawBudget.Data×RawBox.Data×Count×List W×List W×List (List W)×Orient×List Orient |
| structure Pack where |
| p : RawBudget.Data |
| b : RawBox.Data |
| t : Count |
| q : List W |
| r : List W |
| vs : List (List W) |
| o : Orient |
| os : List Orient |
|
|
| def Pack.tuple (z : Pack) : Tuple := (z.p,z.b,z.t,z.q,z.r,z.vs,z.o,z.os) |
| instance : Encoding Pack := ⟨fun z => encode z.tuple⟩ |
| |
| def zeroBudget : RawBudget.Data := ((Array.zero,Array.zero),(Array.zero,Array.zero),[],[]) |
| def zeroBox : RawBox.Data := (Array.zero,[],[]) |
| def Pack.zero : Pack := ⟨zeroBudget,zeroBox,[],[],[],[],(false,[]),[]⟩ |
| |
| noncomputable def proj {α : Type} [Encoding α] (f : Code Tuple α) : Code Pack α := |
| f.recode Pack.tuple (fun z => f z.tuple) (fun _ => rfl) (fun _ => rfl) |
| noncomputable def p : Code Pack RawBudget.Data := proj fst |
| noncomputable def b : Code Pack RawBox.Data := proj (snd ≫ₚ fst) |
| noncomputable def t : Code Pack Count := proj (snd ≫ₚ snd ≫ₚ fst) |
| noncomputable def q : Code Pack (List W) := proj (snd ≫ₚ snd ≫ₚ snd ≫ₚ fst) |
| noncomputable def r : Code Pack (List W) := proj (snd ≫ₚ snd ≫ₚ snd ≫ₚ snd ≫ₚ fst) |
| noncomputable def vs : Code Pack (List (List W)) := proj (snd ≫ₚ snd ≫ₚ snd ≫ₚ snd ≫ₚ snd ≫ₚ fst) |
| noncomputable def o : Code Pack Orient := proj (snd ≫ₚ snd ≫ₚ snd ≫ₚ snd ≫ₚ snd ≫ₚ snd ≫ₚ fst) |
| noncomputable def os : Code Pack (List Orient) := proj (snd ≫ₚ snd ≫ₚ snd ≫ₚ snd ≫ₚ snd ≫ₚ snd ≫ₚ snd) |
| |
| @[simp] theorem p_eval (z : Pack) : p z=z.p := rfl |
| @[simp] theorem b_eval (z : Pack) : b z=z.b := rfl |
| @[simp] theorem t_eval (z : Pack) : t z=z.t := rfl |
| @[simp] theorem q_eval (z : Pack) : q z=z.q := rfl |
| @[simp] theorem r_eval (z : Pack) : r z=z.r := rfl |
| @[simp] theorem vs_eval (z : Pack) : vs z=z.vs := rfl |
| @[simp] theorem o_eval (z : Pack) : o z=z.o := rfl |
| @[simp] theorem os_eval (z : Pack) : os z=z.os := rfl |
| |
| noncomputable def pack {α : Type} [Encoding α] |
| (p : Code α RawBudget.Data := const zeroBudget) |
| (b : Code α RawBox.Data := const zeroBox) |
| (t : Code α Count := const []) |
| (q r : Code α (List W) := const []) |
| (vs : Code α (List (List W)) := const []) |
| (o : Code α Orient := const (false,[])) |
| (os : Code α (List Orient) := const []) : Code α Pack := |
| (p ⋏ₚ b ⋏ₚ t ⋏ₚ q ⋏ₚ r ⋏ₚ vs ⋏ₚ o ⋏ₚ os).recode _root_.id |
| (fun x => ⟨p x,b x,t x,q x,r x,vs x,o x,os x⟩) (fun _ => rfl) (fun _ => rfl) |
| @[simp] theorem pack_eval {α : Type} [Encoding α] |
| (p : Code α RawBudget.Data) (b : Code α RawBox.Data) (t : Code α Count) |
| (q r : Code α (List W)) (vs : Code α (List (List W))) (o : Code α Orient) (os : Code α (List Orient)) (x : α) : |
| pack p b t q r vs o os x=⟨p x,b x,t x,q x,r x,vs x,o x,os x⟩ := rfl |
| |
| abbrev Cell := Count×Pack |
| abbrev State := Cell×List Cell |
| abbrev Env := RawBasic.Arena×Count×Count×Count×Count |
| |
| noncomputable def arena : Code Env RawBasic.Arena := fst |
| noncomputable def exponent : Code Env Count := snd ≫ₚ fst |
| noncomputable def samples : Code Env Count := snd ≫ₚ snd ≫ₚ fst |
| noncomputable def trials : Code Env Count := snd ≫ₚ snd ≫ₚ snd ≫ₚ fst |
| noncomputable def basicSteps : Code Env Count := snd ≫ₚ snd ≫ₚ snd ≫ₚ snd |
| |
| abbrev Input := Env×Count×State |
| noncomputable def env : Code Input Env := fst |
| noncomputable def random : Code Input Count := snd ≫ₚ fst |
| noncomputable def state : Code Input State := snd ≫ₚ snd |
| noncomputable def current : Code Input Pack := state ≫ₚ fst ≫ₚ snd |
| noncomputable def stack : Code Input (List Cell) := state ≫ₚ snd |
| noncomputable def caller : Code Input Pack := stack ≫ₚ head ([],Pack.zero) ≫ₚ snd |
| noncomputable def rest : Code Input (List Cell) := stack ≫ₚ tail |
| noncomputable def makeCell {α : Type} [Encoding α] (tag : ℕ) (c : Code α Pack) : Code α Cell := |
| const (List.replicate tag ()) ⋏ₚ c |
| noncomputable def call {α : Type} [Encoding α] (tag : ℕ) (c : Code α Pack) (k : Code α (List Cell)) : Code α State := |
| makeCell tag c ⋏ₚ k |
| noncomputable def ret {α : Type} [Encoding α] (c : Code α Pack) (k : Code α (List Cell)) : Code α State := call 10 c k |
| noncomputable def push {α : Type} [Encoding α] (tag : ℕ) (c : Code α Pack) (k : Code α (List Cell)) : Code α (List Cell) := |
| (makeCell tag c ⋏ₚ k) ≫ₚ cons |
| noncomputable def save (tag : ℕ) : Code Input (List Cell) := push tag current stack |
| noncomputable def smallWidth (x : Code Input RawBox.Data) : Code Input Bool := |
| ((x ≫ₚ RawBox.width) ⋏ₚ (env ≫ₚ samples ≫ₚ Counter.word ≫ₚ RawBudget.times 128)) ≫ₚ Word.le |
| noncomputable def basic (x : Code Input RawBox.Data) : Code Input (List W) := |
| (((env ≫ₚ arena) ⋏ₚ x) ⋏ₚ (env ≫ₚ basicSteps)) ≫ₚ RawBasic.solve |
| noncomputable def narrow (x : Code Input RawBox.Data) (v : Code Input (List W)) : Code Input RawBox.Data := |
| (((x ⋏ₚ (((env ≫ₚ exponent) ⋏ₚ const (List.replicate 5 ())) ≫ₚ Counter.add)) ≫ₚ RawBox.dividedWidth) ⋏ₚ v) ≫ₚ RawBox.centered |
| noncomputable def wide (x : Code Input RawBox.Data) (v : Code Input (List W)) : Code Input RawBox.Data := |
| (((x ⋏ₚ const (List.replicate 3 ())) ≫ₚ RawBox.dividedWidth) ⋏ₚ v) ≫ₚ RawBox.centered |
| noncomputable def delta (x : Code Input RawBox.Data) : Code Input W := |
| (x ⋏ₚ (((env ≫ₚ exponent) ⋏ₚ const (List.replicate 2 ())) ≫ₚ Counter.add)) ≫ₚ RawBox.dividedWidth |
| noncomputable def capWidth (x : Code Input RawBox.Data) : Code Input W := |
| ((x ≫ₚ RawBox.width) ⋏ₚ delta x) ≫ₚ Word.sub |
| |
| noncomputable def solveCase : Code Input State := |
| Code.branch (current ≫ₚ p ≫ₚ RawBudget.small) |
| (ret (pack (q:=((current ≫ₚ p) ⋏ₚ (current ≫ₚ b)) ≫ₚ RawBox.smallVector)) stack) |
| (Code.branch (smallWidth (current ≫ₚ b)) |
| (ret (pack (q:=basic (current ≫ₚ b))) stack) |
| (call 8 (pack (current ≫ₚ p) (current ≫ₚ b)) (save 15))) |
| noncomputable def askCase : Code Input State := |
| call 2 (pack (current ≫ₚ p) (current ≫ₚ b) (env ≫ₚ trials)) (save 2) |
| noncomputable def trialsCase : Code Input State := |
| Code.branch (current ≫ₚ t ≫ₚ empty) |
| (ret (pack (vs:=const [])) stack) |
| (call 0 current (push 0 (pack (current ≫ₚ p) (current ≫ₚ b) (current ≫ₚ t ≫ₚ tail)) stack)) |
| noncomputable def updateCase : Code Input State := |
| call 1 (pack (current ≫ₚ p ≫ₚ RawBudget.reduceK) (narrow (current ≫ₚ b) (current ≫ₚ q))) (save 3) |
| noncomputable def centersCase : Code Input State := |
| Code.branch (current ≫ₚ t ≫ₚ empty) |
| (ret (pack (vs:=((current ≫ₚ q) ⋏ₚ const []) ≫ₚ cons)) stack) |
| (call 3 current (push 5 (pack (current ≫ₚ p) (current ≫ₚ b) (current ≫ₚ t ≫ₚ tail) (current ≫ₚ q)) stack)) |
| noncomputable def orientCase : Code Input State := |
| Code.branch (smallWidth (current ≫ₚ b)) |
| (ret (pack (o:=((current ≫ₚ p) ⋏ₚ (current ≫ₚ b) ⋏ₚ basic (current ≫ₚ b)) ≫ₚ RawOrientation.base)) stack) |
| (call 4 (pack (current ≫ₚ p) (current ≫ₚ b) (env ≫ₚ samples) (current ≫ₚ b ≫ₚ RawBox.midpoint)) (save 6)) |
| noncomputable def orientTrialsCase : Code Input State := |
| Code.branch (current ≫ₚ t ≫ₚ empty) (ret (pack (os:=const [])) stack) |
| (call 5 current (push 8 (pack (current ≫ₚ p) (current ≫ₚ b) (current ≫ₚ t ≫ₚ tail)) stack)) |
| noncomputable def orientPlusCase : Code Input State := |
| call 6 (pack (current ≫ₚ p) (current ≫ₚ b) (env ≫ₚ trials)) (save 10) |
| noncomputable def tightenCase : Code Input State := |
| call 1 (pack (current ≫ₚ p ≫ₚ RawBudget.reduceK) (current ≫ₚ b)) (save 11) |
| noncomputable def reweightCase : Code Input State := |
| Code.branch (current ≫ₚ o ≫ₚ snd ≫ₚ empty) (ret (pack (vs:=const [])) stack) |
| (call 1 (pack |
| (Code.branch (current ≫ₚ o ≫ₚ fst) |
| (((current ≫ₚ p) ⋏ₚ (current ≫ₚ o ≫ₚ snd ≫ₚ head [])) ≫ₚ RawBudget.reweightM) |
| (((current ≫ₚ p) ⋏ₚ (current ≫ₚ o ≫ₚ snd ≫ₚ head [])) ≫ₚ RawBudget.reweightK)) |
| (current ≫ₚ b)) |
| (push 17 (pack (current ≫ₚ p) (current ≫ₚ b) |
| (o:=(current ≫ₚ o ≫ₚ fst) ⋏ₚ (current ≫ₚ o ≫ₚ snd ≫ₚ tail))) stack)) |
| end RawControl |
| end MeanPayoff.TreeDevice.Certified |
| |
| end |
| |
| section |
| namespace MeanPayoff.TreeDevice.Certified |
| open BinaryData Code |
| local infixl:80 " ≫ₚ " => Code.comp |
| local infixr:70 " ⋏ₚ " => Code.pair |
| namespace Array |
| |
| theorem fold_select_bound (f : Code (W×W) W) (hf : ∀ z, f z=z.1 ∨ f z=z.2) |
| {N : ℕ} {xs : List W} {xss : List (List W)} (h : Bounded xs N) |
| (hs : ∀ ys∈xss, Bounded ys N) : |
| Bounded (Fold.fold (zip zero zero f).eval xs xss) N ∧ |
| (Fold.fold (zip zero zero f).eval xs xss).length=xs.length := by |
| induction xss generalizing xs with |
| | nil => exact ⟨h,rfl⟩ |
| | cons ys yss ih => |
| change Bounded (Fold.fold _ (zip zero zero f (xs,ys)) yss) N ∧ _ |
| have hh := ih (bounded_zip h (hs ys (by simp)) f hf) (fun zs hz => hs zs (by simp [hz])) |
| exact ⟨hh.1,hh.2.trans (zip_length f.eval zero xs ys)⟩ |
| |
| noncomputable def foldSelect (f : Code (W×W) W) (hf : ∀ z, f z=z.1 ∨ f z=z.2) : |
| Code (List W×List (List W)) (List W) := |
| foldPrefix (zip zero zero f) 20 2 (by |
| intro xs xss k _hk |
| let S := treeSize (encode (xs,xss)) |
| have hx : Bounded xs S := fun w hw => (digits_le_wordSize w).trans ((Size.mem hw).trans (Size.fst (xs,xss))) |
| have hxs : ∀ ys∈xss.take k, Bounded ys S := by |
| intro ys hy w hw |
| exact (digits_le_wordSize w).trans ((Size.mem hw).trans |
| ((Size.mem (List.mem_of_mem_take hy)).trans (Size.snd (xs,xss)))) |
| have hb := fold_select_bound f hf hx hxs |
| have ht := size_bound hb.1 |
| rw [hb.2] at ht |
| have hl := (Size.length xs).trans (Size.fst (xs,xss)) |
| change xs.length≤S at hl |
| have hm := Nat.mul_le_mul_right (4*S+6) hl |
| calc |
| treeSize (encode (Fold.fold (zip zero zero f).eval xs (xss.take k))) ≤ xs.length*(4*S+6)+1 := ht |
| _ ≤ 20*(S+1)^2 := by nlinarith) |
| noncomputable def foldMin : Code (List W×List (List W)) (List W) := foldSelect Word.min EdgeScan.low_mem |
| noncomputable def foldMax : Code (List W×List (List W)) (List W) := foldSelect Word.max EdgeScan.high_mem |
| |
| theorem foldMin_rep {n B : ℕ} {I : SolveBox n B} (v : BoxVector I) {xs : List W} |
| (hv : VectorRep v.val xs) {vs : List (BoxVector I)} {xss : List (List W)} |
| (hs : VectorsRep (vs.map Subtype.val) xss) : |
| VectorRep (vs.foldl I.minVector v).val (foldMin (xs,xss)) := by |
| induction vs generalizing v xs xss with |
| | nil => cases hs; exact hv |
| | cons w ws ih => |
| cases hs with |
| | cons hw hws => |
| exact ih (I.minVector v w) (Array.zip_rep Word.min Min.min (fun _ _ => Word.min_val _ _) hv hw) hws |
| |
| theorem foldMax_rep {n B : ℕ} {I : SolveBox n B} (v : BoxVector I) {xs : List W} |
| (hv : VectorRep v.val xs) {vs : List (BoxVector I)} {xss : List (List W)} |
| (hs : VectorsRep (vs.map Subtype.val) xss) : |
| VectorRep (vs.foldl I.maxVector v).val (foldMax (xs,xss)) := by |
| induction vs generalizing v xs xss with |
| | nil => cases hs; exact hv |
| | cons w ws ih => |
| cases hs with |
| | cons hw hws => |
| exact ih (I.maxVector v w) (Array.zip_rep Word.max Max.max (fun _ _ => Word.max_val _ _) hv hw) hws |
| end Array |
| end MeanPayoff.TreeDevice.Certified |
| |
| end |
| |
| section |
| namespace MeanPayoff.TreeDevice.Certified.RawControl |
| open BinaryData Code |
| local infixl:80 " ≫ₚ " => Code.comp |
| local infixr:70 " ⋏ₚ " => Code.pair |
| |
| noncomputable def trialsHeadCase : Code Input State := |
| call 2 (pack (caller ≫ₚ p) (caller ≫ₚ b) (caller ≫ₚ t)) |
| (push 1 (pack (q:=current ≫ₚ q)) rest) |
| noncomputable def vectorConsCase : Code Input State := |
| ret (pack (vs:=((caller ≫ₚ q) ⋏ₚ (current ≫ₚ vs)) ≫ₚ cons)) rest |
| noncomputable def medianCase : Code Input State := |
| ret (pack (q:=((caller ≫ₚ b) ⋏ₚ (current ≫ₚ vs)) ≫ₚ RawMedian.boxed)) rest |
| noncomputable def centerFirstCase : Code Input State := |
| call 1 (pack (caller ≫ₚ p ≫ₚ RawBudget.reduceM) (narrow (caller ≫ₚ b) (caller ≫ₚ q))) |
| (push 4 (pack (b:=caller ≫ₚ b) (r:=current ≫ₚ q)) rest) |
| noncomputable def centerSecondCase : Code Input State := |
| ret (pack (q:=((caller ≫ₚ b) ⋏ₚ (caller ≫ₚ r) ⋏ₚ (current ≫ₚ q)) ≫ₚ RawBox.averageClipped)) rest |
| noncomputable def centersHeadCase : Code Input State := |
| call 4 (pack (caller ≫ₚ p) (caller ≫ₚ b) (caller ≫ₚ t) (current ≫ₚ q)) |
| (push 1 (pack (q:=caller ≫ₚ q)) rest) |
| noncomputable def centerAt (index : Code Input Count) : Code Input (List W) := |
| (((current ≫ₚ vs) ⋏ₚ index) ⋏ₚ (caller ≫ₚ b ≫ₚ RawBox.midpoint)) ≫ₚ getD [] |
| noncomputable def lastPositive : Code Input (List Bool) := |
| ((caller ≫ₚ b) ⋏ₚ (env ≫ₚ samples ≫ₚ Counter.word) ⋏ₚ centerAt (env ≫ₚ samples)) ≫ₚ RawOrientation.positives |
| noncomputable def lastNegative : Code Input (List Bool) := |
| ((caller ≫ₚ b) ⋏ₚ (env ≫ₚ samples ≫ₚ Counter.word) ⋏ₚ centerAt (env ≫ₚ samples)) ≫ₚ RawOrientation.negatives |
| noncomputable def orientLoopCase : Code Input State := |
| Code.branch (((caller ≫ₚ p) ⋏ₚ lastPositive) ≫ₚ RawBudget.measureLarge) |
| (ret (pack (o:=lastPositive ≫ₚ RawOrientation.trueComplement)) rest) |
| (Code.branch (((caller ≫ₚ p) ⋏ₚ lastNegative) ≫ₚ RawBudget.measureLarge) |
| (ret (pack (o:=lastNegative ≫ₚ RawOrientation.falseComplement)) rest) |
| (call 5 (pack (caller ≫ₚ p) (wide (caller ≫ₚ b) (centerAt random))) |
| (push 7 (pack (o:=const false ⋏ₚ ((lastPositive ⋏ₚ ((lastNegative ⋏ₚ const []) ≫ₚ cons)) ≫ₚ cons))) rest))) |
| noncomputable def orientTailCase : Code Input State := |
| ret (pack (o:=((current ≫ₚ o) ⋏ₚ (caller ≫ₚ o ≫ₚ snd ≫ₚ head []) ⋏ₚ |
| (caller ≫ₚ o ≫ₚ snd ≫ₚ tail ≫ₚ head [])) ≫ₚ RawOrientation.extend)) rest |
| noncomputable def orientHeadCase : Code Input State := |
| call 6 (pack (caller ≫ₚ p) (caller ≫ₚ b) (caller ≫ₚ t)) |
| (push 9 (pack (o:=current ≫ₚ o)) rest) |
| noncomputable def orientConsCase : Code Input State := |
| ret (pack (os:=((caller ≫ₚ o) ⋏ₚ (current ≫ₚ os)) ≫ₚ cons)) rest |
| noncomputable def combineCase : Code Input State := |
| ret (pack (o:=current ≫ₚ os ≫ₚ RawOrientation.combine)) rest |
| noncomputable def tightenFirstCase : Code Input State := |
| Code.branch (((caller ≫ₚ b) ⋏ₚ (current ≫ₚ q) ⋏ₚ delta (caller ≫ₚ b)) ≫ₚ RawBox.movedFloor) |
| (call 8 (pack (caller ≫ₚ p) (((caller ≫ₚ b) ⋏ₚ (current ≫ₚ q)) ≫ₚ RawBox.withFloor)) |
| (push 13 (pack (b:=caller ≫ₚ b) (q:=current ≫ₚ q)) rest)) |
| (call 1 (pack (caller ≫ₚ p ≫ₚ RawBudget.reduceM) (caller ≫ₚ b)) (push 12 caller rest)) |
| noncomputable def tightenSecondCase : Code Input State := |
| Code.branch (((caller ≫ₚ b) ⋏ₚ (current ≫ₚ q) ⋏ₚ delta (caller ≫ₚ b)) ≫ₚ RawBox.movedCeiling) |
| (call 8 (pack (caller ≫ₚ p) (((caller ≫ₚ b) ⋏ₚ (current ≫ₚ q)) ≫ₚ RawBox.withCeiling)) |
| (push 14 (pack (b:=caller ≫ₚ b) (q:=current ≫ₚ q)) rest)) |
| (ret (pack (b:=caller ≫ₚ b)) rest) |
| noncomputable def boxPassCase : Code Input State := ret (pack (b:=current ≫ₚ b)) rest |
| noncomputable def solveTightCase : Code Input State := |
| call 7 (pack (caller ≫ₚ p) (current ≫ₚ b)) |
| (push 16 (pack (caller ≫ₚ p) (current ≫ₚ b)) (push 21 (const Pack.zero) rest)) |
| noncomputable def solveOrientedCase : Code Input State := |
| call 9 (pack (caller ≫ₚ p) (caller ≫ₚ b) (o:=current ≫ₚ o)) |
| (push 18 (pack (caller ≫ₚ p) (caller ≫ₚ b) (o:=(current ≫ₚ o ≫ₚ fst) ⋏ₚ const [])) rest) |
| noncomputable def reweightHeadCase : Code Input State := |
| call 9 (pack (caller ≫ₚ p) (caller ≫ₚ b) (o:=caller ≫ₚ o)) |
| (push 1 (pack (q:=current ≫ₚ q)) rest) |
| noncomputable def solveReweightedCase : Code Input State := |
| Code.branch (caller ≫ₚ o ≫ₚ fst) |
| (call 0 (pack (caller ≫ₚ p) (((caller ≫ₚ b) ⋏ₚ capWidth (caller ≫ₚ b)) ≫ₚ RawBox.capHigh)) |
| (push 19 (pack (b:=caller ≫ₚ b) (vs:=current ≫ₚ vs)) rest)) |
| (call 0 (pack (caller ≫ₚ p) (((caller ≫ₚ b) ⋏ₚ capWidth (caller ≫ₚ b)) ≫ₚ RawBox.capLow)) |
| (push 20 (pack (b:=caller ≫ₚ b) (vs:=current ≫ₚ vs)) rest)) |
| noncomputable def capHighCase : Code Input State := |
| ret (pack (q:=((current ≫ₚ q) ⋏ₚ (caller ≫ₚ vs)) ≫ₚ Array.foldMin)) rest |
| noncomputable def capLowCase : Code Input State := |
| ret (pack (q:=((current ≫ₚ q) ⋏ₚ (caller ≫ₚ vs)) ≫ₚ Array.foldMax)) rest |
| noncomputable def includeInnerCase : Code Input State := ret (pack (q:=current ≫ₚ q)) rest |
| |
| noncomputable def resume : Code Input State := |
| Code.branch (stack ≫ₚ empty) state |
| (select (stack ≫ₚ head ([],Pack.zero) ≫ₚ fst) |
| [trialsHeadCase,vectorConsCase,medianCase,centerFirstCase,centerSecondCase,centersHeadCase, |
| orientLoopCase,orientTailCase,orientHeadCase,orientConsCase,combineCase,tightenFirstCase, |
| tightenSecondCase,boxPassCase,boxPassCase,solveTightCase,solveOrientedCase,reweightHeadCase, |
| solveReweightedCase,capHighCase,capLowCase,includeInnerCase] state) |
| |
| noncomputable def dispatch : Code Input State := |
| select (state ≫ₚ fst ≫ₚ fst) |
| [solveCase,askCase,trialsCase,updateCase,centersCase,orientCase,orientTrialsCase,orientPlusCase, |
| tightenCase,reweightCase] resume |
| end MeanPayoff.TreeDevice.Certified.RawControl |
| |
| end |
| |
| section |
| namespace MeanPayoff.SourceControl |
| |
| def sampledResume {G : Game} {B : ℕ} {A C R : Result G B} (f : Frame G B A C) (v : A.Value) |
| (k : Kont G B C R) (j : ℕ) : State G B R := |
| match f with |
| | .trialsHead P I J => (.call (.trials P I J) (.push (.vectorCons v) k)) |
| | .vectorCons a => (.ret k (a :: v)) |
| | .median I => (.ret k (I.medianBox v)) |
| | .centerFirst P _ I hB q => |
| (.call (.ask P.reduceM (I.narrowCentered hB q.val)) (.push (.centerSecond I hB q v) k)) |
| | .centerSecond I _ _ r => (.ret k (I.averageClipped r.val v.val)) |
| | .centersHead P hR I hB t q => |
| (.call (.centers P hR I hB t v) (.push (.vectorCons q) k)) |
| | .orientLoop P hR I hB => |
| let H := PositiveDisplacement I (v.getD (globalS B) I.midpoint) |
| let N := NegativeDisplacement I (v.getD (globalS B) I.midpoint) |
| if hH : 1 / 2 < P.measure H then |
| (.ret k ⟨true, [⟨Hᶜ, by rw [P.measure_compl G.positive]; linarith⟩]⟩) |
| else if hN : 1 / 2 < P.measure N then |
| (.ret k ⟨false, [⟨Nᶜ, by rw [P.measure_compl G.positive]; linarith⟩]⟩) |
| else |
| .call (.orient P hR (I.wideCentered hB (v.getD j I.midpoint).val)) |
| (.push (.orientTail ⟨H, le_of_not_gt hH⟩ ⟨N, le_of_not_gt hN⟩) k) |
| | .orientTail H N => (.ret k ⟨v.chooseY, v.exceptions ++ [H, N]⟩) |
| | .orientHead P hR I J => (.call (.orientTrials P hR I J) (.push (.orientCons v) k)) |
| | .orientCons O => (.ret k (O :: v)) |
| | .combine _ => (.ret k (combineOrientations v)) |
| | .tightenFirst P hR I hB => |
| if _ : ∃ i, (I.delta : ℤ) ≤ v.val i - I.a i then |
| (.call (.tighten P hR (I.withFloor v) hB) (.push (.floor I v) k)) |
| else (.call (.ask P.reduceM I) (.push (.tightenSecond P hR I hB) k)) |
| | .tightenSecond P hR I hB => |
| if _ : ∃ i, (I.delta : ℤ) ≤ I.b i - v.val i then |
| (.call (.tighten P hR (I.withCeiling v) hB) (.push (.ceiling I v) k)) |
| else (.ret k ⟨I, rfl, le_refl _, le_refl _⟩) |
| | .floor _ q => (.ret k ⟨v.box, v.width_eq, q.property.1.trans v.floor_le, v.ceiling_le⟩) |
| | .ceiling _ q => (.ret k ⟨v.box, v.width_eq, v.floor_le, v.ceiling_le.trans q.property.2⟩) |
| | .solveTight P hR _ hB => |
| have hK : 128 * globalS B < v.box.width := by rw [v.width_eq]; exact hB |
| (.call (.orientPlus P hR v.box) (.push (.solveOriented P hR v.box hK) (.push (.includeInner v) k))) |
| | .solveOriented P hR I hB => |
| (.call (.reweight P hR I v.chooseY v.exceptions) (.push (.solveReweighted P hR I hB v.chooseY) k)) |
| | .reweightHead P hR I side Hs => (.call (.reweight P hR I side Hs) (.push (.vectorCons v) k)) |
| | .solveReweighted P _ I hB side => |
| if side then (.call (.solve P (I.capHigh I.C I.C_positive (I.C_smaller hB).le)) (.push (.capHigh I hB v) k)) |
| else (.call (.solve P (I.capLow I.C I.C_positive (I.C_smaller hB).le)) (.push (.capLow I hB v) k)) |
| | .capHigh I hB rs => (.ret k (rs.foldl I.minVector (I.includeCapHigh I.C I.C_positive (I.C_smaller hB).le v))) |
| | .capLow I hB rs => (.ret k (rs.foldl I.maxVector (I.includeCapLow I.C I.C_positive (I.C_smaller hB).le v))) |
| | .includeInner T => (.ret k (T.include v)) |
| |
| def sampledStep {G : Game} {B : ℕ} {R : Result G B} (j : ℕ) : State G B R → State G B R |
| | .ret .done v => (.ret .done v) |
| | .ret (.push f k) v => sampledResume f v k j |
| | .call job k => match job with |
| | .solve P I => if hR : P.parameter < 1 then (.ret k (I.smallVector P)) |
| else if hB : I.width ≤ 128 * globalS B then (.ret k (I.exactVector G)) |
| else (.call (.tighten P (le_of_not_gt hR) I (by omega)) (.push (.solveTight P (le_of_not_gt hR) I (by omega)) k)) |
| | .ask P I => (.call (.trials P I (globalJ G.n B)) (.push (.median I) k)) |
| | .trials P I J => match J with |
| | 0 => (.ret k []) |
| | J + 1 => (.call (.solve P I) (.push (.trialsHead P I J) k)) |
| | .update P hR I hB q => |
| (.call (.ask P.reduceK (I.narrowCentered hB q.val)) (.push (.centerFirst P hR I hB q) k)) |
| | .centers P hR I hB t q => match t with |
| | 0 => (.ret k [q]) |
| | t + 1 => (.call (.update P hR I hB q) (.push (.centersHead P hR I hB t q) k)) |
| | .orient P hR I => |
| if hB : I.width ≤ 128 * globalS B then (.ret k (orientBase G P I)) |
| else (.call (.centers P hR I (by omega) (globalS B) I.midpoint) (.push (.orientLoop P hR I (by omega)) k)) |
| | .orientTrials P hR I J => match J with |
| | 0 => (.ret k []) |
| | J + 1 => (.call (.orient P hR I) (.push (.orientHead P hR I J) k)) |
| | .orientPlus P hR I => (.call (.orientTrials P hR I (globalJ G.n B)) (.push (.combine P) k)) |
| | .tighten P hR I hB => (.call (.ask P.reduceK I) (.push (.tightenFirst P hR I hB) k)) |
| | .reweight P hR I side Hs => match Hs with |
| | [] => (.ret k []) |
| | H :: Hs => |
| (.call (.ask (if side then P.reweightM H.val else P.reweightK H.val) I) |
| (.push (.reweightHead P hR I side Hs) k)) |
| |
| end MeanPayoff.SourceControl |
| |
| end |
| |
| end OAI |
| |
