| import Mathlib |
| import OAI.Probability.Contingency.WeightedSampler |
|
|
| namespace OAI |
|
|
| /-! Prepared Residual. -/ |
|
|
| noncomputable section |
|
|
|
|
| open scoped BigOperators |
| open Filter |
| namespace Contingency.BitModel.StackCode.PaddedWeightedSampler |
| noncomputable section |
|
|
| def groupMass (N : ℕ) (ws : List (List Bool)) (rest : List Bool) (j s : ℕ) : ℝ := |
| ((Finset.univ.filter fun f : Fin s→Bool => (run draw (encodeNat N++(ws.flatten++rest)) f).state=none ∧ |
| Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) |
| (BinarySubtract.value ((run draw (encodeNat N++(ws.flatten++rest)) f).memory.stack 5))=some j).card:ℝ)/2^s |
|
|
| theorem group_sum (N : ℕ) (ws : List (List Bool)) (rest : List Bool) (j s : ℕ) : |
| groupMass N ws rest j s=∑ u : Fin (N+1), |
| if Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) u.val=some j then |
| WeightedSampler.storedMass N (ws.flatten++rest) u s else 0 := by |
| classical |
| let input := encodeNat N++(ws.flatten++rest) |
| have point (f : Fin s→Bool) : |
| (if (run draw input f).state=none ∧ Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) |
| (BinarySubtract.value ((run draw input f).memory.stack 5))=some j then (1:ℝ) else 0)= |
| ∑ u : Fin (N+1),if Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) u.val=some j then |
| (if (run draw input f).state=none ∧ (run draw input f).memory.stack 5=(IntegerDraw.integerWord N u).reverse then (1:ℝ) else 0) else 0 := by |
| by_cases hh : (run draw input f).state=none |
| · obtain ⟨u,hu,h6,h7,hi,ho⟩ := WeightedSampler.first_safe N (ws.flatten++rest) (List.ofFn f) hh |
| change (run draw input f).memory.stack 5=(IntegerDraw.integerWord N u).reverse at hu |
| have hv : BinarySubtract.value ((run draw input f).memory.stack 5)=u.val := by |
| rw [hu,WeightedSampler.reverse_value,IntegerDraw.integerWord_value] |
| rw [Finset.sum_eq_single u] |
| · simp only [hh,true_and,hu,ite_true,WeightedSampler.reverse_value,IntegerDraw.integerWord_value] |
| · intro v _ hne |
| have hn : (run draw input f).memory.stack 5≠(IntegerDraw.integerWord N v).reverse := by |
| intro he |
| have hvu : u.val=v.val := by |
| have hh' := congrArg (fun bs => BinaryTrial.beValue bs.reverse) (hu.symm.trans he) |
| simpa using hh' |
| exact hne (Fin.ext hvu.symm) |
| simp [hn] |
| · simp |
| · simp [hh] |
| unfold groupMass |
| simp only [Finset.card_filter,Nat.cast_sum,Nat.cast_ite,Nat.cast_one,Nat.cast_zero] |
| change (∑ f : Fin s→Bool,if (run draw input f).state=none ∧ _ then (1:ℝ) else 0)/2^s=_ |
| rw [show (∑ f : Fin s→Bool,if (run draw input f).state=none ∧ Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) (BinarySubtract.value ((run draw input f).memory.stack 5))=some j then (1:ℝ) else 0)=_ from Finset.sum_congr rfl (fun f _ => point f)] |
| rw [Finset.sum_comm,Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro u _ |
| by_cases hs : Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) u.val=some j |
| · simp only [hs,ite_true,WeightedSampler.storedMass,Finset.card_filter,Nat.cast_sum,Nat.cast_ite,Nat.cast_one,Nat.cast_zero] |
| rfl |
| · simp [hs] |
|
|
| |
| theorem group_limit (N : ℕ) (ws : List (List Bool)) (rest : List Bool) (j : ℕ) |
| (htotal : WeightedScan.weightTotal ws=N+1) : |
| Tendsto (groupMass N ws rest j) atTop |
| (nhds ((Contingency.IntegerDraw.weight (WeightedScan.indexedWeights ws 0) j:ℝ)/(N+1:ℝ))) := by |
| classical |
| have hc : (∑ u : Fin (N+1),if Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) u.val=some j then (1:ℕ) else 0)= |
| Contingency.IntegerDraw.weight (WeightedScan.indexedWeights ws 0) j := by |
| change (∑ u : Fin (N+1),(fun x : ℕ => if Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) x=some j then (1:ℕ) else 0) u.val)=_ |
| rw [Fin.sum_univ_eq_sum_range (fun x => if Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) x=some j then (1:ℕ) else 0) (N+1)] |
| have ht : Contingency.IntegerDraw.total (WeightedScan.indexedWeights ws 0)=N+1 := |
| (WeightedScan.indexed_total ws 0).trans htotal |
| rw [← ht] |
| exact Contingency.IntegerDraw.scan_count _ _ |
| have hcr : (∑ u : Fin (N+1),if Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) u.val=some j then (1:ℝ) else 0)= |
| (Contingency.IntegerDraw.weight (WeightedScan.indexedWeights ws 0) j:ℝ) := by exact_mod_cast hc |
| have he : (∑ u : Fin (N+1),if Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) u.val=some j then |
| (1/(N+1:ℝ)) else 0)=(Contingency.IntegerDraw.weight (WeightedScan.indexedWeights ws 0) j:ℝ)/(N+1:ℝ) := by |
| rw [← hcr,Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro u _ |
| split_ifs <;> simp |
| rw [← he] |
| have hh := tendsto_finsetSum (Finset.univ : Finset (Fin (N+1))) (fun u _ => |
| show Tendsto (fun s => if Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) u.val=some j then |
| WeightedSampler.storedMass N (ws.flatten++rest) u s else 0) atTop |
| (nhds (if Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) u.val=some j then 1/(N+1:ℝ) else 0)) from by |
| split_ifs |
| · exact WeightedSampler.stored_uniform N (ws.flatten++rest) u |
| · exact tendsto_const_nhds) |
| have heq : groupMass N ws rest j=(fun s => ∑ u : Fin (N+1),if Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) u.val=some j then WeightedSampler.storedMass N (ws.flatten++rest) u s else 0) := by |
| funext s |
| exact group_sum N ws rest j s |
| rw [heq] |
| exact hh |
|
|
| end |
| end Contingency.BitModel.StackCode.PaddedWeightedSampler |
|
|
| |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| open Filter |
| namespace Contingency.BitModel.StackCode.PaddedWeightedSampler |
| noncomputable section |
|
|
| theorem mass_upper (N : ℕ) (ws : List (List Bool)) (rest : List Bool) (j s : ℕ) |
| (hlen : ∀ w∈ws,w.length=N.size+1) (htotal : WeightedScan.weightTotal ws=N+1) : |
| mass program (encodeNat N++(ws.flatten++rest)) (List.replicate j false) s ≤ groupMass N ws rest j s := by |
| classical |
| unfold mass groupMass |
| apply div_le_div_of_nonneg_right _ (by positivity) |
| exact_mod_cast Finset.card_le_card (show |
| (Finset.univ.filter fun f : Fin s→Bool => (run program (encodeNat N++(ws.flatten++rest)) f).state=none ∧ |
| (run program (encodeNat N++(ws.flatten++rest)) f).memory.outputRev.reverse=List.replicate j false) ⊆ |
| (Finset.univ.filter fun f : Fin s→Bool => (run draw (encodeNat N++(ws.flatten++rest)) f).state=none ∧ |
| Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) |
| (BinarySubtract.value ((run draw (encodeNat N++(ws.flatten++rest)) f).memory.stack 5))=some j) from by |
| intro f hf |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and] at hf ⊢ |
| obtain ⟨k,u,hk,hscan,hu,ho⟩ := halted_output N ws rest (List.ofFn f) hlen htotal hf.1 |
| change (run program (encodeNat N++(ws.flatten++rest)) f).memory.outputRev=List.replicate k false at ho |
| have hkj : k=j := by |
| have he := congrArg List.length hf.2 |
| simpa only [List.length_reverse,ho,List.length_replicate] using he |
| subst k |
| refine ⟨first_returned (List.ofFn f) _ hf.1,?_⟩ |
| change (run draw (encodeNat N++(ws.flatten++rest)) f).memory.stack 5=(IntegerDraw.integerWord N u).reverse at hu |
| rw [hu,WeightedSampler.reverse_value,IntegerDraw.integerWord_value] |
| exact hscan) |
|
|
| theorem mass_lower (N : ℕ) (ws : List (List Bool)) (rest : List Bool) (j s : ℕ) |
| (hlen : ∀ w∈ws,w.length=N.size+1) (htotal : WeightedScan.weightTotal ws=N+1) : |
| groupMass N ws rest j s ≤ mass program (encodeNat N++(ws.flatten++rest)) (List.replicate j false) (s+delay N ws) := by |
| classical |
| let e : Fin s→Fin (s+delay N ws) := Fin.castAdd (delay N ws) |
| have hi : Function.Injective e := by |
| intro i j h; exact Fin.ext (congrArg (fun k : Fin (s+delay N ws) => k.val) h) |
| let p : (Fin s→Bool)→Prop := fun f => (run draw (encodeNat N++(ws.flatten++rest)) f).state=none ∧ |
| Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) |
| (BinarySubtract.value ((run draw (encodeNat N++(ws.flatten++rest)) f).memory.stack 5))=some j |
| have he := CoordinateLaw.probability_restrict e hi p |
| simp only [Fintype.card_fin] at he |
| unfold groupMass mass |
| change ((Finset.univ.filter p).card:ℝ)/2^s≤_ |
| rw [← he] |
| apply div_le_div_of_nonneg_right _ (by positivity) |
| exact_mod_cast Finset.card_le_card (show |
| (Finset.univ.filter fun f : Fin (s+delay N ws)→Bool => p (f∘e)) ⊆ |
| (Finset.univ.filter fun f : Fin (s+delay N ws)→Bool => (run program (encodeNat N++(ws.flatten++rest)) f).state=none ∧ |
| (run program (encodeNat N++(ws.flatten++rest)) f).memory.outputRev.reverse=List.replicate j false) from by |
| intro f hf |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and] at hf ⊢ |
| change (run draw (encodeNat N++(ws.flatten++rest)) (f∘e)).state=none ∧ _ at hf |
| obtain ⟨u,hu,h6,h7,hin,hout⟩ := WeightedSampler.first_safe N (ws.flatten++rest) (List.ofFn (f∘e)) hf.1 |
| change (run draw (encodeNat N++(ws.flatten++rest)) (f∘e)).memory.stack 5=(IntegerDraw.integerWord N u).reverse at hu |
| have hs : Contingency.IntegerDraw.scan (WeightedScan.indexedWeights ws 0) u.val=some j := by |
| have hg := hf.2 |
| rw [hu,WeightedSampler.reverse_value,IntegerDraw.integerWord_value] at hg |
| exact hg |
| have ht : (List.ofFn f).take s=List.ofFn (f∘e) := by |
| rw [List.ofFn_add] |
| simp only [List.take_append,List.length_ofFn,Nat.sub_self,List.take_zero,List.append_nil] |
| rw [List.take_of_length_le (by simp)] |
| congr 2 |
| have hc := completes N ws rest (List.ofFn f) s j u hlen htotal |
| ((List.length_ofFn (f:=f)).symm.le) |
| (by rw [ht]; exact hf.1) (by rw [ht]; exact hu) hs |
| refine ⟨hc.1,?_⟩ |
| have ho : (run program (encodeNat N++(ws.flatten++rest)) f).memory.outputRev=List.replicate j false := hc.2 |
| rw [ho,List.reverse_replicate]) |
|
|
| theorem stack_law (N : ℕ) (ws : List (List Bool)) (rest : List Bool) (j : ℕ) |
| (hlen : ∀ w∈ws,w.length=N.size+1) (htotal : WeightedScan.weightTotal ws=N+1) : |
| Tendsto (mass program (encodeNat N++(ws.flatten++rest)) (List.replicate j false)) atTop |
| (nhds ((Contingency.IntegerDraw.weight (WeightedScan.indexedWeights ws 0) j:ℝ)/(N+1:ℝ))) := by |
| obtain ⟨r,hr⟩ := mass_limit_exists program (encodeNat N++(ws.flatten++rest)) (List.replicate j false) |
| have hg := group_limit N ws rest j htotal |
| have hu : r≤(Contingency.IntegerDraw.weight (WeightedScan.indexedWeights ws 0) j:ℝ)/(N+1:ℝ) := |
| le_of_tendsto_of_tendsto' hr hg (fun s => mass_upper N ws rest j s hlen htotal) |
| have hl : (Contingency.IntegerDraw.weight (WeightedScan.indexedWeights ws 0) j:ℝ)/(N+1:ℝ)≤r := |
| le_of_tendsto_of_tendsto' hg (hr.comp (tendsto_add_atTop_nat (delay N ws))) (fun s => mass_lower N ws rest j s hlen htotal) |
| simpa only [le_antisymm hu hl] using hr |
|
|
| |
|
|
| theorem cached_selector (N : ℕ) (ws : List (List Bool)) (rest : List Bool) |
| (hlen : ∀ w∈ws,w.length=N.size+1) (htotal : WeightedScan.weightTotal ws=N+1) : |
| (∀ (t : ℕ) (f : Fin t→Bool),(machine.run (encodeNat N++(ws.flatten++rest)) f).state=none → |
| ∃ j<ws.length,(machine.run (encodeNat N++(ws.flatten++rest)) f).outputRev.reverse=List.replicate j false) ∧ |
| (∀ j,Tendsto (machine.mass (encodeNat N++(ws.flatten++rest)) (List.replicate j false)) atTop |
| (nhds ((Contingency.IntegerDraw.weight (WeightedScan.indexedWeights ws 0) j:ℝ)/(N+1:ℝ)))) ∧ |
| Summable (machine.tail (encodeNat N++(ws.flatten++rest))) ∧ |
| Tendsto (machine.tail (encodeNat N++(ws.flatten++rest))) atTop (nhds 0) ∧ |
| (∑' s,machine.tail (encodeNat N++(ws.flatten++rest)) s)≤70*(N.size:ℝ)+42+2*delay N ws := by |
| refine ⟨?_,?_,charged_time N ws rest hlen htotal⟩ |
| · apply safe_compile program _ (fun out => ∃ j<ws.length,out=List.replicate j false) |
| intro t f hh |
| obtain ⟨j,u,hj,hs,hu,ho⟩ := halted_output N ws rest (List.ofFn f) hlen htotal hh |
| refine ⟨j,hj,?_⟩ |
| change (run program (encodeNat N++(ws.flatten++rest)) f).memory.outputRev=List.replicate j false at ho |
| rw [ho,List.reverse_replicate] |
| · intro j |
| exact mass_limit_compile program _ _ _ (stack_law N ws rest j hlen htotal) |
| |
| end |
| end Contingency.BitModel.StackCode.PaddedWeightedSampler |
| |
| |
| |
| |
| |
| |
| |
| open scoped BigOperators |
| open Filter |
| namespace Contingency.BitModel.StackCode.PaddedWeightedSampler |
| noncomputable section |
| |
| def cacheMaximum (weights : List ℕ) : ℕ := weights.sum-1 |
| |
| def cacheWords (weights : List ℕ) : List (List Bool) := |
| weights.map (BinarySubtract.bits ((cacheMaximum weights).size+1)) |
| |
| def cacheInput (weights : List ℕ) (rest : List Bool) : List Bool := |
| encodeNat (cacheMaximum weights)++((cacheWords weights).flatten++rest) |
| |
| def integerEntries : List ℕ→ℕ→List (ℕ×ℕ) |
| | [],_ => [] |
| | w::ws,i => (i,w)::integerEntries ws (i+1) |
| |
| theorem member_le_sum (weights : List ℕ) (x : ℕ) (hx : x∈weights) : x≤weights.sum := by |
| induction weights with |
| | nil => simp at hx |
| | cons a as ih => |
| simp only [List.mem_cons] at hx |
| simp only [List.sum_cons] |
| rcases hx with rfl|hx |
| · omega |
| · have hh := ih hx; omega |
| |
| theorem cache_width (weights : List ℕ) (hp : 0<weights.sum) : |
| ∀ w∈cacheWords weights,w.length=(cacheMaximum weights).size+1 := by |
| intro w hw |
| obtain ⟨x,hx,rfl⟩ := List.mem_map.mp hw |
| apply BinarySubtract.bits_length |
| have hmax : cacheMaximum weights+1=weights.sum := by dsimp [cacheMaximum]; omega |
| have hb : cacheMaximum weights<2^(cacheMaximum weights).size := Nat.size_le.mp (le_refl _) |
| have hxsum := member_le_sum weights x hx |
| rw [pow_succ] |
| omega |
| |
| theorem cache_total (weights : List ℕ) (hp : 0<weights.sum) : |
| WeightedScan.weightTotal (cacheWords weights)=cacheMaximum weights+1 := by |
| have hmax : cacheMaximum weights+1=weights.sum := by dsimp [cacheMaximum]; omega |
| rw [hmax] |
| unfold WeightedScan.weightTotal cacheWords |
| simp only [List.map_map,Function.comp_def,BinarySubtract.bits_value] |
| have he : (weights.map fun x => x)=weights := by induction weights <;> simp_all |
| rw [he] |
| |
| theorem cache_entries (weights : List ℕ) (i : ℕ) : |
| WeightedScan.indexedWeights (cacheWords weights) i=integerEntries weights i := by |
| have hh (n : ℕ) (as : List ℕ) (j : ℕ) : |
| WeightedScan.indexedWeights (as.map (BinarySubtract.bits n)) j=integerEntries as j := by |
| induction as generalizing j with |
| | nil => rfl |
| | cons a as ih => simp [WeightedScan.indexedWeights,integerEntries,ih] |
| exact hh _ _ _ |
| |
| |
| |
| theorem integer_cache_sampler (weights : List ℕ) (rest : List Bool) (hp : 0<weights.sum) : |
| (∀ (t : ℕ) (f : Fin t→Bool),(machine.run (cacheInput weights rest) f).state=none → |
| ∃ j<weights.length,(machine.run (cacheInput weights rest) f).outputRev.reverse=List.replicate j false) ∧ |
| (∀ j,Tendsto (machine.mass (cacheInput weights rest) (List.replicate j false)) atTop |
| (nhds ((Contingency.IntegerDraw.weight (integerEntries weights 0) j:ℝ)/(weights.sum:ℝ)))) ∧ |
| Summable (machine.tail (cacheInput weights rest)) ∧ |
| Tendsto (machine.tail (cacheInput weights rest)) atTop (nhds 0) ∧ |
| (∑' s,machine.tail (cacheInput weights rest) s)≤ |
| 78*((cacheMaximum weights).size:ℝ)+58+10*((cacheMaximum weights).size+2)*weights.length := by |
| have hc := cached_selector (cacheMaximum weights) (cacheWords weights) rest |
| (cache_width weights hp) (cache_total weights hp) |
| have hmax : cacheMaximum weights+1=weights.sum := by dsimp [cacheMaximum]; omega |
| have hlen : (cacheWords weights).length=weights.length := by simp [cacheWords] |
| have hreal : (cacheMaximum weights:ℝ)+1=(weights.sum:ℝ) := by exact_mod_cast hmax |
| refine ⟨?_,?_,hc.2.2.1,hc.2.2.2.1,?_⟩ |
| · simpa only [cacheInput,hlen] using hc.1 |
| · simpa only [cacheInput,cache_entries,hreal] using hc.2.1 |
| · have ht := hc.2.2.2.2 |
| dsimp only [delay] at ht |
| rw [hlen] at ht |
| push_cast at ht |
| dsimp only [cacheInput] |
| nlinarith |
|
|
| end |
| end Contingency.BitModel.StackCode.PaddedWeightedSampler |
|
|
| |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| open Filter |
| namespace Contingency.BitModel.StackCode.PaddedWeightedSampler |
| noncomputable section |
|
|
| theorem entries_below (ws : List ℕ) (i j : ℕ) (hj : j < i) : |
| Contingency.IntegerDraw.weight (integerEntries ws i) j=0 := by |
| induction ws generalizing i with |
| | nil => rfl |
| | cons a as ih => |
| have hn : i≠j := by omega |
| simp [integerEntries,Contingency.IntegerDraw.weight,hn] |
| exact ih (i+1) (by omega) |
|
|
| theorem entries_lookup (ws : List ℕ) (i j : ℕ) : |
| Contingency.IntegerDraw.weight (integerEntries ws i) (i+j)=ws.getD j 0 := by |
| induction ws generalizing i j with |
| | nil => simp [integerEntries,Contingency.IntegerDraw.weight] |
| | cons a as ih => |
| cases j with |
| | zero => |
| have hz := entries_below as (i+1) i (by omega) |
| simp only [Nat.add_zero,integerEntries,Contingency.IntegerDraw.weight,List.map_cons,List.sum_cons,ite_true] |
| change a+Contingency.IntegerDraw.weight (integerEntries as (i+1)) i=_ |
| rw [hz] |
| simp |
| | succ j => |
| have hn : i≠i+(j+1) := by omega |
| simp only [integerEntries,Contingency.IntegerDraw.weight,List.map_cons,List.sum_cons,hn,ite_false,Nat.zero_add] |
| change Contingency.IntegerDraw.weight (integerEntries as (i+1)) (i+(j+1))=_ |
| rw [show i+(j+1)=(i+1)+j by omega,ih] |
| simp |
|
|
| theorem finite_weights_law {M : ℕ} (w : Fin M→ℕ) (hw : 0<∑ j,w j) (rest : List Bool) (j : Fin M) : |
| Tendsto (machine.mass (cacheInput (List.ofFn w) rest) (List.replicate j.val false)) atTop |
| (nhds ((w j:ℝ)/(∑ a,w a:ℕ))) := by |
| have hp : 0<(List.ofFn w).sum := by simpa only [List.sum_ofFn] using hw |
| have h := (integer_cache_sampler (List.ofFn w) rest hp).2.1 j.val |
| have hl := entries_lookup (List.ofFn w) 0 j.val |
| simp only [Nat.zero_add] at hl |
| rw [hl,List.getD_eq_getElem _ _ (by simp)] at h |
| simpa only [List.getElem_ofFn,List.sum_ofFn] using h |
|
|
| end |
| end Contingency.BitModel.StackCode.PaddedWeightedSampler |
|
|
| namespace Contingency |
| open BitModel.StackCode.PaddedWeightedSampler |
| noncomputable section |
| variable {m n : ℕ} (r : Fin m→ℕ) (c : Fin n→ℕ) |
| local instance preparedResidualVectorTablesFintype : Fintype (Tables r c) := Fintype.ofFinite _ |
| variable (hrc : (∑ i,r i)=∑ j,c j) |
|
|
| |
|
|
| def residualVector : Fin (Fintype.card (Tables r c))→ℕ := |
| fun j => arbitraryResidual r c hrc ((Fintype.equivFin (Tables r c)).symm j) |
|
|
| theorem residualVector_sum : (∑ j,residualVector r c hrc j)=∑ X,arbitraryResidual r c hrc X := by |
| unfold residualVector |
| exact Equiv.sum_comp (Fintype.equivFin (Tables r c)).symm _ |
|
|
| |
|
|
| theorem residual_cache_law (rest : List Bool) (X : Tables r c) : |
| Tendsto (machine.mass (cacheInput (List.ofFn (residualVector r c hrc)) rest) |
| (List.replicate ((Fintype.equivFin (Tables r c)) X).val false)) atTop |
| (nhds ((arbitraryResidual r c hrc X:ℝ)/(Fintype.card (Tables r c)*2^(arbitraryDraw r c hrc (2*Parameters.D m n (∑ i,r i))).bits:ℝ))) := by |
| have hp : 0<∑ j,residualVector r c hrc j := by |
| rw [residualVector_sum] |
| exact arbitraryResidual_total_pos r c hrc |
| have hh := BitModel.StackCode.PaddedWeightedSampler.finite_weights_law (residualVector r c hrc) hp rest |
| ((Fintype.equivFin (Tables r c)) X) |
| have hw : residualVector r c hrc ((Fintype.equivFin (Tables r c)) X)=arbitraryResidual r c hrc X := by |
| simp [residualVector] |
| rw [hw,residualVector_sum,(arbitraryResidual_data r c hrc).2] at hh |
| simpa only [Nat.cast_mul,Nat.cast_pow,Nat.cast_ofNat] using hh |
|
|
| end |
| end Contingency |
|
|
| |
|
|
| |
|
|
| open scoped BigOperators |
| open Filter |
|
|
| namespace Contingency.BitModel.StackCode.PaddedWeightedSampler |
| noncomputable section |
|
|
| |
|
|
| theorem cache_maximum_size_le (weights : List ℕ) (D R : ℕ) |
| (hp : 0 < (weights).sum) (hM : (weights).length ≤ 2 ^ D) |
| (hs : (weights).sum = (weights).length * 2 ^ R) : |
| (cacheMaximum weights).size ≤ D + R := by |
| apply Nat.size_le.mpr |
| have hsum : (weights).sum ≤ 2 ^ (D + R) := by |
| rw [hs, pow_add] |
| exact Nat.mul_le_mul_right _ hM |
| dsimp only [cacheMaximum] |
| exact (Nat.sub_lt hp (by omega)).trans_le hsum |
|
|
| |
|
|
| theorem integer_cache_rare_time (weights : List ℕ) (rest : List Bool) (D R : ℕ) |
| (hp : 0 < (weights).sum) (hM : (weights).length ≤ 2 ^ D) |
| (hs : (weights).sum = (weights).length * 2 ^ R) : |
| (1 / (2 : ℝ) ^ D) * (∑' t, machine.tail (cacheInput weights rest) t) ≤ |
| (100 * (D + R + 1) : ℕ) := by |
| have ht := (integer_cache_sampler weights rest hp).2.2.2.2 |
| have hsize := cache_maximum_size_le weights D R hp hM hs |
| have hδ0 : (0 : ℝ) ≤ 1 / 2 ^ D := by positivity |
| have hδ1 : (1 : ℝ) / 2 ^ D ≤ 1 := |
| (div_le_one (by positivity)).mpr (one_le_pow₀ (by norm_num)) |
| have hδM : (1 / (2 : ℝ) ^ D) * (weights).length ≤ 1 := by |
| calc |
| _ = ((weights).length : ℝ) / 2 ^ D := by ring |
| _ ≤ 1 := (div_le_one (by positivity)).mpr (by exact_mod_cast hM) |
| have hfirst := mul_le_mul_of_nonneg_right hδ1 |
| (show (0 : ℝ) ≤ 78 * (cacheMaximum weights).size + 58 by positivity) |
| have hsecond := mul_le_mul_of_nonneg_left hδM |
| (show (0 : ℝ) ≤ 10 * ((cacheMaximum weights).size + 2) by positivity) |
| have hsizeR : ((cacheMaximum weights).size : ℝ) ≤ (D + R : ℕ) := by |
| exact_mod_cast hsize |
| have hsum0 : (0 : ℝ) ≤ (D + R : ℕ) := Nat.cast_nonneg _ |
| calc |
| _ ≤ (1 / (2 : ℝ) ^ D) * |
| (78 * (cacheMaximum weights).size + 58 + |
| 10 * ((cacheMaximum weights).size + 2) * (weights).length) := |
| mul_le_mul_of_nonneg_left ht hδ0 |
| _ = (1 / (2 : ℝ) ^ D) * (78 * (cacheMaximum weights).size + 58) + |
| 10 * ((cacheMaximum weights).size + 2) * |
| ((1 / (2 : ℝ) ^ D) * (weights).length) := by ring |
| _ ≤ (78 * (cacheMaximum weights).size + 58) + |
| 10 * ((cacheMaximum weights).size + 2) := by |
| simpa only [one_mul, mul_one] using add_le_add hfirst hsecond |
| _ ≤ (100 * (D + R + 1) : ℕ) := by |
| simp only [Nat.cast_mul, Nat.cast_ofNat, Nat.cast_add, Nat.cast_one] at * |
| nlinarith only [hsizeR, hsum0] |
| |
| end |
| end Contingency.BitModel.StackCode.PaddedWeightedSampler |
| |
| namespace Contingency |
| open BitModel.StackCode.PaddedWeightedSampler |
| noncomputable section |
| |
| |
| |
| def residualSelectionBudget (s : ℕ) : ℕ := |
| 100 * (26 ^ 2 * (s + 3) ^ 16 + |
| (32 * (s + 2 * (26 ^ 2 * (s + 3) ^ 16) + 3) ^ 2) ^ 300 + 1) |
| |
| variable {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ) |
| local instance preparedResidualBudgetTablesFintype : Fintype (Tables r c) := Fintype.ofFinite _ |
| variable (hrc : (∑ i, r i) = ∑ j, c j) |
| local notation "D" => Parameters.D m n (∑ i, r i) |
| local notation "p" => arbitraryDraw r c hrc (2 * D) |
| local notation "weights" => List.ofFn (residualVector r c hrc) |
| |
| |
| |
| theorem residual_cache_rare_time (rest : List Bool) : |
| (1 / (2 : ℝ) ^ D) * (∑' t, machine.tail (cacheInput weights rest) t) ≤ |
| (residualSelectionBudget (inputSize m n (∑ i, r i)) : ℕ) := by |
| have hp : 0 < (weights).sum := by |
| rw [List.sum_ofFn, residualVector_sum] |
| exact arbitraryResidual_total_pos r c hrc |
| have hM : (weights).length ≤ 2 ^ D := by |
| simpa only [List.length_ofFn, Nat.card_eq_fintype_card] using |
| Parameters.table_card_D_all r c hrc |
| have hs : (weights).sum = (weights).length * 2 ^ (p).bits := by |
| rw [List.sum_ofFn, residualVector_sum, (arbitraryResidual_data r c hrc).2, |
| List.length_ofFn] |
| have ht := integer_cache_rare_time weights rest D (p).bits hp hM hs |
| have hD := Parameters.D_le_input m n (∑ i, r i) |
| have hk : 1 ≤ 2 * D := by |
| have := Parameters.D_positive m n (∑ i, r i) |
| omega |
| have hR := arbitraryDraw_bits_input r c hrc (2 * D) hk |
| have hbase : inputSize m n (∑ i, r i) + 2 * D + 3 ≤ |
| inputSize m n (∑ i, r i) + |
| 2 * (26 ^ 2 * (inputSize m n (∑ i, r i) + 3) ^ 16) + 3 := by omega |
| have hR' : (p).bits ≤ |
| (32 * (inputSize m n (∑ i, r i) + |
| 2 * (26 ^ 2 * (inputSize m n (∑ i, r i) + 3) ^ 16) + 3) ^ 2) ^ 300 := by |
| calc |
| _ ≤ (32 * (inputSize m n (∑ i, r i) + 2 * D + 3) ^ 2) ^ 300 := hR |
| _ ≤ _ := by gcongr |
| refine ht.trans ?_ |
| apply Nat.cast_le.mpr |
| unfold residualSelectionBudget |
| apply Nat.mul_le_mul_left |
| omega |
| |
| |
| |
| theorem residual_cache_corrected_limit (rest : List Bool) (X : Tables r c) : |
| Tendsto |
| (fun t => (1 - 1 / (2 : ℝ) ^ D) * (p).toLaw.mass X + |
| (1 / (2 : ℝ) ^ D) * |
| machine.mass (cacheInput weights rest) |
| (List.replicate ((Fintype.equivFin (Tables r c)) X).val false) t) |
| atTop (nhds (1 / (Nat.card (Tables r c) : ℝ))) := by |
| classical |
| let := tables_nonempty r c hrc |
| have hM : Fintype.card (Tables r c) ≤ 2 ^ D := by |
| simpa only [Nat.card_eq_fintype_card] using Parameters.table_card_D_all r c hrc |
| have hk : 1 ≤ 2 * D := by |
| have := Parameters.D_positive m n (∑ i, r i) |
| omega |
| have he := corrected_exact p D hM (arbitraryDraw_tv r c hrc (2 * D) hk) X |
| change (1 - 1 / (2 : ℝ) ^ D) * (p).toLaw.mass X + |
| (1 / (2 : ℝ) ^ D) * ((arbitraryResidual r c hrc X : ℝ) / |
| (Fintype.card (Tables r c) * 2 ^ (p).bits : ℝ)) = |
| 1 / (Fintype.card (Tables r c) : ℝ) at he |
| have hl := ((residual_cache_law r c hrc rest X).const_mul ((1 : ℝ) / 2 ^ D)).const_add |
| ((1 - 1 / (2 : ℝ) ^ D) * (p).toLaw.mass X) |
| simpa only [he, Nat.card_eq_fintype_card] using hl |
| |
| |
| |
| theorem prepared_residual_stage (rest : List Bool) : |
| (∀ (t : ℕ) (coins : Fin t → Bool), |
| (machine.run (cacheInput weights rest) coins).state = none → |
| ∃ j < Fintype.card (Tables r c), |
| (machine.run (cacheInput weights rest) coins).outputRev.reverse = |
| List.replicate j false) ∧ |
| Summable (machine.tail (cacheInput weights rest)) ∧ |
| Tendsto (machine.tail (cacheInput weights rest)) atTop (nhds 0) ∧ |
| (1 / (2 : ℝ) ^ D) * (∑' t, machine.tail (cacheInput weights rest) t) ≤ |
| (residualSelectionBudget (inputSize m n (∑ i, r i)) : ℕ) ∧ |
| (∀ X : Tables r c, |
| Tendsto |
| (fun t => (1 - 1 / (2 : ℝ) ^ D) * (p).toLaw.mass X + |
| (1 / (2 : ℝ) ^ D) * |
| machine.mass (cacheInput weights rest) |
| (List.replicate ((Fintype.equivFin (Tables r c)) X).val false) t) |
| atTop (nhds (1 / (Nat.card (Tables r c) : ℝ)))) := by |
| have hp : 0 < (weights).sum := by |
| rw [List.sum_ofFn, residualVector_sum] |
| exact arbitraryResidual_total_pos r c hrc |
| have hc := integer_cache_sampler weights rest hp |
| exact ⟨by simpa only [List.length_ofFn] using hc.1, hc.2.2.1, hc.2.2.2.1, |
| residual_cache_rare_time r c hrc rest, residual_cache_corrected_limit r c hrc rest⟩ |
|
|
| end |
| end Contingency |
|
|
| end |
|
|
| end OAI |
|
|
