Download data/lean/OAI/Computability/MeanPayoff/FiniteIteration.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 13.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/MeanPayoff/FiniteIteration.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/MeanPayoff/FiniteIteration.lean
-
curl -L -o FiniteIteration.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/MeanPayoff/FiniteIteration.lean
13.7 kB
| import OAI.Computability.MeanPayoff.EncodedArithmetic | |
| namespace OAI | |
| section | |
| namespace MeanPayoff.TreeDevice.Certified | |
| open BinaryData Code | |
| local infixl:80 " β«β " => Code.comp | |
| local infixr:70 " ββ " => Code.pair | |
| namespace Array | |
| noncomputable def choose : Code (List Bool Γ List W Γ List W) (List W) := | |
| (fst ββ ((snd β«β fst ββ snd β«β snd) β«β zip zero zero (fst ββ snd))) β«β | |
| zip false (zero,zero) (Code.branch fst (snd β«β fst) (snd β«β snd)) | |
| noncomputable def replicate : Code (W Γ Count) (List W) := envMap fst | |
| noncomputable def anyLE : Code (W Γ List W) Bool := envMap Word.le β«β any Code.id | |
| noncomputable def anyGE : Code (W Γ List W) Bool := envMap ((snd ββ fst) β«β Word.le) β«β any Code.id | |
| theorem map_rep {n : β} (f : Code W W) (g : β€ β β€) | |
| (hf : β w, (f w).val=g w.val) {v : Fin n β β€} {xs : List W} (h : VectorRep v xs) : | |
| VectorRep (fun i => g (v i)) (map f xs) := by | |
| obtain β¨ws,rfl,hwβ© := h | |
| refine β¨f.eval β ws,by simp,?_β© | |
| intro i | |
| simp only [Function.comp_apply,hf,hw] | |
| theorem scale_rep {n : β} {v : Fin n β β€} {xs : List W} (h : VectorRep v xs) (w : W) : | |
| VectorRep (fun i => w.val*v i) (scale (w,xs)) := by | |
| obtain β¨ws,rfl,hwβ© := h | |
| refine β¨fun i => Word.mul (w,ws i),by simp [scale,Function.comp_def],?_β© | |
| intro i | |
| simp [hw] | |
| theorem translate_rep {n : β} {v : Fin n β β€} {xs : List W} (h : VectorRep v xs) (w : W) : | |
| VectorRep (fun i => w.val+v i) (translate (w,xs)) := by | |
| obtain β¨ws,rfl,hwβ© := h | |
| refine β¨fun i => Word.add (w,ws i),by simp [translate,Function.comp_def],?_β© | |
| intro i | |
| simp [hw] | |
| theorem choose_rep {n : β} {H : Finset (Fin n)} {hs : List Bool} | |
| {a b : Fin n β β€} {as bs : List W} (hH : MaskRep H hs) (ha : VectorRep a as) (hb : VectorRep b bs) : | |
| VectorRep (fun i => if iβH then a i else b i) (choose (hs,as,bs)) := by | |
| obtain β¨ws,rfl,hwβ© := ha | |
| obtain β¨vs,rfl,hvβ© := hb | |
| rw [hH] | |
| refine β¨fun i => if iβH then ws i else vs i,?_,?_β© | |
| Β· change Zip.zip _ _ (List.ofFn _) (Zip.zip _ _ (List.ofFn ws) (List.ofFn vs))=_ | |
| rw [zip_ofFn,zip_ofFn] | |
| congr 1 | |
| funext i | |
| simp [comp,fst,snd] | |
| Β· intro i | |
| dsimp only | |
| split_ifs <;> simp_all | |
| theorem lt_rep {n : β} {a b : Fin n β β€} {as bs : List W} | |
| (ha : VectorRep a as) (hb : VectorRep b bs) : | |
| MaskRep (Finset.univ.filter (fun i => a i<b i)) (lt (as,bs)) := by | |
| obtain β¨ws,rfl,hwβ© := ha | |
| obtain β¨vs,rfl,hvβ© := hb | |
| change Zip.zip _ _ (List.ofFn ws) (List.ofFn vs)=_ | |
| rw [zip_ofFn] | |
| simp [Word.lt_eval,hw,hv] | |
| theorem le_rep {n : β} {a b : Fin n β β€} {as bs : List W} | |
| (ha : VectorRep a as) (hb : VectorRep b bs) : | |
| MaskRep (Finset.univ.filter (fun i => a iβ€b i)) (le (as,bs)) := by | |
| obtain β¨ws,rfl,hwβ© := ha | |
| obtain β¨vs,rfl,hvβ© := hb | |
| change Zip.zip _ _ (List.ofFn ws) (List.ofFn vs)=_ | |
| rw [zip_ofFn] | |
| simp [Word.le_eval,hw,hv] | |
| theorem complement_rep {n : β} {H : Finset (Fin n)} {hs : List Bool} (h : MaskRep H hs) : | |
| MaskRep HαΆ (complement hs) := by | |
| rw [h] | |
| simp [MaskRep,complement,Code.not,List.map_ofFn,Function.comp_def] | |
| theorem repeat_rep {n : β} (w : W) (xs : Count) (h : xs.length=n) : | |
| VectorRep (fun _ : Fin n => w.val) (replicate (w,xs)) := by | |
| refine β¨fun _ => w,?_,fun _ => rflβ© | |
| simp [replicate,h,List.ofFn_const] | |
| theorem anyLE_eq {n : β} (w : W) {v : Fin n β β€} {xs : List W} (h : VectorRep v xs) : | |
| anyLE (w,xs)=decide (β i, w.valβ€v i) := by | |
| obtain β¨ws,rfl,hwβ© := h | |
| simp [anyLE,Code.any,Code.filter,Code.empty,Word.le_eval,hw,β decide_not] | |
| theorem anyGE_eq {n : β} (w : W) {v : Fin n β β€} {xs : List W} (h : VectorRep v xs) : | |
| anyGE (w,xs)=decide (β i, v iβ€w.val) := by | |
| obtain β¨ws,rfl,hwβ© := h | |
| simp [anyGE,Code.any,Code.filter,Code.empty,Word.le_eval,hw,β decide_not] | |
| end Array | |
| namespace RawBudget | |
| theorem smallMask_eq {n : β} {P : Budgets n} {p : Data} (h : Rep P p) : | |
| MaskRep (Finset.univ.filter (fun i => P.m < P.beta i)) (smallMask p) := by | |
| obtain β¨a,b,ha,hb,hap,hbp,hea,hebβ© := h.coords | |
| change Zip.zip _ _ (List.map _ p.2.2.2) (List.map _ p.2.2.2)=_ | |
| rw [hb,List.map_ofFn,List.map_ofFn,Array.zip_ofFn] | |
| apply congrArg List.ofFn | |
| funext i | |
| simp only [Function.comp_apply,Word.mul_val,Word.lt_eval,Finset.mem_filter,Finset.mem_univ,true_and] | |
| apply decide_eq_decide.mpr | |
| have hd : (0:β)<p.2.1.2.val := by exact_mod_cast h.md_pos | |
| have hp : (0:β)<(b i).val := by exact_mod_cast hbp i | |
| rw [h.m_eq,heb,div_lt_div_iffβ hd hp] | |
| simp only [one_mul] | |
| change p.2.1.1.val*(b i).val<p.2.1.2.val β _ | |
| exact_mod_cast (Iff.rfl : p.2.1.1.val*(b i).val<p.2.1.2.val β _) | |
| end RawBudget | |
| end MeanPayoff.TreeDevice.Certified | |
| end | |
| section | |
| namespace MeanPayoff.TreeDevice.Certified | |
| open BinaryData Code | |
| local infixl:80 " β«β " => Code.comp | |
| local infixr:70 " ββ " => Code.pair | |
| namespace RawBox | |
| abbrev Data := W Γ List W Γ List W | |
| noncomputable def width : Code Data W := fst | |
| noncomputable def lower : Code Data (List W) := snd β«β fst | |
| noncomputable def upper : Code Data (List W) := snd β«β snd | |
| noncomputable def withFloor : Code (Data Γ List W) Data := | |
| (fst β«β width) ββ snd ββ (fst β«β upper) | |
| noncomputable def withCeiling : Code (Data Γ List W) Data := | |
| (fst β«β width) ββ (fst β«β lower) ββ snd | |
| noncomputable def clip : Code (Data Γ List W) (List W) := | |
| ((fst β«β upper) ββ (((fst β«β lower) ββ snd) β«β Array.max)) β«β Array.min | |
| noncomputable def midpoint : Code Data (List W) := (lower ββ upper) β«β Array.average | |
| noncomputable def averageClipped : Code (Data Γ List W Γ List W) (List W) := | |
| (fst ββ (snd β«β Array.average)) β«β clip | |
| noncomputable def centered : Code (W Γ List W) Data := | |
| (fst β«β Word.double) ββ | |
| (((fst β«β Word.neg) ββ snd) β«β Array.translate) ββ (Code.id β«β Array.translate) | |
| noncomputable def capLow : Code (Data Γ W) Data := | |
| snd ββ (fst β«β lower) ββ | |
| (((fst β«β upper) ββ ((snd ββ (fst β«β lower)) β«β Array.translate)) β«β Array.min) | |
| noncomputable def capHigh : Code (Data Γ W) Data := | |
| snd ββ (((fst β«β lower) ββ (((snd β«β Word.neg) ββ (fst β«β upper)) β«β Array.translate)) β«β Array.max) ββ | |
| (fst β«β upper) | |
| noncomputable def smallVector : Code (RawBudget.Data Γ Data) (List W) := | |
| ((fst β«β RawBudget.smallMask) ββ (snd β«β upper) ββ (snd β«β lower)) β«β Array.choose | |
| noncomputable def dividedWidth : Code (Data Γ Count) W := ((fst β«β width) ββ snd) β«β Word.shiftRight | |
| noncomputable def remainderWidth : Code (Data Γ Count) W := | |
| ((fst β«β width) ββ dividedWidth) β«β Word.sub | |
| noncomputable def movedFloor : Code (Data Γ List W Γ W) Bool := | |
| ((snd β«β snd) ββ (((snd β«β fst) ββ (fst β«β lower)) β«β Array.sub)) β«β Array.anyLE | |
| noncomputable def movedCeiling : Code (Data Γ List W Γ W) Bool := | |
| ((snd β«β snd) ββ (((fst β«β upper) ββ (snd β«β fst)) β«β Array.sub)) β«β Array.anyLE | |
| structure Rep {n B : β} (I : SolveBox n B) (b : Data) : Prop where | |
| width : b.1.val=I.width | |
| lower : VectorRep I.a b.2.1 | |
| upper : VectorRep I.b b.2.2 | |
| theorem floor_rep {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| (v : BoxVector I) {vs : List W} (hv : VectorRep v.val vs) : | |
| Rep (I.withFloor v) (withFloor (b,vs)) := β¨h.width,hv,h.upperβ© | |
| theorem ceiling_rep {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| (v : BoxVector I) {vs : List W} (hv : VectorRep v.val vs) : | |
| Rep (I.withCeiling v) (withCeiling (b,vs)) := β¨h.width,h.lower,hvβ© | |
| theorem clip_rep {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| {v : Fin n β β€} {vs : List W} (hv : VectorRep v vs) : | |
| VectorRep (MeanPayoff.clip I.a I.b v) (clip (b,vs)) := by | |
| exact Array.zip_rep Word.min Min.min (fun _ _ => Word.min_val _ _) h.upper | |
| (Array.zip_rep Word.max Max.max (fun _ _ => Word.max_val _ _) h.lower hv) | |
| theorem midpoint_rep {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) : | |
| VectorRep I.midpoint.val (midpoint b) := by | |
| exact Array.zip_rep Word.average (fun a b => (a+b)/2) (fun _ _ => Word.average_val _ _) h.lower h.upper | |
| theorem average_rep {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| {v w : Fin n β β€} {vs ws : List W} (hv : VectorRep v vs) (hw : VectorRep w ws) : | |
| VectorRep (I.averageClipped v w).val (averageClipped (b,vs,ws)) := by | |
| exact clip_rep h (Array.zip_rep Word.average (fun a b => (a+b)/2) | |
| (fun _ _ => Word.average_val _ _) hv hw) | |
| theorem centered_rep {n B : β} (v : Fin n β β€) {vs : List W} (hv : VectorRep v vs) | |
| {A : β} (hA : 0<A) (hB : 2*Aβ€B) (a : W) (ha : a.val=A) : | |
| Rep (SolveBox.centered v A hA hB) (centered (a,vs)) := by | |
| refine β¨?_,?_,?_β© | |
| Β· simp [centered,Word.double_val,ha,SolveBox.centered] | |
| Β· convert Array.translate_rep hv (Word.neg a) using 1 <;> try rfl | |
| funext i | |
| simp [SolveBox.centered,Word.neg_val,ha] | |
| ring | |
| Β· convert Array.translate_rep hv a using 1 <;> try rfl | |
| funext i | |
| simp [SolveBox.centered,ha,add_comm] | |
| theorem capLow_rep {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| {C : β} (hC : 0<C) (hCI : Cβ€I.width) (c : W) (hc : c.val=C) : | |
| Rep (I.capLow C hC hCI) (capLow (b,c)) := by | |
| refine β¨hc,h.lower,?_β© | |
| convert Array.zip_rep Word.min Min.min (fun _ _ => Word.min_val _ _) h.upper | |
| (Array.translate_rep h.lower c) using 1 <;> try rfl | |
| funext i | |
| simp [SolveBox.capLow,hc,add_comm] | |
| theorem capHigh_rep {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| {C : β} (hC : 0<C) (hCI : Cβ€I.width) (c : W) (hc : c.val=C) : | |
| Rep (I.capHigh C hC hCI) (capHigh (b,c)) := by | |
| refine β¨hc,?_,h.upperβ© | |
| convert Array.zip_rep Word.max Max.max (fun _ _ => Word.max_val _ _) h.lower | |
| (Array.translate_rep h.upper (Word.neg c)) using 1 <;> try rfl | |
| funext i | |
| simp [SolveBox.capHigh,Word.neg_val,hc,sub_eq_neg_add] | |
| theorem smallVector_rep {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| {P : Budgets n} {p : RawBudget.Data} (hp : RawBudget.Rep P p) : | |
| VectorRep (I.smallVector P).val (smallVector (p,b)) := by | |
| convert Array.choose_rep (RawBudget.smallMask_eq hp) h.upper h.lower using 1 <;> try rfl | |
| funext i | |
| simp [SolveBox.smallVector,smallRankAnswer] | |
| theorem dividedWidth_eq {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) (c : Count) : | |
| (dividedWidth (b,c)).val=(I.width:β€)/(2^c.length) := by | |
| simp [dividedWidth,Word.shiftRight_val,width,h.width] | |
| theorem dividedWidth_nat {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| (c : Count) (d : β) (hc : 2^c.length=d) : | |
| (dividedWidth (b,c)).val=(I.width/d:β) := by | |
| rw [dividedWidth_eq h] | |
| norm_cast | |
| rw [hc] | |
| theorem remainderWidth_nat {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| (c : Count) (d : β) (hc : 2^c.length=d) : | |
| (remainderWidth (b,c)).val=(I.width-I.width/d:β) := by | |
| change (Word.sub (b.1,dividedWidth (b,c))).val=_ | |
| rw [Word.sub_val,h.width,dividedWidth_nat h c d hc,Int.ofNat_sub (Nat.div_le_self _ _)] | |
| theorem movedFloor_eq {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| {v : Fin n β β€} {vs : List W} (hv : VectorRep v vs) (d : W) : | |
| movedFloor (b,vs,d)=decide (β i, d.valβ€v i-I.a i) := by | |
| exact Array.anyLE_eq d (Array.zip_rep Word.sub (Β·-Β·) (fun _ _ => Word.sub_val _ _) hv h.lower) | |
| theorem movedCeiling_eq {n B : β} {I : SolveBox n B} {b : Data} (h : Rep I b) | |
| {v : Fin n β β€} {vs : List W} (hv : VectorRep v vs) (d : W) : | |
| movedCeiling (b,vs,d)=decide (β i, d.valβ€I.b i-v i) := by | |
| exact Array.anyLE_eq d (Array.zip_rep Word.sub (Β·-Β·) (fun _ _ => Word.sub_val _ _) h.upper hv) | |
| end RawBox | |
| end MeanPayoff.TreeDevice.Certified | |
| end | |
| section | |
| namespace MeanPayoff | |
| theorem box_iterate_fixed {n : β} (F : Vec (Fin n) β Vec (Fin n)) (hF : Monotone F) | |
| (a b : Vec (Fin n)) (hab : aβ€b) (p : Vec (Fin n)) (_hp : InBox a b p) | |
| (hi : pβ€boxStep F a b p) (t : β) (ht : volume b pβ€t) : | |
| boxStep F a b ((boxStep F a b)^[t] p)=(boxStep F a b)^[t] p := by | |
| by_cases heq : boxStep F a b p=p | |
| Β· have hit : β k, (boxStep F a b)^[k] p=p := by | |
| intro k | |
| induction k with | |
| | zero => rfl | |
| | succ k ih => rw [Function.iterate_succ_apply',ih,heq] | |
| rw [hit,heq] | |
| Β· have hq := boxStep_in_box F hab p | |
| have hnext := boxStep_mono hF a b hi | |
| have hv := volume_decreases hi hq.2 (Ne.symm heq) | |
| cases t with | |
| | zero => omega | |
| | succ t => | |
| rw [Function.iterate_succ_apply] | |
| exact box_iterate_fixed F hF a b hab (boxStep F a b p) hq hnext t (by omega) | |
| termination_by volume b p | |
| theorem SolveBox.volume_bound {n B : β} (I : SolveBox n B) : volume I.b I.aβ€n*I.width := by | |
| unfold volume | |
| calc | |
| β i : Fin n, (I.b i-I.a i).toNat β€ β _i : Fin n, I.width := by | |
| apply Finset.sum_le_sum | |
| intro i _ | |
| exact Int.toNat_le.mpr (by exact_mod_cast I.width_bound i) | |
| _ = n*I.width := by simp | |
| theorem SolveBox.iterate_exact (G : Game) {B : β} (I : SolveBox G.n B) | |
| (t : β) (ht : G.n*I.widthβ€t) : | |
| (boxStep (operator G) I.a I.b)^[t] I.a = (I.exactVector G).val := by | |
| have hf := box_iterate_fixed (operator G) (operator_laws G).mono I.a I.b I.ordered I.a | |
| β¨le_rfl,I.orderedβ© (boxStep_in_box (operator G) I.ordered I.a).1 t (I.volume_bound.trans ht) | |
| have hs := (fixed_iff_comparisons (operator G) I.ordered).mp hf | |
| exact le_antisymm (box_comparison G hs.1 (basic_spec G I.a I.b I.ordered).2.1) | |
| (box_comparison G (basic_spec G I.a I.b I.ordered).1 hs.2) | |
| end MeanPayoff | |
| end | |
| end OAI | |