openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Representation /RepresentationKeys.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedWeights | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationWeightedReader | |
| namespace OAI | |
| /-! # Polynomial-cost representation keys on bounded stored masks | |
| The lists below are the stored mask representation. Their intrinsic length | |
| bound applies to every value of the type, independently of successful | |
| sampling or membership in an enumerated universe. Finite sets occur only in | |
| the semantic map. All signed membership tests are executed on stored lists. | |
| -/ | |
| namespace LowSpaceSubsetSum | |
| structure IndexedMask (n : ℕ) where | |
| indices : List (Fin n) | |
| length_le : indices.length ≤ n | |
| namespace IndexedMask | |
| variable {n : ℕ} | |
| def semantic (M : IndexedMask n) : Finset (Fin n) := M.indices.toFinset | |
| /-- A canonical representation for the semantic correspondence. Enumeration | |
| can instead retain its already generated sublist, with no sorting step. -/ | |
| def ofFinset (S : Finset (Fin n)) : IndexedMask n := | |
| ⟨S.sort (· ≤ ·), by simpa using Finset.card_le_univ S⟩ | |
| @[simp] theorem ofFinset_semantic (S : Finset (Fin n)) : | |
| (ofFinset S).semantic = S := by simp [ofFinset, semantic] | |
| end IndexedMask | |
| structure LeafRecord (n : ℕ) where | |
| top : IndexedMask n | |
| localMask : IndexedMask n | |
| background : IndexedMask n | |
| namespace LeafRecord | |
| variable {n : ℕ} | |
| def semantic (x : LeafRecord n) : RepresentationLeaf.Occurrence (Fin n) := | |
| ((x.top.semantic, x.localMask.semantic), x.background.semantic) | |
| def ofOccurrence (x : RepresentationLeaf.Occurrence (Fin n)) : LeafRecord n := | |
| ⟨IndexedMask.ofFinset x.1.1, IndexedMask.ofFinset x.1.2, IndexedMask.ofFinset x.2⟩ | |
| @[simp] theorem ofOccurrence_semantic (x : RepresentationLeaf.Occurrence (Fin n)) : | |
| (ofOccurrence x).semantic = x := by simp [ofOccurrence, semantic] | |
| end LeafRecord | |
| namespace RepresentationKeys | |
| variable {n : ℕ} | |
| /-- Indexed input lookup, one explicit sign membership test, and negation. -/ | |
| def signedAt (I : Instance n) (F : IndexedMask n) (i : Fin n) : ℤ × ℕ := | |
| let hit := CountedWeights.member i F.indices | |
| (if hit.1 then -(I.values i : ℤ) else (I.values i : ℤ), hit.2 + 2) | |
| theorem signedAt_value (I : Instance n) (F : IndexedMask n) (i : Fin n) : | |
| (signedAt I F i).1 = flip (fun i => (I.values i : ℤ)) F.semantic i := by | |
| simp only [signedAt, CountedWeights.member_value, IndexedMask.semantic, | |
| List.mem_toFinset, flip, decide_eq_true_eq] | |
| theorem signedAt_work (I : Instance n) (F : IndexedMask n) (i : Fin n) : | |
| (signedAt I F i).2 ≤ n + 3 := by | |
| have h := CountedWeights.member_work i F.indices | |
| have hf := F.length_le | |
| change (CountedWeights.member i F.indices).2 + 2 ≤ _ | |
| omega | |
| /-- All input indices are visited; both membership and signed-input lookup | |
| are charged even at indices outside the selected mask. -/ | |
| def sumIndices (I : Instance n) (F M : IndexedMask n) : List (Fin n) → ℤ × ℕ | |
| | [] => (0, 1) | |
| | i :: xs => | |
| let selected := CountedWeights.member i M.indices | |
| let term := signedAt I F i | |
| let rest := sumIndices I F M xs | |
| ((if selected.1 then term.1 else 0) + rest.1, | |
| selected.2 + term.2 + rest.2 + 3) | |
| theorem sumIndices_value (I : Instance n) (F M : IndexedMask n) (xs : List (Fin n)) : | |
| (sumIndices I F M xs).1 = | |
| (xs.map (fun i => if i ∈ M.semantic then | |
| flip (fun i => (I.values i : ℤ)) F.semantic i else 0)).sum := by | |
| induction xs with | |
| | nil => rfl | |
| | cons i xs ih => | |
| simp only [sumIndices, CountedWeights.member_value, signedAt_value, | |
| IndexedMask.semantic, List.mem_toFinset, decide_eq_true_eq, | |
| List.map_cons, List.sum_cons, ih] | |
| theorem sumIndices_work (I : Instance n) (F M : IndexedMask n) (xs : List (Fin n)) : | |
| (sumIndices I F M xs).2 ≤ (2 * n + 7) * xs.length + 1 := by | |
| induction xs with | |
| | nil => simp [sumIndices] | |
| | cons i xs ih => | |
| have hm := CountedWeights.member_work i M.indices | |
| have ht := signedAt_work I F i | |
| have hM := M.length_le | |
| simp only [sumIndices, List.length_cons, Nat.mul_add, Nat.mul_one] | |
| omega | |
| def weight (I : Instance n) (F M : IndexedMask n) : ℤ × ℕ := | |
| sumIndices I F M (List.ofFn id) | |
| theorem weight_value (I : Instance n) (F M : IndexedMask n) : | |
| (weight I F M).1 = LowSpaceSubsetSum.weight | |
| (flip (fun i => (I.values i : ℤ)) F.semantic) M.semantic := by | |
| rw [weight, sumIndices_value] | |
| simp only [List.map_ofFn, Function.comp_id, List.sum_ofFn, LowSpaceSubsetSum.weight] | |
| theorem weight_work (I : Instance n) (F M : IndexedMask n) : | |
| (weight I F M).2 ≤ (2 * n + 7) * n + 1 := by | |
| simpa only [weight, List.length_ofFn] using sumIndices_work I F M (List.ofFn id) | |
| def leafWeight (I : Instance n) (F : IndexedMask n) (x : LeafRecord n) : ℤ × ℕ := | |
| let a := weight I F x.top | |
| let b := weight I F x.localMask | |
| let c := weight I F x.background | |
| (a.1 + b.1 + c.1, a.2 + b.2 + c.2 + 2) | |
| theorem leafWeight_value (I : Instance n) (F : IndexedMask n) (x : LeafRecord n) : | |
| (leafWeight I F x).1 = RepresentationLeaf.occurrenceWeight | |
| (flip (fun i => (I.values i : ℤ)) F.semantic) x.semantic := by | |
| simp only [leafWeight, weight_value, LeafRecord.semantic, RepresentationLeaf.occurrenceWeight] | |
| theorem leafWeight_work (I : Instance n) (F : IndexedMask n) (x : LeafRecord n) : | |
| (leafWeight I F x).2 ≤ 32 * (n + 1) ^ 2 := by | |
| have ha := weight_work I F x.top | |
| have hb := weight_work I F x.localMask | |
| have hc := weight_work I F x.background | |
| change _ + _ + _ + 2 ≤ _ | |
| nlinarith only [ha, hb, hc, Nat.zero_le n] | |
| def pairSemantic (x : LeafRecord n × LeafRecord n) : | |
| RepresentationUniverse.ChildOccurrence (Fin n) := (x.1.semantic, x.2.semantic) | |
| /-- Both complete leaf weights and every modular operation are charged. -/ | |
| def pairKey (I : Instance n) (F : IndexedMask n) (P : ℤ) (mode : FilteredStream.Mode) | |
| (x : LeafRecord n × LeafRecord n) : ℤ × ℕ := | |
| let a := leafWeight I F x.1 | |
| let b := leafWeight I F x.2 | |
| match mode with | |
| | .direct => ((a.1 + b.1) % P, a.2 + b.2 + 4) | |
| | .complementary t => ((t - a.1 - b.1) % P, a.2 + b.2 + 6) | |
| theorem pairKey_value (I : Instance n) (F : IndexedMask n) (P : ℤ) | |
| (mode : FilteredStream.Mode) (x : LeafRecord n × LeafRecord n) : | |
| (pairKey I F P mode x).1 = | |
| FilteredStream.key | |
| (RepresentationLeaf.occurrenceWeight (flip (fun i => (I.values i : ℤ)) F.semantic)) | |
| (RepresentationLeaf.occurrenceWeight (flip (fun i => (I.values i : ℤ)) F.semantic)) | |
| P mode (pairSemantic x) := by | |
| cases mode <;> simp only [pairKey, pairSemantic, FilteredStream.key, leafWeight_value] | |
| theorem pairKey_work (I : Instance n) (F : IndexedMask n) (P : ℤ) | |
| (mode : FilteredStream.Mode) (x : LeafRecord n × LeafRecord n) : | |
| (pairKey I F P mode x).2 ≤ 70 * (n + 1) ^ 2 := by | |
| have ha := leafWeight_work I F x.1 | |
| have hb := leafWeight_work I F x.2 | |
| have hpos : 1 ≤ (n + 1) ^ 2 := Nat.one_le_pow _ _ (by omega) | |
| cases mode <;> change _ + _ + _ ≤ _ <;> omega | |
| /-- Uniform bound for every representable key, with no record-membership | |
| or successful-trial hypothesis. -/ | |
| theorem pairKey_scale (I : Instance n) (F : IndexedMask n) (P : ℤ) | |
| (mode : FilteredStream.Mode) (x : LeafRecord n × LeafRecord n) | |
| (hn : 10000 ≤ n) : | |
| (pairKey I F P mode x).2 ≤ inputScale I ^ 3 := by | |
| have h := pairKey_work I F P mode x | |
| have hnU : n + 1 ≤ inputScale I := by unfold inputScale; omega | |
| have hu : 70 ≤ inputScale I := by omega | |
| have hs := Nat.pow_le_pow_left hnU 2 | |
| have hm := Nat.mul_le_mul_right (inputScale I ^ 2) hu | |
| nlinarith only [h, hs, hm] | |
| /-- The parent key is recovered by the semantic mask map. The sign | |
| representation is fixed once before any reader is created. -/ | |
| theorem parent_pairKey_value (D : RepresentationParentData n) (F : IndexedMask n) | |
| (hF : F.semantic = D.signs) (j : Fin 2) (x : LeafRecord n × LeafRecord n) : | |
| (pairKey D.input F D.modulus (D.pair j).mode x).1 = D.key j (pairSemantic x) := by | |
| rw [pairKey_value, hF] | |
| rfl | |
| private theorem stored_reader (right : Array (LeafRecord n)) : | |
| RowMerge.IsReader (fun s => (FilteredStream.countedRead right s).1) | |
| (FilteredStream.view (α := LeafRecord n) right) := by | |
| simpa only [FilteredStream.countedRead_value] using | |
| (FilteredStream.reader (α := LeafRecord n) right) | |
| /-- All internal tournament keys use the concrete list-mask evaluator. -/ | |
| def read (I : Instance n) (F : IndexedMask n) (P : ℤ) (mode : FilteredStream.Mode) | |
| (right : Array (LeafRecord n)) {d : ℕ} | |
| (s : MergedReader.State (fun x => (pairKey I F P mode x).1) | |
| (FilteredStream.view right) d) := | |
| MergedReader.measuredNext (pairKey I F P mode) (FilteredStream.countedRead right) | |
| (FilteredStream.view right) (stored_reader right) s | |
| theorem read_value (I : Instance n) (F : IndexedMask n) (P : ℤ) | |
| (mode : FilteredStream.Mode) (right : Array (LeafRecord n)) {d : ℕ} | |
| (s : MergedReader.State (fun x => (pairKey I F P mode x).1) | |
| (FilteredStream.view right) d) : | |
| (read I F P mode right s).1 = | |
| MergedReader.next (fun x => (pairKey I F P mode x).1) | |
| (fun s => (FilteredStream.countedRead right s).1) | |
| (FilteredStream.view right) (stored_reader right) s := | |
| MergedReader.measuredNext_value _ _ _ _ _ | |
| theorem read_work (I : Instance n) (F : IndexedMask n) (P : ℤ) | |
| (mode : FilteredStream.Mode) (right : Array (LeafRecord n)) {d : ℕ} | |
| (s : MergedReader.State (fun x => (pairKey I F P mode x).1) | |
| (FilteredStream.view right) d) (hd : d ≤ n) (hn : 10000 ≤ n) : | |
| (read I F P mode right s).2 ≤ (2 * inputScale I ^ 3 + 8) * n + 34 := by | |
| have h := MergedReader.measuredNext_work (pairKey I F P mode) | |
| (FilteredStream.countedRead right) (FilteredStream.view right) (stored_reader right) s | |
| (inputScale I ^ 3) 24 (fun x => pairKey_scale I F P mode x hn) | |
| (FilteredStream.countedRead_work right) | |
| change (read I F P mode right s).2 ≤ _ at h | |
| have hm := Nat.mul_le_mul_left (2 * inputScale I ^ 3 + 8) hd | |
| omega | |
| private theorem read_polynomial {n u : ℕ} (hnu : n ≤ u) (hu : 10000 ≤ u) : | |
| (2 * u ^ 3 + 8) * n + 34 ≤ u ^ 5 := by | |
| have hu3 : 8 ≤ u ^ 3 := by | |
| calc | |
| 8 = 2 ^ 3 := by norm_num | |
| _ ≤ u ^ 3 := Nat.pow_le_pow_left (by omega) _ | |
| have hu4 : 34 ≤ u ^ 4 := by | |
| calc | |
| 34 ≤ 3 ^ 4 := by norm_num | |
| _ ≤ u ^ 4 := Nat.pow_le_pow_left (by omega) _ | |
| have hcoef : 2 * u ^ 3 + 8 ≤ 3 * u ^ 3 := by omega | |
| have hm : (2 * u ^ 3 + 8) * n ≤ 3 * u ^ 4 := by | |
| calc | |
| _ ≤ (3 * u ^ 3) * u := Nat.mul_le_mul hcoef hnu | |
| _ = _ := by ring | |
| have ht : 4 * u ^ 4 ≤ u ^ 5 := by | |
| calc | |
| _ ≤ u * u ^ 4 := Nat.mul_le_mul_right _ (by omega : 4 ≤ u) | |
| _ = _ := (pow_succ' u 4).symm | |
| omega | |
| theorem read_scale (I : Instance n) (F : IndexedMask n) (P : ℤ) | |
| (mode : FilteredStream.Mode) (right : Array (LeafRecord n)) {d : ℕ} | |
| (s : MergedReader.State (fun x => (pairKey I F P mode x).1) | |
| (FilteredStream.view right) d) (hd : d ≤ n) (hn : 10000 ≤ n) : | |
| (read I F P mode right s).2 ≤ inputScale I ^ 5 := by | |
| have hnu : n ≤ inputScale I := by unfold inputScale; omega | |
| exact (read_work I F P mode right s hd hn).trans (read_polynomial hnu (hn.trans hnu)) | |
| end RepresentationKeys | |
| end LowSpaceSubsetSum | |
| end OAI | |