| import OAI.Combinatorics.LowSpaceSubsetSum.Search.BudgetedBucketLedger | |
| namespace OAI | |
| namespace LowSpaceSubsetSum.BudgetedBucketScale | |
| variable {n g : ℕ} | |
| theorem coefficients (I : Instance n) (hn : 10000 ≤ n) : | |
| 2 * inputScale I ^ 9 + inputScale I ^ 3 + 16 ≤ inputScale I ^ 10 ∧ | |
| StoredPrefixController.header n ≤ inputScale I ^ 10 ∧ | |
| 3 * inputScale I ^ 10 ≤ inputScale I ^ 11 := by | |
| let u := inputScale I | |
| have hnu : n + 1 ≤ u := by unfold u inputScale; omega | |
| have hu : 10000 ≤ u := by omega | |
| have h39 : u ^ 3 ≤ u ^ 9 := Nat.pow_le_pow_right (by omega) (by decide) | |
| have h16 : 16 ≤ u ^ 9 := (by omega : 16 ≤ u).trans (Nat.le_self_pow (by decide) u) | |
| have h4 : 4 * u ^ 9 ≤ u ^ 10 := by | |
| calc | |
| _ ≤ u * u ^ 9 := Nat.mul_le_mul_right _ (by omega) | |
| _ = _ := by ring | |
| have h2 : (n + 1) ^ 2 ≤ u ^ 2 := Nat.pow_le_pow_left hnu 2 | |
| have hone : 1 ≤ u ^ 2 := Nat.one_le_pow _ _ (by omega) | |
| have h28 : 28 ≤ u ^ 2 := (by omega : 28 ≤ u).trans (Nat.le_self_pow (by decide) u) | |
| have h24 : 28 * u ^ 2 ≤ u ^ 4 := by | |
| calc | |
| _ ≤ u ^ 2 * u ^ 2 := Nat.mul_le_mul_right _ h28 | |
| _ = _ := by ring | |
| have h410 : u ^ 4 ≤ u ^ 10 := Nat.pow_le_pow_right (by omega) (by decide) | |
| refine ⟨by change 2 * u ^ 9 + u ^ 3 + 16 ≤ u ^ 10; omega, ?_, ?_⟩ | |
| · change StoredPrefixController.header n ≤ u ^ 10 | |
| unfold StoredPrefixController.header | |
| have hm := Nat.mul_le_mul_left 20 h2 | |
| omega | |
| · change 3 * u ^ 10 ≤ u ^ 11 | |
| calc | |
| _ ≤ u * u ^ 10 := Nat.mul_le_mul_right _ (by omega) | |
| _ = _ := by ring | |
| theorem prefix_charge (D : RepresentationBucketData n g) (hn : 10000 ≤ n) | |
| (B L C : ℕ) (hL : L ≤ C + 1) : | |
| BudgetedBucketLedger.prefixCharge D B L ≤ inputScale D.right.input ^ 11 * | |
| ((C + D.right.capacity + 3) * D.right.taskStarts B D.topOrder MaskRestriction.empty + | |
| (D.right.prefixLedger B D.topOrder MaskRestriction.empty).queries + | |
| B * (D.right.prefixLedger B D.topOrder MaskRestriction.empty).copies) := by | |
| let u := inputScale D.right.input | |
| let S := C + D.right.capacity + 3 | |
| let A := 2 * u ^ 9 + u ^ 3 + 16 | |
| have hu : 1 ≤ u := by unfold u inputScale; omega | |
| obtain ⟨hA, hh, h3⟩ := coefficients D.right.input hn | |
| change A ≤ u ^ 10 at hA | |
| change StoredPrefixController.header n ≤ u ^ 10 at hh | |
| change 3 * u ^ 10 ≤ u ^ 11 at h3 | |
| have h6 : u ^ 6 ≤ u ^ 10 := Nat.pow_le_pow_right (by omega) (by decide) | |
| have h7 : u ^ 7 ≤ u ^ 11 := Nat.pow_le_pow_right (by omega) (by decide) | |
| have hone : 1 ≤ u ^ 11 := Nat.one_le_pow _ _ hu | |
| have ha := (Nat.mul_le_mul_right (D.right.capacity + 1) hA).trans | |
| (Nat.mul_le_mul_left (u ^ 10) (by unfold S; omega : D.right.capacity + 1 ≤ S)) | |
| have hh' := hh.trans (Nat.le_mul_of_pos_right (u ^ 10) (by unfold S; omega : 0 < S)) | |
| have hl := (Nat.mul_le_mul_right (L + D.right.capacity + 2) h6).trans | |
| (Nat.mul_le_mul_left (u ^ 10) (by unfold S; omega : L + D.right.capacity + 2 ≤ S)) | |
| have hcoeff : A * (D.right.capacity + 1) + StoredPrefixController.header n + | |
| u ^ 6 * (L + D.right.capacity + 2) ≤ u ^ 11 * S := by | |
| have hmul := Nat.mul_le_mul_right S h3 | |
| simp only [Nat.mul_assoc] at hmul | |
| omega | |
| have hT := Nat.mul_le_mul_right (D.right.taskStarts B D.topOrder MaskRestriction.empty) hcoeff | |
| have hQ := Nat.mul_le_mul_right | |
| (D.right.prefixLedger B D.topOrder MaskRestriction.empty).queries h7 | |
| have hC := Nat.mul_le_mul_right | |
| (B * (D.right.prefixLedger B D.topOrder MaskRestriction.empty).copies) hone | |
| change _ ≤ u ^ 11 * (S * _ + _ + _) | |
| unfold BudgetedBucketLedger.prefixCharge | |
| change (A * (D.right.capacity + 1) + StoredPrefixController.header n) * _ + | |
| u ^ 7 * _ + B * _ + u ^ 6 * (L + D.right.capacity + 2) * _ ≤ _ | |
| calc | |
| _ = (A * (D.right.capacity + 1) + StoredPrefixController.header n + | |
| u ^ 6 * (L + D.right.capacity + 2)) * | |
| D.right.taskStarts B D.topOrder MaskRestriction.empty + | |
| u ^ 7 * (D.right.prefixLedger B D.topOrder MaskRestriction.empty).queries + | |
| B * (D.right.prefixLedger B D.topOrder MaskRestriction.empty).copies := by ring | |
| _ ≤ u ^ 11 * S * D.right.taskStarts B D.topOrder MaskRestriction.empty + | |
| u ^ 11 * (D.right.prefixLedger B D.topOrder MaskRestriction.empty).queries + | |
| u ^ 11 * (B * (D.right.prefixLedger B D.topOrder MaskRestriction.empty).copies) := by omega | |
| _ = _ := by ring | |
| theorem parent_bill (D : RepresentationParentData n) (hn : 10000 ≤ n) | |
| (B C : ℕ) (P : StoredRestriction n) : | |
| BudgetedParentCollector.bill D B C P ≤ | |
| inputScale D.input ^ 10 * (C + 1) + | |
| inputScale D.input ^ 7 * ({D with maskRestriction := P.semantic}.collect B).state.queries + | |
| B * ({D with maskRestriction := P.semantic}.collect B).state.copies := by | |
| have h := Nat.mul_le_mul_right (C + 1) (coefficients D.input hn).1 | |
| have ha : inputScale D.input ^ 3 + 16 ≤ | |
| (inputScale D.input ^ 3 + 16) * (C + 1) := Nat.le_mul_of_pos_right _ (by omega) | |
| unfold BudgetedParentCollector.bill BudgetedPreparedParent.setupCharge | |
| simp only [Nat.add_mul] at h ha | |
| omega | |
| noncomputable def units (D : RepresentationBucketData n g) (B : ℕ) | |
| (families : Fin 4 → Array (Finset (Fin g))) : ℕ := | |
| (D.left.capacity + 1) + (D.left.capacity + D.right.capacity + 3) * | |
| D.right.taskStarts B D.topOrder MaskRestriction.empty + | |
| (D.left.collect B).state.queries + | |
| (D.right.prefixLedger B D.topOrder MaskRestriction.empty).queries + | |
| B * (D.left.collect B).state.copies + | |
| B * (D.right.prefixLedger B D.topOrder MaskRestriction.empty).copies + | |
| D.coordinates.totalScans families D.target (D.checkList B) + 1 | |
| theorem allowance_scale (D : RepresentationBucketData n g) (FL FR : IndexedMask n) | |
| (hFL : FL.semantic = D.left.signs) (hFR : FR.semantic = D.right.signs) | |
| (hleft : D.left.maskRestriction = MaskRestriction.empty) | |
| (hinput : D.left.input = D.right.input) (hn : 10000 ≤ n) (B : ℕ) | |
| (families : Fin 4 → Array (Finset (Fin g))) : | |
| BudgetedPreparedBucket.allowance D FL FR hFL hFR B families ≤ | |
| inputScale D.right.input ^ 12 * units D B families := by | |
| let u := inputScale D.right.input | |
| let left := (ComputedParentExecution.run D.left FL StoredRestriction.empty hFL B).1.dictionary | |
| have hu : 8 ≤ u := by unfold u inputScale; omega | |
| have hU : 1 ≤ u ^ 12 := Nat.one_le_pow _ _ (by omega) | |
| have h8 : 8 ≤ u ^ 12 := hu.trans (Nat.le_self_pow (by decide) u) | |
| have h10 : u ^ 10 ≤ u ^ 12 := Nat.pow_le_pow_right (by omega) (by decide) | |
| have h11 : u ^ 11 ≤ u ^ 12 := Nat.pow_le_pow_right (by omega) (by decide) | |
| have h7 : u ^ 7 ≤ u ^ 12 := Nat.pow_le_pow_right (by omega) (by decide) | |
| have h6 : u ^ 6 ≤ u ^ 12 := Nat.pow_le_pow_right (by omega) (by decide) | |
| have hreset : {D.left with maskRestriction := MaskRestriction.empty} = D.left := by rw [← hleft] | |
| have hb := parent_bill D.left hn B D.left.capacity StoredRestriction.empty | |
| rw [StoredRestriction.empty_value, hreset, hinput] at hb | |
| change BudgetedParentCollector.bill D.left B D.left.capacity StoredRestriction.empty ≤ | |
| u ^ 10 * (D.left.capacity + 1) + u ^ 7 * (D.left.collect B).state.queries + | |
| B * (D.left.collect B).state.copies at hb | |
| have hb' : BudgetedParentCollector.bill D.left B D.left.capacity StoredRestriction.empty ≤ | |
| u ^ 12 * ((D.left.capacity + 1) + (D.left.collect B).state.queries + | |
| B * (D.left.collect B).state.copies) := by | |
| have hC := Nat.mul_le_mul_right (D.left.capacity + 1) h10 | |
| have hQ := Nat.mul_le_mul_right (D.left.collect B).state.queries h7 | |
| have hR := Nat.mul_le_mul_right (B * (D.left.collect B).state.copies) hU | |
| change _ ≤ u ^ 12 * _ | |
| rw [Nat.mul_add, Nat.mul_add] | |
| simp only [Nat.one_mul] at hR | |
| omega | |
| have hsize : left.val.records.size ≤ D.left.capacity + 1 := | |
| (RecordedDictionary.storage left.property).1 | |
| have hp := prefix_charge D hn B left.val.records.size D.left.capacity hsize | |
| have hp' : BudgetedBucketLedger.prefixCharge D B left.val.records.size ≤ | |
| u ^ 12 * ((D.left.capacity + D.right.capacity + 3) * | |
| D.right.taskStarts B D.topOrder MaskRestriction.empty + | |
| (D.right.prefixLedger B D.topOrder MaskRestriction.empty).queries + | |
| B * (D.right.prefixLedger B D.topOrder MaskRestriction.empty).copies) := by | |
| exact hp.trans (Nat.mul_le_mul_right _ h11) | |
| have hs := Nat.mul_le_mul_right | |
| (D.coordinates.totalScans families D.target (D.checkList B)) h6 | |
| have hl := BudgetedBucketLedger.allowance_ledger D FL FR hFL hFR hleft B families | |
| change _ ≤ 8 + BudgetedParentCollector.bill D.left B D.left.capacity StoredRestriction.empty + | |
| BudgetedBucketLedger.prefixCharge D B left.val.records.size + | |
| u ^ 6 * D.coordinates.totalScans families D.target (D.checkList B) at hl | |
| calc | |
| _ ≤ 8 + BudgetedParentCollector.bill D.left B D.left.capacity StoredRestriction.empty + | |
| BudgetedBucketLedger.prefixCharge D B left.val.records.size + | |
| u ^ 6 * D.coordinates.totalScans families D.target (D.checkList B) := hl | |
| _ ≤ u ^ 12 + | |
| u ^ 12 * ((D.left.capacity + 1) + (D.left.collect B).state.queries + | |
| B * (D.left.collect B).state.copies) + | |
| u ^ 12 * ((D.left.capacity + D.right.capacity + 3) * | |
| D.right.taskStarts B D.topOrder MaskRestriction.empty + | |
| (D.right.prefixLedger B D.topOrder MaskRestriction.empty).queries + | |
| B * (D.right.prefixLedger B D.topOrder MaskRestriction.empty).copies) + | |
| u ^ 12 * D.coordinates.totalScans families D.target (D.checkList B) := by omega | |
| _ = _ := by unfold units; change _ = u ^ 12 * _; ring | |
| end LowSpaceSubsetSum.BudgetedBucketScale | |
| end OAI | |