| import OAI.Combinatorics.EditApproximation.Binary.BinaryActionSelection |
| import OAI.Combinatorics.EditApproximation.Binary.BinaryActualBandOptimizer |
|
|
| namespace OAI |
|
|
| /-! Materialized Boolean vertices retain their band labels. The resulting |
| selected action, including every tie, is the action used by the online |
| sampler in the accuracy development. -/ |
|
|
| namespace EditApproximation |
| namespace BinaryFraction |
|
|
| def labeledBandVerticesWithWork {M d : ℕ} {σ : Type*} [DecidableEq σ] |
| (coordinates : Vector (Fin M × σ) d) (mass : Vector BinaryFraction M) |
| (band : List (Fin M → σ)) : List ((Fin M → σ) × Vector BinaryFraction d) × ℕ := |
| let total := bandMassTotalWithWork mass |
| let vertices := band.map fun action => |
| let vertex := vectorMapWithWork d fun i => |
| bandCoordinateWithWork mass total.1 action (coordinates.get i) |
| ((action, vertex.1), vertex.2) |
| (vertices.map Prod.fst, total.2 + (vertices.map Prod.snd).sum + 8 * band.length) |
|
|
| theorem labeledBandVerticesWithWork_vectors {M d : ℕ} {σ : Type*} [DecidableEq σ] |
| (coordinates : Vector (Fin M × σ) d) (mass : Vector BinaryFraction M) |
| (band : List (Fin M → σ)) : |
| (labeledBandVerticesWithWork coordinates mass band).1.map Prod.snd = |
| (bandVerticesWithWork coordinates mass band).1 := by |
| simp only [labeledBandVerticesWithWork, bandVerticesWithWork, List.map_map, Function.comp_def] |
|
|
| theorem labeledBandVerticesWithWork_values {M d : ℕ} {σ : Type*} [DecidableEq σ] |
| (coordinates : Vector (Fin M × σ) d) (mass : Vector BinaryFraction M) |
| (band : List (Fin M → σ)) : |
| (labeledBandVerticesWithWork coordinates mass band).1.map |
| (fun pair => (pair.1, pair.2.map value)) = |
| band.map (fun action => (action, |
| restrictOptimizerVector coordinates (actionVector (fun j => (mass.get j).value) action))) := by |
| simp only [labeledBandVerticesWithWork, List.map_map, Function.comp_def] |
| apply List.map_congr_left |
| intro action _ |
| apply Prod.ext |
| · rfl |
| apply Vector.ext |
| intro i hi |
| simp only [Vector.getElem_map] |
| change ((vectorMapWithWork (α := BinaryFraction) d _).1.get ⟨i, hi⟩).value = |
| (restrictOptimizerVector coordinates (actionVector (fun j => (mass.get j).value) action)).get ⟨i, hi⟩ |
| rw [vectorMapWithWork_value, bandCoordinateWithWork_value, restrictOptimizerVector_get] |
|
|
| theorem labeledBandVerticesWithWork_cost {M d : ℕ} {σ : Type*} [DecidableEq σ] |
| (coordinates : Vector (Fin M × σ) d) (mass : Vector BinaryFraction M) |
| (band : List (Fin M → σ)) : |
| (labeledBandVerticesWithWork coordinates mass band).2 = |
| (bandVerticesWithWork coordinates mass band).2 + 2 * band.length := by |
| simp only [labeledBandVerticesWithWork, bandVerticesWithWork, List.map_map, Function.comp_def] |
| omega |
|
|
| def preparedBandActionWithWork {M : ℕ} {σ : Type*} [DecidableEq σ] |
| (mass : Vector BinaryFraction M) (table : ℕ → Fin M × σ → BinaryFraction) |
| (eta kappa : BinaryFraction) (band : List (Fin M → σ)) (G j t : ℕ) : |
| Option (Fin M → σ) × ℕ := |
| let coordinates := listedBandCoordinateVector band |
| let vertices := labeledBandVerticesWithWork coordinates mass band |
| let linear := vectorMapWithWork _ fun i => |
| onlineLinearWithWork (fun j => mass.get j) table eta kappa t (coordinates.get i) |
| let selected := selectionWithWork vertices.1 linear.1 G j |
| (selected.1, vertices.2 + linear.2 + selected.2 + 2) |
|
|
| theorem preparedBandActionWithWork_value {M : ℕ} {σ : Type*} [DecidableEq σ] |
| (mass : Vector BinaryFraction M) (table : ℕ → Fin M × σ → BinaryFraction) |
| (eta kappa : BinaryFraction) (band : List (Fin M → σ)) (hband : band ≠ []) (G j t : ℕ) : |
| (preparedBandActionWithWork mass table eta kappa band G j t).1.getD (band.head hband) = |
| finiteOptimizerAction band hband (fun i => (mass.get i).value) |
| (rationalOnlineLinear eta.value kappa.value |
| (childGain (fun i => (mass.get i).value) (fun s i => (table s i).value)) |
| (childDecrement (fun i => (mass.get i).value) (fun s i => (table s i).value)) t) G j := by |
| let coordinates := listedBandCoordinateVector band |
| let linear := rationalOnlineLinear eta.value kappa.value |
| (childGain (fun i => (mass.get i).value) (fun s i => (table s i).value)) |
| (childDecrement (fun i => (mass.get i).value) (fun s i => (table s i).value)) t |
| have hl : (vectorMapWithWork _ (fun i => onlineLinearWithWork |
| (fun k => mass.get k) table eta kappa t (coordinates.get i))).1.map value = |
| restrictOptimizerVector coordinates linear := by |
| apply Vector.ext |
| intro i hi |
| simp only [Vector.getElem_map] |
| change ((vectorMapWithWork (α := BinaryFraction) _ _).1.get ⟨i, hi⟩).value = |
| (restrictOptimizerVector coordinates linear).get ⟨i, hi⟩ |
| rw [vectorMapWithWork_value, onlineLinearWithWork_value, restrictOptimizerVector_get] |
| change (selectionWithWork (labeledBandVerticesWithWork coordinates mass band).1 |
| (vectorMapWithWork _ (fun i => onlineLinearWithWork |
| (fun k => mass.get k) table eta kappa t (coordinates.get i))).1 G j).1.getD _ = _ |
| rw [selectionWithWork_value, labeledBandVerticesWithWork_values, hl] |
| exact materializedBandActionWithWork_value band hband (fun i => (mass.get i).value) linear G j |
|
|
| def preparedBandActionBitBudget (M d vertices G K t Be Bk Bm Bt E : ℕ) : ℕ := |
| bandPreparationBitBudget M d vertices Bm + 2 * vertices + |
| d * (onlineLinearBitBudget Be Bk Bm Bt t + 6) + |
| selectionBitBudget d vertices G K (bandVertexWordBudget M Bm) (bandVertexWordBudget M Bm) |
| (onlineLinearStorageBudget Be Bk Bm Bt t) (E * (2 * t + 1)) + 2 |
|
|
| theorem preparedBandActionWithWork_cost {M : ℕ} {σ : Type*} [DecidableEq σ] |
| (mass : Vector BinaryFraction M) (table : ℕ → Fin M × σ → BinaryFraction) |
| (eta kappa : BinaryFraction) (band : List (Fin M → σ)) (G K t Be Bk Bm Bt E : ℕ) |
| (hband : band ≠ []) (he : eta.width ≤ Be) (hk : kappa.width ≤ Bk) |
| (hm : ∀ j, (mass.get j).width ≤ Bm) (hmpos : ∀ j, 0 < (mass.get j).value) |
| (ht : ∀ s ≤ t + 1, ∀ i : Fin (listedBandCoordinates band).length, |
| (table s ((listedBandCoordinateVector band).get i)).width ≤ Bt) |
| (heabs : |eta.value| ≤ E) (hkrange : 0 ≤ kappa.value ∧ kappa.value ≤ 1) |
| (htrange : ∀ s ≤ t + 1, ∀ i : Fin (listedBandCoordinates band).length, |
| 0 ≤ (table s ((listedBandCoordinateVector band).get i)).value ∧ |
| (table s ((listedBandCoordinateVector band).get i)).value ≤ |
| (mass.get ((listedBandCoordinateVector band).get i).1).value) : |
| (preparedBandActionWithWork mass table eta kappa band G K t).2 ≤ |
| preparedBandActionBitBudget M (listedBandCoordinates band).length band.length G K t Be Bk Bm Bt E := by |
| let coordinates := listedBandCoordinateVector band |
| let vertices := (labeledBandVerticesWithWork coordinates mass band).1 |
| let linear := (vectorMapWithWork _ fun i => |
| onlineLinearWithWork (fun j => mass.get j) table eta kappa t (coordinates.get i)).1 |
| have hlength : vertices.length = band.length := by |
| simp only [vertices, labeledBandVerticesWithWork, List.length_map] |
| have hvertices : vertices ≠ [] := by |
| intro h |
| rw [h, List.length_nil] at hlength |
| exact hband (List.length_eq_zero_iff.mp hlength.symm) |
| have hv (v : (Fin M → σ) × Vector BinaryFraction (listedBandCoordinates band).length) |
| (hmem : v ∈ vertices) (i : Fin (listedBandCoordinates band).length) := |
| bandVerticesWithWork_input_bounds coordinates mass band Bm hm hmpos v.2 |
| (by rw [← labeledBandVerticesWithWork_vectors] |
| exact List.mem_map.mpr ⟨v, hmem, rfl⟩) i |
| have hlwidth (i : Fin (listedBandCoordinates band).length) : |
| (linear.get i).width ≤ onlineLinearStorageBudget Be Bk Bm Bt t := by |
| simp only [linear, vectorMapWithWork_value] |
| exact onlineLinearWithWork_storage (fun j => mass.get j) table eta kappa t |
| (coordinates.get i) Be Bk Bm Bt he hk (hm _) (fun s hs => ht s hs i) |
| have hlvalue (i : Fin (listedBandCoordinates band).length) : |
| |(linear.get i).value| ≤ (E * (2 * t + 1) : ℕ) := by |
| simp only [linear, vectorMapWithWork_value, onlineLinearWithWork_value] |
| have h := rationalOnlineLinear_abs (fun j => (mass.get j).value) |
| (fun s j => (table s j).value) eta.value kappa.value t E (coordinates.get i) |
| heabs (hmpos _) hkrange (fun s hs => htrange s hs i) |
| simpa only [Nat.cast_mul, Nat.cast_add, Nat.cast_ofNat, Nat.cast_one] using h |
| have hc := selectionWithWork_cost vertices linear G K (bandVertexWordBudget M Bm) |
| (bandVertexWordBudget M Bm) (onlineLinearStorageBudget Be Bk Bm Bt t) (E * (2 * t + 1)) |
| hvertices (fun v hv' i => ⟨(hv v hv' i).1, (hv v hv' i).2.1, (hv v hv' i).2.2.1⟩) |
| (fun v hv' i => (hv v hv' i).2.2.2) hlwidth hlvalue |
| rw [hlength] at hc |
| have hp := bandVerticesWithWork_cost coordinates mass band Bm hm |
| have hl := vectorMapWithWork_cost_le _ |
| (fun i => onlineLinearWithWork (fun j => mass.get j) table eta kappa t (coordinates.get i)) |
| (onlineLinearBitBudget Be Bk Bm Bt t) (fun i => onlineLinearWithWork_cost |
| (fun j => mass.get j) table eta kappa t (coordinates.get i) Be Bk Bm Bt |
| he hk (hm _) (fun s hs => ht s hs i)) |
| change (labeledBandVerticesWithWork coordinates mass band).2 + |
| (vectorMapWithWork _ (fun i => onlineLinearWithWork (fun j => mass.get j) |
| table eta kappa t (coordinates.get i))).2 + |
| (selectionWithWork vertices linear G K).2 + 2 ≤ _ |
| rw [labeledBandVerticesWithWork_cost] |
| unfold preparedBandActionBitBudget |
| omega |
| |
| def bandActionWithWork {M ny : ℕ} (b : ℕ) |
| (initial : Fin M → TargetInterval ny → BinaryFraction) |
| (table : ℕ → Fin M × TargetInterval ny → BinaryFraction) |
| (eta kappa : BinaryFraction) (band : List (Fin M → TargetInterval ny)) (G j t : ℕ) : |
| Option (Fin M → TargetInterval ny) × ℕ := |
| let mass := envelopeVectorWithWork b band initial |
| let selected := preparedBandActionWithWork mass.1 table eta kappa band G j t |
| (selected.1, mass.2 + selected.2 + 1) |
| |
| theorem bandActionWithWork_value {M ny : ℕ} (b : ℕ) |
| (initial : Fin M → TargetInterval ny → BinaryFraction) |
| (table : ℕ → Fin M × TargetInterval ny → BinaryFraction) |
| (eta kappa : BinaryFraction) (band : List (Fin M → TargetInterval ny)) |
| (hband : band ≠ []) (G j t : ℕ) (hb : 0 < b) : |
| (bandActionWithWork b initial table eta kappa band G j t).1.getD (band.head hband) = |
| finiteOptimizerAction band hband (bandChildEnvelope b band (fun i q => (initial i q).value)) |
| (rationalOnlineLinear eta.value kappa.value |
| (childGain (bandChildEnvelope b band (fun i q => (initial i q).value)) |
| (fun s i => (table s i).value)) |
| (childDecrement (bandChildEnvelope b band (fun i q => (initial i q).value)) |
| (fun s i => (table s i).value)) t) G j := by |
| change (preparedBandActionWithWork (envelopeVectorWithWork b band initial).1 |
| table eta kappa band G j t).1.getD _ = _ |
| rw [preparedBandActionWithWork_value] |
| have hm : (fun i => ((envelopeVectorWithWork b band initial).1.get i).value) = |
| bandChildEnvelope b band (fun i q => (initial i q).value) := by |
| funext i |
| exact envelopeVectorWithWork_value b band initial hb i |
| rw [hm] |
| |
| def bandActionBitBudget (M d b vertices G K t Be Bk Bi Bt E : ℕ) : ℕ := |
| M * (bandEnvelopeBitBudget b M vertices Bi + 6) + |
| preparedBandActionBitBudget M d vertices G K t Be Bk |
| (3 * bandEnvelopeWordBudget b M Bi + 1) Bt E + 1 |
| |
| theorem bandActionWithWork_cost {M ny : ℕ} (b : ℕ) |
| (initial : Fin M → TargetInterval ny → BinaryFraction) |
| (table : ℕ → Fin M × TargetInterval ny → BinaryFraction) |
| (eta kappa : BinaryFraction) (band : List (Fin M → TargetInterval ny)) |
| (G K t Be Bk Bi Bt E : ℕ) (hband : band ≠ []) (hb : 0 < b) (hM : 0 < M) |
| (he : eta.width ≤ Be) (hk : kappa.width ≤ Bk) |
| (hi : ∀ action ∈ band, ∀ j, (initial j (action j)).width ≤ Bi) |
| (ht : ∀ s ≤ t + 1, ∀ i : Fin (listedBandCoordinates band).length, |
| (table s ((listedBandCoordinateVector band).get i)).width ≤ Bt) |
| (heabs : |eta.value| ≤ E) (hkrange : 0 ≤ kappa.value ∧ kappa.value ≤ 1) |
| (htrange : ∀ s ≤ t + 1, ∀ i : Fin (listedBandCoordinates band).length, |
| 0 ≤ (table s ((listedBandCoordinateVector band).get i)).value ∧ |
| (table s ((listedBandCoordinateVector band).get i)).value ≤ |
| (initial ((listedBandCoordinateVector band).get i).1 |
| ((listedBandCoordinateVector band).get i).2).value) : |
| (bandActionWithWork b initial table eta kappa band G K t).2 ≤ |
| bandActionBitBudget M (listedBandCoordinates band).length b band.length G K t Be Bk Bi Bt E := by |
| let coordinates := listedBandCoordinateVector band |
| let mass := (envelopeVectorWithWork b band initial).1 |
| have hmv (j : Fin M) : (mass.get j).value = |
| bandChildEnvelope b band (fun k q => (initial k q).value) j := |
| envelopeVectorWithWork_value b band initial hb j |
| have hm (j : Fin M) : (mass.get j).width ≤ 3 * bandEnvelopeWordBudget b M Bi + 1 := by |
| simp only [mass, envelopeVectorWithWork, vectorMapWithWork_value] |
| exact bandEnvelopeWithWork_width b band initial j Bi (fun action ha => hi action ha j) |
| have hmpos (j : Fin M) : 0 < (mass.get j).value := by |
| rw [hmv] |
| exact lt_of_lt_of_le (div_pos (by exact_mod_cast hb) (by exact_mod_cast hM)) |
| (bandChildEnvelope_lower b band (fun j q => (initial j q).value) j).1 |
| have hnormalized (s : ℕ) (hs : s ≤ t + 1) (i : Fin (listedBandCoordinates band).length) : |
| 0 ≤ (table s (coordinates.get i)).value ∧ |
| (table s (coordinates.get i)).value ≤ (mass.get (coordinates.get i).1).value := by |
| refine ⟨(htrange s hs i).1, ?_⟩ |
| obtain ⟨action, ha, heq⟩ := listedBandCoordinateVector_coverage band i |
| have henv := (bandChildEnvelope_lower b band (fun j q => (initial j q).value) |
| (coordinates.get i).1).2 action ha |
| rw [heq] at henv |
| rw [hmv] |
| exact (htrange s hs i).2.trans henv |
| have hp := preparedBandActionWithWork_cost mass table eta kappa band G K t |
| Be Bk (3 * bandEnvelopeWordBudget b M Bi + 1) Bt E hband he hk hm hmpos ht heabs hkrange hnormalized |
| have hc := vectorMapWithWork_cost_le M (bandEnvelopeWithWork b band initial) |
| (bandEnvelopeBitBudget b M band.length Bi) |
| (fun j => bandEnvelopeWithWork_cost b band initial j Bi (fun action ha => hi action ha j)) |
| change (envelopeVectorWithWork b band initial).2 + |
| (preparedBandActionWithWork mass table eta kappa band G K t).2 + 1 ≤ _ |
| change (envelopeVectorWithWork b band initial).2 ≤ _ at hc |
| unfold bandActionBitBudget |
| omega |
| |
| end BinaryFraction |
| end EditApproximation |
| |
| end OAI |
| |
