openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Representation /RepresentationBackgroundPreparation.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.CanonicalBackground | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Storage.StoredBackgroundBlocks | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationAllocationExecution | |
| namespace OAI | |
| /-! # Materializing the eight allocated background lists | |
| The outside domain is scanned and sorted, the six binomial widths determine | |
| the eight sizes, and the consecutive rows are copied from that domain. The | |
| size check makes every array access valid on every input execution. | |
| -/ | |
| namespace LowSpaceSubsetSum.RepresentationBackgroundPreparation | |
| open scoped BigOperators | |
| variable {n : ℕ} | |
| def run (_I : Instance n) (v : Vector (Fin n) n) (guesses : Vector ℕ 3) : | |
| Option (Vector (List (Fin n)) 8) × ℕ := | |
| let outside := CanonicalBackground.run v | |
| let counts := RepresentationAllocationExecution.run n guesses | |
| if h : (∑ i : Fin 8, counts.1[i.val]) = outside.1.length then | |
| let xs : Vector (Fin n) outside.1.length := ⟨outside.1.toArray, by simp only [List.size_toArray]⟩ | |
| let rows := StoredBackgroundBlocks.run xs counts.1 h | |
| (some rows.1, outside.2 + counts.2 + rows.2 + 20) | |
| else (none, outside.2 + counts.2 + 20) | |
| theorem run_of_size (I : Instance n) (v : Vector (Fin n) n) (guesses : Vector ℕ 3) | |
| (h : (∑ i : Fin 8, (RepresentationAllocationExecution.run n guesses).1[i.val]) = | |
| (CanonicalBackground.run v).1.length) : | |
| (run I v guesses).1 = some | |
| (StoredBackgroundBlocks.run | |
| (⟨(CanonicalBackground.run v).1.toArray, by simp only [List.size_toArray]⟩) | |
| (RepresentationAllocationExecution.run n guesses).1 h).1 := by | |
| unfold run | |
| dsimp only | |
| rw [dite_eq_left h] | |
| theorem work (I : Instance n) (v : Vector (Fin n) n) (guesses : Vector ℕ 3) : | |
| (run I v guesses).2 ≤ 1000 * (n + 1) ^ 2 := by | |
| have ho := CanonicalBackground.work v | |
| have hl := CanonicalBackground.length_le v | |
| have hc := RepresentationAllocationExecution.work n guesses | |
| unfold run | |
| dsimp only | |
| split | |
| · change (CanonicalBackground.run v).2 + | |
| (RepresentationAllocationExecution.run n guesses).2 + | |
| (32 * (CanonicalBackground.run v).1.length + 200) + 20 ≤ _ | |
| nlinarith only [ho, hl, hc, Nat.zero_le (n ^ 2)] | |
| · change (CanonicalBackground.run v).2 + | |
| (RepresentationAllocationExecution.run n guesses).2 + 20 ≤ _ | |
| nlinarith only [ho, hc, Nat.zero_le (n ^ 2)] | |
| theorem lengths (I : Instance n) (v : Vector (Fin n) n) (guesses : Vector ℕ 3) | |
| (rows : Vector (List (Fin n)) 8) (h : (run I v guesses).1 = some rows) | |
| (j : Fin 8) : rows[j.val].length ≤ n := by | |
| have hout := CanonicalBackground.length_le v | |
| unfold run at h | |
| dsimp only at h | |
| split at h | |
| next hc => | |
| simp only [Option.some.injEq] at h | |
| subst rows | |
| simp only [StoredBackgroundBlocks.run, Vector.getElem_ofFn, | |
| StoredBackgroundBlocks.row_length] | |
| have hj := Finset.single_le_sum | |
| (fun i (_ : i ∈ (Finset.univ : Finset (Fin 8))) => | |
| Nat.zero_le (RepresentationAllocationExecution.run n guesses).1[i.val]) | |
| (Finset.mem_univ j) | |
| exact hj.trans (hc.le.trans hout) | |
| next hc => simp only [reduceCtorEq] at h | |
| end LowSpaceSubsetSum.RepresentationBackgroundPreparation | |
| end OAI | |