| import OAI.Computability.MeanPayoff.Traversal |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace MeanPayoff |
| namespace RandomTree |
|
|
| theorem map_bind {α β γ : Type} (t : RandomTree α) (f : α → RandomTree β) (g : β → γ) : |
| (t.bind f).map g = t.bind (fun a => (f a).map g) := by |
| induction t with |
| | leaf a => rfl |
| | coin l r il ir => simpa only [map, bind] using congrArg₂ coin il ir |
|
|
| theorem failure_and_metadata {α : Type} (t : RandomTree α) (A B : α → Prop) (h : t.All A) : |
| t.probability (fun a => ¬(A a ∧ B a)) ≤ t.probability (fun a => ¬B a) := by |
| apply probability_mono_all |
| exact all_mono t h (fun a ha hf hb => hf ⟨ha, hb⟩) |
|
|
| end RandomTree |
|
|
| def nodeError (n Bmax : ℕ) : ℚ := |
| (2 * (n : ℚ) * Bmax + globalListBound n Bmax + 3) * epsilon n Bmax |
|
|
| theorem nodeError_nonneg (n Bmax : ℕ) : 0 ≤ nodeError n Bmax := by |
| unfold nodeError |
| exact mul_nonneg (by positivity) (epsilon_nonneg _ _) |
|
|
| theorem orientStage_high (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (hl : LowerComparisons G P lower) |
| (I : SolveBox G.n Bmax) (hB : 128 * globalS Bmax < I.width) |
| (up : RandomTree (BoxVector (I.capHigh I.C I.C_positive (I.C_smaller hB).le))) |
| (lo : RandomTree (BoxVector (I.capLow I.C I.C_positive (I.C_smaller hB).le))) |
| {δ : ℚ} (hδ : 0 ≤ δ) |
| (hup : HighAccuracy G P _ up δ) (hlo : HighAccuracy G P _ lo δ) |
| (y : Vec (Fin G.n)) (hy : AdmissibleSub (operator G) I.a I.b y P) |
| (hc : (I.C : ℤ) < deviation G y I.a → (4 / 5) * P.k < mass P.alpha (highCore I y)) : |
| ((orientPlus (orient G P hR lower I) (globalJ G.n Bmax)).bind |
| (fun O => finishChoice G P hR lower I hB O up lo)).probability (fun p => ¬y ≤ p.val) ≤ |
| ((globalListBound G.n Bmax : ℚ) + 1) * epsilon G.n Bmax + δ := by |
| let t := orientPlus (orient G P hR lower I) (globalJ G.n Bmax) |
| let A := fun O : Orientation P => O.exceptions.length ≤ globalListBound G.n Bmax |
| let B := fun O : Orientation P => (I.C : ℤ) < deviation G y I.a → HighAlternative I P y O |
| have he := epsilon_nonneg G.n Bmax |
| have ht : t.probability (fun O => ¬(A O ∧ B O)) ≤ epsilon G.n Bmax := by |
| apply (RandomTree.failure_and_metadata t A B (orientPlus_length G P hR lower I)).trans |
| apply RandomTree.imp_error t _ _ he |
| intro hd |
| exact orientPlus_high G P hR lower hl I y hy (hc hd) |
| apply le_trans (RandomTree.bind_error t (fun O => finishChoice G P hR lower I hB O up lo) |
| (fun O => A O ∧ B O) (fun p : BoxVector I => ¬y ≤ p.val) |
| (ε := (globalListBound G.n Bmax : ℚ) * epsilon G.n Bmax + δ) |
| (add_nonneg (mul_nonneg (Nat.cast_nonneg _) he) hδ) ht ?_) (by ring_nf; rfl) |
| intro O hO |
| apply (finishChoice_high G P hR lower hl I hB O up lo hδ hup hlo y hy hO.2).trans |
| exact add_le_add (mul_le_mul_of_nonneg_right (Nat.cast_le.mpr hO.1) he) le_rfl |
|
|
| theorem orientStage_low (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (hl : LowerComparisons G P lower) |
| (I : SolveBox G.n Bmax) (hB : 128 * globalS Bmax < I.width) |
| (up : RandomTree (BoxVector (I.capHigh I.C I.C_positive (I.C_smaller hB).le))) |
| (lo : RandomTree (BoxVector (I.capLow I.C I.C_positive (I.C_smaller hB).le))) |
| {δ : ℚ} (hδ : 0 ≤ δ) |
| (hup : LowAccuracy G P _ up δ) (hlo : LowAccuracy G P _ lo δ) |
| (z : Vec (Fin G.n)) (hz : AdmissibleSuper (operator G) I.a I.b z P) |
| (hc : (I.C : ℤ) < deviation G I.b z → (4 / 5) * P.m < mass P.beta (lowCore I z)) : |
| ((orientPlus (orient G P hR lower I) (globalJ G.n Bmax)).bind |
| (fun O => finishChoice G P hR lower I hB O up lo)).probability (fun p => ¬p.val ≤ z) ≤ |
| ((globalListBound G.n Bmax : ℚ) + 1) * epsilon G.n Bmax + δ := by |
| let t := orientPlus (orient G P hR lower I) (globalJ G.n Bmax) |
| let A := fun O : Orientation P => O.exceptions.length ≤ globalListBound G.n Bmax |
| let B := fun O : Orientation P => (I.C : ℤ) < deviation G I.b z → LowAlternative I P z O |
| have he := epsilon_nonneg G.n Bmax |
| have ht : t.probability (fun O => ¬(A O ∧ B O)) ≤ epsilon G.n Bmax := by |
| apply (RandomTree.failure_and_metadata t A B (orientPlus_length G P hR lower I)).trans |
| apply RandomTree.imp_error t _ _ he |
| intro hd |
| exact orientPlus_low G P hR lower hl I z hz (hc hd) |
| apply le_trans (RandomTree.bind_error t (fun O => finishChoice G P hR lower I hB O up lo) |
| (fun O => A O ∧ B O) (fun p : BoxVector I => ¬p.val ≤ z) |
| (ε := (globalListBound G.n Bmax : ℚ) * epsilon G.n Bmax + δ) |
| (add_nonneg (mul_nonneg (Nat.cast_nonneg _) he) hδ) ht ?_) (by ring_nf; rfl) |
| intro O hO |
| apply (finishChoice_low G P hR lower hl I hB O up lo hδ hup hlo z hz hO.2).trans |
| exact add_le_add (mul_le_mul_of_nonneg_right (Nat.cast_le.mpr hO.1) he) le_rfl |
|
|
|
|
|
|
| theorem node_error_step {n Bmax : ℕ} (I : SolveBox n Bmax) : |
| (2 * (volume I.b I.a : ℚ) + 2) * epsilon n Bmax + |
| (((globalListBound n Bmax : ℚ) + 1) * epsilon n Bmax + |
| ((I.width - 1 : ℕ) : ℚ) * nodeError n Bmax) ≤ (I.width : ℚ) * nodeError n Bmax := by |
| have he := epsilon_nonneg n Bmax |
| have hv : (volume I.b I.a : ℚ) ≤ (n : ℚ) * Bmax := by exact_mod_cast I.volume_le |
| have hp : ((I.width - 1 : ℕ) : ℚ) + 1 = I.width := by |
| exact_mod_cast Nat.sub_add_cancel I.positive |
| calc |
| _ = (2 * (volume I.b I.a : ℚ) + globalListBound n Bmax + 3) * epsilon n Bmax + |
| ((I.width - 1 : ℕ) : ℚ) * nodeError n Bmax := by ring |
| _ ≤ nodeError n Bmax + ((I.width - 1 : ℕ) : ℚ) * nodeError n Bmax := by |
| apply add_le_add _ le_rfl |
| exact mul_le_mul_of_nonneg_right (by linarith only [hv]) he |
| _ = _ := by rw [← hp]; ring |
|
|
| theorem solveWidth_high (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (hl : LowerComparisons G P lower) |
| (I : SolveBox G.n Bmax) (y : Vec (Fin G.n)) |
| (hy : AdmissibleSub (operator G) I.a I.b y P) : |
| (solveWidth G P hR lower I).probability (fun p => ¬y ≤ p.val) ≤ |
| (I.width : ℚ) * nodeError G.n Bmax := by |
| by_cases hsmall : I.width ≤ 128 * globalS Bmax |
| · have hc : y ≤ (I.exactVector G).val := box_comparison G hy.1 (basic_spec G I.a I.b I.ordered).2.1 |
| rw [solveWidth, dite_eq_left hsmall, RandomTree.probability_leaf, ite_eq_right (not_not_intro hc)] |
| exact mul_nonneg (Nat.cast_nonneg _) (nodeError_nonneg _ _) |
| · have hB : 128 * globalS Bmax < I.width := lt_of_not_ge hsmall |
| rw [solveWidth, dite_eq_right hsmall] |
| dsimp only |
| let δ : ℚ := ((I.width - 1 : ℕ) : ℚ) * nodeError G.n Bmax |
| have hδ : 0 ≤ δ := mul_nonneg (Nat.cast_nonneg _) (nodeError_nonneg _ _) |
| have he := epsilon_nonneg G.n Bmax |
| apply le_trans (RandomTree.bind_error (tighten P hR lower I hB) _ |
| (TightHigh G P y) (fun p : BoxVector I => ¬y ≤ p.val) |
| (ε := ((globalListBound G.n Bmax : ℚ) + 1) * epsilon G.n Bmax + δ) |
| (add_nonneg (mul_nonneg (by positivity) he) hδ) |
| (tighten_high G P hR lower hl I hB y hy) ?_) (node_error_step I) |
| intro T hT |
| obtain ⟨u, hyu, hu, hcore⟩ := hT |
| let K := T.box |
| have hK : 128 * globalS Bmax < K.width := by change 128 * globalS Bmax < T.box.width; rw [T.width_eq]; exact hB |
| let up := solveWidth G P hR lower (K.capHigh K.C K.C_positive (K.C_smaller hK).le) |
| let lo := solveWidth G P hR lower (K.capLow K.C K.C_positive (K.C_smaller hK).le) |
| have hc : K.C ≤ I.width - 1 := by have hh := K.C_smaller hK; have hw := T.width_eq; dsimp [K] at hh ⊢; omega |
| have hup : HighAccuracy G P _ up δ := by |
| intro v hv |
| apply (solveWidth_high G P hR lower hl (K.capHigh K.C K.C_positive (K.C_smaller hK).le) v hv).trans |
| exact mul_le_mul_of_nonneg_right (Nat.cast_le.mpr hc) (nodeError_nonneg _ _) |
| have hlo : HighAccuracy G P _ lo δ := by |
| intro v hv |
| apply (solveWidth_high G P hR lower hl (K.capLow K.C K.C_positive (K.C_smaller hK).le) v hv).trans |
| exact mul_le_mul_of_nonneg_right (Nat.cast_le.mpr hc) (nodeError_nonneg _ _) |
| change ((orientPlus (orient G P hR lower K) (globalJ G.n Bmax)).bind |
| (fun O => (finishChoice G P hR lower K hK O up lo).map T.include)).probability |
| (fun p => ¬y ≤ p.val) ≤ _ |
| rw [← RandomTree.map_bind] |
| apply RandomTree.map_error _ T.include (fun p : BoxVector K => u ≤ p.val) _ |
| (orientStage_high G P hR lower hl K hK up lo hδ hup hlo u hu hcore) |
| intro p hp hf |
| exact hf (hyu.trans hp) |
| termination_by I.width |
| decreasing_by |
| all_goals |
| change K.C < I.width |
| rw [← T.width_eq] |
| exact K.C_smaller hK |
|
|
|
|
|
|
| theorem solveWidth_low (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (hl : LowerComparisons G P lower) |
| (I : SolveBox G.n Bmax) (z : Vec (Fin G.n)) |
| (hz : AdmissibleSuper (operator G) I.a I.b z P) : |
| (solveWidth G P hR lower I).probability (fun p => ¬p.val ≤ z) ≤ |
| (I.width : ℚ) * nodeError G.n Bmax := by |
| by_cases hsmall : I.width ≤ 128 * globalS Bmax |
| · have hc : (I.exactVector G).val ≤ z := box_comparison G (basic_spec G I.a I.b I.ordered).1 hz.1 |
| rw [solveWidth, dite_eq_left hsmall, RandomTree.probability_leaf, ite_eq_right (not_not_intro hc)] |
| exact mul_nonneg (Nat.cast_nonneg _) (nodeError_nonneg _ _) |
| · have hB : 128 * globalS Bmax < I.width := lt_of_not_ge hsmall |
| rw [solveWidth, dite_eq_right hsmall] |
| dsimp only |
| let δ : ℚ := ((I.width - 1 : ℕ) : ℚ) * nodeError G.n Bmax |
| have hδ : 0 ≤ δ := mul_nonneg (Nat.cast_nonneg _) (nodeError_nonneg _ _) |
| have he := epsilon_nonneg G.n Bmax |
| apply le_trans (RandomTree.bind_error (tighten P hR lower I hB) _ |
| (TightLow G P z) (fun p : BoxVector I => ¬p.val ≤ z) |
| (ε := ((globalListBound G.n Bmax : ℚ) + 1) * epsilon G.n Bmax + δ) |
| (add_nonneg (mul_nonneg (by positivity) he) hδ) |
| (tighten_low G P hR lower hl I hB z hz) ?_) (node_error_step I) |
| intro T hT |
| obtain ⟨u, huz, hu, hcore⟩ := hT |
| let K := T.box |
| have hK : 128 * globalS Bmax < K.width := by change 128 * globalS Bmax < T.box.width; rw [T.width_eq]; exact hB |
| let up := solveWidth G P hR lower (K.capHigh K.C K.C_positive (K.C_smaller hK).le) |
| let lo := solveWidth G P hR lower (K.capLow K.C K.C_positive (K.C_smaller hK).le) |
| have hc : K.C ≤ I.width - 1 := by have hh := K.C_smaller hK; have hw := T.width_eq; dsimp [K] at hh ⊢; omega |
| have hup : LowAccuracy G P _ up δ := by |
| intro v hv |
| apply (solveWidth_low G P hR lower hl (K.capHigh K.C K.C_positive (K.C_smaller hK).le) v hv).trans |
| exact mul_le_mul_of_nonneg_right (Nat.cast_le.mpr hc) (nodeError_nonneg _ _) |
| have hlo : LowAccuracy G P _ lo δ := by |
| intro v hv |
| apply (solveWidth_low G P hR lower hl (K.capLow K.C K.C_positive (K.C_smaller hK).le) v hv).trans |
| exact mul_le_mul_of_nonneg_right (Nat.cast_le.mpr hc) (nodeError_nonneg _ _) |
| change ((orientPlus (orient G P hR lower K) (globalJ G.n Bmax)).bind |
| (fun O => (finishChoice G P hR lower K hK O up lo).map T.include)).probability |
| (fun p => ¬p.val ≤ z) ≤ _ |
| rw [← RandomTree.map_bind] |
| apply RandomTree.map_error _ T.include (fun p : BoxVector K => p.val ≤ u) _ |
| (orientStage_low G P hR lower hl K hK up lo hδ hup hlo u hu hcore) |
| intro p hp hf |
| exact hf (hp.trans huz) |
| termination_by I.width |
| decreasing_by |
| all_goals |
| change K.C < I.width |
| rw [← T.width_eq] |
| exact K.C_smaller hK |
|
|
|
|
|
|
| theorem root_error_coefficient (n Bmax : ℕ) : |
| Bmax * (2 * n * Bmax + globalListBound n Bmax + 3) * 16 ≤ 2 ^ globalJ n Bmax := by |
| by_cases hB : Bmax = 0 |
| · simp [hB] |
| have hb : 1 ≤ Bmax := by omega |
| let s := globalS Bmax |
| let k := s * (n + 1) |
| have hs : 16 ≤ s := globalS_large Bmax |
| have hsk : s ≤ k := by dsimp [k]; nlinarith |
| have hk : 16 ≤ k := hs.trans hsk |
| have hn : n ≤ k := by dsimp [k]; nlinarith |
| have hg : globalG Bmax ≤ s := by |
| have h := globalS_lower Bmax |
| change 131072 * (globalG Bmax + 1) ≤ s at h |
| omega |
| have hclog : Nat.clog 2 (Bmax + 1) ≤ s := by unfold globalG at hg; omega |
| have hBs : Bmax ≤ 2 ^ s := |
| (Nat.le_succ Bmax).trans ((Nat.clog_le_iff_le_pow (by norm_num)).mp hclog) |
| have hk6 : k ^ 2 ≤ k ^ 6 := Nat.pow_le_pow_right (by omega) (by norm_num) |
| have hk7 : k ^ 2 ≤ k ^ 7 := Nat.pow_le_pow_right (by omega) (by norm_num) |
| have hJ : globalJ n Bmax ≤ 3 * k ^ 6 := by |
| have hpow : 1 ≤ k ^ 6 := Nat.one_le_pow _ _ (by omega) |
| change 2 * k ^ 6 + 1 ≤ 3 * k ^ 6 |
| omega |
| have hM : globalListBound n Bmax ≤ 9 * k ^ 7 := by |
| have hfac : 2 * globalG Bmax + 3 ≤ 3 * k := by omega |
| calc |
| _ ≤ (3 * k ^ 6) * (3 * k) := Nat.mul_le_mul hJ hfac |
| _ = 9 * k ^ 7 := by ring |
| have hpoly : 2 * n + globalListBound n Bmax + 3 ≤ 10 * k ^ 7 := by |
| have hx : 2 * n + 3 ≤ k ^ 7 := by nlinarith |
| omega |
| have hpowK : k ≤ 2 ^ k := Nat.le_of_lt Nat.lt_two_pow_self |
| have hten : 10 ≤ 2 ^ (3 * k) := by |
| apply le_trans (show 10 ≤ 2 ^ 4 by norm_num) |
| exact Nat.pow_le_pow_right (by norm_num) (by omega) |
| have hpolyExp : 10 * k ^ 7 ≤ 2 ^ (10 * k) := by |
| calc |
| _ ≤ 2 ^ (3 * k) * (2 ^ k) ^ 7 := Nat.mul_le_mul hten (Nat.pow_le_pow_left hpowK 7) |
| _ = 2 ^ (10 * k) := by |
| rw [← pow_mul, ← pow_add, show 3 * k + k * 7 = 10 * k by omega] |
| have hN : Bmax * (2 * n * Bmax + globalListBound n Bmax + 3) ≤ 2 ^ (12 * k) := by |
| calc |
| _ ≤ Bmax ^ 2 * (2 * n + globalListBound n Bmax + 3) := by |
| have hscale : Bmax * (globalListBound n Bmax + 3) ≤ |
| Bmax ^ 2 * (globalListBound n Bmax + 3) := |
| Nat.mul_le_mul_right _ (by nlinarith : Bmax ≤ Bmax ^ 2) |
| nlinarith only [hscale] |
| _ ≤ (2 ^ s) ^ 2 * (10 * k ^ 7) := Nat.mul_le_mul (Nat.pow_le_pow_left hBs 2) hpoly |
| _ ≤ (2 ^ s) ^ 2 * 2 ^ (10 * k) := Nat.mul_le_mul_left _ hpolyExp |
| _ = 2 ^ (s * 2 + 10 * k) := by rw [← pow_mul, ← pow_add] |
| _ ≤ 2 ^ (12 * k) := Nat.pow_le_pow_right (by norm_num) (by omega) |
| have hAbsorb : 12 * k + 4 ≤ globalJ n Bmax := by |
| change 12 * k + 4 ≤ 2 * k ^ 6 + 1 |
| nlinarith |
| calc |
| _ ≤ 2 ^ (12 * k) * 16 := Nat.mul_le_mul_right 16 hN |
| _ = 2 ^ (12 * k + 4) := by rw [pow_add]; rfl |
| _ ≤ 2 ^ globalJ n Bmax := Nat.pow_le_pow_right (by norm_num) hAbsorb |
|
|
| theorem root_error_small (n Bmax : ℕ) : (Bmax : ℚ) * nodeError n Bmax ≤ 1 / 16 := by |
| have h := root_error_coefficient n Bmax |
| have hq : ((Bmax : ℚ) * (2 * n * Bmax + globalListBound n Bmax + 3)) * 16 ≤ |
| (2 : ℚ) ^ globalJ n Bmax := by exact_mod_cast h |
| have hp : 0 < (2 : ℚ) ^ globalJ n Bmax := pow_pos (by norm_num) _ |
| dsimp [nodeError, epsilon] |
| rw [div_pow, one_pow, ← mul_assoc, mul_one_div, div_le_iff₀ hp] |
| linarith only [hq] |
|
|
| theorem width_error_small {n Bmax : ℕ} (I : SolveBox n Bmax) : |
| (I.width : ℚ) * nodeError n Bmax ≤ 1 / 16 := by |
| exact (mul_le_mul_of_nonneg_right (Nat.cast_le.mpr I.bounded) |
| (nodeError_nonneg _ _)).trans (root_error_small n Bmax) |
|
|
| end MeanPayoff |
| end |
|
|
| end OAI |
|
|
