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