openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Separators /BudgetedSeparatorNode.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorCall | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.MeasuredSeparatorTraversal | |
| namespace OAI | |
| /-! # Prepaid filter nodes with cached output lengths | |
| The successful node retains only filtered lists and two scalar lengths. | |
| Its whole filtering, length computation and branch bookkeeping is reserved | |
| before either interval predicate is evaluated. | |
| -/ | |
| namespace LowSpaceSubsetSum.BudgetedSeparatorNode | |
| variable {α β : Type*} | |
| structure Frame (α β : Type*) where | |
| left : List α | |
| right : List β | |
| nx : ℕ | |
| ny : ℕ | |
| left_size : left.length = nx | |
| right_size : right.length = ny | |
| def prepare (test₁ : α → ℕ → ℕ → Bool × ℕ) (test₂ : β → ℕ → ℕ → Bool × ℕ) | |
| (lo hi : ℕ) (xs : List α) (ys : List β) : Frame α β × ℕ := | |
| let a := MeasuredSeparatorTraversal.keep test₁ lo hi xs | |
| let b := MeasuredSeparatorTraversal.keep test₂ lo hi ys | |
| let nx := a.1.length | |
| let ny := b.1.length | |
| (⟨a.1, b.1, nx, ny, rfl, rfl⟩, a.2 + b.2 + 2 * (nx + ny) + 12) | |
| def charge (K nx ny : ℕ) : ℕ := (K + 20) * (nx + ny + 1) | |
| theorem prepare_work (test₁ : α → ℕ → ℕ → Bool × ℕ) | |
| (test₂ : β → ℕ → ℕ → Bool × ℕ) (K : ℕ) | |
| (h₁ : ∀ x lo hi, (test₁ x lo hi).2 ≤ K) | |
| (h₂ : ∀ y lo hi, (test₂ y lo hi).2 ≤ K) | |
| (lo hi : ℕ) (xs : List α) (ys : List β) : | |
| (prepare test₁ test₂ lo hi xs ys).2 + 1 ≤ charge K xs.length ys.length := by | |
| have ha := MeasuredSeparatorTraversal.keep_work test₁ K h₁ lo hi xs | |
| have hb := MeasuredSeparatorTraversal.keep_work test₂ K h₂ lo hi ys | |
| have hla : (MeasuredSeparatorTraversal.keep test₁ lo hi xs).1.length ≤ xs.length := by | |
| simp only [MeasuredSeparatorTraversal.keep, MeasuredFilter.runAcc_value, | |
| List.reverse_nil, List.nil_append] | |
| exact List.length_filter_le _ _ | |
| have hlb : (MeasuredSeparatorTraversal.keep test₂ lo hi ys).1.length ≤ ys.length := by | |
| simp only [MeasuredSeparatorTraversal.keep, MeasuredFilter.runAcc_value, | |
| List.reverse_nil, List.nil_append] | |
| exact List.length_filter_le _ _ | |
| unfold prepare charge | |
| dsimp only | |
| nlinarith only [ha, hb, hla, hlb, Nat.zero_le K, Nat.zero_le xs.length, Nat.zero_le ys.length] | |
| def run (K : ℕ) (test₁ : α → ℕ → ℕ → Bool × ℕ) | |
| (test₂ : β → ℕ → ℕ → Bool × ℕ) (lo hi : ℕ) | |
| (xs : List α) (ys : List β) (nx ny budget : ℕ) : | |
| BudgetedSeparatorCall.Outcome (Frame α β) := | |
| BudgetedSeparatorCall.run (charge K nx ny) | |
| (fun _ => prepare test₁ test₂ lo hi xs ys) budget | |
| theorem work (K : ℕ) (test₁ : α → ℕ → ℕ → Bool × ℕ) | |
| (test₂ : β → ℕ → ℕ → Bool × ℕ) | |
| (h₁ : ∀ x lo hi, (test₁ x lo hi).2 ≤ K) | |
| (h₂ : ∀ y lo hi, (test₂ y lo hi).2 ≤ K) | |
| (lo hi : ℕ) (xs : List α) (ys : List β) (nx ny budget : ℕ) | |
| (hx : xs.length = nx) (hy : ys.length = ny) : | |
| (run K test₁ test₂ lo hi xs ys nx ny budget).2 ≤ budget + 1 := by | |
| apply BudgetedSeparatorCall.work | |
| simpa only [hx, hy] using prepare_work test₁ test₂ K h₁ h₂ lo hi xs ys | |
| theorem spent (K : ℕ) (test₁ : α → ℕ → ℕ → Bool × ℕ) | |
| (test₂ : β → ℕ → ℕ → Bool × ℕ) | |
| (h₁ : ∀ x lo hi, (test₁ x lo hi).2 ≤ K) | |
| (h₂ : ∀ y lo hi, (test₂ y lo hi).2 ≤ K) | |
| (lo hi : ℕ) (xs : List α) (ys : List β) (nx ny budget : ℕ) | |
| (hx : xs.length = nx) (hy : ys.length = ny) | |
| (out : Frame α β) (left : ℕ) | |
| (h : (run K test₁ test₂ lo hi xs ys nx ny budget).1 = some (out, left)) : | |
| left ≤ budget ∧ (run K test₁ test₂ lo hi xs ys nx ny budget).2 ≤ budget - left := by | |
| apply BudgetedSeparatorCall.spent _ _ _ ?_ _ _ h | |
| simpa only [hx, hy] using prepare_work test₁ test₂ K h₁ h₂ lo hi xs ys | |
| theorem value (K : ℕ) (test₁ : α → ℕ → ℕ → Bool × ℕ) | |
| (test₂ : β → ℕ → ℕ → Bool × ℕ) (lo hi : ℕ) | |
| (xs : List α) (ys : List β) (nx ny budget : ℕ) | |
| (out : Frame α β) (left : ℕ) | |
| (h : (run K test₁ test₂ lo hi xs ys nx ny budget).1 = some (out, left)) : | |
| out = (prepare test₁ test₂ lo hi xs ys).1 ∧ | |
| left = budget - charge K nx ny ∧ charge K nx ny ≤ budget := | |
| BudgetedSeparatorCall.value _ _ _ _ _ h | |
| theorem complete (K : ℕ) (test₁ : α → ℕ → ℕ → Bool × ℕ) | |
| (test₂ : β → ℕ → ℕ → Bool × ℕ) (lo hi : ℕ) | |
| (xs : List α) (ys : List β) (nx ny budget : ℕ) | |
| (h : charge K nx ny ≤ budget) : | |
| (run K test₁ test₂ lo hi xs ys nx ny budget).1 = | |
| some ((prepare test₁ test₂ lo hi xs ys).1, budget - charge K nx ny) := by | |
| rw [run, BudgetedSeparatorCall.complete _ _ _ h] | |
| end LowSpaceSubsetSum.BudgetedSeparatorNode | |
| end OAI | |