| import OAI.Computability.MeanPayoff.Recursion |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace MeanPayoff |
|
|
| def deviation (G : Game) (y q : Vec (Fin G.n)) : ℤ := |
| Finset.univ.sup' ⟨⟨0, G.positive⟩, Finset.mem_univ _⟩ (fun i => y i - q i) |
|
|
| theorem le_deviation (G : Game) (y q : Vec (Fin G.n)) (i : Fin G.n) : |
| y i - q i ≤ deviation G y q := |
| Finset.le_sup' (fun j => y j - q j) (Finset.mem_univ i) |
|
|
| theorem deviation_le (G : Game) {y q : Vec (Fin G.n)} {d : ℤ} |
| (h : ∀ i, y i - q i ≤ d) : deviation G y q ≤ d := |
| Finset.sup'_le _ _ (fun i _ => h i) |
|
|
| theorem deviation_attained (G : Game) (y q : Vec (Fin G.n)) : |
| ∃ i, deviation G y q = y i - q i := by |
| obtain ⟨i, _, hi⟩ := Finset.exists_mem_eq_sup' |
| (show (Finset.univ : Finset (Fin G.n)).Nonempty from ⟨⟨0, G.positive⟩, Finset.mem_univ _⟩) |
| (fun i => y i - q i) |
| exact ⟨i, hi⟩ |
|
|
| def highCore {n Bmax : ℕ} (I : SolveBox n Bmax) (y : Vec (Fin n)) : Finset (Fin n) := |
| Finset.univ.filter (fun i => (globalS Bmax : ℤ) * I.width - I.width ≤ |
| (globalS Bmax : ℤ) * (y i - I.a i)) |
| def lowCore {n Bmax : ℕ} (I : SolveBox n Bmax) (z : Vec (Fin n)) : Finset (Fin n) := |
| Finset.univ.filter (fun i => (globalS Bmax : ℤ) * I.width - I.width ≤ |
| (globalS Bmax : ℤ) * (I.b i - z i)) |
|
|
| def nearHigh (G : Game) (y q : Vec (Fin G.n)) (A : ℕ) : Finset (Fin G.n) := |
| Finset.univ.filter (fun i => deviation G y q - 2 * A < y i - q i) |
| def nearLow (G : Game) (z q : Vec (Fin G.n)) (A : ℕ) : Finset (Fin G.n) := |
| Finset.univ.filter (fun i => deviation G q z - 2 * A < q i - z i) |
|
|
| namespace SolveBox |
|
|
| theorem radius_bounds {n Bmax : ℕ} (I : SolveBox n Bmax) |
| (hB : 128 * globalS Bmax < I.width) : |
| I.width ≤ 64 * globalS Bmax * I.D ∧ globalS Bmax * I.D ≤ I.E ∧ |
| 32 * globalS Bmax * I.D ≤ I.width ∧ 8 * I.E ≤ I.width := by |
| have hs := globalS_large Bmax |
| have hd := Nat.div_mul_le_self I.width (32 * globalS Bmax) |
| have hdm := Nat.div_add_mod I.width (32 * globalS Bmax) |
| have hdr := Nat.mod_lt I.width (show 0 < 32 * globalS Bmax by omega) |
| have he := Nat.div_mul_le_self I.width 8 |
| have hem := Nat.div_add_mod I.width 8 |
| have her := Nat.mod_lt I.width (show 0 < 8 by omega) |
| change I.width ≤ 64 * globalS Bmax * (I.width / (32 * globalS Bmax)) ∧ |
| globalS Bmax * (I.width / (32 * globalS Bmax)) ≤ I.width / 8 ∧ |
| 32 * globalS Bmax * (I.width / (32 * globalS Bmax)) ≤ I.width ∧ |
| 8 * (I.width / 8) ≤ I.width |
| constructor |
| · nlinarith |
| constructor |
| · nlinarith |
| constructor <;> nlinarith |
| |
| theorem midpoint_twice {n Bmax : ℕ} (I : SolveBox n Bmax) (i : Fin n) : |
| I.b i - I.a i - 1 ≤ 2 * (I.midpoint.val i - I.a i) ∧ |
| 2 * (I.midpoint.val i - I.a i) ≤ I.b i - I.a i := by |
| change I.b i - I.a i - 1 ≤ 2 * ((I.a i + I.b i) / 2 - I.a i) ∧ |
| 2 * ((I.a i + I.b i) / 2 - I.a i) ≤ I.b i - I.a i |
| omega |
|
|
| theorem average_movement {n Bmax : ℕ} (I : SolveBox n Bmax) (q : BoxVector I) |
| {A : ℤ} (_hA : 0 ≤ A) {r₁ r₂ : Vec (Fin n)} |
| (h₁ : InBox (fun i => q.val i - A) (fun i => q.val i + A) r₁) |
| (h₂ : InBox (fun i => q.val i - A) (fun i => q.val i + A) r₂) (i : Fin n) : |
| |(I.averageClipped r₁ r₂).val i - q.val i| ≤ A := by |
| have h1a : q.val i - A ≤ r₁ i := h₁.1 i |
| have h1b : r₁ i ≤ q.val i + A := h₁.2 i |
| have h2a : q.val i - A ≤ r₂ i := h₂.1 i |
| have h2b : r₂ i ≤ q.val i + A := h₂.2 i |
| have ha : I.a i ≤ q.val i := q.property.1 i |
| have hb : q.val i ≤ I.b i := q.property.2 i |
| rw [abs_le] |
| change -A ≤ min (I.b i) (max (I.a i) ((r₁ i + r₂ i) / 2)) - q.val i ∧ |
| min (I.b i) (max (I.a i) ((r₁ i + r₂ i) / 2)) - q.val i ≤ A |
| omega |
|
|
| end SolveBox |
|
|
| theorem highCore_support {n Bmax : ℕ} (I : SolveBox n Bmax) (y : Vec (Fin n)) : |
| highCore I y ⊆ lowerActive I.a y := by |
| intro i hi |
| have hi' := (Finset.mem_filter.mp hi).2 |
| have hs : (16 : ℤ) ≤ globalS Bmax := by exact_mod_cast globalS_large Bmax |
| have hb : (0 : ℤ) < I.width := by exact_mod_cast I.positive |
| simp only [lowerActive, Finset.mem_filter, Finset.mem_univ, true_and] |
| nlinarith |
|
|
| theorem lowCore_support {n Bmax : ℕ} (I : SolveBox n Bmax) (z : Vec (Fin n)) : |
| lowCore I z ⊆ upperActive I.b z := by |
| intro i hi |
| have hi' := (Finset.mem_filter.mp hi).2 |
| have hs : (16 : ℤ) ≤ globalS Bmax := by exact_mod_cast globalS_large Bmax |
| have hb : (0 : ℤ) < I.width := by exact_mod_cast I.positive |
| simp only [upperActive, Finset.mem_filter, Finset.mem_univ, true_and] |
| nlinarith |
|
|
| theorem high_initial_deficit (G : Game) {Bmax : ℕ} (I : SolveBox G.n Bmax) |
| {y : Vec (Fin G.n)} (hy : y ≤ I.b) {i : Fin G.n} (hi : i ∈ highCore I y) : |
| (globalS Bmax : ℤ) * (deviation G y I.midpoint.val - (y i - I.midpoint.val i)) ≤ |
| I.width + globalS Bmax := by |
| obtain ⟨j, hj⟩ := deviation_attained G y I.midpoint.val |
| have hmt := I.midpoint_twice j |
| have hmi := I.midpoint_twice i |
| have hwj := I.width_bound j |
| have hwi := I.width_bound i |
| have hyj : y j ≤ I.b j := hy j |
| have hcore := (Finset.mem_filter.mp hi).2 |
| have hs : (0 : ℤ) ≤ globalS Bmax := Int.natCast_nonneg _ |
| have hmul₁ := mul_le_mul_of_nonneg_left hmt.1 hs |
| have hmul₂ := mul_le_mul_of_nonneg_left hmi.2 hs |
| have hmul₃ := mul_le_mul_of_nonneg_left hwj hs |
| have hmul₄ := mul_le_mul_of_nonneg_left hwi hs |
| have hmul₅ := mul_le_mul_of_nonneg_left hyj hs |
| rw [hj] |
| nlinarith only [hcore, hs, hmul₁, hmul₂, hmul₃, hmul₄, hmul₅] |
|
|
| theorem low_initial_deficit (G : Game) {Bmax : ℕ} (I : SolveBox G.n Bmax) |
| {z : Vec (Fin G.n)} (hz : I.a ≤ z) {i : Fin G.n} (hi : i ∈ lowCore I z) : |
| (globalS Bmax : ℤ) * (deviation G I.midpoint.val z - (I.midpoint.val i - z i)) ≤ |
| I.width + globalS Bmax := by |
| obtain ⟨j, hj⟩ := deviation_attained G I.midpoint.val z |
| have hmt := I.midpoint_twice j |
| have hmi := I.midpoint_twice i |
| have hwj := I.width_bound j |
| have hwi := I.width_bound i |
| have hzj : I.a j ≤ z j := hz j |
| have hcore := (Finset.mem_filter.mp hi).2 |
| have hs : (0 : ℤ) ≤ globalS Bmax := Int.natCast_nonneg _ |
| have hmul₁ := mul_le_mul_of_nonneg_left hmt.2 hs |
| have hmul₂ := mul_le_mul_of_nonneg_left hmi.1 hs |
| have hmul₃ := mul_le_mul_of_nonneg_left hwj hs |
| have hmul₄ := mul_le_mul_of_nonneg_left hwi hs |
| have hmul₅ := mul_le_mul_of_nonneg_left hzj hs |
| rw [hj] |
| nlinarith only [hcore, hs, hmul₁, hmul₂, hmul₃, hmul₄, hmul₅] |
|
|
| theorem high_center_deviation (G : Game) {Bmax : ℕ} (I : SolveBox G.n Bmax) |
| (hB : 128 * globalS Bmax < I.width) {y q : Vec (Fin G.n)} |
| (hy : y ≤ I.b) (hcore : (highCore I y).Nonempty) |
| (hq : ∀ i, |q i - I.midpoint.val i| ≤ (globalS Bmax : ℤ) * I.D) : |
| 2 * (I.E : ℤ) ≤ deviation G y q := by |
| obtain ⟨i, hi⟩ := hcore |
| have hic := (Finset.mem_filter.mp hi).2 |
| have hs : (16 : ℤ) ≤ globalS Bmax := by exact_mod_cast globalS_large Bmax |
| have hm := I.midpoint_twice i |
| have hyi : y i ≤ I.b i := hy i |
| have hw := I.width_bound i |
| have hb : (0 : ℤ) < I.width := by exact_mod_cast I.positive |
| have hwgt : (y i - I.a i) ≤ I.width := by omega |
| have h15 : 15 * (I.width : ℤ) ≤ 16 * (y i - I.a i) := by |
| nlinarith only [hic, mul_nonneg (sub_nonneg.mpr hs) (sub_nonneg.mpr hwgt)] |
| have hr := I.radius_bounds hB |
| have hD : 32 * (globalS Bmax : ℤ) * I.D ≤ I.width := by exact_mod_cast hr.2.2.1 |
| have hE : 8 * (I.E : ℤ) ≤ I.width := by exact_mod_cast hr.2.2.2 |
| have hq' := (abs_le.mp (hq i)).2 |
| have hd := le_deviation G y q i |
| nlinarith only [h15, hm.2, hw, hb, hD, hE, hq', hd] |
|
|
| theorem low_center_deviation (G : Game) {Bmax : ℕ} (I : SolveBox G.n Bmax) |
| (hB : 128 * globalS Bmax < I.width) {z q : Vec (Fin G.n)} |
| (hz : I.a ≤ z) (hcore : (lowCore I z).Nonempty) |
| (hq : ∀ i, |q i - I.midpoint.val i| ≤ (globalS Bmax : ℤ) * I.D) : |
| 2 * (I.E : ℤ) ≤ deviation G q z := by |
| obtain ⟨i, hi⟩ := hcore |
| have hic := (Finset.mem_filter.mp hi).2 |
| have hs : (16 : ℤ) ≤ globalS Bmax := by exact_mod_cast globalS_large Bmax |
| have hm := I.midpoint_twice i |
| have hzi : I.a i ≤ z i := hz i |
| have hw := I.width_bound i |
| have hb : (0 : ℤ) < I.width := by exact_mod_cast I.positive |
| have hwgt : (I.b i - z i) ≤ I.width := by omega |
| have h15 : 15 * (I.width : ℤ) ≤ 16 * (I.b i - z i) := by |
| nlinarith only [hic, mul_nonneg (sub_nonneg.mpr hs) (sub_nonneg.mpr hwgt)] |
| have hr := I.radius_bounds hB |
| have hD : 32 * (globalS Bmax : ℤ) * I.D ≤ I.width := by exact_mod_cast hr.2.2.1 |
| have hE : 8 * (I.E : ℤ) ≤ I.width := by exact_mod_cast hr.2.2.2 |
| have hq' := (abs_le.mp (hq i)).1 |
| have hd := le_deviation G q z i |
| have hb' : (128 : ℤ) * globalS Bmax < I.width := by exact_mod_cast hB |
| nlinarith only [h15, hm.1, hw, hb, hD, hE, hq', hd, hb', hs] |
|
|
|
|
| namespace RandomTree |
|
|
| open Classical in |
| @[simp] theorem probability_leaf {α : Type} (a : α) (P : α → Prop) : |
| (leaf a).probability P = if P a then 1 else 0 := by |
| classical |
| rfl |
|
|
| theorem probability_zero_of_all {α : Type} (t : RandomTree α) {P : α → Prop} |
| (h : t.All (fun a => ¬P a)) : t.probability P = 0 := by |
| classical |
| apply le_antisymm _ (probability_nonneg t P) |
| have hh := expect_mono_all t (fun a => if P a then (1 : ℚ) else 0) (fun _ => 0) |
| (all_mono _ h (fun a ha => by simp [ha])) |
| simpa [probability] using hh |
|
|
| theorem bind_error {α β : Type} (t : RandomTree α) (f : α → RandomTree β) |
| (good : α → Prop) (bad : β → Prop) {ρ ε : ℚ} (hε : 0 ≤ ε) |
| (ht : t.probability (fun a => ¬good a) ≤ ρ) |
| (hf : ∀ a, good a → (f a).probability bad ≤ ε) : |
| (t.bind f).probability bad ≤ ρ + ε := by |
| classical |
| have hs : (t.bind f).probability bad ≤ t.probability (fun a => ¬good a) + ε := by |
| unfold probability |
| rw [expect_bind] |
| rw [← expect_const t ε, ← expect_add] |
| apply expect_mono |
| intro a |
| by_cases ha : good a |
| · simpa [ha, probability] using hf a ha |
| · have hh := probability_le_one (f a) bad |
| simp only [ha, not_false_eq_true, ite_true] |
| change (f a).probability bad ≤ 1 + ε |
| linarith |
| linarith |
|
|
| theorem bind_probability_le {α β : Type} (t : RandomTree α) (f : α → RandomTree β) |
| (bad : β → Prop) {ε : ℚ} (hf : ∀ a, (f a).probability bad ≤ ε) : |
| (t.bind f).probability bad ≤ ε := by |
| classical |
| unfold probability |
| rw [expect_bind, ← expect_const t ε] |
| exact expect_mono t _ _ hf |
|
|
| theorem map_error {α β : Type} (t : RandomTree α) (f : α → β) |
| (good : α → Prop) (bad : β → Prop) {ε : ℚ} |
| (ht : t.probability (fun a => ¬good a) ≤ ε) |
| (hf : ∀ a, good a → ¬bad (f a)) : (t.map f).probability bad ≤ ε := by |
| rw [probability_map] |
| apply le_trans _ ht |
| exact probability_mono t (fun a ha hg => hf a hg ha) |
|
|
| end RandomTree |
|
|
| def Comparisons (G : Game) {Bmax : ℕ} (P : Budgets G.n) |
| (solver : (I : SolveBox G.n Bmax) → RandomTree (BoxVector I)) : Prop := |
| (∀ I y, AdmissibleSub (operator G) I.a I.b y P → |
| (solver I).probability (fun p => ¬ y ≤ p.val) ≤ 1 / 16) ∧ |
| (∀ I z, AdmissibleSuper (operator G) I.a I.b z P → |
| (solver I).probability (fun p => ¬ p.val ≤ z) ≤ 1 / 16) |
|
|
| def LowerComparisons (G : Game) {Bmax : ℕ} (P : Budgets G.n) |
| (lower : LowerSolver (Bmax := Bmax) P) : Prop := |
| ∀ Q hQ, Comparisons G Q (lower Q hQ) |
|
|
| theorem centered_active_high (G : Game) (y q : Vec (Fin G.n)) (A : ℕ) : |
| lowerActive (fun i => q i - A) (centerSub y q (deviation G y q) A) = nearHigh G y q A := by |
| ext i |
| simp only [lowerActive, nearHigh, Finset.mem_filter, Finset.mem_univ, true_and, |
| centerSub, lt_max_iff, lt_self_iff_false, or_false] |
| omega |
|
|
| theorem centered_active_low (G : Game) (z q : Vec (Fin G.n)) (A : ℕ) : |
| upperActive (fun i => q i + A) (centerSuper z q (deviation G q z) A) = nearLow G z q A := by |
| ext i |
| simp only [upperActive, nearLow, Finset.mem_filter, Finset.mem_univ, true_and, |
| centerSuper, min_lt_iff, lt_self_iff_false, or_false] |
| omega |
|
|
| theorem centered_admissible_high (G : Game) {Bmax : ℕ} (I : SolveBox G.n Bmax) |
| (P : Budgets G.n) {y : Vec (Fin G.n)} (hy : AdmissibleSub (operator G) I.a I.b y P) |
| (q : BoxVector I) (A : ℕ) (hA : 0 < A) (hmax : 2 * A ≤ Bmax) |
| (hd : 2 * (A : ℤ) ≤ deviation G y q.val) : |
| AdmissibleSub (operator G) (SolveBox.centered q.val A hA hmax).a |
| (SolveBox.centered q.val A hA hmax).b (centerSub y q.val (deviation G y q.val) A) P := by |
| have hp := centered_subsolution (operator_laws G) hy.1 q.property |
| (show (0 : ℤ) < A by exact_mod_cast hA) (le_deviation G y q.val) hd |
| refine ⟨hp.1, ?_⟩ |
| apply le_trans _ hy.2 |
| apply mass_mono (fun i => (P.alpha_pos i).le) |
| intro i hi |
| have hi' : i ∈ subSupport (fun i => q.val i - A) |
| (centerSub y q.val (deviation G y q.val) A) := (Finset.mem_filter.mp hi).2 |
| have hh := hp.2 hi' |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, hh⟩ |
|
|
| theorem centered_admissible_low (G : Game) {Bmax : ℕ} (I : SolveBox G.n Bmax) |
| (P : Budgets G.n) {z : Vec (Fin G.n)} (hz : AdmissibleSuper (operator G) I.a I.b z P) |
| (q : BoxVector I) (A : ℕ) (hA : 0 < A) (hmax : 2 * A ≤ Bmax) |
| (hd : 2 * (A : ℤ) ≤ deviation G q.val z) : |
| AdmissibleSuper (operator G) (SolveBox.centered q.val A hA hmax).a |
| (SolveBox.centered q.val A hA hmax).b (centerSuper z q.val (deviation G q.val z) A) P := by |
| have hp := centered_supersolution (operator_laws G) hz.1 q.property |
| (show (0 : ℤ) < A by exact_mod_cast hA) (le_deviation G q.val z) hd |
| refine ⟨hp.1, ?_⟩ |
| apply le_trans _ hz.2 |
| apply mass_mono (fun i => (P.beta_pos i).le) |
| intro i hi |
| have hi' : i ∈ superSupport (fun i => q.val i + A) |
| (centerSuper z q.val (deviation G q.val z) A) := (Finset.mem_filter.mp hi).2 |
| have hh := hp.2 hi' |
| exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, hh⟩ |
|
|
| end MeanPayoff |
| end |
|
|
| end OAI |
|
|
