| import OAI.Combinatorics.ContingencyTables.Sampling.ExactGatePublic |
| import OAI.Combinatorics.ContingencyTables.Sampling.ExactPublicLaw |
| import OAI.Combinatorics.ContingencyTables.Machines.QuadraticPrefixRuntime |
|
|
| namespace OAI |
|
|
| /-! |
|
|
| namespace ContingencyTables.ExactExpectedTime |
| open MatchingFPRAS MatchingFPRAS.PhysicalStream MatchingFPRAS.PhysicalPost Turing |
| open DensePrograms SmallGraphProfiles PhysicalRetryTail |
| open scoped BigOperators Classical |
| noncomputable section |
|
|
| variable {m n : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ) |
| local notation "dim" => CompletionCounts.dimensionAllowance (I := Fin m) (J := Fin n) |
|
|
| attribute [local irreducible] ExactPublicPrefix.program ExactTablePrefix.experiment |
| PublishedInputs.FiniteBoxPrekopaLeindler PublishedInputs.FiniteCheeger |
|
|
| /-- Expected runtime is bounded by the explicit costs of the ordinary |
| prefix and the probability-weighted correction branch. -/ |
| theorem bound |
| (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) (B L : ℕ) |
| (hB : ∀ X : Table r c,GreedyFeasibleTable.printMatrixRealizer.cost (matrixCode X.val)≤B) |
| (hL : ∀ X : Table r c,(ExactPublicPrefix.word r c X).length≤L) : |
| let S := ExactGatePublic.budget r c B L |
| let T := ExactPublicCost.budget r c 1 B L+1 |
| let tail := PhysicalRetryTail.tail ExactPublicPrefix.program.table |
| (ExactPublicPrefix.program.initial (Tape.mk₁ (Algorithms.encodeMargins r c))) |
| Summable tail ∧ (∑' t,tail t)≤(S:ℝ)+11*(1/(2:ℝ)^correctionPrecision r c)*T := by |
| dsimp only |
| let S := ExactGatePublic.budget r c B L |
| let T := ExactPublicCost.budget r c 1 B L+1 |
| let M := ExactPublicPrefix.program.table |
| let init := ExactPublicPrefix.program.initial (Tape.mk₁ (Algorithms.encodeMargins r c)) |
| refine QuadraticPrefixRuntime.expected_time (PhysicalRetryTail.tail M init) S T |
| (Nat.zero_lt_succ _) (1/(2:ℝ)^correctionPrecision r c) (by positivity) |
| (tail_nonnegative M init) ?_ (tail_antitone M init) ?_ ?_ |
| · intro t |
| have h := PhysicalEventBounds.mean_mono (experiment M t init) live (fun _ => 1) live_le_one |
| rw [PhysicalPartialSequence.mean_const] at h |
| unfold PhysicalRetryTail.tail |
| exact_mod_cast h |
| · obtain ⟨p,hp,hm,hc⟩ := ExactGatePublic.prefix_correct_cost r c htotal B L hB hL |
| have h := tail_le_failure M (ExactGatePublic.publicOutput r c) init p hp |
| (ExactGatePublic.publicOutput_halted r c) S hc |
| rw [hm,ExactGatePublic.failure r c htotal] at h |
| simpa only [Rat.cast_div,Rat.cast_one,Rat.cast_pow,Rat.cast_ofNat] using h |
| · intro N |
| obtain ⟨p,hp,hm,hc⟩ := ExactPublicCost.prefix_correct_cost r c htotal N B L hB hL |
| have hcost : p.cost≤S+T*(N+1)^2 := by |
| have hq := ExactPublicCost.quadratic_budget r c N B L |
| have ht := Nat.mul_le_mul_right ((N+1)^2) |
| (Nat.le_succ (ExactPublicCost.budget r c 1 B L)) |
| exact (hc.trans (hq.trans ht)).trans (Nat.le_add_left _ _) |
| have h := tail_le_failure M (ExactPublicPrefix.output r c) init p hp |
| (ExactPublicPrefix.output_halted r c) _ hcost |
| rw [hm] at h |
| have hf := ExactTablePrefix.failure_bound r c (hPL _) (hCheeger _ dim) htotal N |
| have hfr := (Rat.cast_le (K := ℝ)).mpr hf |
| exact h.trans (by |
| simpa only [Rat.cast_mul,Rat.cast_div,Rat.cast_one,Rat.cast_pow,Rat.cast_ofNat] using hfr) |
|
|
| /-- The physical tail is summable for every equal-total margin pair. -/ |
| theorem summable |
| (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) : |
| Summable (fun t => 1-Algorithms.haltMass ExactPublicPrefix.machine (Algorithms.encodeMargins r c) t) := by |
| obtain ⟨p,hp⟩ := ExactPrintCost.polynomial_print_bound |
| let B := p.eval (ExactPrintCost.matrixSize (n := n) r) |
| have hB (X : Table r c) : GreedyFeasibleTable.printMatrixRealizer.cost (matrixCode X.val)≤B := |
| (Nat.le_add_right _ _).trans (hp m n r c X) |
| have hL (X : Table r c) : (ExactPublicPrefix.word r c X).length≤B := |
| (MatchingFPRAS.TreeTyped.list_length_le_weight _).trans |
| ((Nat.le_add_left _ _).trans (hp m n r c X)) |
| have hs := (bound r c hPL hCheeger htotal B B hB hL).1 |
| have he : (fun t => 1-Algorithms.haltMass ExactPublicPrefix.machine (Algorithms.encodeMargins r c) t)= |
| PhysicalRetryTail.tail ExactPublicPrefix.program.table |
| (ExactPublicPrefix.program.initial (Tape.mk₁ (Algorithms.encodeMargins r c))) := by |
| funext t |
| exact PhysicalPublicLaw.tail_eq _ _ _ |
| rw [he] |
| exact hs |
|
|
| end |
| end ContingencyTables.ExactExpectedTime |
|
|
| end OAI |
|
|
