openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Separators /BudgetedSeparatorRefinement.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorTraversal | |
| namespace OAI | |
| /-! # Exact values of the interrupted separator traversal -/ | |
| namespace LowSpaceSubsetSum.BudgetedSeparatorTraversal | |
| open BudgetedSeparatorCall BudgetedSeparatorFlow | |
| variable {α β : Type*} | |
| theorem reference_value (K : ℕ) (test₁ : α → ℕ → ℕ → Bool × ℕ) | |
| (test₂ : β → ℕ → ℕ → Bool × ℕ) (leaf : ℕ → List α → List β → Bool × ℕ) | |
| (k lo hi : ℕ) (xs : List α) (ys : List β) : | |
| (reference K test₁ test₂ leaf k lo hi xs ys).1 = | |
| (MeasuredSeparatorTraversal.run test₁ test₂ leaf k lo hi xs ys).1 := by | |
| induction k generalizing lo hi xs ys with | |
| | zero => | |
| simp only [reference, BudgetedSeparatorNode.prepare, MeasuredSeparatorTraversal.run] | |
| split_ifs <;> simp_all only [Bool.false_eq_true, ↓reduceIte] | |
| | succ k ih => | |
| simp only [reference, BudgetedSeparatorNode.prepare, MeasuredSeparatorTraversal.run] | |
| by_cases he : ((MeasuredSeparatorTraversal.keep test₁ lo hi xs).1.isEmpty || | |
| (MeasuredSeparatorTraversal.keep test₂ lo hi ys).1.isEmpty) = true | |
| · simp only [he, ↓reduceIte] | |
| · simp only [he, Bool.false_eq_true, ↓reduceIte] | |
| by_cases hs : hi ≤ lo + 1 | |
| · simp only [hs, ↓reduceIte] | |
| · simp only [hs, ↓reduceIte, ih] | |
| theorem execute_value (K : ℕ) (test₁ : α → ℕ → ℕ → Bool × ℕ) | |
| (test₂ : β → ℕ → ℕ → Bool × ℕ) | |
| (leaf : ℕ → List α → List β → ℕ → ℕ → ℕ → Outcome Bool) | |
| (source : ℕ → List α → List β → Bool × ℕ) | |
| (hleaf : ∀ j as bs na nb budget result left, as.length = na → bs.length = nb → | |
| (leaf j as bs na nb budget).1 = some (result, left) → result = (source j as bs).1) | |
| (k lo hi : ℕ) (xs : List α) (ys : List β) (nx ny budget : ℕ) | |
| (result : Bool) (left : ℕ) | |
| (h : (execute K test₁ test₂ leaf k lo hi xs ys nx ny budget).1 = some (result, left)) : | |
| result = (reference K test₁ test₂ source k lo hi xs ys).1 := by | |
| induction k generalizing lo hi xs ys nx ny budget result left with | |
| | zero => | |
| rw [execute] at h | |
| obtain ⟨f, remaining, hf, h⟩ := (bind_eq_some _ _ _ _).mp h | |
| obtain ⟨rfl, _, _⟩ := BudgetedSeparatorNode.value K test₁ test₂ lo hi xs ys nx ny budget | |
| f remaining hf | |
| simp only [reference] | |
| split at h | |
| · rename_i he | |
| simp only [he, ↓reduceIte] | |
| cases h | |
| rfl | |
| · rename_i he | |
| simp only [he, Bool.false_eq_true, ↓reduceIte] | |
| exact hleaf _ _ _ _ _ _ _ _ rfl rfl h | |
| | succ k ih => | |
| rw [execute] at h | |
| obtain ⟨f, remaining, hf, h⟩ := (bind_eq_some _ _ _ _).mp h | |
| obtain ⟨rfl, _, _⟩ := BudgetedSeparatorNode.value K test₁ test₂ lo hi xs ys nx ny budget | |
| f remaining hf | |
| simp only [reference] | |
| split at h | |
| · rename_i he | |
| simp only [he, ↓reduceIte] | |
| cases h | |
| rfl | |
| · rename_i he | |
| simp only [he, Bool.false_eq_true, ↓reduceIte] | |
| split at h | |
| · rename_i hsmall | |
| simp only [hsmall, ↓reduceIte] | |
| exact hleaf _ _ _ _ _ _ _ _ rfl rfl h | |
| · rename_i hsmall | |
| simp only [hsmall, ↓reduceIte] | |
| obtain ⟨first, midBudget, hfirst, hrest⟩ := (bind_eq_some _ _ _ _).mp h | |
| obtain ⟨second, finalBudget, hsecond, hfinal⟩ := (bind_eq_some _ _ _ _).mp hrest | |
| cases hfinal | |
| rw [ih _ _ _ _ _ _ _ _ _ hfirst, ih _ _ _ _ _ _ _ _ _ hsecond] | |
| theorem execute_complete (K : ℕ) (test₁ : α → ℕ → ℕ → Bool × ℕ) | |
| (test₂ : β → ℕ → ℕ → Bool × ℕ) | |
| (leaf : ℕ → List α → List β → ℕ → ℕ → ℕ → Outcome Bool) | |
| (source : ℕ → List α → List β → Bool × ℕ) | |
| (hleaf : ∀ j as bs na nb budget, as.length = na → bs.length = nb → | |
| (source j as bs).2 ≤ budget → | |
| (leaf j as bs na nb budget).1 = | |
| some ((source j as bs).1, budget - (source j as bs).2)) | |
| (k lo hi : ℕ) (xs : List α) (ys : List β) (nx ny budget : ℕ) | |
| (hx : xs.length = nx) (hy : ys.length = ny) | |
| (hb : (reference K test₁ test₂ source k lo hi xs ys).2 ≤ budget) : | |
| (execute K test₁ test₂ leaf k lo hi xs ys nx ny budget).1 = | |
| some ((reference K test₁ test₂ source k lo hi xs ys).1, | |
| budget - (reference K test₁ test₂ source k lo hi xs ys).2) := by | |
| induction k generalizing lo hi xs ys nx ny budget with | |
| | zero => | |
| let f := (BudgetedSeparatorNode.prepare test₁ test₂ lo hi xs ys).1 | |
| let fee := BudgetedSeparatorNode.charge K nx ny | |
| have heq : BudgetedSeparatorNode.charge K xs.length ys.length = fee := by rw [hx, hy] | |
| simp only [reference, heq] at hb ⊢ | |
| change (if f.left.isEmpty || f.right.isEmpty then (false, fee) | |
| else ((source lo f.left f.right).1, fee + (source lo f.left f.right).2)).2 ≤ budget at hb | |
| rw [execute] | |
| apply (bind_eq_some _ _ _ _).mpr | |
| have hf : fee ≤ budget := by split at hb <;> dsimp only at hb <;> omega | |
| refine ⟨f, budget - fee, BudgetedSeparatorNode.complete K test₁ test₂ lo hi xs ys | |
| nx ny budget hf, ?_⟩ | |
| change _ = some ((if f.left.isEmpty || f.right.isEmpty then (false, fee) | |
| else ((source lo f.left f.right).1, fee + (source lo f.left f.right).2)).1, | |
| budget - (if f.left.isEmpty || f.right.isEmpty then (false, fee) | |
| else ((source lo f.left f.right).1, fee + (source lo f.left f.right).2)).2) | |
| split | |
| · rfl | |
| · have hs : (source lo f.left f.right).2 ≤ budget - fee := by | |
| simp_all only [Bool.false_eq_true, ↓reduceIte] | |
| omega | |
| rw [hleaf lo f.left f.right f.nx f.ny _ f.left_size f.right_size hs] | |
| congr 2 | |
| omega | |
| | succ k ih => | |
| let f := (BudgetedSeparatorNode.prepare test₁ test₂ lo hi xs ys).1 | |
| let fee := BudgetedSeparatorNode.charge K nx ny | |
| let mid := (lo + hi) / 2 | |
| let a := reference K test₁ test₂ source k lo mid f.left f.right | |
| let b := reference K test₁ test₂ source k mid hi f.left f.right | |
| have heq : BudgetedSeparatorNode.charge K xs.length ys.length = fee := by rw [hx, hy] | |
| simp only [reference, heq] at hb ⊢ | |
| change (if f.left.isEmpty || f.right.isEmpty then (false, fee) | |
| else if hi ≤ lo + 1 then ((source lo f.left f.right).1, fee + (source lo f.left f.right).2) | |
| else (a.1 || b.1, fee + a.2 + b.2)).2 ≤ budget at hb | |
| have hf : fee ≤ budget := by split at hb <;> (try split at hb) <;> dsimp only at hb <;> omega | |
| rw [execute] | |
| apply (bind_eq_some _ _ _ _).mpr | |
| refine ⟨f, budget - fee, BudgetedSeparatorNode.complete K test₁ test₂ lo hi xs ys | |
| nx ny budget hf, ?_⟩ | |
| change _ = some ((if f.left.isEmpty || f.right.isEmpty then (false, fee) | |
| else if hi ≤ lo + 1 then ((source lo f.left f.right).1, fee + (source lo f.left f.right).2) | |
| else (a.1 || b.1, fee + a.2 + b.2)).1, | |
| budget - (if f.left.isEmpty || f.right.isEmpty then (false, fee) | |
| else if hi ≤ lo + 1 then ((source lo f.left f.right).1, fee + (source lo f.left f.right).2) | |
| else (a.1 || b.1, fee + a.2 + b.2)).2) | |
| split | |
| · rfl | |
| · split | |
| · have hs : (source lo f.left f.right).2 ≤ budget - fee := by | |
| simp_all only [Bool.false_eq_true, ↓reduceIte] | |
| omega | |
| rw [hleaf lo f.left f.right f.nx f.ny _ f.left_size f.right_size hs] | |
| congr 2 | |
| omega | |
| · have ha : a.2 ≤ budget - fee := by | |
| simp_all only [Bool.false_eq_true, ↓reduceIte] | |
| omega | |
| have hb' : b.2 ≤ budget - fee - a.2 := by | |
| simp_all only [Bool.false_eq_true, ↓reduceIte] | |
| omega | |
| apply (bind_eq_some _ _ _ _).mpr | |
| refine ⟨a.1, budget - fee - a.2, | |
| ih lo mid f.left f.right f.nx f.ny (budget - fee) | |
| f.left_size f.right_size ha, ?_⟩ | |
| apply (bind_eq_some _ _ _ _).mpr | |
| refine ⟨b.1, budget - fee - a.2 - b.2, | |
| ih mid hi f.left f.right f.nx f.ny (budget - fee - a.2) | |
| f.left_size f.right_size hb', ?_⟩ | |
| change some (a.1 || b.1, budget - fee - a.2 - b.2) = _ | |
| congr 2 | |
| omega | |
| end LowSpaceSubsetSum.BudgetedSeparatorTraversal | |
| end OAI | |