File size: 5,759 Bytes
5d5048e | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 | import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionInitializationCells
import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionContext
import OAI.Combinatorics.LowSpaceSubsetSum.Storage.MeasuredSortCells
namespace OAI
/-! # Preparing a shared compression reader context
Sort the right array once, then initialize rows by reading that same array.
The trace includes the old array, list view and returned sorted array, as
well as the direct tournament construction.
-/
namespace LowSpaceSubsetSum.CompressionContextCells
open CompressionContext (Context)
def compare (P : ℤ) (x y : ℤ) : (Bool × ℕ) × ℕ :=
(CompressionContext.compare P x y,8)
def sort (P : ℤ) (xs : Array ℤ) : (Array ℤ × ℕ) × ℕ :=
let out := MeasuredSortCells.run 1 (compare P) (Nat.clog 2 xs.size) xs.toList
((out.1.1.toArray,out.1.2+xs.size+1),out.2+3*(xs.size+1)+16)
theorem sort_value (P : ℤ) (xs : Array ℤ) :
(sort P xs).1 = CompressionContext.sort P xs := by
simp only [sort, MeasuredSortCells.run_value, compare, CompressionContext.sort,
MeasuredSort.sort, Array.length_toList]
theorem sort_size (P : ℤ) (xs : Array ℤ) : (sort P xs).1.1.size = xs.size := by
rw [sort_value, CompressionContext.sort_size]
theorem sort_cells {n : ℕ} (I : Instance n) (hn : 10000 ≤ n)
(P : ℤ) (xs : Array ℤ) (C : ℕ) (hsize : xs.size ≤ C) (hC : C ≤ 2^n) :
(sort P xs).2 ≤ inputScale I^3*(C+1) := by
let u := inputScale I
have hu : n+1 ≤ u := by unfold u inputScale; omega
have hd := Nat.clog_le_of_le_pow (hsize.trans hC)
have h := MeasuredSortCells.run_cells 1 (compare P) 8 (fun _ _ => le_rfl)
(Nat.clog 2 xs.size) xs.toList
simp only [Array.length_toList] at h
have hcoef : 24*(1+2)*(xs.size+1)+8 ≤ 80*(C+1) := by omega
have hm := h.trans (Nat.mul_le_mul (show Nat.clog 2 xs.size+1 ≤ u by omega) hcoef)
have hs : (sort P xs).2 ≤ 100*u*(C+1) := by
change _+3*(xs.size+1)+16 ≤ _
nlinarith only [hm,hu,hsize,hn]
have hp : 100*u ≤ u^3 := by
have hl : 100 ≤ u^2 := by nlinarith only [hu,hn]
have hm := Nat.mul_le_mul_right u hl
simpa only [pow_succ] using hm
exact hs.trans (Nat.mul_le_mul_right (C+1) hp)
private theorem primary (P : ℤ) (xs : Array ℤ) :
FilteredRow.PrimarySorted (sort P xs).1.1 id 1 := by
rw [sort_value, CompressionContext.sort_value]
exact ResidueSort.primary _ _ _ _
private theorem secondary (P : ℤ) (xs : Array ℤ) :
FilteredRow.SecondarySorted (sort P xs).1.1 id 1 P := by
rw [sort_value, CompressionContext.sort_value]
exact ResidueSort.secondary _ _ _ _
def fromArrays (left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1)
(ht : FilteredRow.SecondarySorted right id 1 P) (hP : 0 < P)
(mode : FilteredStream.Mode) : (Context P mode × ℕ) × ℕ :=
let out := CompressionInitializationCells.start left right P hs ht hP mode
((⟨right,Nat.clog 2 left.size,out.1.1⟩,out.1.2),out.2+4*(left.size+right.size+1)+32)
theorem fromArrays_value (left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1)
(ht : FilteredRow.SecondarySorted right id 1 P) (hP : 0 < P)
(mode : FilteredStream.Mode) :
(fromArrays left right P hs ht hP mode).1 =
CompressionContext.fromArrays left right P hs ht hP mode := by
simp only [fromArrays,CompressionInitializationCells.start_value,CompressionContext.fromArrays]
def build (left right : Array ℤ) (P : ℤ) (hP : 0 < P) (mode : FilteredStream.Mode) :
(Context P mode × ℕ) × ℕ :=
let sorted := sort P right
let out := fromArrays left sorted.1.1 P (primary P right) (secondary P right) hP mode
((out.1.1,sorted.1.2+out.1.2+2),sorted.2+out.2+4*(left.size+right.size+1)+32)
theorem build_value (left right : Array ℤ) (P : ℤ) (hP : 0 < P) (mode : FilteredStream.Mode) :
(build left right P hP mode).1 = CompressionContext.build left right P hP mode := by
simp only [build,fromArrays_value,sort_value,CompressionContext.build]
theorem build_cells {n : ℕ} (I : Instance n) (hn : 10000 ≤ n)
(left right : Array ℤ) (P : ℤ) (hP : 0 < P) (mode : FilteredStream.Mode)
(C : ℕ) (hL : left.size ≤ C) (hR : right.size ≤ C) (hC : C ≤ 2^n) :
(build left right P hP mode).2 ≤ inputScale I^6*(C+1) := by
let u := inputScale I
have hu : 10000 ≤ u := by unfold u inputScale; omega
have hs := sort_cells I hn P right C hR hC
have hi := CompressionInitializationCells.start_cells I hn left (sort P right).1.1 P
(primary P right) (secondary P right) hP mode C hL hC
have hlen : (sort P right).1.1.size ≤ C := (sort_size P right).le.trans hR
have hp : u^3 ≤ u^5 := Nat.pow_le_pow_right (by omega) (by decide)
have hpoly : 128 ≤ u^5 := by
have : u ≤ u^5 := by
simpa only [pow_one] using Nat.pow_le_pow_right (show 1 ≤ u by omega)
(by decide : 1 ≤ 5)
omega
have hm : 4*u^5 ≤ u^6 := by
calc
_ ≤ u*u^5 := Nat.mul_le_mul_right _ (by omega)
_ = _ := (pow_succ' _ _).symm
change _ ≤ u^6*(C+1)
change (sort P right).2 + ((CompressionInitializationCells.start left (sort P right).1.1
P (primary P right) (secondary P right) hP mode).2+
4*(left.size+(sort P right).1.1.size+1)+32)+4*(left.size+right.size+1)+32 ≤ _
have hsmall : (sort P right).2 + ((CompressionInitializationCells.start left (sort P right).1.1
P (primary P right) (secondary P right) hP mode).2+
4*(left.size+(sort P right).1.1.size+1)+32)+4*(left.size+right.size+1)+32 ≤
4*u^5*(C+1) := by
nlinarith only [hs,hi,hL,hR,hlen,hpoly,Nat.mul_le_mul_right (C+1) hp]
exact hsmall.trans (Nat.mul_le_mul_right (C+1) hm)
end LowSpaceSubsetSum.CompressionContextCells
end OAI
|