File size: 5,041 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Storage.IntervalDomainExecution
import OAI.Combinatorics.LowSpaceSubsetSum.Storage.MeasuredFilterCells
import OAI.Combinatorics.LowSpaceSubsetSum.Storage.MeasuredSortCells
namespace OAI
/-! # Live storage for arithmetic interval domain construction
The scan tests only the two interval endpoints. It filters the bounded
index list, looks up the stored permutation, and sorts the resulting
indices. The immutable permutation array is shared throughout.
-/
namespace LowSpaceSubsetSum.IntervalDomainCells
variable {n : ℕ}
def test (start len : ℕ) (i : Fin n) : (Bool × ℕ) × ℕ :=
((decide (start ≤ i.val ∧ i.val < start+len), 2), 8)
def positions (n start len : ℕ) : List (Fin n) × ℕ :=
let r := MeasuredFilterCells.run (test start len) (List.finRange n)
(r.1.1, r.2+2*n+8)
theorem positions_value (n start len : ℕ) :
(positions n start len).1 = IntervalDomainExecution.positions n start len := by
simp only [positions, MeasuredFilterCells.run_value, MeasuredFilter.runAcc_value,
List.reverse_nil, List.nil_append, test, IntervalDomainExecution.positions]
theorem positions_length (n start len : ℕ) : (positions n start len).1.length ≤ n := by
rw [positions_value]
simpa only [IntervalDomainExecution.positions, List.length_finRange] using
List.length_filter_le (fun i : Fin n => decide (start ≤ i.val ∧ i.val < start+len))
(List.finRange n)
theorem positions_length_interval (n start len : ℕ) (h : start+len ≤ n) :
(positions n start len).1.length = len := by
rw [positions_value]
have hn := (List.nodup_finRange n).filter
(fun i : Fin n => decide (start ≤ i.val ∧ i.val < start+len))
have hs : (IntervalDomainExecution.positions n start len).toFinset =
indexInterval n start len := by
ext i
simp only [IntervalDomainExecution.positions, List.mem_toFinset, List.mem_filter,
List.mem_finRange, true_and, decide_eq_true_eq, indexInterval, Finset.mem_filter,
Finset.mem_univ]
have hc := List.toFinset_card_of_nodup hn
change (IntervalDomainExecution.positions n start len).toFinset.card =
(IntervalDomainExecution.positions n start len).length at hc
rw [hs, indexInterval_card h] at hc
exact hc.symm
theorem positions_cells (n start len : ℕ) : (positions n start len).2 ≤ 4*n+20 := by
have h := MeasuredFilterCells.run_cells (test start len) 8 (fun _ => le_rfl) (List.finRange n)
simp only [List.length_finRange] at h
change _+2*n+8 ≤ _
omega
def map (v : Vector (Fin n) n) : List (Fin n) → List (Fin n) × ℕ
| [] => ([], 4)
| i :: xs =>
let r := map v xs
(v[i.val]::r.1, r.2+8)
theorem map_value (v : Vector (Fin n) n) (xs : List (Fin n)) :
(map v xs).1 = xs.map (fun i => v[i.val]) := by
induction xs with
| nil => rfl
| cons i xs ih => simp only [map, List.map_cons, ih]
theorem map_cells (v : Vector (Fin n) n) (xs : List (Fin n)) :
(map v xs).2 ≤ 8*xs.length+4 := by
induction xs with
| nil => exact le_rfl
| cons i xs ih => simp only [map, List.length_cons]; omega
def compare (x y : Fin n) : (Bool × ℕ) × ℕ := ((decide (x ≤ y), 1), 4)
def run (v : Vector (Fin n) n) (start len : ℕ) : (List (Fin n) × ℕ) × ℕ :=
let ps := positions n start len
let xs := map v ps.1
let sorted := MeasuredSortCells.run 1 compare (Nat.clog 2 xs.1.length) xs.1
((sorted.1.1, sorted.1.2+8*(n+1)^2), ps.2+xs.2+sorted.2+4*(n+1))
theorem run_value (v : Vector (Fin n) n) (start len : ℕ) :
(run v start len).1 = IntervalDomainExecution.run v start len := by
simp only [run, MeasuredSortCells.run_value, map_value, positions_value,
IntervalDomainExecution.run, MeasuredSort.sort, compare]
theorem run_length (v : Vector (Fin n) n) (start len : ℕ) (h : start+len ≤ n) :
(run v start len).1.1.length = len := by
rw [run_value]
simp only [IntervalDomainExecution.run, MeasuredSort.sort_value, List.length_mergeSort,
List.length_map]
simpa only [positions_value] using positions_length_interval n start len h
theorem run_cells (v : Vector (Fin n) n) (start len : ℕ) :
(run v start len).2 ≤ 128*(n+1)^2 := by
let ps := positions n start len
let xs := map v ps.1
have hp := positions_cells n start len
have hm := map_cells v ps.1
have hl := positions_length n start len
have hxs : xs.1.length ≤ n := by
dsimp only [xs]
rw [map_value, List.length_map]
exact hl
have hd : Nat.clog 2 xs.1.length ≤ n :=
Nat.clog_le_of_le_pow (hxs.trans (Nat.lt_two_pow_self (n := n)).le)
have hs := MeasuredSortCells.run_cells 1 compare 4 (fun _ _ => le_rfl)
(Nat.clog 2 xs.1.length) xs.1
have hcoef : 24*(1+2)*(xs.1.length+1)+4 ≤ 76*(n+1) := by omega
have hs' := hs.trans (Nat.mul_le_mul (show Nat.clog 2 xs.1.length+1 ≤ n+1 by omega) hcoef)
change ps.2+xs.2+_+4*(n+1) ≤ _
change ps.2 ≤ _ at hp
change xs.2 ≤ _ at hm
change ps.1.length ≤ n at hl
nlinarith only [hp, hm, hl, hs']
end LowSpaceSubsetSum.IntervalDomainCells
end OAI
|