openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Compression /CompressionReader.lean
| 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 | |