openAI-math-dataset / lean /OAI /Combinatorics /LowSpaceSubsetSum /Separators /BudgetedSeparatorCheckRefinement.lean
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorCheck | |
| import OAI.Combinatorics.LowSpaceSubsetSum.Separators.BudgetedSeparatorRefinement | |
| namespace OAI | |
| /-! # Completed budgeted checks retain the original acceptance test -/ | |
| namespace LowSpaceSubsetSum.BudgetedSeparatorCheck | |
| open BudgetedSeparatorCall BudgetedSeparatorFlow StoredSeparatorCheck | |
| variable {n g : ℕ} | |
| theorem execute_value (capacity : ℕ) (target : ℤ) (blocks : List (Block n g)) | |
| (xs ys : List (StoredEntry n)) (nx ny budget : ℕ) | |
| (hx : xs.length = nx) (hy : ys.length = ny) (result : Bool) (left : ℕ) | |
| (h : (execute capacity target blocks xs ys nx ny budget).1 = some (result, left)) : | |
| result = (reference capacity target blocks xs ys).1 := by | |
| induction blocks generalizing xs ys nx ny budget result left with | |
| | nil => | |
| rw [execute] at h | |
| obtain ⟨fits, remaining, hf, hout⟩ := (bind_eq_some _ _ _ _).mp h | |
| obtain ⟨rfl, _, _⟩ := BudgetedSeparatorCall.value 4 _ budget fits remaining hf | |
| simp only [reference, hx, hy] | |
| by_cases hb : nx + ny ≤ capacity | |
| · simp only [hb, decide_true, ↓reduceIte] at hout ⊢ | |
| exact (BudgetedSeparatorCall.value _ _ _ _ _ hout).1 | |
| · simp only [hb, decide_false, Bool.false_eq_true, ↓reduceIte, BudgetedSeparatorFlow.pure] at hout ⊢ | |
| cases hout | |
| rfl | |
| | cons b rest ih => | |
| rw [execute] at h | |
| obtain ⟨fits, remaining, hf, hout⟩ := (bind_eq_some _ _ _ _).mp h | |
| obtain ⟨rfl, _, _⟩ := BudgetedSeparatorCall.value 4 _ budget fits remaining hf | |
| simp only [reference, hx, hy] | |
| by_cases hb : nx + ny ≤ capacity | |
| · simp only [hb, decide_true, ↓reduceIte] at hout ⊢ | |
| have hv := BudgetedSeparatorTraversal.execute_value b.queryBound b.leftQuery b.rightQuery | |
| (fun _ as bs na nb rem => execute capacity target rest as bs na nb rem) | |
| (fun _ as bs => reference capacity target rest as bs) | |
| (fun _ as bs na nb rem r l ha hb hr => ih as bs na nb rem ha hb r l hr) | |
| b.depth 0 b.familySize xs ys nx ny remaining result left hout | |
| exact hv | |
| · simp only [hb, decide_false, Bool.false_eq_true, ↓reduceIte, BudgetedSeparatorFlow.pure] at hout ⊢ | |
| cases hout | |
| rfl | |
| theorem reference_value (capacity : ℕ) (hcap : capacity = 2 ^ n) (target : ℤ) | |
| (blocks : List (Block n g)) (xs ys : List (StoredEntry n)) : | |
| (reference capacity target blocks xs ys).1 = | |
| (SeparatorBlocks.check n StoredEntry.value StoredEntry.value target | |
| (blocks.map Block.source) xs ys).accepted := by | |
| subst capacity | |
| induction blocks generalizing xs ys with | |
| | nil => | |
| simp only [reference, List.map_nil, SeparatorBlocks.check, SeparatorTerminal.bounded] | |
| split | |
| · exact StoredEntryTerminal.run_value target xs ys (by omega) (by omega) | |
| · rfl | |
| | cons b rest ih => | |
| simp only [reference, List.map_cons, SeparatorBlocks.check] | |
| split | |
| · rw [BudgetedSeparatorTraversal.reference_value] | |
| have h := MeasuredSeparatorTraversal.run_value b.leftQuery b.rightQuery b.left b.right | |
| b.leftQuery_value b.rightQuery_value | |
| (fun _ as bs => reference (2 ^ n) target rest as bs) | |
| (fun _ as bs => SeparatorBlocks.check n StoredEntry.value StoredEntry.value target | |
| (rest.map Block.source) as bs) | |
| (fun _ as bs => ih as bs) b.depth 0 b.familySize xs ys | |
| rw [h, b.depth_eq] | |
| rfl | |
| · rfl | |
| theorem execute_complete (capacity : ℕ) (target : ℤ) (blocks : List (Block n g)) | |
| (xs ys : List (StoredEntry n)) (nx ny budget : ℕ) | |
| (hx : xs.length = nx) (hy : ys.length = ny) | |
| (hb : (reference capacity target blocks xs ys).2 ≤ budget) : | |
| (execute capacity target blocks xs ys nx ny budget).1 = | |
| some ((reference capacity target blocks xs ys).1, | |
| budget - (reference capacity target blocks xs ys).2) := by | |
| induction blocks generalizing xs ys nx ny budget with | |
| | nil => | |
| simp only [reference, hx, hy] at hb ⊢ | |
| have hfour : 4 ≤ budget := by split at hb <;> dsimp only at hb <;> omega | |
| rw [execute] | |
| apply (bind_eq_some _ _ _ _).mpr | |
| refine ⟨decide (nx + ny ≤ capacity), budget - 4, ?_, ?_⟩ | |
| · exact congrArg Prod.fst (BudgetedSeparatorCall.complete 4 _ budget hfour) | |
| · by_cases hs : nx + ny ≤ capacity | |
| · simp only [hs, decide_true, ↓reduceIte] at hb ⊢ | |
| have hc : BudgetedSeparatorTerminal.charge n nx ny ≤ budget - 4 := by omega | |
| rw [BudgetedSeparatorTerminal.complete target xs ys nx ny _ hc] | |
| congr 2 | |
| omega | |
| · simp only [hs, decide_false, Bool.false_eq_true, ↓reduceIte, BudgetedSeparatorFlow.pure] | |
| | cons b rest ih => | |
| simp only [reference, hx, hy] at hb ⊢ | |
| have hfour : 4 ≤ budget := by split at hb <;> dsimp only at hb <;> omega | |
| rw [execute] | |
| apply (bind_eq_some _ _ _ _).mpr | |
| refine ⟨decide (nx + ny ≤ capacity), budget - 4, ?_, ?_⟩ | |
| · exact congrArg Prod.fst (BudgetedSeparatorCall.complete 4 _ budget hfour) | |
| · by_cases hs : nx + ny ≤ capacity | |
| · simp only [hs, decide_true, ↓reduceIte] at hb ⊢ | |
| have ht := BudgetedSeparatorTraversal.execute_complete b.queryBound b.leftQuery b.rightQuery | |
| (fun _ as bs na nb rem => execute capacity target rest as bs na nb rem) | |
| (fun _ as bs => reference capacity target rest as bs) | |
| (fun _ as bs na nb rem ha hb hc => ih as bs na nb rem ha hb hc) | |
| b.depth 0 b.familySize xs ys nx ny (budget - 4) hx hy (by omega) | |
| simpa only [Nat.sub_sub] using ht | |
| · simp only [hs, decide_false, Bool.false_eq_true, ↓reduceIte, BudgetedSeparatorFlow.pure] | |
| end LowSpaceSubsetSum.BudgetedSeparatorCheck | |
| end OAI | |