| import OAI.Computability.BinPacking.Arithmetic.NatExpressionBounds |
| import OAI.Computability.BinPacking.Machines.PackingCountedProgram |
|
|
| namespace OAI |
|
|
| namespace BinPackingGap.PackingRegisterUpdate |
|
|
| open Turing |
| open BinPackingGames.Foundations.Complexity |
| open BinaryRegisterProgram |
| open FiniteTapeProgram PackingMachineBlocks |
|
|
| inductive Kind |
| | add | multiply |
| deriving DecidableEq |
|
|
| instance : Fintype Kind where |
| elems := {.add, .multiply} |
| complete k := by cases k <;> simp |
|
|
| def operation (kind : Kind) : Nat → Nat → Nat := |
| match kind with |
| | .add => Nat.add |
| | .multiply => Nat.mul |
|
|
| def operands : Operands (Fin 3) where |
| destination := 2 |
| left := 0 |
| right := 1 |
| left_ne_right := by decide |
| left_ne_destination := by decide |
| right_ne_destination := by decide |
|
|
| def operator : Kind → Command (Fin 3) |
| | .add => .add operands |
| | .multiply => .mul operands |
|
|
| def commands (kind : Kind) : List (Command (Fin 3)) := |
| [operator kind, .clear 1, .copy 1 2 (by decide), .clear 2] |
|
|
| def values (a b : Nat) : Fin 3 → Nat := ![a, b, 0] |
|
|
| theorem commands_ready (kind : Kind) (a b : Nat) : Ready (commands kind) (values a b) := by |
| cases kind <;> |
| simp [commands, operator, Ready, commandReady, result, destination, value, operands, values] |
|
|
| theorem commands_result (kind : Kind) (a b : Nat) : |
| resultOf (commands kind) (values a b) = values a (operation kind a b) := by |
| funext r |
| cases kind <;> fin_cases r <;> |
| simp [commands, operator, resultOf_cons, result, destination, value, operands, values, |
| operation] |
|
|
| theorem operation_size_le (kind : Kind) (a b : Nat) : |
| (operation kind a b).size ≤ a.size + b.size + 1 := by |
| cases kind with |
| | add => |
| have h := BinaryArithmetic.size_add_le a b |
| change (a + b).size ≤ a.size + b.size + 1 |
| omega |
| | multiply => |
| exact (BinaryArithmetic.size_mul_le a b).trans (Nat.le_succ _) |
|
|
| theorem commands_budget (kind : Kind) (a b : Nat) : |
| budget (commands kind) (values a b) = |
| cost (operator kind) (values a b) + b.size + 3 * (operation kind a b).size + 4 := by |
| cases kind <;> |
| simp [commands, operator, budget, MachineFiniteSequence.steps, result, destination, |
| value, operands, values, cost, operation] <;> omega |
|
|
| theorem commands_budget_le (kind : Kind) (a b : Nat) : |
| budget (commands kind) (values a b) + 1 ≤ 64 * (a.size + b.size + 1) ^ 2 := by |
| have hsize := operation_size_le kind a b |
| have hw : 1 ≤ a.size + b.size + 1 := by omega |
| have hsquare : a.size + b.size + 1 ≤ (a.size + b.size + 1) ^ 2 := by nlinarith |
| rw [commands_budget] |
| cases kind <;> simp [operator, cost, operands, values, operation] at * <;> nlinarith |
|
|
| def main (kind : Kind) : BinaryRegisterProgram.Label (commands kind) := |
| .inl (BinaryRegisterProgram.main (operator kind)) |
|
|
| variable {K : Type} [DecidableEq K] |
|
|
| def code (slots : (Fin 3 ⊕ Fin 6) ↪ K) (kind : Kind) : Code (K := K) (S := State) := |
| invoke arithmeticControl (BinaryAddMachine.clean ()) (main kind) |
| (BinaryRegisterProgram.program slots (commands kind)) |
|
|
| theorem exec (slots : (Fin 3 ⊕ Fin 6) ↪ K) (kind : Kind) |
| (base : K → List Bool) (a b : Nat) (state : State) : |
| ∃ steps ≤ 64 * (a.size + b.size + 1) ^ 2, |
| Exec (code slots kind) ⟨state, registerTapes slots base (values a b)⟩ steps |
| ⟨.arithmetic (BinaryAddMachine.clean ()), |
| registerTapes slots base (values a (operation kind a b))⟩ := by |
| have run := BinaryRegisterProgram.programInTime slots (commands kind) base |
| (values a b) (commands_ready kind a b) () |
| rw [commands_result] at run |
| have run' : StateTransition.EvalsToInTime |
| (TM2.step (BinaryRegisterProgram.program (A := Unit) slots (commands kind))) |
| ⟨some (main kind), BinaryAddMachine.clean (), registerTapes slots base (values a b)⟩ |
| (some ⟨none, BinaryAddMachine.clean (), |
| registerTapes slots base (values a (operation kind a b))⟩) |
| (budget (commands kind) (values a b)) := run |
| obtain ⟨n, hn, hrun⟩ := invokeExecInTime arithmeticControl (BinaryAddMachine.clean ()) |
| (main kind) (BinaryRegisterProgram.program slots (commands kind)) |
| ⟨state, registerTapes slots base (values a b)⟩ (BinaryAddMachine.clean ()) |
| (registerTapes slots base (values a (operation kind a b))) _ run' |
| exact ⟨n, hn.trans (commands_budget_le kind a b), hrun⟩ |
|
|
| end BinPackingGap.PackingRegisterUpdate |
|
|
| end OAI |
|
|
