| import OAI.Combinatorics.ContingencyTables.Sampling.ExactPublicPrefix |
| import OAI.Combinatorics.ContingencyTables.Sampling.PhysicalPublicLaw |
|
|
| namespace OAI |
|
|
| /-! # Exact public output law and almost-sure termination -/ |
|
|
| namespace ContingencyTables.ExactPublicLaw |
| open MatchingFPRAS MatchingFPRAS.PhysicalStream MatchingFPRAS.PhysicalPost Turing |
| open PhysicalEventBounds PhysicalPublicLaw ExactPublicPrefix SmallGraphProfiles |
| open scoped BigOperators Classical |
| noncomputable section |
| attribute [local irreducible] ExactPublicPrefix.program ExactPublicPrefix.output |
| ExactTablePrefix.experiment correctionPrecision |
| PublishedInputs.FiniteBoxPrekopaLeindler PublishedInputs.FiniteCheeger |
| CompletionCounts.dimensionAllowance |
|
|
| variable {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ) |
| local notation "d" => CompletionCounts.dimensionAllowance (I := Fin m) (J := Fin n) |
|
|
| def prefixError (N : ℕ) : ℝ := |
| (1/(2:ℝ)^(correctionPrecision r c))*(1/2:ℝ)^N |
|
|
| lemma error_limit : Filter.Tendsto (prefixError r c) Filter.atTop (nhds 0) := by |
| have h := (tendsto_pow_atTop_nhds_zero_of_lt_one (by norm_num : (0:ℝ)≤1/2) |
| (by norm_num : (1/2:ℝ)<1)).const_mul (1/(2:ℝ)^correctionPrecision r c) |
| change Filter.Tendsto (fun N => (1/(2:ℝ)^(correctionPrecision r c))*(1/2:ℝ)^N) _ _ |
| simpa only [mul_zero] using h |
|
|
| lemma event_output (X Y : Table r c) : |
| outputs (Algorithms.encodeMatrix X.val) (output r c (some Y)) ↔ Y=X := by |
| simp only [outputs,output_halted,output_tape,true_and] |
| constructor |
| · intro h |
| exact Subtype.ext (Algorithms.blankMatrix_injective _ _ h) |
| · rintro rfl; rfl |
|
|
| section Conditional |
| variable |
| (hPL : ∀ q,PublishedInputs.FiniteBoxPrekopaLeindler q) |
| (hCheeger : ∀ q k,PublishedInputs.FiniteCheeger |
| (GridBoundary.Grid (I := Fin q) (4*k^8))) |
| (htotal : (∑ i,r i)=∑ j,c j) |
| include hPL hCheeger htotal |
|
|
| lemma prefix_error (N : ℕ) : |
| ((ExactTablePrefix.experiment r c N).mean (fun o => if o=none then 1 else 0):ℝ)≤prefixError r c N := by |
| have h := ExactTablePrefix.failure_bound r c (hPL _) (hCheeger _ d) htotal N |
| have hR := (Rat.cast_le (K := ℝ)).mpr h |
| simpa only [prefixError,Rat.cast_mul,Rat.cast_div,Rat.cast_pow,Rat.cast_one,Rat.cast_ofNat] using hR |
|
|
| theorem tableMass_limit (X : Table r c) : |
| Filter.Tendsto (fun t => Algorithms.tableMass machine (Algorithms.encodeMargins r c) t X.val) |
| Filter.atTop (nhds ((Fintype.card (Table r c):ℝ)⁻¹)) := by |
| apply tendsto_of_prefix_bounds _ |
| (fun N => ((ExactTablePrefix.experiment r c N).mean (fun o => if o=some X then 1 else 0):ℝ)) |
| (prefixError r c) _ (ExactTablePrefix.point_limit r c (hPL _) (hCheeger _ d) htotal X) (error_limit r c) |
| intro N |
| obtain ⟨p,hp,hm⟩ := prefix_correct r c htotal N |
| refine ⟨p.cost,?_⟩ |
| intro t ht |
| have h := stopped_event_bounds program.table (output r c) |
| (program.initial (Tape.mk₁ (ExactTablePrefix.input r c))) p hp |
| (output_halted r c) (outputs (Algorithms.encodeMatrix X.val)) t ht |
| have he : (fun o : Option (Table r c) => o.elim 0 |
| (fun Y => event (outputs (Algorithms.encodeMatrix X.val)) (output r c (some Y))))= |
| (fun o => if o=some X then 1 else 0) := by |
| funext o |
| cases o with |
| | none => simp |
| | some Y => simp only [Option.elim_some,event,event_output,Option.some.injEq] |
| rw [he,hm,hm] at h |
| have hl : ((ExactTablePrefix.experiment r c N).mean |
| (fun o => if o=some X then 1 else 0):ℝ)≤ |
| ((experiment program.table t (program.initial (Tape.mk₁ (Algorithms.encodeMargins r c)))).mean |
| (event (outputs (Algorithms.encodeMatrix X.val))):ℝ) := by exact_mod_cast h.1 |
| have hu : ((experiment program.table t (program.initial (Tape.mk₁ (Algorithms.encodeMargins r c)))).mean |
| (event (outputs (Algorithms.encodeMatrix X.val))):ℝ)≤ |
| ((ExactTablePrefix.experiment r c N).mean (fun o => if o=some X then 1 else 0):ℝ)+ |
| ((ExactTablePrefix.experiment r c N).mean (fun o => if o=none then 1 else 0):ℝ) := by |
| exact_mod_cast h.2 |
| have hm : Algorithms.tableMass machine (Algorithms.encodeMargins r c) t X.val= |
| ((experiment program.table t (program.initial (Tape.mk₁ (Algorithms.encodeMargins r c)))).mean |
| (event (outputs (Algorithms.encodeMatrix X.val))):ℝ) := tableMass_eq program _ t X.val |
| exact ⟨hl.trans_eq hm.symm,hm.le.trans |
| (hu.trans (add_le_add le_rfl (prefix_error r c hPL hCheeger htotal N)))⟩ |
|
|
| theorem tail_limit : |
| Filter.Tendsto (PhysicalRetryTail.tail program.table |
| (program.initial (Tape.mk₁ (Algorithms.encodeMargins r c)))) Filter.atTop (nhds 0) := by |
| apply tendsto_of_prefix_bounds _ (fun _ => 0) (prefixError r c) 0 tendsto_const_nhds (error_limit r c) |
| intro N |
| obtain ⟨p,hp,hm⟩ := prefix_correct r c htotal N |
| refine ⟨p.cost,?_⟩ |
| intro t ht |
| have h := PhysicalRetryTail.tail_le_failure program.table (output r c) _ p hp |
| (output_halted r c) t ht |
| rw [hm] at h |
| exact ⟨PhysicalRetryTail.tail_nonnegative _ _ _, |
| (h.trans (prefix_error r c hPL hCheeger htotal N)).trans_eq (zero_add _).symm⟩ |
|
|
| theorem haltMass_limit : |
| Filter.Tendsto (Algorithms.haltMass machine (Algorithms.encodeMargins r c)) |
| Filter.atTop (nhds 1) := by |
| have h := (tail_limit r c hPL hCheeger htotal).const_sub 1 |
| have he : (fun t => 1-PhysicalRetryTail.tail program.table |
| (program.initial (Tape.mk₁ (Algorithms.encodeMargins r c))) t)= |
| Algorithms.haltMass machine (Algorithms.encodeMargins r c) := by |
| funext t |
| rw [←tail_eq] |
| change 1-(1-Algorithms.haltMass program.machine (Algorithms.encodeMargins r c) t)= |
| Algorithms.haltMass program.machine (Algorithms.encodeMargins r c) t |
| ring |
| simpa only [he,sub_zero] using h |
|
|
| /-- Every finite halted public execution is feasible, including events of |
| arbitrarily small positive probability. -/ |
| theorem halted_feasible (t : ℕ) (bits : Bits t) |
| (hh : (MatchingFPRAS.run machine (Algorithms.encodeMargins r c) bits).state=none) : |
| ∃ X : Table r c,Algorithms.OutputsTable machine (Algorithms.encodeMargins r c) bits X.val := by |
| let bad : Cfg Symbol program.State → Prop := fun cfg => cfg.state=none ∧ |
| ¬∃ X : Table r c,cfg.tape.right₀=ListBlank.mk (Algorithms.encodeMatrix X.val) |
| have hb (N : ℕ) : |
| ((experiment program.table t (program.initial (Tape.mk₁ (Algorithms.encodeMargins r c)))).mean |
| (event bad):ℝ)≤prefixError r c N := by |
| obtain ⟨p,hp,hm⟩ := prefix_correct r c htotal N |
| have h := absent_event_bound program.table (output r c) _ p hp (output_halted r c) bad |
| (fun cfg hd => hd.1) (by intro X hX; exact hX.2 ⟨X,output_tape r c X⟩) t |
| rw [hm] at h |
| exact (show ((experiment program.table t (program.initial |
| (Tape.mk₁ (Algorithms.encodeMargins r c)))).mean (event bad):ℝ)≤ |
| ((ExactTablePrefix.experiment r c N).mean (fun o => if o=none then 1 else 0):ℝ) by |
| exact_mod_cast h).trans (prefix_error r c hPL hCheeger htotal N) |
| have hzR := ge_of_tendsto' (error_limit r c) hb |
| have hz : (experiment program.table t (program.initial (Tape.mk₁ (Algorithms.encodeMargins r c)))).mean |
| (event bad)=0 := by |
| have hnonneg := (experiment program.table t (program.initial (Tape.mk₁ (Algorithms.encodeMargins r c)))).mean_nonneg |
| (event bad) ((Experiment.all_true _).mono (fun cfg _ => event_nonneg bad cfg)) |
| exact le_antisymm (by exact_mod_cast hzR) hnonneg |
| have hall : (experiment program.table t (program.initial |
| (Tape.mk₁ (Algorithms.encodeMargins r c)))).All (fun cfg => ¬bad cfg) := by |
| rw [Experiment.all_indicator] |
| change (experiment program.table t (program.initial |
| (Tape.mk₁ (Algorithms.encodeMargins r c)))).mean (fun cfg => if ¬bad cfg then 0 else 1)=0 |
| have he : (fun cfg : Cfg Symbol program.State => if ¬bad cfg then (0:ℚ) else 1)=event bad := by |
| funext cfg |
| by_cases hb : bad cfg <;> simp [event,hb] |
| rw [he] |
| exact hz |
| have hn := Experiment.all_run _ _ hall (extend bits) |
| rw [experiment_run] at hn |
| have hh' := (run_halted_iff program (Algorithms.encodeMargins r c) t bits).mp hh |
| have hout : ∃ X : Table r c,(execute program.table t (program.initial |
| (Tape.mk₁ (Algorithms.encodeMargins r c))) (extend bits)).tape.right₀= |
| ListBlank.mk (Algorithms.encodeMatrix X.val) := by |
| by_contra h |
| exact hn ⟨hh',h⟩ |
| obtain ⟨X,hX⟩ := hout |
| exact ⟨X,hh,(congrArg Tape.right₀ (Program.run_tape program _ t bits)).trans hX⟩ |
| |
| end Conditional |
| end |
| end ContingencyTables.ExactPublicLaw |
| |
| end OAI |
| |
