File size: 4,824 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationWeightedReader
import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionProgram
namespace OAI
/-! # Measured shared-array readers for the compression branch -/
namespace LowSpaceSubsetSum.CompressionReader
abbrev key (P : ℤ) (mode : FilteredStream.Mode) (p : ℤ × ℤ) : ℤ × ℕ :=
(FilteredStream.key id id P mode p, 6)
abbrev State (P : ℤ) (mode : FilteredStream.Mode) (right : Array ℤ) (d : ℕ) :=
MergedReader.State (FilteredStream.key id id P mode) (FilteredStream.view (α := ℤ) right) d
private theorem row_reader (right : Array ℤ) :
RowMerge.IsReader (fun s => (FilteredStream.countedRead right s).1)
(FilteredStream.view (α := ℤ) right) := by
simpa only [FilteredStream.countedRead_value] using (FilteredStream.reader (α := ℤ) right)
def read (P : ℤ) (mode : FilteredStream.Mode) (right : Array ℤ) {d : ℕ}
(s : State P mode right d) : Option (ℤ × State P mode right d) × ℕ :=
let out := MergedReader.measuredNext (key P mode) (FilteredStream.countedRead right)
(FilteredStream.view right) (row_reader right) s
(out.1.map (fun p => (p.1.1 + p.1.2, p.2)), out.2 + 2)
theorem read_value (P : ℤ) (mode : FilteredStream.Mode) (right : Array ℤ) {d : ℕ}
(s : State P mode right d) :
(read P mode right s).1 =
mapReader (fun p : ℤ × ℤ => p.1 + p.2)
(MergedReader.next (FilteredStream.key id id P mode)
(FilteredStream.read right) (FilteredStream.view right) (FilteredStream.reader right)) s := by
have hr : (fun s => (FilteredStream.countedRead (α := ℤ) right s).1) =
FilteredStream.read (α := ℤ) right :=
funext (FilteredStream.countedRead_value right)
have hv := MergedReader.measuredNext_value (key P mode) (FilteredStream.countedRead right)
(FilteredStream.view right) (row_reader right) s
change _ = MergedReader.next (FilteredStream.key id id P mode)
(fun s => (FilteredStream.countedRead right s).1) (FilteredStream.view right) _ s at hv
have hv' : (MergedReader.measuredNext (key P mode) (FilteredStream.countedRead right)
(FilteredStream.view right) (row_reader right) s).1 =
MergedReader.next (FilteredStream.key id id P mode) (FilteredStream.read right)
(FilteredStream.view right) (FilteredStream.reader right) s := by
simpa only [hr] using hv
exact congrArg (Option.map (fun p => (p.1.1 + p.1.2, p.2))) hv'
theorem read_work (P : ℤ) (mode : FilteredStream.Mode) (right : Array ℤ) {d : ℕ}
(s : State P mode right d) : (read P mode right s).2 ≤ 20 * d + 36 := by
have h := MergedReader.measuredNext_work (key P mode) (FilteredStream.countedRead right)
(FilteredStream.view right) (row_reader right) s 6 24
(fun _ => le_rfl) (FilteredStream.countedRead_work right)
change _ + 2 ≤ _
omega
theorem read_scale {n : ℕ} (I : Instance n) (hn : 10000 ≤ n)
(P : ℤ) (mode : FilteredStream.Mode) (right : Array ℤ) {d : ℕ}
(s : State P mode right d) (hd : d ≤ n) :
(read P mode right s).2 ≤ inputScale I ^ 2 := by
have h := read_work P mode right s
have hu : n ≤ inputScale I := by unfold inputScale; omega
nlinarith only [h, hd, hn, hu]
def scalarKey (P : ℤ) (mode : FilteredStream.Mode) (x : ℤ) : ℤ × ℕ :=
match mode with
| .direct => (x % P, 2)
| .complementary t => ((t - x) % P, 3)
theorem scalarKey_work (P : ℤ) (mode : FilteredStream.Mode) (x : ℤ) :
(scalarKey P mode x).2 ≤ 3 := by cases mode <;> simp only [scalarKey] <;> omega
def snapshot (P : ℤ) (mode : FilteredStream.Mode) (right : Array ℤ) {d : ℕ}
(s : State P mode right d) : State P mode right d × ℕ :=
let out := Tournament.countedCopy 10 s.tree
have he : out.1 = s.tree := Tournament.countedCopy_value _ _
(⟨out.1, he.symm ▸ s.valid, he.symm ▸ s.aligned, he.symm ▸ s.sorted⟩, out.2)
theorem snapshot_value (P : ℤ) (mode : FilteredStream.Mode) (right : Array ℤ) {d : ℕ}
(s : State P mode right d) : (snapshot P mode right s).1 = s := by
cases s
simp only [snapshot, Tournament.countedCopy_value]
theorem snapshot_work (P : ℤ) (mode : FilteredStream.Mode) (right : Array ℤ) {d : ℕ}
(s : State P mode right d) : (snapshot P mode right s).2 ≤ 10 * 2 ^ (d + 1) := by
have he := Tournament.nodes_exact s.tree
simp only [snapshot, Tournament.countedCopy_cells]
exact Nat.mul_le_mul_left _ (by omega)
theorem groupRead_value {n : ℕ} (D : CompressionData n) (e : Equiv.Perm (Fin n))
(q : CompressionSetup.PrimeSpace n) (i : Fin 4) (mode : FilteredStream.Mode)
(s : D.GroupState e q i mode) :
(read q.val mode (D.storedRightArray e q i) s).1 = D.groupRead e q i mode s :=
read_value _ _ _ _
end LowSpaceSubsetSum.CompressionReader
end OAI
|