| import OAI.Computability.MeanPayoff.GridLabels |
|
|
| namespace OAI |
|
|
| namespace MeanPayoff.Label |
|
|
| variable {n : ℕ} |
|
|
| theorem dyadic_splits {d : ℕ} (hd : 12 ≤ d) : |
| (2 : ℤ)^d = 4096*2^(d-12) ∧ |
| (2 : ℤ)^(d-7) = 32*2^(d-12) ∧ |
| (2 : ℤ)^(d-1) = 2048*2^(d-12) := by |
| constructor |
| · nth_rw 1 [show d = (d-12)+12 by omega] |
| rw [pow_add] |
| norm_num |
| ring |
| constructor |
| · rw [show d-7 = (d-12)+5 by omega, pow_add] |
| norm_num |
| ring |
| · rw [show d-1 = (d-12)+11 by omega, pow_add] |
| norm_num |
| ring |
|
|
| theorem narrow_rank {a b : Fin n → ℚ} |
| (ha : ∀ i, 0 < a i) (hb : ∀ i, 0 < b i) |
| (hbase : ¬ ∀ i, 1 < a i*b i) (d : ℕ) : |
| d-7 + budget a (fun i => 4/3*b i) ha (fun i => mul_pos (by norm_num) (hb i)) |
| < d + budget a b ha hb ∧ |
| d-7 + budget (fun i => 4/3*a i) b (fun i => mul_pos (by norm_num) (ha i)) hb |
| < d + budget a b ha hb := by |
| have hd := budget_decreases ha hb ha (fun i => mul_pos (by norm_num) (hb i)) hbase |
| (a' := a) (b' := fun i => 4/3*b i) (fun i => by |
| have h := mul_pos (ha i) (hb i) |
| nlinarith only [h]) |
| have hu := budget_decreases ha hb (fun i => mul_pos (by norm_num) (ha i)) hb hbase |
| (a' := fun i => 4/3*a i) (b' := b) (fun i => by |
| have h := mul_pos (ha i) (hb i) |
| nlinarith only [h]) |
| omega |
|
|
| theorem continuation_rank {a b : Fin n → ℚ} |
| (ha : ∀ i, 0 < a i) (hb : ∀ i, 0 < b i) |
| (hbase : ¬ ∀ i, 1 < a i*b i) (d : ℕ) (labels : Fin n → Bool) : |
| d + budget (reweight a labels) (reweight b (fun i => !(labels i))) |
| (reweight_pos ha labels) (reweight_pos hb (fun i => !(labels i))) |
| < d + budget a b ha hb := by |
| have h := budget_decreases ha hb (reweight_pos ha labels) |
| (reweight_pos hb (fun i => !(labels i))) hbase (fun i => by |
| rw [reweight_product]) |
| omega |
|
|
| theorem good_width {F : Vec (Fin n) → Vec (Fin n)} {A : Vec (Fin n)} |
| {D E : ℤ} {a b : Fin n → ℚ} {labels : Fin n → Bool} (h : D = E) : |
| Good F A D a b labels ↔ Good F A E a b labels := by rw [h] |
|
|
| def labeller (G : Game) (A : Vec (Fin G.n)) (d : ℕ) (a b : Fin G.n → ℚ) |
| (ha : ∀ i, 0 < a i) (hb : ∀ i, 0 < b i) : |
| {labels : Fin G.n → Bool |
| by_cases hbase : ∀ i, 1 < a i*b i |
| · exact ⟨massLabels b, massBase_good (by positivity) ha hb hbase⟩ |
| · by_cases hsmall : d < 12 |
| · let z := (basic G A (shift A ((2 : ℤ)^d)) |
| (fun i => by |
| dsimp [shift] |
| exact le_add_of_nonneg_right (by positivity))).1 |
| exact ⟨widthLabels A z ((2 : ℤ)^d), widthBase_good G (by positivity) a b⟩ |
| · have hd : 12 ≤ d := Nat.le_of_not_gt hsmall |
| let t : ℤ := 2^(d-12) |
| have ht : 0 < t := by dsimp [t]; positivity |
| have hs := dyadic_splits hd |
| have hD : (2 : ℤ)^d = 4096*t := hs.1 |
| have hq : (2 : ℤ)^(d-7) = 32*t := hs.2.1 |
| have hr : (2 : ℤ)^(d-1) = 2048*t := hs.2.2 |
| let ad : Fin G.n → ℚ := fun i => (4/3)*a i |
| let bd : Fin G.n → ℚ := fun i => (4/3)*b i |
| have had : ∀ i, 0 < ad i := fun i => mul_pos (by norm_num) (ha i) |
| have hbd : ∀ i, 0 < bd i := fun i => mul_pos (by norm_num) (hb i) |
| have hdn : d-7+budget a bd ha hbd < d+budget a b ha hb := (narrow_rank ha hb hbase d).1 |
| have hun : d-7+budget ad b had hb < d+budget a b ha hb := (narrow_rank ha hb hbase d).2 |
| have hpn : d-1+budget a b ha hb < d+budget a b ha hb := by omega |
| let downChild := fun g : Grid G.n => |
| labeller G (fun i => gridPivot A t g i-16*t) (d-7) a bd ha hbd |
| let down : Grid G.n → (Fin G.n → Bool) := fun g => (downChild g).val |
| have hdgood : ∀ g, Good (operator G) (fun i => gridPivot A t g i-16*t) |
| (32*t) a bd (down g) := by |
| intro g |
| exact (good_width hq).mp (downChild g).property |
| let upChild := fun g : Grid G.n => |
| labeller G (fun i => gridPivot A t g i-16*t) (d-7) ad b had hb |
| let up : Grid G.n → (Fin G.n → Bool) := fun g => (upChild g).val |
| have hugood : ∀ g, Good (operator G) (fun i => gridPivot A t g i-16*t) |
| (32*t) ad b (up g) := by |
| intro g |
| exact (good_width hq).mp (upChild g).property |
| let provisional := labeller G (fun i => finalPivot A t down up i-1024*t) (d-1) a b ha hb |
| have hpgood : Good (operator G) (fun i => finalPivot A t down up i-1024*t) |
| (2048*t) a b provisional.val := by |
| exact (good_width hr).mp provisional.property |
| let abar := reweight a provisional.val |
| let bbar := reweight b (fun i => !(provisional.val i)) |
| have ha' : ∀ i, 0 < abar i := reweight_pos ha _ |
| have hb' : ∀ i, 0 < bbar i := reweight_pos hb _ |
| have hcn : d+budget abar bbar ha' hb' < d+budget a b ha hb := |
| continuation_rank ha hb hbase d _ |
| let continuation := labeller G A d abar bbar ha' hb' |
| have hcgood : Good (operator G) A (4096*t) abar bbar continuation.val := by |
| exact (good_width hD).mp continuation.property |
| refine ⟨override A (downPivot A t down) (finalPivot A t down up) t continuation.val, ?_⟩ |
| apply (good_width hD).mpr |
| exact passes_good G.positive (operator_laws G) ht ha hb down up hdgood hugood hpgood hcgood |
| termination_by d + budget a b ha hb |
| decreasing_by |
| all_goals first | exact hdn | exact hun | exact hpn | exact hcn |
|
|
| theorem labeller_good (G : Game) (A : Vec (Fin G.n)) (d : ℕ) (a b : Fin G.n → ℚ) |
| (ha : ∀ i, 0 < a i) (hb : ∀ i, 0 < b i) : |
| Good (operator G) A ((2 : ℤ)^d) a b (labeller G A d a b ha hb).val := |
| (labeller G A d a b ha hb).property |
|
|
| end MeanPayoff.Label |
|
|
| end OAI |
|
|
