| import OAI.Combinatorics.LowSpaceSubsetSum.Counting.CountedBinomial |
| import OAI.Combinatorics.LowSpaceSubsetSum.Representation.RepresentationLeafWork |
|
|
| namespace OAI |
|
|
| /-! # Computed and cached parent loop limits |
|
|
| Only domain scans, two multiplicative binomial loops, and a doubling loop |
| are run per leaf. No subset list is enumerated to obtain a loop limit. |
| -/ |
|
|
| namespace LowSpaceSubsetSum.ComputedParentFuels |
|
|
| variable {n : ℕ} |
|
|
| private def lengthAcc {α : Type*} : List α → ℕ → ℕ → ℕ × ℕ |
| | [], value, work => (value, work + 1) |
| | _ :: xs, value, work => lengthAcc xs (value + 1) (work + 2) |
|
|
| private theorem lengthAcc_eq {α : Type*} (xs : List α) (value work : ℕ) : |
| lengthAcc xs value work = (value + xs.length, work + 2 * xs.length + 1) := by |
| induction xs generalizing value work with |
| | nil => simp [lengthAcc] |
| | cons x xs ih => simp only [lengthAcc, ih, List.length_cons]; congr 1 <;> omega |
|
|
| private def powerAcc : ℕ → ℕ → ℕ → ℕ × ℕ |
| | 0, value, work => (value, work + 1) |
| | k + 1, value, work => powerAcc k (2 * value) (work + 3) |
|
|
| private theorem powerAcc_eq (k value work : ℕ) : |
| powerAcc k value work = (value * 2 ^ k, work + 3 * k + 1) := by |
| induction k generalizing value work with |
| | zero => simp [powerAcc] |
| | succ k ih => |
| simp only [powerAcc, ih, pow_succ] |
| congr 1 <;> ring |
|
|
| def leaf (L : RepresentationLeaf (Fin n)) : ℕ × ℕ := |
| let ts := RepresentationLeaf.domainSort L.top |
| let ms := RepresentationLeaf.domainSort L.mixer |
| let bs := RepresentationLeaf.domainSort L.background |
| let nt := lengthAcc ts.1 0 0 |
| let nm := lengthAcc ms.1 0 0 |
| let nb := lengthAcc bs.1 0 0 |
| let a := CountedBinomial.run nt.1 L.topCount |
| let b := CountedBinomial.run nm.1 L.localCount |
| let c := powerAcc nb.1 1 0 |
| (a.value * b.value * c.1, |
| ts.2 + ms.2 + bs.2 + nt.2 + nm.2 + nb.2 + |
| 8 * a.steps + 8 * b.steps + c.2 + 12) |
|
|
| theorem leaf_value (L : RepresentationLeaf (Fin n)) : (leaf L).1 = L.occurrences.card := by |
| simp only [leaf, lengthAcc_eq, powerAcc_eq, Nat.zero_add, Nat.one_mul, |
| RepresentationLeaf.domainSort_length, CountedBinomial.run_value, |
| RepresentationLeaf.occurrences_card] |
|
|
| /-- Closed form for the leaf count and its charged scalar-loop work. -/ |
| theorem leaf_formula (L : RepresentationLeaf (Fin n)) : |
| leaf L = |
| (L.top.card.choose L.topCount * L.mixer.card.choose L.localCount * 2^L.background.card, |
| (RepresentationLeaf.domainSort L.top).2 + (RepresentationLeaf.domainSort L.mixer).2 + |
| (RepresentationLeaf.domainSort L.background).2 + (2*L.top.card+1) + |
| (2*L.mixer.card+1) + (2*L.background.card+1) + |
| 8*(CountedBinomial.run L.top.card L.topCount).steps + |
| 8*(CountedBinomial.run L.mixer.card L.localCount).steps + |
| (3*L.background.card+1) + 12) := by |
| simp only [leaf, lengthAcc_eq, powerAcc_eq, Nat.zero_add, Nat.one_mul, |
| RepresentationLeaf.domainSort_length, CountedBinomial.run_value] |
|
|
| theorem leaf_work (L : RepresentationLeaf (Fin n)) : (leaf L).2 ≤ 100 * (n + 1) ^ 2 := by |
| have ht := RepresentationLeaf.domainSort_work L.top |
| have hm := RepresentationLeaf.domainSort_work L.mixer |
| have hb := RepresentationLeaf.domainSort_work L.background |
| have hct : L.top.card ≤ n := by simpa using Finset.card_le_univ L.top |
| have hcm : L.mixer.card ≤ n := by simpa using Finset.card_le_univ L.mixer |
| have hcb : L.background.card ≤ n := by simpa using Finset.card_le_univ L.background |
| have ha := CountedBinomial.run_steps L.top.card L.topCount |
| have hbb := CountedBinomial.run_steps L.mixer.card L.localCount |
| simp only [leaf, lengthAcc_eq, powerAcc_eq, Nat.zero_add, |
| RepresentationLeaf.domainSort_length] |
| nlinarith only [ht, hm, hb, hct, hcm, hcb, ha, hbb, Nat.zero_le n] |
|
|
| theorem leaf_bound (L : RepresentationLeaf (Fin n)) : (leaf L).1 ≤ 2 ^ (3 * n) := by |
| rw [leaf_value, RepresentationLeaf.occurrences_card] |
| have ht : L.top.card.choose L.topCount ≤ 2 ^ n := |
| (Nat.choose_le_two_pow _ _).trans (Nat.pow_le_pow_right (by decide) |
| (by simpa using Finset.card_le_univ L.top)) |
| have hm : L.mixer.card.choose L.localCount ≤ 2 ^ n := |
| (Nat.choose_le_two_pow _ _).trans (Nat.pow_le_pow_right (by decide) |
| (by simpa using Finset.card_le_univ L.mixer)) |
| have hb : 2 ^ L.background.card ≤ 2 ^ n := Nat.pow_le_pow_right (by decide) |
| (by simpa using Finset.card_le_univ L.background) |
| calc |
| _ ≤ (2 ^ n * 2 ^ n) * 2 ^ n := Nat.mul_le_mul (Nat.mul_le_mul ht hm) hb |
| _ = _ := by rw [← pow_add, ← pow_add]; congr 1; omega |
|
|
| structure Values where |
| first : ℕ |
| second : ℕ |
| control : ℕ |
|
|
| /-- The four scalar counts are retained long enough to form both limits. -/ |
| def run (D : RepresentationParentData n) : Values × ℕ := |
| let a := leaf (D.leaves 0) |
| let b := leaf (D.leaves 1) |
| let c := leaf (D.leaves 2) |
| let d := leaf (D.leaves 3) |
| let f := a.1 * b.1 |
| let g := c.1 * d.1 |
| (⟨f, g, f + g + 1⟩, a.2 + b.2 + c.2 + d.2 + 7) |
|
|
| theorem run_restrict (D : RepresentationParentData n) (P : MaskRestriction n) : |
| run {D with maskRestriction := P} = run D := rfl |
|
|
| theorem run_congr_leaves (D E : RepresentationParentData n) (h : D.leaves = E.leaves) : |
| run D = run E := by |
| simp only [run, h] |
|
|
| private theorem lengthBound_eq (D : RepresentationPairData n) : |
| D.lengthBound = D.left.occurrences.card * D.right.occurrences.card := by |
| simp only [RepresentationPairData.lengthBound, RepresentationLeaf.enumerate_length] |
|
|
| theorem first_value (D : RepresentationParentData n) : |
| (run D).1.first = (D.pair 0).lengthBound := by |
| simp only [run, leaf_value, lengthBound_eq, RepresentationParentData.pair] |
| rfl |
|
|
| theorem second_value (D : RepresentationParentData n) : |
| (run D).1.second = (D.pair 1).lengthBound := by |
| simp only [run, leaf_value, lengthBound_eq, RepresentationParentData.pair] |
| rfl |
|
|
| theorem control_value (D : RepresentationParentData n) : |
| (run D).1.control = (D.pair 0).lengthBound + (D.pair 1).lengthBound + 1 := by |
| change (run D).1.first + (run D).1.second + 1 = _ |
| rw [first_value, second_value] |
|
|
| theorem run_bounds (D : RepresentationParentData n) : |
| (run D).1.first ≤ 2 ^ (6 * n) ∧ (run D).1.second ≤ 2 ^ (6 * n) ∧ |
| (run D).1.control ≤ 2 ^ (6 * n + 2) := by |
| have h0 := Nat.mul_le_mul (leaf_bound (D.leaves 0)) (leaf_bound (D.leaves 1)) |
| have h1 := Nat.mul_le_mul (leaf_bound (D.leaves 2)) (leaf_bound (D.leaves 3)) |
| have he : 2 ^ (3 * n) * 2 ^ (3 * n) = 2 ^ (6 * n) := by |
| rw [← pow_add]; congr 1; omega |
| rw [he] at h0 h1 |
| have hp : 1 ≤ 2 ^ (6 * n) := Nat.one_le_two_pow |
| dsimp only [run] |
| rw [pow_add] |
| norm_num |
| exact ⟨h0, h1, by omega⟩ |
|
|
| theorem run_work (D : RepresentationParentData n) : |
| (run D).2 ≤ 512 * (n + 1) ^ 2 := by |
| have h0 := leaf_work (D.leaves 0) |
| have h1 := leaf_work (D.leaves 1) |
| have h2 := leaf_work (D.leaves 2) |
| have h3 := leaf_work (D.leaves 3) |
| have hp : 1 ≤ (n + 1) ^ 2 := Nat.one_le_pow _ _ (by omega) |
| change _ + _ + _ + _ + 7 ≤ _ |
| omega |
|
|
| theorem run_scale (D : RepresentationParentData n) (hn : 10000 ≤ n) : |
| (run D).2 ≤ inputScale D.input ^ 3 := by |
| have hnu : n + 1 ≤ inputScale D.input := by unfold inputScale; omega |
| have hs := Nat.pow_le_pow_left hnu 2 |
| have hm := Nat.mul_le_mul_right (inputScale D.input ^ 2) |
| (show 512 ≤ inputScale D.input by omega) |
| exact (run_work D).trans (by nlinarith only [hs, hm]) |
|
|
| end LowSpaceSubsetSum.ComputedParentFuels |
|
|
| end OAI |
|
|
