| import OAI.Computability.RandomMean.Allocation |
|
|
| namespace OAI |
|
|
| section |
| namespace MeanPayoff.TreeDevice.Certified |
| open BinaryData Code |
| local infixl:80 " ≫ₚ " => Code.comp |
| local infixr:70 " ⋏ₚ " => Code.pair |
| namespace Preparation |
| abbrev Seed := (Count×Count)×(W×RawControl.Acc) |
| abbrev Aux := (Count×Count)×Count×(W×RawControl.Acc) |
| noncomputable def inputLength : Code Digits Count := by |
| let F := Map.device (TreeDevice.constant boolData Median.unitData ()) |
| refine ⟨fun d => d.bits.map (fun _ => ()),F.recode encode encode Digits.bits |
| (fun d => d.bits.map (fun _ => ())) (fun _ => rfl) (fun _ => rfl),?_⟩ |
| obtain ⟨K,d,h⟩ := PolynomialCost.map (LinearCost.constant boolData Median.unitData ()).polynomial |
| exact ⟨K,d,fun z => h z.bits⟩ |
| noncomputable def logarithm : Code Digits Count := |
| inputLength ≫ₚ Counter.inc ≫ₚ Counter.inc ≫ₚ Counter.word ≫ₚ NaturalLog.ceil |
| noncomputable def exponent : Code Digits Count := |
| ((const (List.replicate 25000 ())) ⋏ₚ (logarithm ≫ₚ Counter.fixedPower 2)) ≫ₚ Counter.mul |
| noncomputable def root : Code Digits Seed := InputCode.parse ≫ₚ |
| ((RootCode.exponent ⋏ₚ RootCode.samples) ⋏ₚ (InputCode.width ⋏ₚ (RootCode.env ⋏ₚ RootCode.state))) |
| noncomputable def seed : Code Digits (Count×Seed) := exponent ⋏ₚ root |
| noncomputable def inflate : Device encode encode |
| (fun z : Count×Seed => (Fold.fold Allocation.double.eval [()] z.1,z.2)) := |
| pairMap Allocation.device (TreeDevice.identity encode) |
| noncomputable def assemble : Code (Count×Seed) (Count×Aux) := |
| (((snd ≫ₚ fst ≫ₚ fst) ⋏ₚ fst) ≫ₚ Counter.mul) ⋏ₚ ((snd ≫ₚ fst) ⋏ₚ fst ⋏ₚ (snd ≫ₚ snd)) |
| noncomputable def value (d : Digits) : Count×Aux := |
| assemble (Fold.fold Allocation.double.eval [()] (exponent d),root d) |
| noncomputable def device : Device encode encode value := |
| @compose Digits (Count×Seed) (Count×Aux) encode encode encode seed.eval |
| (fun z => assemble (Fold.fold Allocation.double.eval [()] z.1,z.2)) seed.device |
| (@compose (Count×Seed) (Count×Seed) (Count×Aux) encode encode encode |
| (fun z => (Fold.fold Allocation.double.eval [()] z.1,z.2)) assemble.eval inflate assemble.device) |
| theorem logarithm_length (d : Digits) : (logarithm d).length=Nat.clog 2 (d.bits.length+2) := by |
| change (NaturalLog.ceil (Counter.word (Counter.inc (Counter.inc (inputLength d))))).length=_ |
| rw [NaturalLog.ceil_exact _ (by rw [Counter.word_val]; simp only [Counter.inc_length]; positivity),Counter.word_val,Int.toNat_natCast] |
| change Nat.clog 2 ((d.bits.map (fun _ => ())).length+1+1)=_ |
| simp only [List.length_map,Nat.add_assoc] |
| theorem exponent_length (d : Digits) : (exponent d).length=25000*(Nat.clog 2 (d.bits.length+2))^2 := by |
| simp only [exponent,comp_eval,pair_eval,Counter.mul_length,const_eval,List.length_replicate,Counter.fixedPower_length,logarithm_length] |
| theorem iterations (d : Digits) : (value d).2.2.1=List.replicate (2^(exponent d).length) () := Allocation.exact _ |
| theorem bits_length (d : Digits) : (value d).1.length=(root d).1.1.length*2^(exponent d).length := by |
| change (Counter.mul ((root d).1.1,Fold.fold Allocation.double.eval [()] (exponent d))).length=_ |
| rw [Counter.mul_length,Allocation.exact,List.length_replicate] |
| theorem aux (d : Digits) : (value d).2=((root d).1,List.replicate (2^(exponent d).length) (), (root d).2) := by |
| change ((root d).1,Fold.fold Allocation.double.eval [()] (exponent d),(root d).2)=_ |
| rw [Allocation.exact] |
| end Preparation |
| end MeanPayoff.TreeDevice.Certified |
|
|
| end |
|
|
| section |
| namespace MeanPayoff.TreeDevice.Certified.Preparation |
| open BinaryData |
| theorem seed_eval (d : Digits) : seed d=(exponent d,root d) := rfl |
| theorem inflate_limit (z : Count×Seed) : inflate.limit z=Allocation.device.limit z.1+1+ |
| 24*treeSize (encode (Fold.fold Allocation.double.eval [()] z.1))+24*treeSize (encode z.2)+50 := by |
| rcases z with ⟨c,s⟩ |
| rw [inflate,pairMap_limit] |
| change _+1+24*_+12*_+12*_+50=_ |
| simp only [id_eq] |
| omega |
| theorem device_limit (d : Digits) : device.limit d= |
| seed.device.limit d+inflate.limit (seed d)+ |
| assemble.device.limit (Fold.fold Allocation.double.eval [()] (exponent d),root d)+4 := by |
| simp only [device, compose_limit] |
| simp only [seed_eval] |
| omega |
| end MeanPayoff.TreeDevice.Certified.Preparation |
|
|
| end |
|
|
| section |
| namespace MeanPayoff.TreeDevice.Certified.Preparation |
| open BinaryData |
| theorem exponent_poly : PolynomialCost exponent.device := exponent.polynomial |
| theorem root_poly : PolynomialCost root.device := root.polynomial |
| theorem seed_poly : PolynomialCost seed.device := PolynomialCost.fanout exponent_poly root_poly |
| theorem assemble_poly : PolynomialCost assemble.device := assemble.polynomial |
| end MeanPayoff.TreeDevice.Certified.Preparation |
|
|
| end |
|
|
| section |
| namespace MeanPayoff.TreeDevice.Certified.Preparation |
| open BinaryData |
| noncomputable def resource (d : Digits) : ℕ := treeSize (encode d)+2^(exponent d).length |
| theorem input_bound : PolyBound resource (fun d => treeSize (encode d)) := |
| (PolyBound.base resource).mono (fun _ => Nat.le_add_right _ _) |
| theorem seed_cost : PolyBound resource seed.device.limit := by |
| obtain ⟨K,e,h⟩ := seed_poly |
| refine ⟨K,e,fun d => (h d).trans ?_⟩ |
| apply Nat.mul_le_mul_left |
| apply Nat.pow_le_pow_left |
| exact Nat.add_le_add_right (Nat.le_add_right _ _) 1 |
| theorem seed_size_le (d : Digits) : treeSize (encode (seed d)) ≤ treeSize (encode d)+seed.device.limit d := |
| output_size seed.device d |
| theorem seed_size : PolyBound resource (fun d => treeSize (encode (seed d))) := |
| (input_bound.add seed_cost).mono seed_size_le |
| theorem exponent_size : PolyBound resource (fun d => treeSize (encode (exponent d))) := by |
| apply seed_size.mono |
| intro d |
| have h := Size.fst (seed d) |
| rw [seed_eval] at h |
| exact h |
| theorem exponent_size_length : PolyBound resource (fun d => (exponent d).length) := |
| exponent_size.mono (fun _ => Size.length _) |
| theorem power_bound : PolyBound resource (fun d => 2^(exponent d).length) := |
| (PolyBound.base resource).mono (fun _ => Nat.le_add_left _ _) |
| theorem allocation_init_cost : PolyBound resource (fun d => Allocation.init.device.limit (exponent d)) := |
| polynomial_limit Allocation.init.polynomial resource exponent exponent_size |
| theorem allocation_fold_cost : PolyBound resource |
| (fun d => (Fold.device Allocation.double.device).limit ([()],exponent d)) := by |
| obtain ⟨K,e,hK⟩ := Allocation.fold_bound |
| apply ((PolyBound.const resource K).mul |
| (((power_bound.add exponent_size_length).add (PolyBound.const resource 1)).pow e)).mono |
| intro d |
| simpa only [List.length_cons,List.length_nil,Nat.zero_add,Nat.one_mul,Nat.add_comm] using hK [()] (exponent d) |
| theorem allocation_cost : PolyBound resource (fun d => Allocation.device.limit (exponent d)) := by |
| apply ((allocation_init_cost.add allocation_fold_cost).add (PolyBound.const resource 2)).mono |
| intro d |
| rfl |
| theorem allocation_size : PolyBound resource |
| (fun d => treeSize (encode (Fold.fold Allocation.double.eval [()] (exponent d)))) := |
| polynomial_output Allocation.device resource exponent exponent_size allocation_cost |
| theorem root_size : PolyBound resource (fun d => treeSize (encode (root d))) := by |
| apply seed_size.mono |
| intro d |
| have h := Size.snd (seed d) |
| rw [seed_eval] at h |
| exact h |
| theorem inflate_cost : PolyBound resource (fun d => inflate.limit (seed d)) := by |
| apply ((((allocation_cost.add (PolyBound.const resource 1)).add |
| ((PolyBound.const resource 24).mul allocation_size)).add |
| ((PolyBound.const resource 24).mul root_size)).add (PolyBound.const resource 50)).mono |
| intro d |
| rw [inflate_limit,seed_eval] |
| theorem inflate_size : PolyBound resource |
| (fun d => treeSize (encode (Fold.fold Allocation.double.eval [()] (exponent d),root d))) := by |
| have h := polynomial_output inflate resource (fun d => seed d) seed_size inflate_cost |
| simpa only [seed_eval] using h |
| theorem assemble_cost : PolyBound resource |
| (fun d => assemble.device.limit (Fold.fold Allocation.double.eval [()] (exponent d),root d)) := |
| @polynomial_limit Digits (Count×Seed) (Count×Aux) encode encode assemble.eval assemble.device |
| assemble_poly resource (fun d => (Fold.fold Allocation.double.eval [()] (exponent d),root d)) inflate_size |
| theorem cost_bound : PolyBound resource device.limit := by |
| apply (((seed_cost.add inflate_cost).add assemble_cost).add (PolyBound.const resource 4)).mono |
| intro d |
| rw [device_limit] |
| theorem output_size_le (d : Digits) : treeSize (encode (value d)) ≤ treeSize (encode d)+device.limit d := |
| output_size device d |
| theorem output_bound : PolyBound resource (fun d => treeSize (encode (value d))) := |
| (input_bound.add cost_bound).mono output_size_le |
| end MeanPayoff.TreeDevice.Certified.Preparation |
|
|
| end |
|
|
| end OAI |
|
|
