File size: 4,694 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 | import OAI.Combinatorics.LowSpaceSubsetSum.Storage.PermutationArray
import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionArrayBuild
namespace OAI
/-! # Constructing the ten compression domains from a permutation array
The scan reads each domain's original positions, maps them by one array
lookup, and sorts the resulting indices into the canonical order expected
by raw subset enumeration.
-/
namespace LowSpaceSubsetSum.CompressionDomains
variable {n : ℕ}
def positions (S : Finset (Fin n)) : List (Fin n) :=
(List.finRange n).filter (fun i => decide (i ∈ S))
def unsorted (v : Vector (Fin n) n) (S : Finset (Fin n)) : List (Fin n) :=
(positions S).map (fun i => v[i.val])
theorem positions_length (S : Finset (Fin n)) : (positions S).length ≤ n := by
simpa only [positions, List.length_finRange] using
List.length_filter_le (fun i => decide (i ∈ S)) (List.finRange n)
theorem unsorted_source (v : Vector (Fin n) n) (e : Equiv.Perm (Fin n))
(hv : ∀ i : Fin n, v[i.val] = e i) (S : Finset (Fin n)) :
(unsorted v S).toFinset = permuteSubset e S := by
ext x
simp only [unsorted, List.mem_toFinset, List.mem_map, positions, List.mem_filter,
List.mem_finRange, true_and, decide_eq_true_eq, permuteSubset, Finset.mem_map]
simp_rw [hv]
rfl
theorem unsorted_nodup (v : Vector (Fin n) n) (e : Equiv.Perm (Fin n))
(hv : ∀ i : Fin n, v[i.val] = e i) (S : Finset (Fin n)) : (unsorted v S).Nodup := by
unfold unsorted
have hf : (fun i : Fin n => v[i.val]) = e := funext hv
rw [hf]
exact (List.nodup_finRange n).filter _ |>.map e.injective
def domain (v : Vector (Fin n) n) (S : Finset (Fin n)) : List (Fin n) × ℕ :=
let xs := unsorted v S
let sorted := MeasuredSort.sort (fun x y : Fin n => (decide (x ≤ y), 1)) xs
(sorted.1, sorted.2 + 8 * (n + 1) ^ 2)
theorem domain_value (v : Vector (Fin n) n) (e : Equiv.Perm (Fin n))
(hv : ∀ i : Fin n, v[i.val] = e i) (S : Finset (Fin n)) :
(domain v S).1 = (permuteSubset e S).sort (· ≤ ·) := by
rw [domain, MeasuredSort.sort_value]
have hp := List.mergeSort_perm (unsorted v S) (fun x y => decide (x ≤ y))
have hn := hp.nodup_iff.mpr (unsorted_nodup v e hv S)
have hs := List.pairwise_mergeSort' (· ≤ ·) (unsorted v S)
have hh := (List.toFinset_sort (r := (· ≤ ·)) hn).mpr hs
have hset : ((unsorted v S).mergeSort (fun x y => decide (x ≤ y))).toFinset =
permuteSubset e S := by
have he : ((unsorted v S).mergeSort (fun x y => decide (x ≤ y))).toFinset =
(unsorted v S).toFinset := by
ext x
simp only [List.mem_toFinset, hp.mem_iff]
exact he.trans (unsorted_source v e hv S)
rw [hset] at hh
exact hh.symm
theorem domain_work (v : Vector (Fin n) n) (S : Finset (Fin n)) :
(domain v S).2 ≤ 40 * (n + 1) ^ 2 := by
have hl : (unsorted v S).length ≤ n := by
simpa only [unsorted, List.length_map] using positions_length S
have hpow : n ≤ 2 ^ n := (Nat.lt_two_pow_self (n := n)).le
have hs := MeasuredSort.sort_work (fun x y : Fin n => (decide (x ≤ y), 1)) 1
(fun _ _ => le_rfl) (unsorted v S) n (hl.trans hpow)
change _ + 8 * (n + 1) ^ 2 ≤ _
nlinarith only [hs, hl]
def prepare (v : Vector (Fin n) n) : CompressionArrayBuild.Blocks n × ℕ :=
let compact := Vector.ofFn (fun i : Fin 7 => domain v (compressionBlock n i))
let left := domain v (compressionLeftRaw n)
let right := Vector.ofFn (fun i : Fin 2 => domain v (compressionRightRaw n i))
(⟨fun i => compact[i.val].1, left.1, fun i => right[i.val].1⟩,
(∑ i : Fin 7, compact[i.val].2) + left.2 + (∑ i : Fin 2, right[i.val].2) + 20)
theorem prepare_value (D : CompressionData n) (v : Vector (Fin n) n) (e : Equiv.Perm (Fin n))
(hv : ∀ i : Fin n, v[i.val] = e i) :
(prepare v).1 = CompressionArrayBuild.source D e := by
simp only [prepare, Vector.getElem_ofFn, domain_value v e hv,
CompressionArrayBuild.source, CompressionData.block, CompressionData.leftRaw,
CompressionData.rightRaw]
theorem prepare_work (v : Vector (Fin n) n) : (prepare v).2 ≤ 500 * (n + 1) ^ 2 := by
have hc := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 7))) =>
domain_work v (compressionBlock n i))
have hr := Finset.sum_le_sum (fun i (_ : i ∈ (Finset.univ : Finset (Fin 2))) =>
domain_work v (compressionRightRaw n i))
have hl := domain_work v (compressionLeftRaw n)
have hpos : 1 ≤ (n + 1) ^ 2 := Nat.one_le_pow _ _ (by omega)
simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] at hc hr
simp only [prepare, Vector.getElem_ofFn, Fin.eta]
nlinarith only [hc, hr, hl, hpos]
end LowSpaceSubsetSum.CompressionDomains
end OAI
|