| import OAI.Combinatorics.EditApproximation.Binary.BinaryOptimizerWork |
| import OAI.Combinatorics.EditApproximation.Geometry.BandNumericalBits |
| import OAI.Combinatorics.EditApproximation.Definitions |
|
|
|
|
| namespace OAI |
|
|
| /-! Actual Boolean construction of the normalized band vertices. |
| The input masses are stored fractions; their sum and divisions use the |
| counted routines and no reduced-rational conversion is performed. -/ |
|
|
| namespace EditApproximation |
| namespace BinaryFraction |
|
|
| open Finset |
|
|
| theorem value_abs_le_pow_width (a : BinaryFraction) : |a.value| ≤ (2 : ℚ) ^ a.width := by |
| have hn := (bitWordValue_lt_pow_length a.numerator.bits).le |
| have hw : a.numerator.bits.length ≤ a.width := le_max_left _ _ |
| have hn' : bitWordValue a.numerator.bits ≤ 2 ^ a.width := |
| hn.trans (Nat.pow_le_pow_right (by decide) hw) |
| have hden : (1 : ℚ) ≤ bitWordValue a.denominator := by exact_mod_cast a.denominator_pos |
| have habs : |(a.numerator.value : ℚ)| = bitWordValue a.numerator.bits := by |
| cases h : a.numerator.negative <;> simp [SignedBinary.value, signedMagnitude, h] |
| unfold value |
| rw [abs_div, habs, abs_of_pos (lt_of_lt_of_le (by norm_num : (0 : ℚ) < 1) hden)] |
| apply (div_le_iff₀ (lt_of_lt_of_le (by norm_num : (0 : ℚ) < 1) hden)).mpr |
| have hnQ : (bitWordValue a.numerator.bits : ℚ) ≤ (2 : ℚ) ^ a.width := by exact_mod_cast hn' |
| exact hnQ.trans (le_mul_of_one_le_right (by positivity) hden) |
|
|
|
|
|
|
| theorem bandMassTotalWithWork_value {M : ℕ} (mass : Vector BinaryFraction M) : |
| (bandMassTotalWithWork mass).1.value = ∑ i, (mass.get i).value := by |
| rw [bandMassTotalWithWork, ← representation_value, dotWithWork_representation, |
| UnreducedRational.dot_value] |
| simp [one_representation] |
|
|
| def bandMassTotalStorageBudget (M B : ℕ) : ℕ := |
| Nat.size M + B + 2 * (1 + M * (B + 1)) + 2 |
|
|
| theorem bandMassTotalWithWork_storage {M : ℕ} (mass : Vector BinaryFraction M) |
| (B : ℕ) (hmass : ∀ i, (mass.get i).width ≤ B) : |
| (bandMassTotalWithWork mass).1.representation.storageBits ≤ bandMassTotalStorageBudget M B := by |
| have hvalue (i : Fin M) : |(mass.get i).value| ≤ ((2 ^ B : ℕ) : ℚ) := by |
| have h := (value_abs_le_pow_width (mass.get i)).trans |
| (pow_le_pow_right₀ (by norm_num : (1 : ℚ) ≤ 2) (hmass i)) |
| simpa only [Nat.cast_pow, Nat.cast_ofNat] using h |
| have h := UnreducedRational.dotList_storageBits |
| (mass.map representation) ((Vector.replicate M one).map representation) |
| (List.finRange M) B 1 (2 ^ B) 1 |
| (by intro i _; simpa only [vector_map_get] using (representation_den_bits_le_width (mass.get i)).trans (hmass i)) |
| (by intro i _; simp [one_representation, UnreducedRational.one, UnreducedRational.ofRat]) |
| (by intro i _; simpa only [vector_map_get, representation_value] using hvalue i) |
| (by intro i _; simp [one_representation]) |
| simp only [List.length_finRange, Nat.mul_one] at h |
| have hsize := (natural_product_bit_length M (2 ^ B)).trans |
| (Nat.add_le_add_left (by rw [Nat.size_pow] : Nat.size (2 ^ B) ≤ B + 1) M.size) |
| rw [bandMassTotalWithWork, dotWithWork_representation] |
| change (UnreducedRational.dotList (mass.map representation) |
| ((Vector.replicate M one).map representation) (List.finRange M)).storageBits ≤ _ |
| unfold bandMassTotalStorageBudget |
| omega |
|
|
| def bandVertexWordBudget (M B : ℕ) : ℕ := 2 * B + bandMassTotalStorageBudget M B + 3 |
|
|
| def bandCoordinateWithWork {M : ℕ} {σ : Type*} [DecidableEq σ] |
| (mass : Vector BinaryFraction M) (total : BinaryFraction) |
| (action : Fin M → σ) (coordinate : Fin M × σ) : BinaryFraction × ℕ := |
| if coordinate.2 = action coordinate.1 then divWithWork (mass.get coordinate.1) total else (zero, 1) |
|
|
| theorem bandCoordinateWithWork_value {M : ℕ} {σ : Type*} [DecidableEq σ] |
| (mass : Vector BinaryFraction M) (action : Fin M → σ) (coordinate : Fin M × σ) : |
| (bandCoordinateWithWork mass (bandMassTotalWithWork mass).1 action coordinate).1.value = |
| actionVector (fun i => (mass.get i).value) action coordinate := by |
| unfold bandCoordinateWithWork actionVector |
| split_ifs |
| · rw [← representation_value, divWithWork_representation, |
| UnreducedRational.value_div, representation_value, representation_value, |
| bandMassTotalWithWork_value] |
| · simp [zero, value, SignedBinary.value, signedMagnitude, bitWordValue] |
|
|
| theorem bandCoordinateWithWork_bounds {M : ℕ} {σ : Type*} [DecidableEq σ] |
| (mass : Vector BinaryFraction M) (action : Fin M → σ) (coordinate : Fin M × σ) |
| (B : ℕ) (hmass : ∀ i, (mass.get i).width ≤ B) (hpos : ∀ i, 0 < (mass.get i).value) : |
| let output := (bandCoordinateWithWork mass (bandMassTotalWithWork mass).1 action coordinate).1 |
| output.width ≤ output.representation.storageBits ∧ |
| (0 ≤ output.value ∧ output.value ≤ 1) ∧ |
| output.representation.storageBits ≤ bandVertexWordBudget M B := by |
| dsimp only |
| have hvalues := actionVector_zero_one (fun i => (mass.get i).value) action coordinate hpos |
| rw [← bandCoordinateWithWork_value mass action coordinate] at hvalues |
| refine ⟨?_, hvalues, ?_⟩ |
| · unfold bandCoordinateWithWork |
| split_ifs |
| · exact divWithWork_self_width _ _ |
| · exact zero_width_le_storageBits |
| · have ht := bandMassTotalWithWork_storage mass B hmass |
| have hm := representation_storageBits_le (mass.get coordinate.1) |
| have hi := hmass coordinate.1 |
| unfold bandCoordinateWithWork |
| split_ifs |
| · rw [divWithWork_representation] |
| have hd := UnreducedRational.storageBits_div (mass.get coordinate.1).representation |
| (bandMassTotalWithWork mass).1.representation |
| unfold bandVertexWordBudget |
| omega |
| · change UnreducedRational.zero.storageBits ≤ _ |
| rw [UnreducedRational.storageBits_zero] |
| unfold bandVertexWordBudget |
| omega |
|
|
| def bandVerticesWithWork {M d : ℕ} {σ : Type*} [DecidableEq σ] |
| (coordinates : Vector (Fin M × σ) d) (mass : Vector BinaryFraction M) |
| (band : List (Fin M → σ)) : List (Vector BinaryFraction d) × ℕ := |
| let total := bandMassTotalWithWork mass |
| let vertices := band.map fun action => vectorMapWithWork d fun i => |
| bandCoordinateWithWork mass total.1 action (coordinates.get i) |
| (vertices.map Prod.fst, total.2 + (vertices.map Prod.snd).sum + 6 * band.length) |
|
|
| theorem bandVerticesWithWork_values {M d : ℕ} {σ : Type*} [DecidableEq σ] |
| (coordinates : Vector (Fin M × σ) d) (mass : Vector BinaryFraction M) |
| (band : List (Fin M → σ)) : |
| (bandVerticesWithWork coordinates mass band).1.map (fun v i => (v.get i).value) = |
| band.map (fun action i => actionVector (fun i => (mass.get i).value) action (coordinates.get i)) := by |
| simp only [bandVerticesWithWork, List.map_map, Function.comp_def] |
| apply List.map_congr_left |
| intro action _ |
| funext i |
| simp only [vectorMapWithWork_value, bandCoordinateWithWork_value] |
|
|
| theorem bandVerticesWithWork_input_bounds {M d : ℕ} {σ : Type*} [DecidableEq σ] |
| (coordinates : Vector (Fin M × σ) d) (mass : Vector BinaryFraction M) |
| (band : List (Fin M → σ)) (B : ℕ) |
| (hmass : ∀ i, (mass.get i).width ≤ B) (hpos : ∀ i, 0 < (mass.get i).value) |
| (v : Vector BinaryFraction d) (hv : v ∈ (bandVerticesWithWork coordinates mass band).1) |
| (i : Fin d) : |
| (v.get i).width ≤ (v.get i).representation.storageBits ∧ |
| (0 ≤ (v.get i).value ∧ (v.get i).value ≤ 1) ∧ |
| Nat.size (v.get i).representation.den ≤ bandVertexWordBudget M B ∧ |
| (v.get i).width ≤ bandVertexWordBudget M B := by |
| simp only [bandVerticesWithWork, List.map_map, Function.comp_def] at hv |
| obtain ⟨action, _, rfl⟩ := List.mem_map.mp hv |
| simp only [vectorMapWithWork_value] |
| have h := bandCoordinateWithWork_bounds mass action (coordinates.get i) B hmass hpos |
| dsimp only at h |
| refine ⟨h.1, h.2.1, ?_, h.1.trans h.2.2⟩ |
| apply le_trans ?_ h.2.2 |
| unfold UnreducedRational.storageBits |
| omega |
|
|
| end BinaryFraction |
| end EditApproximation |
|
|
| end OAI |
|
|
