| import OAI.Computability.MeanPayoff.CountedTraversal |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace MeanPayoff |
|
|
| def SolveBox.repeatedCounted {n Bmax : ℕ} (I : SolveBox n Bmax) |
| (t : Counted (BoxVector I)) (J : ℕ) : Counted (BoxVector I) := |
| (Counted.trials t J).map I.medianBox |
|
|
| namespace CountedAlgorithm |
|
|
| abbrev LowerSolver {n Bmax : ℕ} (P : Budgets n) := |
| (Q : Budgets n) → parameterRank Q.parameter < parameterRank P.parameter → |
| (I : SolveBox n Bmax) → Counted (BoxVector I) |
|
|
| def centerUpdate {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox n Bmax) |
| (hB : 128 * globalS Bmax < I.width) (q : BoxVector I) : Counted (BoxVector I) := |
| let K := I.narrowCentered hB q.val |
| (K.repeatedCounted (lower P.reduceK (P.reduceK_rank hR) K) (globalJ n Bmax)).bind fun r₁ => |
| (K.repeatedCounted (lower P.reduceM (P.reduceM_rank hR) K) (globalJ n Bmax)).map fun r₂ => |
| I.averageClipped r₁.val r₂.val |
|
|
| def centerSteps {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox n Bmax) |
| (hB : 128 * globalS Bmax < I.width) : |
| ℕ → BoxVector I → Counted (List (BoxVector I)) |
| | 0, q => Counted.pure [q] |
| | t + 1, q => |
| (centerUpdate P hR lower I hB q).bind fun q' => |
| (centerSteps P hR lower I hB t q').map (q :: ·) |
|
|
| def orientationTail (G : Game) {Bmax : ℕ} (P : Budgets G.n) (I : SolveBox G.n Bmax) |
| (qs : List (BoxVector I)) (child : BoxVector I → Counted (Orientation P)) : |
| Counted (Orientation P) := |
| let H := PositiveDisplacement I (qs.getD (globalS Bmax) I.midpoint) |
| let N := NegativeDisplacement I (qs.getD (globalS Bmax) I.midpoint) |
| if hH : 1 / 2 < P.measure H then |
| Counted.pure ⟨true, [⟨Hᶜ, by rw [P.measure_compl G.positive]; linarith⟩]⟩ |
| else if hN : 1 / 2 < P.measure N then |
| Counted.pure ⟨false, [⟨Nᶜ, by rw [P.measure_compl G.positive]; linarith⟩]⟩ |
| else |
| (Counted.lift (RandomTree.uniformBelow (sampleExponent Bmax))).bind fun j => |
| (child (qs.getD j I.midpoint)).map fun O => |
| ⟨O.chooseY, O.exceptions ++ [⟨H, le_of_not_gt hH⟩, ⟨N, le_of_not_gt hN⟩]⟩ |
| |
| def orient (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox G.n Bmax) : |
| Counted (Orientation P) := |
| if hB : I.width ≤ 128 * globalS Bmax then |
| Counted.pure (orientBase G P I) |
| else |
| let hb : 128 * globalS Bmax < I.width := lt_of_not_ge hB |
| (centerSteps P hR lower I hb (globalS Bmax) I.midpoint).bind fun qs => |
| orientationTail G P I qs (fun q => orient G P hR lower (I.wideCentered hb q.val)) |
| termination_by I.width |
| decreasing_by exact I.E_smaller |
|
|
| def orientPlus {n : ℕ} {P : Budgets n} (t : Counted (Orientation P)) (J : ℕ) : |
| Counted (Orientation P) := |
| (Counted.trials t J).map combineOrientations |
|
|
| def tighten {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox n Bmax) |
| (hB : 128 * globalS Bmax < I.width) : Counted (InnerBox I) := |
| (I.repeatedCounted (lower P.reduceK (P.reduceK_rank hR) I) (globalJ n Bmax)).bind fun r₁ => |
| if _h₁ : ∃ i, (I.delta : ℤ) ≤ r₁.val i - I.a i then |
| let K := I.withFloor r₁ |
| (tighten P hR lower K hB).map fun T => |
| ⟨T.box, T.width_eq, r₁.property.1.trans T.floor_le, T.ceiling_le⟩ |
| else |
| (I.repeatedCounted (lower P.reduceM (P.reduceM_rank hR) I) (globalJ n Bmax)).bind fun r₂ => |
| if _h₂ : ∃ i, (I.delta : ℤ) ≤ I.b i - r₂.val i then |
| let K := I.withCeiling r₂ |
| (tighten P hR lower K hB).map fun T => |
| ⟨T.box, T.width_eq, T.floor_le, T.ceiling_le.trans r₂.property.2⟩ |
| else Counted.pure ⟨I, rfl, le_refl _, le_refl _⟩ |
| termination_by volume I.b I.a |
| decreasing_by |
| · apply volume_decreases r₁.property.1 r₁.property.2 |
| obtain ⟨i, hi⟩ := _h₁ |
| have hd := I.delta_positive hB |
| intro heq |
| have he := congrFun heq i |
| omega |
| · apply volume_ceiling_decreases r₂.property.1 r₂.property.2 |
| obtain ⟨i, hi⟩ := _h₂ |
| have hd := I.delta_positive hB |
| intro heq |
| have he := congrFun heq i |
| omega |
|
|
| def finishChoice (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (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))) : |
| Counted (BoxVector I) := |
| if O.chooseY then |
| (Counted.traverse (fun H : SmallSet P => |
| I.repeatedCounted (lower (P.reweightM H.val) |
| (P.reweightM_rank G.positive hR H.property) I) (globalJ G.n Bmax)) O.exceptions).bind fun rs => |
| up.map fun p => rs.foldl I.minVector (I.includeCapHigh I.C I.C_positive (I.C_smaller hB).le p) |
| else |
| (Counted.traverse (fun H : SmallSet P => |
| I.repeatedCounted (lower (P.reweightK H.val) |
| (P.reweightK_rank G.positive hR H.property) I) (globalJ G.n Bmax)) O.exceptions).bind fun rs => |
| lo.map fun p => rs.foldl I.maxVector (I.includeCapLow I.C I.C_positive (I.C_smaller hB).le p) |
|
|
| def solveWidth (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox G.n Bmax) : Counted (BoxVector I) := |
| Counted.charge 1 <| |
| if hB : I.width ≤ 128 * globalS Bmax then Counted.pure (I.exactVector G) |
| else |
| (tighten P hR lower I (lt_of_not_ge hB)).bind fun T => |
| let K := T.box |
| have hK : 128 * globalS Bmax < K.width := by rw [T.width_eq]; omega |
| let c := K.C |
| have hc : 0 < c := K.C_positive |
| have hcsmall : c < K.width := K.C_smaller hK |
| (orientPlus (orient G P hR lower K) (globalJ G.n Bmax)).bind fun O => |
| (finishChoice G P hR lower K hK O |
| (solveWidth G P hR lower (K.capHigh c hc hcsmall.le)) |
| (solveWidth G P hR lower (K.capLow c hc hcsmall.le))).map T.include |
| termination_by I.width |
| decreasing_by |
| all_goals |
| change c < I.width |
| rw [← T.width_eq] |
| exact hcsmall |
|
|
| def solve (G : Game) {Bmax : ℕ} (P : Budgets G.n) (I : SolveBox G.n Bmax) : |
| Counted (BoxVector I) := |
| if hR : P.parameter < 1 then Counted.charge 1 (Counted.pure (I.smallVector P)) |
| else solveWidth G P (le_of_not_gt hR) (fun Q _ K => solve G Q K) I |
| termination_by parameterRank P.parameter |
|
|
| end CountedAlgorithm |
|
|
|
|
| @[simp] theorem SolveBox.erase_repeated {n Bmax : ℕ} (I : SolveBox n Bmax) |
| (t : Counted (BoxVector I)) (J : ℕ) : |
| (I.repeatedCounted t J).erase = I.repeated t.erase J := by |
| simp [SolveBox.repeatedCounted, SolveBox.repeated] |
|
|
| theorem SolveBox.bounded_repeated {n Bmax : ℕ} (I : SolveBox n Bmax) |
| {t : Counted (BoxVector I)} {N : ℕ} (h : t.Bounded N) (J : ℕ) : |
| (I.repeatedCounted t J).Bounded (J * N) := |
| Counted.bounded_map _ (Counted.bounded_trials h J) |
|
|
| namespace CountedAlgorithm |
|
|
| def eraseLower {n Bmax : ℕ} {P : Budgets n} (lower : LowerSolver (Bmax := Bmax) P) : |
| MeanPayoff.LowerSolver (Bmax := Bmax) P := fun Q h I => (lower Q h I).erase |
|
|
| abbrev LowerBound {n Bmax : ℕ} {P : Budgets n} (lower : LowerSolver (Bmax := Bmax) P) |
| (N : ℕ) : Prop := ∀ Q h I, (lower Q h I).Bounded N |
|
|
| @[simp] theorem erase_centerUpdate {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox n Bmax) |
| (hB : 128 * globalS Bmax < I.width) (q : BoxVector I) : |
| (centerUpdate P hR lower I hB q).erase = |
| MeanPayoff.centerUpdate P hR (eraseLower lower) I hB q := by |
| simp [centerUpdate, MeanPayoff.centerUpdate, eraseLower] |
|
|
| @[simp] theorem erase_centerSteps {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox n Bmax) |
| (hB : 128 * globalS Bmax < I.width) (t : ℕ) (q : BoxVector I) : |
| (centerSteps P hR lower I hB t q).erase = |
| MeanPayoff.centerSteps P hR (eraseLower lower) I hB t q := by |
| induction t generalizing q with |
| | zero => rfl |
| | succ t ih => simp only [centerSteps, MeanPayoff.centerSteps, Counted.erase_bind, |
| erase_centerUpdate, Counted.erase_map, ih] |
|
|
| @[simp] theorem erase_orientationTail (G : Game) {Bmax : ℕ} (P : Budgets G.n) |
| (I : SolveBox G.n Bmax) (qs : List (BoxVector I)) |
| (child : BoxVector I → Counted (Orientation P)) : |
| (orientationTail G P I qs child).erase = |
| MeanPayoff.orientationTail G P I qs (fun q => (child q).erase) := by |
| unfold orientationTail MeanPayoff.orientationTail |
| dsimp only |
| split_ifs <;> simp |
| |
| @[simp] theorem erase_orient (G : Game) {Bmax : ℕ} (P : Budgets G.n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox G.n Bmax) : |
| (orient G P hR lower I).erase = MeanPayoff.orient G P hR (eraseLower lower) I := by |
| rw [orient, MeanPayoff.orient] |
| split_ifs with h |
| · rfl |
| · simp only [Counted.erase_bind, erase_centerSteps, erase_orientationTail] |
| apply congrArg (RandomTree.bind _) |
| funext qs |
| apply congrArg (MeanPayoff.orientationTail G P I qs) |
| funext q |
| exact erase_orient G P hR lower (I.wideCentered (lt_of_not_ge h) q.val) |
| termination_by I.width |
| decreasing_by exact I.E_smaller |
|
|
| @[simp] theorem erase_orientPlus {n : ℕ} {P : Budgets n} |
| (t : Counted (Orientation P)) (J : ℕ) : |
| (orientPlus t J).erase = MeanPayoff.orientPlus t.erase J := by |
| simp [orientPlus, MeanPayoff.orientPlus] |
|
|
| @[simp] theorem erase_tighten {n Bmax : ℕ} (P : Budgets n) (hR : 1 ≤ P.parameter) |
| (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox n Bmax) |
| (hB : 128 * globalS Bmax < I.width) : |
| (tighten P hR lower I hB).erase = MeanPayoff.tighten P hR (eraseLower lower) I hB := by |
| rw [tighten, MeanPayoff.tighten] |
| simp only [Counted.erase_bind, SolveBox.erase_repeated] |
| congr 1 |
| funext r₁ |
| split_ifs with h₁ |
| · simp only [Counted.erase_map, erase_tighten P hR lower (I.withFloor r₁) hB] |
| · simp only [Counted.erase_bind, SolveBox.erase_repeated] |
| congr 1 |
| funext r₂ |
| split_ifs with h₂ |
| · simp only [Counted.erase_map, erase_tighten P hR lower (I.withCeiling r₂) hB] |
| · rfl |
| termination_by volume I.b I.a |
| decreasing_by |
| · apply volume_decreases r₁.property.1 r₁.property.2 |
| obtain ⟨i, hi⟩ := h₁ |
| have hd := I.delta_positive hB |
| intro heq |
| have he := congrFun heq i |
| omega |
| · apply volume_ceiling_decreases r₂.property.1 r₂.property.2 |
| obtain ⟨i, hi⟩ := h₂ |
| have hd := I.delta_positive hB |
| intro heq |
| have he := congrFun heq i |
| omega |
|
|
| @[simp] theorem erase_finishChoice (G : Game) {Bmax : ℕ} (P : Budgets G.n) |
| (hR : 1 ≤ P.parameter) (lower : LowerSolver (Bmax := Bmax) P) (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))) : |
| (finishChoice G P hR lower I hB O up lo).erase = |
| MeanPayoff.finishChoice G P hR (eraseLower lower) I hB O up.erase lo.erase := by |
| unfold finishChoice MeanPayoff.finishChoice |
| split_ifs <;> simp [eraseLower] |
| |
| @[simp] theorem erase_solveWidth (G : Game) {Bmax : ℕ} (P : Budgets G.n) |
| (hR : 1 ≤ P.parameter) (lower : LowerSolver (Bmax := Bmax) P) (I : SolveBox G.n Bmax) : |
| (solveWidth G P hR lower I).erase = MeanPayoff.solveWidth G P hR (eraseLower lower) I := by |
| rw [solveWidth, MeanPayoff.solveWidth, Counted.erase_charge] |
| split_ifs with hB |
| · rfl |
| · simp only [Counted.erase_bind, erase_tighten] |
| congr 1 |
| funext T |
| simp only [erase_orientPlus, erase_orient] |
| congr 1 |
| funext O |
| simp only [Counted.erase_map, erase_finishChoice] |
| congr 2 |
| · exact erase_solveWidth G P hR lower _ |
| · exact erase_solveWidth G P hR lower _ |
| termination_by I.width |
| decreasing_by |
| all_goals |
| change T.box.C < I.width |
| rw [← T.width_eq] |
| exact T.box.C_smaller (by rw [T.width_eq]; omega) |
| |
| @[simp] theorem erase_solve (G : Game) {Bmax : ℕ} (P : Budgets G.n) (I : SolveBox G.n Bmax) : |
| (solve G P I).erase = MeanPayoff.solve G P I := by |
| rw [solve, MeanPayoff.solve] |
| split_ifs with hR |
| · rfl |
| · rw [erase_solveWidth] |
| congr 1 |
| funext Q h K |
| exact erase_solve G Q K |
| termination_by parameterRank P.parameter |
|
|
| end CountedAlgorithm |
| end MeanPayoff |
| end |
|
|
| end OAI |
|
|
