| import Lean.Elab.Tactic.Omega |
| import Mathlib.Data.Nat.Size |
| import Mathlib.Tactic.Linarith |
| import Mathlib.Tactic.Ring |
|
|
| namespace OAI |
|
|
| namespace BinPackingGap |
|
|
| theorem nat_size_mono {a b : ℕ} (h : a ≤ b) : Nat.size a ≤ Nat.size b := |
| Nat.size_le_size h |
|
|
| theorem nat_size_mul_le (a b : ℕ) : |
| Nat.size (a * b) ≤ Nat.size a + Nat.size b := by |
| apply Nat.size_le.mpr |
| simpa only [Nat.pow_add] using |
| Nat.mul_lt_mul_of_lt_of_lt (Nat.lt_size_self a) (Nat.lt_size_self b) |
|
|
| theorem nat_size_pow_succ_le (a m : ℕ) : |
| Nat.size (a ^ (m + 1)) ≤ (m + 1) * Nat.size a := by |
| induction m with |
| | zero => simp |
| | succ m ih => |
| calc |
| Nat.size (a ^ (m + 1 + 1)) = Nat.size (a ^ (m + 1) * a) := by rw [Nat.pow_succ] |
| _ ≤ Nat.size (a ^ (m + 1)) + Nat.size a := nat_size_mul_le _ _ |
| _ ≤ (m + 1) * Nat.size a + Nat.size a := Nat.add_le_add_right ih _ |
| _ = (m + 1 + 1) * Nat.size a := by simp only [Nat.add_mul, Nat.one_mul] |
|
|
| theorem nat_size_pow_le_of_pos (a m : ℕ) (hm : 0 < m) : |
| Nat.size (a ^ m) ≤ m * Nat.size a := by |
| cases m with |
| | zero => omega |
| | succ m => exact nat_size_pow_succ_le a m |
|
|
| theorem nat_size_pow_le (a m : ℕ) : |
| Nat.size (a ^ m) ≤ m * Nat.size a + 1 := by |
| cases m with |
| | zero => simp [Nat.size_one] |
| | succ m => exact Nat.le_trans (nat_size_pow_succ_le a m) (Nat.le_succ _) |
|
|
| theorem nat_size_add_le_max (a b : ℕ) : |
| Nat.size (a + b) ≤ max (Nat.size a) (Nat.size b) + 1 := by |
| apply Nat.size_le.mpr |
| have ha : a < 2 ^ max (Nat.size a) (Nat.size b) := |
| Nat.size_le.mp (Nat.le_max_left _ _) |
| have hb : b < 2 ^ max (Nat.size a) (Nat.size b) := |
| Nat.size_le.mp (Nat.le_max_right _ _) |
| calc |
| a + b < 2 ^ max (Nat.size a) (Nat.size b) + |
| 2 ^ max (Nat.size a) (Nat.size b) := Nat.add_lt_add ha hb |
| _ = 2 ^ (max (Nat.size a) (Nat.size b) + 1) := by |
| rw [Nat.pow_succ] |
| omega |
|
|
| theorem nat_size_add_le (a b : ℕ) : |
| Nat.size (a + b) ≤ Nat.size a + Nat.size b + 1 := by |
| have h := nat_size_add_le_max a b |
| omega |
|
|
| theorem nat_size_le_self (n : ℕ) : Nat.size n ≤ n := |
| Nat.size_le.mpr Nat.lt_two_pow_self |
|
|
| theorem nat_size_sub_le (a b : ℕ) : Nat.size (a - b) ≤ Nat.size a := |
| nat_size_mono (Nat.sub_le a b) |
|
|
| theorem nat_size_succ_le (a : ℕ) : Nat.size (a + 1) ≤ Nat.size a + 1 := by |
| cases a with |
| | zero => simp [Nat.size_zero, Nat.size_one] |
| | succ a => |
| have hpos : 1 ≤ Nat.size (a + 1) := Nat.size_pos.mpr (Nat.succ_pos a) |
| have h := nat_size_add_le_max (a + 1) 1 |
| simpa only [Nat.size_one, Nat.max_eq_left hpos] using h |
|
|
| end BinPackingGap |
|
|
| namespace BinPackingGap.GraphPackingBounds |
|
|
| def repetitionCoefficient (P K : ℕ) : ℕ := 100 * (P + K + 1) |
|
|
| def binCoefficient (P K t d : ℕ) : ℕ := t + 4 * d * repetitionCoefficient P K |
|
|
| def widthCoefficient (P K T P₀ : ℕ) : ℕ := |
| repetitionCoefficient P K + Nat.size T + Nat.size P₀ + |
| Nat.size 160 + Nat.size 1000000000 + 5 |
|
|
| theorem one_le_input_square (s : ℕ) : 1 ≤ (s + 1) ^ 2 := |
| Nat.pow_pos (Nat.succ_pos s) |
|
|
| theorem input_le_input_square (s : ℕ) : s + 1 ≤ (s + 1) ^ 2 := by nlinarith |
|
|
| theorem constant_le_quadratic (c s : ℕ) : c ≤ c * (s + 1) ^ 2 := by |
| simpa only [Nat.mul_one] using Nat.mul_le_mul_left c (one_le_input_square s) |
|
|
| theorem linear_le_quadratic (c s : ℕ) : |
| c * (s + 1) ≤ c * (s + 1) ^ 2 := |
| Nat.mul_le_mul_left c (input_le_input_square s) |
|
|
| theorem repetitions_le_linear (P K n s : ℕ) (hn : n ≤ s) : |
| 100 * (P + n * K + 1) ≤ repetitionCoefficient P K * (s + 1) := by |
| have hnk := Nat.mul_le_mul_right K hn |
| unfold repetitionCoefficient |
| nlinarith [Nat.zero_le (P * s)] |
|
|
| theorem bins_le_quadratic (P K n m t d s : ℕ) (hn : n ≤ s) (hm : m ≤ s) : |
| n * t + 4 * d * m * (100 * (P + n * K + 1)) ≤ |
| binCoefficient P K t d * (s + 1) ^ 2 := by |
| let c := repetitionCoefficient P K |
| have hR := repetitions_le_linear P K n s hn |
| have hmul := Nat.mul_le_mul (show m ≤ s + 1 by omega) hR |
| have hmul' : m * (100 * (P + n * K + 1)) ≤ c * (s + 1) ^ 2 := by |
| dsimp [c] |
| nlinarith [hmul] |
| have hnt : n * t ≤ t * (s + 1) ^ 2 := by |
| have hn' : n ≤ (s + 1) ^ 2 := by |
| exact hn.trans ((Nat.le_succ s).trans (input_le_input_square s)) |
| simpa only [Nat.mul_comm] using Nat.mul_le_mul_right t hn' |
| have hrest := Nat.mul_le_mul_left (4 * d) hmul' |
| unfold binCoefficient |
| dsimp [c] at hrest |
| nlinarith |
|
|
| theorem size_repetitions_le_linear (P K n s : ℕ) (hn : n ≤ s) : |
| Nat.size (100 * (P + n * K + 1)) ≤ |
| repetitionCoefficient P K * (s + 1) := |
| (nat_size_le_self _).trans (repetitions_le_linear P K n s hn) |
|
|
| theorem size_bin_count_le_quadratic (P K n m t d s : ℕ) |
| (hn : n ≤ s) (hm : m ≤ s) : |
| Nat.size (n * t + 4 * d * m * (100 * (P + n * K + 1))) ≤ |
| binCoefficient P K t d * (s + 1) ^ 2 := |
| (nat_size_le_self _).trans (bins_le_quadratic P K n m t d s hn hm) |
|
|
| theorem size_radix_le_linear (P K n s : ℕ) (hn : n ≤ s) : |
| Nat.size (100 * (P + n * K + 1) + 1) ≤ |
| (repetitionCoefficient P K + 1) * (s + 1) := by |
| have h := (nat_size_le_self _).trans |
| (Nat.add_le_add_right (repetitions_le_linear P K n s hn) 1) |
| nlinarith |
|
|
| theorem size_edge_power_le_quadratic (P K n m s : ℕ) (hn : n ≤ s) (hm : m ≤ s) : |
| Nat.size ((100 * (P + n * K + 1) + 1) ^ m) ≤ |
| (repetitionCoefficient P K + 2) * (s + 1) ^ 2 := by |
| have hpow := nat_size_pow_le (100 * (P + n * K + 1) + 1) m |
| have hradix := size_radix_le_linear P K n s hn |
| have hm' : m ≤ s + 1 := by omega |
| have hprod := Nat.mul_le_mul hm' hradix |
| have hsq := one_le_input_square s |
| nlinarith |
|
|
| theorem size_vertex_power_le_linear (n s : ℕ) (hn : n ≤ s) : |
| Nat.size (3 ^ n) ≤ 3 * (s + 1) := by |
| have h := nat_size_pow_le 3 n |
| have hthree : Nat.size 3 ≤ 2 := by decide |
| have hp := Nat.mul_le_mul_left n hthree |
| omega |
|
|
| theorem size_geometry_denominator_le_quadratic (P K T n m s : ℕ) |
| (hn : n ≤ s) (hm : m ≤ s) : |
| Nat.size (160 * (100 * (P + n * K + 1) + 1) ^ m * T) ≤ |
| (repetitionCoefficient P K + 2 + Nat.size 160 + Nat.size T) * |
| (s + 1) ^ 2 := by |
| have hmul₁ := nat_size_mul_le 160 ((100 * (P + n * K + 1) + 1) ^ m) |
| have hmul₂ := nat_size_mul_le (160 * (100 * (P + n * K + 1) + 1) ^ m) T |
| have hp := size_edge_power_le_quadratic P K n m s hn hm |
| have hc₁ := constant_le_quadratic (Nat.size 160) s |
| have hc₂ := constant_le_quadratic (Nat.size T) s |
| nlinarith |
|
|
| theorem size_size_denominator_le_quadratic (P K T P₀ n m s : ℕ) |
| (hn : n ≤ s) (hm : m ≤ s) : |
| Nat.size (1000000000 * P₀ * 3 ^ n * |
| (160 * (100 * (P + n * K + 1) + 1) ^ m * T)) ≤ |
| widthCoefficient P K T P₀ * (s + 1) ^ 2 := by |
| have hmul₁ := nat_size_mul_le 1000000000 P₀ |
| have hmul₂ := nat_size_mul_le (1000000000 * P₀) (3 ^ n) |
| have hmul₃ := nat_size_mul_le (1000000000 * P₀ * 3 ^ n) |
| (160 * (100 * (P + n * K + 1) + 1) ^ m * T) |
| have hgeom := size_geometry_denominator_le_quadratic P K T n m s hn hm |
| have hQ := (size_vertex_power_le_linear n s hn).trans (linear_le_quadratic 3 s) |
| have hc₁ := constant_le_quadratic (Nat.size 1000000000) s |
| have hc₂ := constant_le_quadratic (Nat.size P₀) s |
| unfold widthCoefficient |
| nlinarith |
|
|
| theorem size_le_scaled_size_denominator (P K T P₀ n m s c v : ℕ) |
| (hn : n ≤ s) (hm : m ≤ s) |
| (hv : v ≤ c * (1000000000 * P₀ * 3 ^ n * |
| (160 * (100 * (P + n * K + 1) + 1) ^ m * T))) : |
| Nat.size v ≤ (Nat.size c + widthCoefficient P K T P₀) * (s + 1) ^ 2 := by |
| have hvsize := nat_size_mono hv |
| have hmul := nat_size_mul_le c (1000000000 * P₀ * 3 ^ n * |
| (160 * (100 * (P + n * K + 1) + 1) ^ m * T)) |
| have hden := size_size_denominator_le_quadratic P K T P₀ n m s hn hm |
| have hc := constant_le_quadratic (Nat.size c) s |
| nlinarith |
|
|
| theorem construction_cost_le_degree_eight |
| (s operations arithmetic width scan finish bins scratch : ℕ) : |
| operations * (s + 1) ^ 2 * |
| (arithmetic * (width * (s + 1) ^ 2 + 1) ^ 2 + scan * (s + 1) ^ 2) + |
| finish * (5 * (bins * (s + 1) ^ 2) * (width * (s + 1) ^ 2 + 1) + |
| scratch * (s + 1) ^ 4 + 1) ≤ |
| (operations * (arithmetic * (width + 1) ^ 2 + scan) + |
| finish * (5 * bins * (width + 1) + scratch + 1)) * (s + 1) ^ 8 := by |
| let S := s + 1 |
| have hS : 0 < S := by dsimp [S]; omega |
| have h1 : 1 ≤ S ^ 2 := by dsimp [S]; exact one_le_input_square s |
| have h24 : S ^ 2 ≤ S ^ 4 := Nat.pow_le_pow_right hS (by decide) |
| have h48 : S ^ 4 ≤ S ^ 8 := Nat.pow_le_pow_right hS (by decide) |
| have h68 : S ^ 6 ≤ S ^ 8 := Nat.pow_le_pow_right hS (by decide) |
| have hw : width * S ^ 2 + 1 ≤ (width + 1) * S ^ 2 := by nlinarith |
| have hw2 : (width * S ^ 2 + 1) ^ 2 ≤ (width + 1) ^ 2 * S ^ 4 := by |
| calc |
| _ ≤ ((width + 1) * S ^ 2) ^ 2 := Nat.pow_le_pow_left hw 2 |
| _ = _ := by ring |
| have hbody : arithmetic * (width * S ^ 2 + 1) ^ 2 + scan * S ^ 2 ≤ |
| (arithmetic * (width + 1) ^ 2 + scan) * S ^ 4 := by |
| have ha := Nat.mul_le_mul_left arithmetic hw2 |
| have hb := Nat.mul_le_mul_left scan h24 |
| nlinarith |
| have hmain : operations * S ^ 2 * |
| (arithmetic * (width * S ^ 2 + 1) ^ 2 + scan * S ^ 2) ≤ |
| (operations * (arithmetic * (width + 1) ^ 2 + scan)) * S ^ 8 := by |
| calc |
| _ ≤ operations * S ^ 2 * |
| ((arithmetic * (width + 1) ^ 2 + scan) * S ^ 4) := |
| Nat.mul_le_mul_left (operations * S ^ 2) hbody |
| _ = (operations * (arithmetic * (width + 1) ^ 2 + scan)) * S ^ 6 := by ring |
| _ ≤ _ := Nat.mul_le_mul_left _ h68 |
| have hitems : 5 * (bins * S ^ 2) * (width * S ^ 2 + 1) ≤ |
| (5 * bins * (width + 1)) * S ^ 4 := by |
| have h := Nat.mul_le_mul_left (5 * (bins * S ^ 2)) hw |
| nlinarith |
| have hfinish : finish * (5 * (bins * S ^ 2) * (width * S ^ 2 + 1) + |
| scratch * S ^ 4 + 1) ≤ |
| (finish * (5 * bins * (width + 1) + scratch + 1)) * S ^ 8 := by |
| have hinside : 5 * (bins * S ^ 2) * (width * S ^ 2 + 1) + scratch * S ^ 4 + 1 ≤ |
| (5 * bins * (width + 1) + scratch + 1) * S ^ 4 := by |
| nlinarith [h1.trans h24] |
| calc |
| _ ≤ finish * ((5 * bins * (width + 1) + scratch + 1) * S ^ 4) := |
| Nat.mul_le_mul_left finish hinside |
| _ = (finish * (5 * bins * (width + 1) + scratch + 1)) * S ^ 4 := by ring |
| _ ≤ _ := Nat.mul_le_mul_left _ h48 |
| change operations * S ^ 2 * |
| (arithmetic * (width * S ^ 2 + 1) ^ 2 + scan * S ^ 2) + |
| finish * (5 * (bins * S ^ 2) * (width * S ^ 2 + 1) + scratch * S ^ 4 + 1) ≤ _ |
| calc |
| _ ≤ (operations * (arithmetic * (width + 1) ^ 2 + scan)) * S ^ 8 + |
| (finish * (5 * bins * (width + 1) + scratch + 1)) * S ^ 8 := |
| Nat.add_le_add hmain hfinish |
| _ = _ := by dsimp [S]; ring |
| |
| end BinPackingGap.GraphPackingBounds |
| |
| end OAI |
| |
