openAI-math-dataset / lean /OAI /Computability /BinPacking /Arithmetic /ResetExpressionCompiler.lean
| import OAI.Computability.BinPacking.Packing.PairExpressionCompiler | |
| namespace OAI | |
| noncomputable section | |
| namespace BinPackingGap.ResetExpressionCompiler | |
| open NatExpressionCompiler BinaryRegisterProgram PairExpressionCompiler | |
| variable {α Reg : Type} [DecidableEq Reg] | |
| def nodeList (expression : Expr α) (nodes : Node expression ↪ Reg) : List Reg := | |
| (Finset.univ : Finset (Node expression)).toList.map nodes | |
| omit [DecidableEq Reg] in | |
| theorem mem_nodeList (expression : Expr α) (nodes : Node expression ↪ Reg) (r : Reg) : | |
| r ∈ nodeList expression nodes ↔ ∃ n, r = nodes n := by | |
| simp [nodeList, eq_comm] | |
| def commands (inputs : α → Reg) (expression : Expr α) | |
| (nodes : Node expression ↪ Reg) (apart : ∀ a n, inputs a ≠ nodes n) | |
| (output : Reg) (outputApart : ∀ n, output ≠ nodes n) : List (Command Reg) := | |
| .clear output :: (compileInto inputs expression nodes apart ++ | |
| (.copy output (nodes (root expression)) (outputApart _) :: | |
| clearList (nodeList expression nodes))) | |
| theorem correct (inputs : α → Reg) (expression : Expr α) | |
| (nodes : Node expression ↪ Reg) (apart : ∀ a n, inputs a ≠ nodes n) | |
| (output : Reg) (outputApart : ∀ n, output ≠ nodes n) | |
| (inputOutput : ∀ a, inputs a ≠ output) | |
| (values : Reg → Nat) (empty : ∀ n, values (nodes n) = 0) : | |
| Ready (commands inputs expression nodes apart output outputApart) values ∧ | |
| resultOf (commands inputs expression nodes apart output outputApart) values = | |
| Function.update values output (eval (fun a => values (inputs a)) expression) := by | |
| let reset := result (.clear output) values | |
| let calculated := resultOf (compileInto inputs expression nodes apart) reset | |
| have resetNodes : ∀ n, reset (nodes n) = 0 := by | |
| intro n | |
| simp [reset, result, destination, value, Ne.symm (outputApart n), empty n] | |
| have resetInputs : ∀ a, reset (inputs a) = values (inputs a) := by | |
| intro a | |
| simp [reset, result, destination, value, inputOutput a] | |
| have compiled := compileInto_correct inputs expression nodes apart reset resetNodes | |
| have outputZero : calculated output = 0 := by | |
| rw [show calculated output = reset output from compiled.2.2 output outputApart] | |
| simp [reset, result, destination, value] | |
| have rootValue : calculated (nodes (root expression)) = | |
| eval (fun a => values (inputs a)) expression := by | |
| simpa only [calculated, resetInputs] using compiled.2.1 | |
| constructor | |
| · change True ∧ Ready (compileInto inputs expression nodes apart ++ _) reset | |
| refine ⟨True.intro, ?_⟩ | |
| rw [Ready_append] | |
| refine ⟨compiled.1, ?_⟩ | |
| change calculated output = 0 ∧ _ | |
| exact ⟨outputZero, clearList_ready _ _⟩ | |
| · funext r | |
| simp only [commands, resultOf_cons, resultOf_append] | |
| rw [clearList_result] | |
| by_cases member : r ∈ nodeList expression nodes | |
| · obtain ⟨n, rfl⟩ := (mem_nodeList expression nodes r).mp member | |
| simp only [ite_eq_left member] | |
| simp [Ne.symm (outputApart n), empty n] | |
| · rw [ite_eq_right member] | |
| have outside : ∀ n, r ≠ nodes n := by | |
| intro n hn | |
| exact member ((mem_nodeList expression nodes r).mpr ⟨n, hn⟩) | |
| by_cases same : r = output | |
| · subst r | |
| simpa only [calculated, reset, result, destination, value, Function.update_self] using rootValue | |
| · have preserved : calculated r = reset r := compiled.2.2 r outside | |
| change (result (.copy output (nodes (root expression)) (outputApart _)) | |
| calculated) r = Function.update values output _ r | |
| rw [result_other _ _ _ same, preserved] | |
| simp [reset, result, destination, value, same] | |
| end BinPackingGap.ResetExpressionCompiler | |
| end | |
| end OAI | |