openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Compression /CompressionQueryBounds.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Compression.CompressionWorkBounds | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.ResidueMatchAccounting | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Streams.DictionaryPrefixes | |
| namespace OAI | |
| /-! # Actual compression join queries across the deterministic residue loop -/ | |
| noncomputable section | |
| namespace LowSpaceSubsetSum | |
| open scoped BigOperators | |
| namespace MatchPotential | |
| theorem count_perm {α β : Type*} (k₁ : α → ℤ) (k₂ : β → ℤ) | |
| {xs xs' : List α} {ys ys' : List β} (hx : xs.Perm xs') (hy : ys.Perm ys') : | |
| count k₁ k₂ xs ys = count k₁ k₂ xs' ys' := by | |
| rw [count_eq_filter_product_length, count_eq_filter_product_length] | |
| exact ((hx.product hy).filter _).length_eq | |
| end MatchPotential | |
| namespace CompressionData | |
| variable {n : ℕ} (D : CompressionData n) | |
| theorem groupOutput_perm (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) | |
| (i : Fin 4) (mode : FilteredStream.Mode) : | |
| (D.groupOutput e q i mode (D.groupStart e q i mode)).Perm (D.groupList e i) := by | |
| have hp := (FilteredStream.sorted_output_perm | |
| (D.storedFirst e i).toArray (D.storedSecond e i).toArray id id 1 q.val 0 | |
| (by exact_mod_cast (primeRange_prime q.property).pos) mode).map | |
| (fun p : ℤ × ℤ => p.1 + p.2) | |
| simpa only [groupOutput, groupStart, storedRightArray, groupList, pairSumList, id_eq, | |
| Int.emod_one, decide_true, List.filter_true, List.toList_toArray, SProd.sprod] using hp | |
| def leftJoin (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) | |
| (z : Fin q.val) (fuel : ℕ) := | |
| StreamJoin.run (D.groupRead e q 0 .direct) (fun x => x % (q.val : ℤ)) | |
| (D.groupRead e q 1 (.complementary z.val)) (fun y => ((z.val : ℤ) - y) % q.val) | |
| (BinaryTrie.callback (compressionDictionaryCapacity n) | |
| (fun x y => WeightEncoding.weightKey D.input (x + y))) | |
| B (D.streamLength e 0) (D.streamLength e 1) fuel | |
| (D.groupStart e q 0 .direct) (D.groupStart e q 1 (.complementary z.val)) | |
| ⟨.empty, false, 0⟩ | |
| def rightJoin (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) | |
| (z : Fin q.val) (tree : BinaryTrie.Tree) (fuel : ℕ) := | |
| let target := (D.input.target : ℤ) - z.val | |
| StreamJoin.run (D.groupRead e q 2 .direct) (fun x => x % (q.val : ℤ)) | |
| (D.groupRead e q 3 (.complementary target)) (fun y => (target - y) % q.val) | |
| (StreamWitness.remember (fun x y => BinaryTrie.contains tree | |
| (WeightEncoding.weightKey D.input ((D.input.target : ℤ) - (x + y))))) | |
| B (D.streamLength e 2) (D.streamLength e 3) fuel | |
| (D.groupStart e q 2 .direct) (D.groupStart e q 3 (.complementary target)) false | |
| theorem leftJoin_user (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) | |
| (z : Fin q.val) : | |
| (D.leftJoin B e q z (D.streamLength e 0 + D.streamLength e 1 + 1)).user = | |
| D.actualLeftDictionary B e q z := rfl | |
| theorem rightJoin_user (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) | |
| (z : Fin q.val) (tree : BinaryTrie.Tree) : | |
| (D.rightJoin B e q z tree (D.streamLength e 2 + D.streamLength e 3 + 1)).user = | |
| D.actualRightHit B e q z tree := rfl | |
| def leftPotential (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) (z : Fin q.val) : ℕ := | |
| MatchPotential.count (fun x => x % (q.val : ℤ)) (fun y => ((z.val : ℤ) - y) % q.val) | |
| (D.groupList e 0) (D.groupList e 1) | |
| def rightPotential (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) (z : Fin q.val) : ℕ := | |
| MatchPotential.count (fun x => x % (q.val : ℤ)) | |
| (fun y => ((D.input.target : ℤ) - z.val - y) % q.val) | |
| (D.groupList e 2) (D.groupList e 3) | |
| theorem leftJoin_bounds (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) | |
| (z : Fin q.val) (fuel : ℕ) : | |
| (D.leftJoin B e q z fuel).queries ≤ | |
| 6 * (D.streamLength e 0 + D.streamLength e 1) + D.leftPotential e q z + 2 ∧ | |
| (D.leftJoin B e q z fuel).reports ≤ D.leftPotential e q z ∧ | |
| B * (D.leftJoin B e q z fuel).copies ≤ 2 * D.leftPotential e q z := by | |
| have h := StreamJoin.run_bounds | |
| (D.groupRead e q 0 .direct) (fun x => x % (q.val : ℤ)) | |
| (D.groupRead e q 1 (.complementary z.val)) (fun y => ((z.val : ℤ) - y) % q.val) | |
| (BinaryTrie.callback (compressionDictionaryCapacity n) | |
| (fun x y => WeightEncoding.weightKey D.input (x + y))) (fun _ _ _ => rfl) | |
| (D.groupOutput e q 0 .direct) (D.groupRead_law e q 0 .direct) | |
| (D.groupOutput e q 1 (.complementary z.val)) (D.groupRead_law e q 1 (.complementary z.val)) | |
| B (D.streamLength e 0) (D.streamLength e 1) fuel | |
| (D.groupStart e q 0 .direct) (D.groupStart e q 1 (.complementary z.val)) ⟨.empty, false, 0⟩ | |
| (D.groupOutput_sorted e q 0 .direct) (D.groupOutput_sorted e q 1 (.complementary z.val)) | |
| (by rw [D.initial_output_length]) (by rw [D.initial_output_length]) | |
| have hp := MatchPotential.count_perm | |
| (fun x => x % (q.val : ℤ)) (fun y => ((z.val : ℤ) - y) % q.val) | |
| (D.groupOutput_perm e q 0 .direct) (D.groupOutput_perm e q 1 (.complementary z.val)) | |
| simpa only [leftJoin, leftPotential, D.initial_output_length, hp] using h | |
| theorem rightJoin_bounds (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) | |
| (z : Fin q.val) (tree : BinaryTrie.Tree) (fuel : ℕ) : | |
| (D.rightJoin B e q z tree fuel).queries ≤ | |
| 6 * (D.streamLength e 2 + D.streamLength e 3) + D.rightPotential e q z + 2 ∧ | |
| (D.rightJoin B e q z tree fuel).reports ≤ D.rightPotential e q z ∧ | |
| B * (D.rightJoin B e q z tree fuel).copies ≤ 2 * D.rightPotential e q z := by | |
| let target := (D.input.target : ℤ) - z.val | |
| have h := StreamJoin.run_bounds | |
| (D.groupRead e q 2 .direct) (fun x => x % (q.val : ℤ)) | |
| (D.groupRead e q 3 (.complementary target)) (fun y => (target - y) % q.val) | |
| (StreamWitness.remember (fun x y => BinaryTrie.contains tree | |
| (WeightEncoding.weightKey D.input ((D.input.target : ℤ) - (x + y))))) (fun _ _ _ => rfl) | |
| (D.groupOutput e q 2 .direct) (D.groupRead_law e q 2 .direct) | |
| (D.groupOutput e q 3 (.complementary target)) (D.groupRead_law e q 3 (.complementary target)) | |
| B (D.streamLength e 2) (D.streamLength e 3) fuel | |
| (D.groupStart e q 2 .direct) (D.groupStart e q 3 (.complementary target)) false | |
| (D.groupOutput_sorted e q 2 .direct) (D.groupOutput_sorted e q 3 (.complementary target)) | |
| (by rw [D.initial_output_length]) (by rw [D.initial_output_length]) | |
| have hp := MatchPotential.count_perm | |
| (fun x => x % (q.val : ℤ)) (fun y => (target - y) % q.val) | |
| (D.groupOutput_perm e q 2 .direct) (D.groupOutput_perm e q 3 (.complementary target)) | |
| simpa only [rightJoin, rightPotential, target, D.initial_output_length, hp] using h | |
| theorem sum_leftPotential (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) : | |
| (∑ z, D.leftPotential e q z) = D.streamLength e 0 * D.streamLength e 1 := by | |
| have h := ResidueMatchAccounting.sum_potential (primeRange_prime q.property).pos | |
| id id (D.groupList e 0) (D.groupList e 1) | |
| simpa only [leftPotential, groupList, pairSumList_length, streamLength, id_eq] using h | |
| theorem sum_rightPotential (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) : | |
| (∑ z, D.rightPotential e q z) = D.streamLength e 2 * D.streamLength e 3 := by | |
| have h := ResidueMatchAccounting.sum_complementary_potential (primeRange_prime q.property).pos | |
| (D.input.target : ℤ) id id (D.groupList e 2) (D.groupList e 3) | |
| simpa only [rightPotential, groupList, pairSumList_length, streamLength, id_eq] using h | |
| /-- The query counter of the actually enabled two joins. The right join is | |
| skipped on overflow, and all joins are skipped when a compact-list test fails. -/ | |
| def residueQueries (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) | |
| (z : Fin q.val) : ℕ := | |
| if D.compactTests e then | |
| let left := D.leftJoin B e q z (D.streamLength e 0 + D.streamLength e 1 + 1) | |
| left.queries + if left.user.overflow then 0 else | |
| (D.rightJoin B e q z left.user.tree (D.streamLength e 2 + D.streamLength e 3 + 1)).queries | |
| else 0 | |
| theorem residueQueries_le (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) | |
| (z : Fin q.val) : | |
| D.residueQueries B e q z ≤ 6 * (∑ i : Fin 4, D.streamLength e i) + | |
| D.leftPotential e q z + D.rightPotential e q z + 4 := by | |
| have hl := (D.leftJoin_bounds B e q z (D.streamLength e 0 + D.streamLength e 1 + 1)).1 | |
| have hr := (D.rightJoin_bounds B e q z | |
| (D.leftJoin B e q z (D.streamLength e 0 + D.streamLength e 1 + 1)).user.tree | |
| (D.streamLength e 2 + D.streamLength e 3 + 1)).1 | |
| simp only [residueQueries] | |
| split | |
| · split <;> simp only [Fin.sum_univ_four] <;> omega | |
| · omega | |
| theorem sum_residueQueries_le (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) : | |
| (∑ z, D.residueQueries B e q z) ≤ | |
| 6 * (q.val * ∑ i : Fin 4, D.streamLength e i) + | |
| D.streamLength e 0 * D.streamLength e 1 + | |
| D.streamLength e 2 * D.streamLength e 3 + 4 * q.val := by | |
| apply (Finset.sum_le_sum (fun z _ => D.residueQueries_le B e q z)).trans_eq | |
| rw [Finset.sum_add_distrib, Finset.sum_add_distrib, Finset.sum_add_distrib, | |
| D.sum_leftPotential, D.sum_rightPotential] | |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul] | |
| ring | |
| theorem queries_half_exponential (B : ℕ) (e : Equiv.Perm (Fin n)) | |
| (q : CompressionSetup.PrimeSpace n) (hn : 2000 ≤ n) : | |
| ((∑ z, D.residueQueries B e q z) : ℝ) ≤ 30 * (2 : ℝ) ^ ((n : ℝ) / 2) := by | |
| by_cases he : D.compactTests e = true | |
| · have hs : ((q.val * ∑ i : Fin 4, D.streamLength e i : ℕ) : ℝ) ≤ | |
| 4 * (2 : ℝ) ^ ((n : ℝ) / 2) := by | |
| rw [Finset.mul_sum, Nat.cast_sum] | |
| apply (Finset.sum_le_sum (fun i _ => D.prime_regeneration_bound e he hn q i)).trans_eq | |
| simp | |
| have hp := D.matching_product_bound e he hn | |
| have hq : (q.val : ℝ) ≤ (2 : ℝ) ^ ((n : ℝ) / 2) := by | |
| have hq' : q.val ≤ 2 ^ compressionPrimeExponent n := | |
| Nat.le_of_mem_primesLE (Finset.mem_filter.mp q.property).1 | |
| apply (Nat.cast_le.mpr hq').trans | |
| rw [Nat.cast_pow, Nat.cast_ofNat, ← Real.rpow_natCast] | |
| apply Real.rpow_le_rpow_of_exponent_le (by norm_num) | |
| have hfloor : 1000 * compressionPrimeExponent n ≤ 249 * n := by | |
| unfold compressionPrimeExponent | |
| omega | |
| have hR : (1000 : ℝ) * compressionPrimeExponent n ≤ 249 * n := by exact_mod_cast hfloor | |
| linarith | |
| have hledger : ((∑ z, D.residueQueries B e q z) : ℝ) ≤ | |
| 6 * (q.val * ∑ i : Fin 4, D.streamLength e i : ℕ) + | |
| (D.streamLength e 0 * D.streamLength e 1 : ℕ) + | |
| (D.streamLength e 2 * D.streamLength e 3 : ℕ) + 4 * (q.val : ℝ) := by | |
| exact_mod_cast D.sum_residueQueries_le B e q | |
| linarith [hp.1, hp.2] | |
| · have hf : D.compactTests e = false := Bool.eq_false_iff.mpr he | |
| simp only [residueQueries, hf, Bool.false_eq_true, ↓reduceIte, Finset.sum_const_zero, Nat.cast_zero] | |
| positivity | |
| /-- Capacity is respected even at arbitrary stopped control prefixes. -/ | |
| theorem leftJoin_nodes (B : ℕ) (e : Equiv.Perm (Fin n)) (q : CompressionSetup.PrimeSpace n) | |
| (z : Fin q.val) (fuel : ℕ) : | |
| BinaryTrie.nodes (D.leftJoin B e q z fuel).user.tree ≤ | |
| (WeightEncoding.weightWidth D.input + 1) * (compressionDictionaryCapacity n + 1) := by | |
| exact DictionaryPrefixes.stopped_nodes | |
| (D.groupRead e q 0 .direct) (fun x => x % (q.val : ℤ)) | |
| (D.groupRead e q 1 (.complementary z.val)) (fun y => ((z.val : ℤ) - y) % q.val) | |
| (fun x y => WeightEncoding.weightKey D.input (x + y)) | |
| (fun x y => WeightEncoding.weightKey_length D.input (x + y)) | |
| B (D.streamLength e 0) (D.streamLength e 1) fuel | |
| (D.groupStart e q 0 .direct) (D.groupStart e q 1 (.complementary z.val)) | |
| end CompressionData | |
| end LowSpaceSubsetSum | |
| end | |
| end OAI | |