| import OAI.Computability.MeanPayoff.CountedRecursion |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace MeanPayoff |
|
|
| theorem volume_add {n : ℕ} {a r b : Vec (Fin n)} (har : a ≤ r) (hrb : r ≤ b) : |
| volume b a = volume b r + volume r a := by |
| unfold volume |
| rw [← Finset.sum_add_distrib] |
| apply Finset.sum_congr rfl |
| intro i hi |
| have ha : a i ≤ r i := har i |
| have hb : r i ≤ b i := hrb i |
| change (b i - a i).toNat = (b i - r i).toNat + (r i - a i).toNat |
| omega |
|
|
| theorem volume_floor_drop {n Bmax : ℕ} (I : SolveBox n Bmax) (r : BoxVector I) |
| (h : ∃ i, (I.delta : ℤ) ≤ r.val i - I.a i) : |
| volume (I.withFloor r).b (I.withFloor r).a + I.delta ≤ volume I.b I.a := by |
| obtain ⟨i, hi⟩ := h |
| have hcoord : I.delta ≤ (r.val i - I.a i).toNat := by omega |
| have hv : I.delta ≤ volume r.val I.a := hcoord.trans |
| (Finset.single_le_sum (fun j _ => Nat.zero_le ((r.val j - I.a j).toNat)) (Finset.mem_univ i)) |
| have heq := volume_add r.property.1 r.property.2 |
| change volume I.b r.val + I.delta ≤ volume I.b I.a |
| omega |
|
|
| theorem volume_ceiling_drop {n Bmax : ℕ} (I : SolveBox n Bmax) (r : BoxVector I) |
| (h : ∃ i, (I.delta : ℤ) ≤ I.b i - r.val i) : |
| volume (I.withCeiling r).b (I.withCeiling r).a + I.delta ≤ volume I.b I.a := by |
| obtain ⟨i, hi⟩ := h |
| have hcoord : I.delta ≤ (I.b i - r.val i).toNat := by omega |
| have hv : I.delta ≤ volume I.b r.val := hcoord.trans |
| (Finset.single_le_sum (fun j _ => Nat.zero_le ((I.b j - r.val j).toNat)) (Finset.mem_univ i)) |
| have heq := volume_add r.property.1 r.property.2 |
| change volume r.val I.a + I.delta ≤ volume I.b I.a |
| omega |
|
|
| theorem quotient_drop {v w d : ℕ} (hd : 0 < d) (h : w + d ≤ v) : w / d + 1 ≤ v / d := by |
| have hh := Nat.div_le_div_right (c := d) h |
| rwa [Nat.add_div_right _ hd] at hh |
|
|
| namespace CountedAlgorithm |
|
|
| theorem bounded_centerUpdate {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) {N : ℕ} (hN : LowerBound lower N) |
| (I : SolveBox n Bmax) (hB : 128 * globalS Bmax < I.width) (q : BoxVector I) : |
| (centerUpdate P hR lower I hB q).Bounded (2 * globalJ n Bmax * N) := by |
| unfold centerUpdate |
| apply Counted.bounded_mono (Counted.bounded_bind _ (SolveBox.bounded_repeated _ (hN _ _ _) _) |
| (fun _ => Counted.bounded_map _ (SolveBox.bounded_repeated _ (hN _ _ _) _))) |
| nlinarith |
|
|
| theorem bounded_centerSteps {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) {N : ℕ} (hN : LowerBound lower N) |
| (I : SolveBox n Bmax) (hB : 128 * globalS Bmax < I.width) (t : ℕ) (q : BoxVector I) : |
| (centerSteps P hR lower I hB t q).Bounded (t * (2 * globalJ n Bmax * N)) := by |
| induction t generalizing q with |
| | zero => exact Counted.bounded_pure _ |
| | succ t ih => |
| unfold centerSteps |
| apply Counted.bounded_mono (Counted.bounded_bind _ |
| (bounded_centerUpdate P hR lower hN I hB q) (fun q' => Counted.bounded_map _ (ih q'))) |
| simp only [Nat.add_mul, one_mul] |
| omega |
|
|
| theorem bounded_orientationTail (G : Game) {Bmax : ℕ} (P : Budgets G.n) |
| (I : SolveBox G.n Bmax) (qs : List (BoxVector I)) |
| (child : BoxVector I → Counted (Orientation P)) {N : ℕ} (hN : ∀ q, (child q).Bounded N) : |
| (orientationTail G P I qs child).Bounded N := by |
| unfold orientationTail |
| dsimp only |
| split_ifs |
| · exact Counted.bounded_pure _ |
| · exact Counted.bounded_pure _ |
| · simpa only [zero_add] using Counted.bounded_bind _ (Counted.bounded_lift _) |
| (fun j => Counted.bounded_map _ (hN _)) |
|
|
| theorem bounded_orient (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) {N : ℕ} (hN : LowerBound lower N) |
| (I : SolveBox G.n Bmax) : |
| (orient G P hR lower I).Bounded |
| ((Nat.clog 2 I.width + 1) * (globalS Bmax * (2 * globalJ G.n Bmax * N))) := by |
| induction I using (measure (fun I : SolveBox G.n Bmax => I.width)).wf.induction with |
| | h I ih => |
| rw [orient] |
| split_ifs with hB |
| · exact Counted.bounded_pure _ |
| · have hb : 128 * globalS Bmax < I.width := lt_of_not_ge hB |
| have hs := globalS_large Bmax |
| have hr := (I.radius_bounds hb).2.2.2 |
| have hc := clog_double_decrease (by omega : 1 < I.width) (by omega : 2 * (2 * I.E) ≤ I.width) |
| have hchild : ∀ q : BoxVector I, |
| (orient G P hR lower (I.wideCentered hb q.val)).Bounded |
| ((Nat.clog 2 (2 * I.E) + 1) * (globalS Bmax * (2 * globalJ G.n Bmax * N))) := by |
| intro q |
| exact ih (I.wideCentered hb q.val) (by exact I.E_smaller) |
| have htail := fun qs => bounded_orientationTail G P I qs _ hchild |
| have hineq : globalS Bmax * (2 * globalJ G.n Bmax * N) + |
| (Nat.clog 2 (2 * I.E) + 1) * (globalS Bmax * (2 * globalJ G.n Bmax * N)) ≤ |
| (Nat.clog 2 I.width + 1) * (globalS Bmax * (2 * globalJ G.n Bmax * N)) := by |
| calc |
| _ = (Nat.clog 2 (2 * I.E) + 1 + 1) * (globalS Bmax * (2 * globalJ G.n Bmax * N)) := by ring |
| _ ≤ _ := Nat.mul_le_mul_right _ (Nat.add_le_add_right hc 1) |
| dsimp only |
| with_reducible |
| exact Counted.bounded_mono |
| (Counted.bounded_bind |
| (t := centerSteps P hR lower I hb (globalS Bmax) I.midpoint) |
| (fun qs => orientationTail G P I qs (fun q => orient G P hR lower (I.wideCentered hb q.val))) |
| (bounded_centerSteps P hR lower hN I hb (globalS Bmax) I.midpoint) htail) hineq |
|
|
| theorem bounded_orient_global (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) {N : ℕ} (hN : LowerBound lower N) |
| (I : SolveBox G.n Bmax) : |
| (orient G P hR lower I).Bounded |
| ((globalG Bmax + 1) * (globalS Bmax * (2 * globalJ G.n Bmax * N))) := by |
| apply Counted.bounded_mono (bounded_orient G P hR lower hN I) |
| apply Nat.mul_le_mul_right |
| have hh := Nat.clog_mono_right 2 (show I.width ≤ Bmax + 1 from I.bounded.trans (Nat.le_succ Bmax)) |
| unfold globalG |
| omega |
|
|
| theorem bounded_orientPlus {n : ℕ} {P : Budgets n} {t : Counted (Orientation P)} |
| {N : ℕ} (hN : t.Bounded N) (J : ℕ) : (orientPlus t J).Bounded (J * N) := |
| Counted.bounded_map _ (Counted.bounded_trials hN J) |
|
|
| theorem bounded_tighten {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) {N : ℕ} (hN : LowerBound lower N) |
| (I : SolveBox n Bmax) (hB : 128 * globalS Bmax < I.width) : |
| (tighten P hR lower I hB).Bounded |
| ((volume I.b I.a / I.delta + 1) * (2 * globalJ n Bmax * N)) := by |
| rw [tighten] |
| refine Counted.bounded_mono (Counted.bounded_bind (M := globalJ n Bmax * N + |
| (volume I.b I.a / I.delta) * (2 * globalJ n Bmax * N)) _ |
| (SolveBox.bounded_repeated _ (hN _ _ _) _) ?_) ?_ |
| · intro r₁ |
| split_ifs with h₁ |
| · have hv := quotient_drop (I.delta_positive hB) (volume_floor_drop I r₁ h₁) |
| apply Counted.bounded_mono (Counted.bounded_map _ |
| (bounded_tighten P hR lower hN (I.withFloor r₁) hB)) |
| change (volume (I.withFloor r₁).b (I.withFloor r₁).a / I.delta + 1) * _ ≤ _ |
| exact (Nat.mul_le_mul_right _ hv).trans (Nat.le_add_left _ _) |
| · refine Counted.bounded_mono (Counted.bounded_bind (M := |
| (volume I.b I.a / I.delta) * (2 * globalJ n Bmax * N)) _ |
| (SolveBox.bounded_repeated _ (hN _ _ _) _) ?_) ?_ |
| · intro r₂ |
| split_ifs with h₂ |
| · have hv := quotient_drop (I.delta_positive hB) (volume_ceiling_drop I r₂ h₂) |
| apply Counted.bounded_mono (Counted.bounded_map _ |
| (bounded_tighten P hR lower hN (I.withCeiling r₂) hB)) |
| change (volume (I.withCeiling r₂).b (I.withCeiling r₂).a / I.delta + 1) * _ ≤ _ |
| exact Nat.mul_le_mul_right _ hv |
| · exact Counted.bounded_pure _ |
| · exact le_rfl |
| · nlinarith |
| termination_by volume I.b I.a |
| decreasing_by |
| · have hv := volume_floor_drop I r₁ h₁ |
| have hd := I.delta_positive hB |
| omega |
| · have hv := volume_ceiling_drop I r₂ h₂ |
| have hd := I.delta_positive hB |
| omega |
|
|
| end CountedAlgorithm |
|
|
|
|
| def widthPotential (s B : ℕ) : ℕ := |
| 8 * s * Nat.log 2 B + (8 * s * B) / (2 ^ Nat.log 2 B) |
|
|
| theorem widthPotential_bound (s B : ℕ) (hs : 0 < s) : |
| widthPotential s B < 8 * s * (Nat.log 2 B + 2) := by |
| have hp : 0 < 2 ^ Nat.log 2 B := pow_pos (by norm_num) _ |
| have hb := Nat.lt_pow_succ_log_self (by norm_num : 1 < 2) B |
| rw [pow_succ] at hb |
| have hd : 8 * s * B / 2 ^ Nat.log 2 B < 16 * s := by |
| apply (Nat.div_lt_iff_lt_mul hp).mpr |
| nlinarith |
| unfold widthPotential |
| nlinarith |
|
|
| theorem widthPotential_decreases {s B C : ℕ} (hs : 0 < s) (hC : 0 < C) |
| (hCB : C < B) (hdrop : B ≤ 8 * s * (B - C)) : |
| widthPotential s C < widthPotential s B := by |
| have hB : 0 < B := hC.trans hCB |
| have hp : 0 < 2 ^ Nat.log 2 B := pow_pos (by norm_num) _ |
| have hpb : 2 ^ Nat.log 2 B ≤ B := Nat.pow_log_le_self 2 (by omega) |
| have hlog : Nat.log 2 C ≤ Nat.log 2 B := Nat.log_mono_right hCB.le |
| have hlower : 8 * s ≤ (8 * s * B) / 2 ^ Nat.log 2 B := by |
| apply (Nat.le_div_iff_mul_le hp).mpr |
| exact Nat.mul_le_mul_left _ hpb |
| rcases eq_or_lt_of_le hlog with heq | hlt |
| · have hsub : 8 * s * C + 2 ^ Nat.log 2 B ≤ 8 * s * B := by |
| have ht : C + (B - C) = B := Nat.add_sub_of_le hCB.le |
| nlinarith |
| have hdiv := Nat.div_le_div_right (c := 2 ^ Nat.log 2 B) hsub |
| rw [Nat.add_div_right _ hp] at hdiv |
| unfold widthPotential |
| rw [heq] |
| omega |
| · have hc := widthPotential_bound s C hs |
| have hm : 8 * s * (Nat.log 2 C + 2) ≤ 8 * s * (Nat.log 2 B + 1) := by |
| apply Nat.mul_le_mul_left |
| omega |
| unfold widthPotential at hc ⊢ |
| nlinarith |
|
|
|
|
|
|
| theorem SolveBox.delta_lower {n Bmax : ℕ} (I : SolveBox n Bmax) |
| (hB : 128 * globalS Bmax < I.width) : I.width ≤ 8 * globalS Bmax * I.delta := by |
| have hs := globalS_large Bmax |
| have hp := I.delta_positive hB |
| have hd := Nat.lt_mul_div_succ I.width (by omega : 0 < 4 * globalS Bmax) |
| change I.width < 4 * globalS Bmax * (I.delta + 1) at hd |
| nlinarith |
|
|
| theorem SolveBox.volume_width {n Bmax : ℕ} (I : SolveBox n Bmax) : |
| volume I.b I.a ≤ n * I.width := by |
| calc |
| _ ≤ ∑ _i : Fin n, I.width := Finset.sum_le_sum (fun i _ => (Int.toNat_le).mpr (I.width_bound i)) |
| _ = _ := by simp |
|
|
| theorem SolveBox.tightening_passes {n Bmax : ℕ} (I : SolveBox n Bmax) |
| (hB : 128 * globalS Bmax < I.width) : volume I.b I.a / I.delta ≤ 8 * n * globalS Bmax := by |
| apply Nat.le_of_lt_succ |
| apply (Nat.div_lt_iff_lt_mul (I.delta_positive hB)).mpr |
| have hm := Nat.mul_le_mul_left n (I.delta_lower hB) |
| have hv := I.volume_width |
| have hd := I.delta_positive hB |
| nlinarith |
|
|
| theorem SolveBox.C_potential {n Bmax : ℕ} (I : SolveBox n Bmax) |
| (hB : 128 * globalS Bmax < I.width) : |
| widthPotential (globalS Bmax) I.C < widthPotential (globalS Bmax) I.width := by |
| apply widthPotential_decreases (by have hh := globalS_large Bmax; omega) |
| I.C_positive (I.C_smaller hB) |
| have h := I.delta_lower hB |
| have hd := I.delta_smaller |
| have he : I.width - I.C = I.delta := by unfold SolveBox.C; omega |
| simpa only [he, Nat.mul_assoc] using h |
| |
| namespace CountedAlgorithm |
| |
| theorem bounded_tighten_global {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) {N : ℕ} (hN : LowerBound lower N) |
| (I : SolveBox n Bmax) (hB : 128 * globalS Bmax < I.width) : |
| (tighten P hR lower I hB).Bounded ((16 * n * globalS Bmax + 2) * globalJ n Bmax * N) := by |
| apply Counted.bounded_mono (bounded_tighten P hR lower hN I hB) |
| calc |
| _ ≤ (8 * n * globalS Bmax + 1) * (2 * globalJ n Bmax * N) := |
| Nat.mul_le_mul_right _ (Nat.add_le_add_right (I.tightening_passes hB) 1) |
| _ = _ := by ring |
|
|
| theorem bounded_finishChoice (G : Game) {Bmax : ℕ} (P : Budgets G.n) |
| (hR : 1 ≤ P.parameter) (lower : LowerSolver (Bmax := Bmax) P) {N : ℕ} (hN : LowerBound lower N) |
| (I : SolveBox G.n Bmax) (hB : 128 * globalS Bmax < I.width) (O : Orientation P) |
| (up : Counted (BoxVector (I.capHigh I.C I.C_positive (I.C_smaller hB).le))) |
| (lo : Counted (BoxVector (I.capLow I.C I.C_positive (I.C_smaller hB).le))) |
| {M : ℕ} (hu : up.Bounded M) (hl : lo.Bounded M) : |
| (finishChoice G P hR lower I hB O up lo).Bounded |
| (O.exceptions.length * (globalJ G.n Bmax * N) + M) := by |
| unfold finishChoice |
| split_ifs |
| · exact Counted.bounded_bind _ |
| (Counted.bounded_traverse _ (fun H => I.bounded_repeated (hN _ _ _) _) _) |
| (fun _ => Counted.bounded_map _ hu) |
| · exact Counted.bounded_bind _ |
| (Counted.bounded_traverse _ (fun H => I.bounded_repeated (hN _ _ _) _) _) |
| (fun _ => Counted.bounded_map _ hl) |
|
|
| end CountedAlgorithm |
| end MeanPayoff |
| end |
|
|
| end OAI |
|
|
