File size: 7,401 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 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionRowCells
import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionReaderCells
import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationInitializationCells
namespace OAI
/-! # Compression tournament construction with live storage
The already-built left and right arrays are retained by the caller. The
initializer reads them by index and creates only the padded tournament;
there is no row-array copy for an individual tournament leaf.
-/
namespace LowSpaceSubsetSum.CompressionInitializationCells
open RepresentationInitializationCells (index)
def front (left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1) (mode : FilteredStream.Mode)
(d : ℕ) (path : RowMerge.Path d) :
(Option (RowMerge.Front d (ℤ × ℤ)
(FilteredStream.Cursor (α := ℤ) right)) × ℕ) × ℕ :=
let i := index d path
if h : i.1.1 < left.size then
let row := CompressionRowCells.run right P hs mode left[i.1.1]
let out := CompressionReaderCells.rowRead right (some row.1.1)
((out.1.1.map (fun z => ⟨path,z.1,z.2⟩),i.1.2+row.1.2+out.1.2+6),
max i.2 (max row.2 out.2)+32)
else ((none,i.1.2+2),i.2+16)
theorem front_value (left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1) (mode : FilteredStream.Mode)
(d : ℕ) (path : RowMerge.Path d) :
(front left right P hs mode d path).1 = FilteredStream.measuredFront left right
(CompressionInitialization.row right P hs mode) d path := by
simp only [front, FilteredStream.measuredFront, RepresentationInitializationCells.index_value]
split <;> simp only [CompressionRowCells.value, CompressionReaderCells.rowRead_value]
theorem front_cells (left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1) (mode : FilteredStream.Mode)
(d : ℕ) (path : RowMerge.Path d) :
(front left right P hs mode d path).2 ≤ 300*(d+1) := by
have hi := RepresentationInitializationCells.index_cells d path
unfold front
dsimp only
split
· have hr := CompressionRowCells.cells right P hs mode left[(index d path).1.1]
have hq := CompressionReaderCells.rowRead_cells right
(some (CompressionRowCells.run right P hs mode left[(index d path).1.1]).1.1)
change max _ (max _ _) + 32 ≤ _
omega
· dsimp only; omega
def tree (left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1) (mode : FilteredStream.Mode) :=
MeasuredBuildCells.run 32 (fun x => CompressionReaderCells.pairKey P mode x.value)
(Nat.clog 2 left.size) (front left right P hs mode (Nat.clog 2 left.size))
theorem tree_value (left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1) (mode : FilteredStream.Mode) :
(tree left right P hs mode).1 = CompressionInitialization.tree left right P hs mode := by
rw [tree, MeasuredBuildCells.run_value]
have hk : (fun x : RowMerge.Front (Nat.clog 2 left.size) (ℤ × ℤ)
(FilteredStream.Cursor (α := ℤ) right) =>
(CompressionReaderCells.pairKey P mode x.value).1) =
(fun x => CompressionReader.key P mode x.value) := rfl
have hf : (fun path => (front left right P hs mode (Nat.clog 2 left.size) path).1) =
FilteredStream.measuredFront left right (CompressionInitialization.row right P hs mode)
(Nat.clog 2 left.size) := funext (front_value left right P hs mode _)
rw [hk,hf]
rfl
private theorem padded_pow (R : ℕ) : 2^(Nat.clog 2 R+1) ≤ 4*(R+1) := by
have h := Tournament.padded_nodes_le R
(Tournament.build (fun _ : Unit => (0 : ℤ)) (Nat.clog 2 R) (fun _ => none))
simpa only [Tournament.nodes_exact] using h
theorem tree_cells {n : ℕ} (I : Instance n) (hn : 10000 ≤ n)
(left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1) (mode : FilteredStream.Mode)
(C : ℕ) (hL : left.size ≤ C) (hC : C ≤ 2^n) :
(tree left right P hs mode).2 ≤ inputScale I^4*(C+1) := by
let d := Nat.clog 2 left.size
let u := inputScale I
have hd : d ≤ n := Nat.clog_le_of_le_pow (hL.trans hC)
have hu : n+1 ≤ u := by unfold u inputScale; omega
have ht : 2^(d+1) ≤ 4*(C+1) :=
(padded_pow left.size).trans (Nat.mul_le_mul_left 4 (Nat.add_le_add_right hL 1))
have h := @MeasuredBuildCells.run_cells
(RowMerge.Front d (ℤ × ℤ) (FilteredStream.Cursor (α := ℤ) right))
32 (fun x => CompressionReaderCells.pairKey P mode x.value) 8 (300*(d+1))
(fun _ => le_rfl) d (front left right P hs mode d)
(front_cells left right P hs mode d)
change (tree left right P hs mode).2 ≤ _ at h
have hcoef : 4*(32*2^(d+1))+8+300*(d+1)+64 ≤ 884*u*(C+1) := by
have hh := Nat.mul_le_mul_left 128 ht
nlinarith only [hh,hu,hd,hn]
have hm := Nat.mul_le_mul (show d+1 ≤ u by omega) hcoef
have hp : 884*u^2 ≤ u^4 := by
have hl : 884 ≤ u^2 := by nlinarith only [hu,hn]
have hh := Nat.mul_le_mul_right (u^2) hl
simpa only [←pow_add] using hh
change (tree left right P hs mode).2 ≤ u^4*(C+1)
calc
_ ≤ (d+1)*(4*(32*2^(d+1))+8+300*(d+1)+64) := h
_ ≤ u*(884*u*(C+1)) := hm
_ = 884*u^2*(C+1) := by ring
_ ≤ _ := Nat.mul_le_mul_right (C+1) hp
def start (left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1)
(ht : FilteredRow.SecondarySorted right id 1 P) (hP : 0 < P)
(mode : FilteredStream.Mode) :
(CompressionReader.State P mode right (Nat.clog 2 left.size) × ℕ) × ℕ :=
let out := tree left right P hs mode
let source := FilteredStream.start left right id id 1 P 0 hs ht hP mode
have he : out.1.1 = source.tree :=
(congrArg Prod.fst (tree_value left right P hs mode)).trans
(CompressionInitialization.tree_value left right P hs ht hP mode)
((⟨out.1.1,he.symm ▸ source.valid,he.symm ▸ source.aligned,he.symm ▸ source.sorted⟩,
out.1.2),out.2+16)
theorem start_value (left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1)
(ht : FilteredRow.SecondarySorted right id 1 P) (hP : 0 < P)
(mode : FilteredStream.Mode) :
(start left right P hs ht hP mode).1 =
CompressionInitialization.start left right P hs ht hP mode := by
have h := tree_value left right P hs mode
unfold start CompressionInitialization.start
simp only [h]
theorem start_cells {n : ℕ} (I : Instance n) (hn : 10000 ≤ n)
(left right : Array ℤ) (P : ℤ)
(hs : FilteredRow.PrimarySorted right id 1)
(ht : FilteredRow.SecondarySorted right id 1 P) (hP : 0 < P)
(mode : FilteredStream.Mode) (C : ℕ) (hL : left.size ≤ C) (hC : C ≤ 2^n) :
(start left right P hs ht hP mode).2 ≤ inputScale I^5*(C+1) := by
have h := tree_cells I hn left right P hs mode C hL hC
have hu : 10000 ≤ inputScale I := by unfold inputScale; omega
have hp : 16 ≤ inputScale I^4 := by
have : inputScale I ≤ inputScale I^4 := by
simpa only [pow_one] using Nat.pow_le_pow_right (show 1 ≤ inputScale I by omega)
(by decide : 1 ≤ 4)
omega
have hm : 2*inputScale I^4 ≤ inputScale I^5 := by
calc
_ ≤ inputScale I*inputScale I^4 := Nat.mul_le_mul_right _ (by omega)
_ = _ := (pow_succ' _ _).symm
have hb := Nat.mul_le_mul_right (C+1) hm
change _+16 ≤ _
nlinarith only [h,hp,hb]
end LowSpaceSubsetSum.CompressionInitializationCells
end OAI
|