| import OAI.Computability.BinPacking.Arithmetic.NatExpressionBranch |
| import OAI.Computability.BinPacking.Machines.GraphPackingBounds |
|
|
| namespace OAI |
|
|
| namespace BinPackingGap.BinaryRegisterProgram |
|
|
| section |
|
|
| open Turing |
| open BinPackingGames.Foundations.Complexity |
|
|
| variable {Reg K Λ A : Type} [DecidableEq Reg] [DecidableEq K] |
|
|
| noncomputable def addCommandInTime (slot : (Reg ⊕ Fin 6) ↪ K) (op : Operands Reg) |
| (labels : LocalLabel (.add op) → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (BinaryAddMachine.State A)) |
| (atLabels : ∀ label, |
| p (labels label) = localInstruction slot (.add op) labels exit label) |
| (base : K → List Bool) (values : Reg → Nat) |
| (ready : commandReady (.add op) values) (ambient : A) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨some (labels (main (.add op))), BinaryAddMachine.clean ambient, |
| registerTapes slot base values⟩ |
| (some ⟨exit, BinaryAddMachine.clean ambient, |
| registerTapes slot base (result (.add op) values)⟩) |
| (cost (.add op) values) := by |
| have hd : values op.destination = 0 := ready |
| have run := BinaryAddPreserving.addInLinearTime (addSlots slot op) labels exit p |
| (fun label => atLabels label) (registerTapes slot base values) |
| (values op.left) (values op.right) |
| (by simp) (by simp) (by simp) (by simp) (by simp) (by simp [hd]) (by simp) ambient |
| have hresult : BinaryAddPreserving.resultTapes (addSlots slot op) |
| (registerTapes slot base values) (values op.left) (values op.right) = |
| registerTapes slot base (result (.add op) values) := by |
| simpa only [BinaryAddPreserving.resultTapes, addSlots_five, result, destination, value] |
| using registerTapes_update slot base values op.destination |
| (values op.left + values op.right) |
| simpa only [hresult, main, cost] using run |
|
|
| noncomputable def mulCommandInTime (slot : (Reg ⊕ Fin 6) ↪ K) (op : Operands Reg) |
| (labels : LocalLabel (.mul op) → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (BinaryAddMachine.State A)) |
| (atLabels : ∀ label, |
| p (labels label) = localInstruction slot (.mul op) labels exit label) |
| (base : K → List Bool) (values : Reg → Nat) |
| (ready : commandReady (.mul op) values) (ambient : A) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨some (labels (main (.mul op))), BinaryAddMachine.clean ambient, |
| registerTapes slot base values⟩ |
| (some ⟨exit, BinaryAddMachine.clean ambient, |
| registerTapes slot base (result (.mul op) values)⟩) |
| (cost (.mul op) values) := by |
| have hd : values op.destination = 0 := ready |
| have hout : registerTapes slot base values (mulSlots slot op 2) = [] := by simp [hd] |
| have run := BinaryMulMachine.multiplyNatInPolynomialTime (mulSlots slot op) labels exit p |
| (fun label => atLabels label) (registerTapes slot base values) |
| (values op.left) (values op.right) (by simp) (by simp) |
| (registerTapes_mul_workspace slot op base values) ambient |
| have hresult : Function.update (registerTapes slot base values) (mulSlots slot op 2) |
| ((values op.left * values op.right).bits ++ |
| registerTapes slot base values (mulSlots slot op 2)) = |
| registerTapes slot base (result (.mul op) values) := by |
| rw [hout, List.append_nil, mulSlots_two] |
| exact registerTapes_update slot base values op.destination |
| (values op.left * values op.right) |
| simpa only [hresult, main, cost, BinaryMulMachine.clean, |
| BinaryAddMachine.clean, BinaryAddMachine.state, BinaryMulMachine.timePolynomial, |
| Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_C, |
| Polynomial.eval_pow, Polynomial.eval_X] using run |
|
|
| noncomputable def monusCommandInTime (slot : (Reg ⊕ Fin 6) ↪ K) (op : Operands Reg) |
| (labels : LocalLabel (.monus op) → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (BinaryAddMachine.State A)) |
| (atLabels : ∀ label, |
| p (labels label) = localInstruction slot (.monus op) labels exit label) |
| (base : K → List Bool) (values : Reg → Nat) |
| (ready : commandReady (.monus op) values) (ambient : A) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨some (labels (main (.monus op))), BinaryAddMachine.clean ambient, |
| registerTapes slot base values⟩ |
| (some ⟨exit, BinaryAddMachine.clean ambient, |
| registerTapes slot base (result (.monus op) values)⟩) |
| (cost (.monus op) values) := by |
| have hd : values op.destination = 0 := ready |
| have hwork : ∀ i : Fin 7, 2 ≤ i.val → |
| registerTapes slot base values (addSlots slot op i) = [] := by |
| intro i hi |
| by_cases hout : i = 5 |
| · subst i; simp [hd] |
| · exact registerTapes_add_workspace slot op base values i hi hout |
| have run := BinaryMonusPreserving.monusInLinearTime (addSlots slot op) labels exit p |
| (fun label => atLabels label) (registerTapes slot base values) |
| (values op.left) (values op.right) (by simp) (by simp) hwork ambient |
| have hresult : BinaryMonusPreserving.resultTapes (addSlots slot op) |
| (registerTapes slot base values) (values op.left) (values op.right) = |
| registerTapes slot base (result (.monus op) values) := by |
| simpa only [BinaryMonusPreserving.resultTapes, addSlots_five, result, destination, value] |
| using registerTapes_update slot base values op.destination |
| (values op.left - values op.right) |
| simpa only [hresult, main, cost] using run |
|
|
| end |
|
|
| section |
|
|
| open Turing |
| open BinPackingGames.Foundations.Complexity |
| open BinPackingGames.Reduction |
| open BinaryAddMachine (State clean) |
|
|
| variable {Reg K Λ A : Type} [DecidableEq Reg] [DecidableEq K] |
|
|
| noncomputable def constantCommandInTime (slot : (Reg ⊕ Fin 6) ↪ K) (dst : Reg) (n : ℕ) |
| (labels : LocalLabel (.constant dst n) → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (State A)) |
| (atLabels : ∀ l, |
| p (labels l) = localInstruction slot (.constant dst n) labels exit l) |
| (base : K → List Bool) (vals : Reg → ℕ) |
| (ready : commandReady (.constant dst n) vals) (ambient : A) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨some (labels (main (.constant dst n))), clean ambient, registerTapes slot base vals⟩ |
| (some ⟨exit, clean ambient, registerTapes slot base (result (.constant dst n) vals)⟩) |
| (cost (.constant dst n) vals) := by |
| have hzero : vals dst = 0 := ready |
| have hempty : registerTapes slot base vals (slot (.inl dst)) = [] := by |
| simp only [registerTapes_reg, hzero, Nat.zero_bits] |
| refine { steps := 1, evals_in_steps := ?_, steps_le_m := le_rfl } |
| change some (TM2.stepAux (p (labels ())) (clean ambient) (registerTapes slot base vals)) = |
| some ⟨exit, clean ambient, registerTapes slot base (result (.constant dst n) vals)⟩ |
| rw [atLabels ()] |
| simp only [localInstruction] |
| rw [MachineSubstitution.stepAux_pushWord] |
| simp only [List.reverse_reverse, hempty, List.append_nil, registerTapes_update] |
| cases exit <;> rfl |
|
|
| noncomputable def clearCommandInTime (slot : (Reg ⊕ Fin 6) ↪ K) (dst : Reg) |
| (labels : LocalLabel (.clear dst) → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (State A)) |
| (atLabels : ∀ l, p (labels l) = localInstruction slot (.clear dst) labels exit l) |
| (base : K → List Bool) (vals : Reg → ℕ) |
| (_ready : commandReady (.clear dst) vals) (ambient : A) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨some (labels (main (.clear dst))), clean ambient, registerTapes slot base vals⟩ |
| (some ⟨exit, clean ambient, registerTapes slot base (result (.clear dst) vals)⟩) |
| (cost (.clear dst) vals) := by |
| have run := MachineDrain.drainInTime (slot (.inl dst)) (labels ()) exit p |
| (by simpa only [localInstruction] using atLabels ()) |
| (registerTapes slot base vals) ((ambient, false), none) none |
| have hframe : Function.update (registerTapes slot base vals) (slot (.inl dst)) [] = |
| registerTapes slot base (result (.clear dst) vals) := by |
| simpa only [result, destination, value, Nat.zero_bits] using |
| registerTapes_update slot base vals dst 0 |
| rw [hframe] at run |
| simpa only [main, cost, BinaryAddMachine.clean, BinaryAddMachine.state, |
| registerTapes_reg, Nat.size_eq_bits_len] using run |
|
|
| noncomputable def copyCommandInTime (slot : (Reg ⊕ Fin 6) ↪ K) (dst src : Reg) (different : dst ≠ src) |
| (labels : LocalLabel (.copy dst src different) → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (State A)) |
| (atLabels : ∀ l, |
| p (labels l) = localInstruction slot (.copy dst src different) labels exit l) |
| (base : K → List Bool) (vals : Reg → ℕ) |
| (ready : commandReady (.copy dst src different) vals) (ambient : A) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨some (labels (main (.copy dst src different))), clean ambient, |
| registerTapes slot base vals⟩ |
| (some ⟨exit, clean ambient, |
| registerTapes slot base (result (.copy dst src different) vals)⟩) |
| (cost (.copy dst src different) vals) := by |
| have hzero : vals dst = 0 := ready |
| have hSD : slot (.inl src) ≠ slot (.inl dst) := |
| slot.injective.ne (by simpa only [ne_eq, Sum.inl.injEq] using different.symm) |
| have hSC : slot (.inl src) ≠ slot (.inr (0 : Fin 6)) := |
| slot.injective.ne (by simp) |
| have hDC : slot (.inl dst) ≠ slot (.inr (0 : Fin 6)) := |
| slot.injective.ne (by simp) |
| have run := MachineCopy.copyInTime (slot (.inl src)) (slot (.inl dst)) |
| (slot (.inr (0 : Fin 6))) hSD hSC hDC false (labels false) (labels true) exit p |
| (by simpa [localInstruction] using atLabels false) |
| (by simpa [localInstruction] using atLabels true) |
| (registerTapes slot base vals) (by simp only [registerTapes_scratch]) |
| ((ambient, false), none) none |
| have hframe : Function.update (registerTapes slot base vals) (slot (.inl dst)) |
| (registerTapes slot base vals (slot (.inl src)) ++ |
| registerTapes slot base vals (slot (.inl dst))) = |
| registerTapes slot base (result (.copy dst src different) vals) := by |
| simp only [registerTapes_reg, hzero, Nat.zero_bits, List.append_nil] |
| exact registerTapes_update slot base vals dst (vals src) |
| rw [hframe] at run |
| simpa only [main, cost, BinaryAddMachine.clean, BinaryAddMachine.state, |
| registerTapes_reg, Nat.size_eq_bits_len] using run |
|
|
| end |
|
|
| open Turing |
| open BinPackingGames.Foundations.Complexity |
|
|
| variable {Reg K Λ A : Type} [DecidableEq Reg] [DecidableEq K] |
|
|
| def appendRuns {X : Type} {step : X → Option X} {a b c : X} {m n : Nat} |
| (first : StateTransition.EvalsToInTime step a (some b) m) |
| (second : StateTransition.EvalsToInTime step b (some c) n) : |
| StateTransition.EvalsToInTime step a (some c) (m + n) where |
| steps := first.steps + second.steps |
| evals_in_steps := by |
| rw [Nat.add_comm, Function.iterate_add_apply, first.evals_in_steps] |
| exact second.evals_in_steps |
| steps_le_m := Nat.add_le_add first.steps_le_m second.steps_le_m |
|
|
| noncomputable def commandInTime (slot : (Reg ⊕ Fin 6) ↪ K) (command : Command Reg) |
| (labels : LocalLabel command → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (BinaryAddMachine.State A)) |
| (atLabels : ∀ l, p (labels l) = localInstruction slot command labels exit l) |
| (base : K → List Bool) (values : Reg → Nat) (ready : commandReady command values) |
| (ambient : A) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨some (labels (main command)), BinaryAddMachine.clean ambient, registerTapes slot base values⟩ |
| (some ⟨exit, BinaryAddMachine.clean ambient, registerTapes slot base (result command values)⟩) |
| (cost command values) := by |
| cases command with |
| | add op => exact addCommandInTime slot op labels exit p atLabels base values ready ambient |
| | mul op => exact mulCommandInTime slot op labels exit p atLabels base values ready ambient |
| | monus op => exact monusCommandInTime slot op labels exit p atLabels base values ready ambient |
| | constant dst n => |
| exact constantCommandInTime slot dst n labels exit p atLabels base values ready ambient |
| | clear dst => exact clearCommandInTime slot dst labels exit p atLabels base values ready ambient |
| | copy dst src different => |
| exact copyCommandInTime slot dst src different labels exit p atLabels base values ready ambient |
|
|
| noncomputable def runInTime (slot : (Reg ⊕ Fin 6) ↪ K) |
| (commands : List (Command Reg)) (labels : Label commands → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (BinaryAddMachine.State A)) |
| (atLabels : ∀ l, p (labels l) = instruction slot commands labels exit l) |
| (base : K → List Bool) (values : Reg → Nat) (ready : Ready commands values) (ambient : A) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨entry commands labels exit, BinaryAddMachine.clean ambient, registerTapes slot base values⟩ |
| (some ⟨exit, BinaryAddMachine.clean ambient, |
| registerTapes slot base (resultOf commands values)⟩) (budget commands values) := by |
| induction commands generalizing values with |
| | nil => exact { steps := 0, evals_in_steps := rfl, steps_le_m := Nat.le_refl 0 } |
| | cons command commands ih => |
| have firstRun := commandInTime slot command (fun l => labels (.inl l)) |
| (entry commands (fun l => labels (.inr l)) exit) p |
| (fun l => atLabels (.inl l)) base values ready.1 ambient |
| have tailRun := ih (fun l => labels (.inr l)) (fun l => atLabels (.inr l)) |
| (result command values) ready.2 |
| exact appendRuns firstRun tailRun |
|
|
| def program (slot : (Reg ⊕ Fin 6) ↪ K) (commands : List (Command Reg)) : |
| Label commands → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) (Label commands) |
| (BinaryAddMachine.State A) := instruction slot commands id none |
|
|
| noncomputable def programInTime (slot : (Reg ⊕ Fin 6) ↪ K) |
| (commands : List (Command Reg)) (base : K → List Bool) (values : Reg → Nat) |
| (ready : Ready commands values) (ambient : A) : |
| StateTransition.EvalsToInTime (TM2.step (program (A := A) slot commands)) |
| ⟨entry commands id none, BinaryAddMachine.clean ambient, registerTapes slot base values⟩ |
| (some ⟨none, BinaryAddMachine.clean ambient, |
| registerTapes slot base (resultOf commands values)⟩) (budget commands values) := |
| runInTime slot commands id none (program slot commands) (fun _ => rfl) base values ready ambient |
|
|
| def BitBounded (width : Nat) : List (Command Reg) → (Reg → Nat) → Prop |
| | [], values => ∀ r, (values r).size ≤ width |
| | command :: commands, values => |
| (∀ r, (values r).size ≤ width) ∧ BitBounded width commands (result command values) |
|
|
| def commandBound (width : Nat) : Nat := 16 * width ^ 2 + 28 * width + 12 |
|
|
| omit [DecidableEq Reg] in |
| theorem cost_le (command : Command Reg) (values : Reg → Nat) (width : Nat) |
| (bounded : ∀ r, (values r).size ≤ width) : cost command values ≤ commandBound width := by |
| cases command with |
| | add op => |
| have hl := bounded op.left |
| have hr := bounded op.right |
| simp only [cost, commandBound] |
| omega |
| | mul op => |
| have hsum : (values op.left).size + (values op.right).size ≤ 2 * width := by |
| have hl := bounded op.left |
| have hr := bounded op.right |
| omega |
| have hsquare := Nat.mul_le_mul hsum hsum |
| simp only [cost, commandBound] |
| nlinarith |
| | monus op => |
| have hl := bounded op.left |
| have hr := bounded op.right |
| simp only [cost, commandBound] |
| omega |
| | constant dst n => simp only [cost, commandBound]; omega |
| | clear dst => |
| have hd := bounded dst |
| simp only [cost, commandBound] |
| omega |
| | copy dst src different => |
| have hs := bounded src |
| simp only [cost, commandBound] |
| omega |
|
|
| theorem budget_le (commands : List (Command Reg)) (values : Reg → Nat) (width : Nat) |
| (bounded : BitBounded width commands values) : |
| budget commands values ≤ commands.length * commandBound width := by |
| induction commands generalizing values with |
| | nil => simp [budget, MachineFiniteSequence.steps] |
| | cons command commands ih => |
| have headBound := cost_le command values width bounded.1 |
| have tailBound := ih (result command values) bounded.2 |
| change cost command values + budget commands (result command values) ≤ |
| (commands.length + 1) * commandBound width |
| calc |
| _ ≤ commandBound width + commands.length * commandBound width := |
| Nat.add_le_add headBound tailBound |
| _ = _ := by simp [Nat.add_mul, Nat.add_comm] |
|
|
| noncomputable def programInQuadraticTime (slot : (Reg ⊕ Fin 6) ↪ K) |
| (commands : List (Command Reg)) (base : K → List Bool) (values : Reg → Nat) |
| (ready : Ready commands values) (ambient : A) (width : Nat) |
| (bounded : BitBounded width commands values) : |
| StateTransition.EvalsToInTime (TM2.step (program (A := A) slot commands)) |
| ⟨entry commands id none, BinaryAddMachine.clean ambient, registerTapes slot base values⟩ |
| (some ⟨none, BinaryAddMachine.clean ambient, |
| registerTapes slot base (resultOf commands values)⟩) |
| (commands.length * commandBound width) := by |
| let run := programInTime slot commands base values ready ambient |
| exact { steps := run.steps |
| evals_in_steps := run.evals_in_steps |
| steps_le_m := run.steps_le_m.trans (budget_le commands values width bounded) } |
|
|
| noncomputable def runInQuadraticTime (slot : (Reg ⊕ Fin 6) ↪ K) |
| (commands : List (Command Reg)) (labels : Label commands → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (BinaryAddMachine.State A)) |
| (atLabels : ∀ l, p (labels l) = instruction slot commands labels exit l) |
| (base : K → List Bool) (values : Reg → Nat) (ready : Ready commands values) |
| (ambient : A) (width : Nat) (bounded : BitBounded width commands values) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨entry commands labels exit, BinaryAddMachine.clean ambient, registerTapes slot base values⟩ |
| (some ⟨exit, BinaryAddMachine.clean ambient, |
| registerTapes slot base (resultOf commands values)⟩) |
| (commands.length * commandBound width) := by |
| let run := runInTime slot commands labels exit p atLabels base values ready ambient |
| exact { steps := run.steps |
| evals_in_steps := run.evals_in_steps |
| steps_le_m := run.steps_le_m.trans (budget_le commands values width bounded) } |
|
|
| end BinPackingGap.BinaryRegisterProgram |
|
|
| namespace BinPackingGap.NatExpressionCompiler |
|
|
| open BinaryRegisterProgram |
|
|
| variable {α Reg : Type} [DecidableEq Reg] |
|
|
| def compileInto (inputs : α → Reg) : |
| (expression : Expr α) → (nodes : Node expression ↪ Reg) → |
| (∀ a node, inputs a ≠ nodes node) → List (Command Reg) |
| | .constant n, nodes, _ => [.constant (nodes ()) n] |
| | .input a, nodes, apart => [.copy (nodes ()) (inputs a) (apart a ()).symm] |
| | .add left right, nodes, apart => |
| (compileInto inputs left (leftReg nodes) (fun a node => apart a (.inr (.inl node))) ++ |
| compileInto inputs right (rightReg nodes) (fun a node => apart a (.inr (.inr node)))) ++ |
| [command .add (branchOperands nodes (root left) (root right))] |
| | .mul left right, nodes, apart => |
| (compileInto inputs left (leftReg nodes) (fun a node => apart a (.inr (.inl node))) ++ |
| compileInto inputs right (rightReg nodes) (fun a node => apart a (.inr (.inr node)))) ++ |
| [command .mul (branchOperands nodes (root left) (root right))] |
| | .monus left right, nodes, apart => |
| (compileInto inputs left (leftReg nodes) (fun a node => apart a (.inr (.inl node))) ++ |
| compileInto inputs right (rightReg nodes) (fun a node => apart a (.inr (.inr node)))) ++ |
| [command .monus (branchOperands nodes (root left) (root right))] |
|
|
| theorem compileInto_correct (inputs : α → Reg) (expression : Expr α) |
| (nodes : Node expression ↪ Reg) (apart : ∀ a node, inputs a ≠ nodes node) : |
| Correct inputs nodes (root expression) (fun values => eval values expression) |
| (compileInto inputs expression nodes apart) := by |
| induction expression with |
| | constant n => |
| intro values empty |
| refine ⟨?_, ?_, ?_⟩ |
| · change values (nodes ()) = 0 ∧ True |
| exact ⟨empty (), trivial⟩ |
| · simp [compileInto, result, destination, value] |
| · intro r outside |
| simpa only [compileInto, resultOf_cons, resultOf_nil] using |
| result_other (.constant (nodes ()) n) values r (outside ()) |
| | input a => |
| intro values empty |
| refine ⟨?_, ?_, ?_⟩ |
| · change values (nodes ()) = 0 ∧ True |
| exact ⟨empty (), trivial⟩ |
| · simp [compileInto, result, destination, value] |
| · intro r outside |
| simpa only [compileInto, resultOf_cons, resultOf_nil] using |
| result_other (.copy (nodes ()) (inputs a) (apart a ()).symm) values r (outside ()) |
| | add left right ihLeft ihRight => |
| exact branchCorrect .add inputs nodes apart (root left) (root right) |
| (fun values => eval values left) (fun values => eval values right) |
| (compileInto inputs left (leftReg nodes) (fun a node => apart a (.inr (.inl node)))) |
| (compileInto inputs right (rightReg nodes) (fun a node => apart a (.inr (.inr node)))) |
| (ihLeft (leftReg nodes) (fun a node => apart a (.inr (.inl node)))) |
| (ihRight (rightReg nodes) (fun a node => apart a (.inr (.inr node)))) |
| | mul left right ihLeft ihRight => |
| exact branchCorrect .mul inputs nodes apart (root left) (root right) |
| (fun values => eval values left) (fun values => eval values right) |
| (compileInto inputs left (leftReg nodes) (fun a node => apart a (.inr (.inl node)))) |
| (compileInto inputs right (rightReg nodes) (fun a node => apart a (.inr (.inr node)))) |
| (ihLeft (leftReg nodes) (fun a node => apart a (.inr (.inl node)))) |
| (ihRight (rightReg nodes) (fun a node => apart a (.inr (.inr node)))) |
| | monus left right ihLeft ihRight => |
| exact branchCorrect .monus inputs nodes apart (root left) (root right) |
| (fun values => eval values left) (fun values => eval values right) |
| (compileInto inputs left (leftReg nodes) (fun a node => apart a (.inr (.inl node)))) |
| (compileInto inputs right (rightReg nodes) (fun a node => apart a (.inr (.inr node)))) |
| (ihLeft (leftReg nodes) (fun a node => apart a (.inr (.inl node)))) |
| (ihRight (rightReg nodes) (fun a node => apart a (.inr (.inr node)))) |
|
|
| abbrev Register (expression : Expr α) := α ⊕ Node expression |
|
|
| def inputRegister (expression : Expr α) : α → Register expression := Sum.inl |
|
|
| def nodeRegister (expression : Expr α) : Node expression ↪ Register expression where |
| toFun := Sum.inr |
| inj' := by |
| intro a b h |
| exact Sum.inr.inj h |
| |
| theorem registers_disjoint (expression : Expr α) (a : α) (node : Node expression) : |
| inputRegister expression a ≠ nodeRegister expression node := by |
| simp [inputRegister, nodeRegister] |
| |
| def initialValues (expression : Expr α) (values : α → Nat) : Register expression → Nat |
| | .inl a => values a |
| | .inr _ => 0 |
| |
| variable [DecidableEq α] |
| |
| def commands (expression : Expr α) : List (Command (Register expression)) := |
| compileInto (inputRegister expression) expression (nodeRegister expression) |
| (registers_disjoint expression) |
| |
| theorem commands_correct (expression : Expr α) : |
| Correct (inputRegister expression) (nodeRegister expression) (root expression) |
| (fun values => eval values expression) (commands expression) := |
| compileInto_correct _ _ _ _ |
| |
| theorem commands_ready (expression : Expr α) (values : α → Nat) : |
| Ready (commands expression) (initialValues expression values) := by |
| have h := commands_correct expression (initialValues expression values) (fun _ => rfl) |
| exact h.1 |
| |
| theorem commands_output (expression : Expr α) (values : α → Nat) : |
| resultOf (commands expression) (initialValues expression values) |
| (nodeRegister expression (root expression)) = eval values expression := by |
| have h := commands_correct expression (initialValues expression values) (fun _ => rfl) |
| simpa only [inputRegister, initialValues] using h.2.1 |
| |
| theorem commands_preserve_input (expression : Expr α) (values : α → Nat) (a : α) : |
| resultOf (commands expression) (initialValues expression values) |
| (inputRegister expression a) = values a := by |
| have h := commands_correct expression (initialValues expression values) (fun _ => rfl) |
| exact h.2.2 (inputRegister expression a) (registers_disjoint expression a) |
| |
| noncomputable def compiledProgramInTime {K A : Type} [DecidableEq K] |
| (expression : Expr α) (slot : (Register expression ⊕ Fin 6) ↪ K) |
| (base : K → List Bool) (values : α → Nat) (ambient : A) : |
| StateTransition.EvalsToInTime |
| (Turing.TM2.step (BinaryRegisterProgram.program (A := A) slot (commands expression))) |
| ⟨BinaryRegisterProgram.entry (commands expression) id none, |
| BinaryAddMachine.clean ambient, |
| registerTapes slot base (initialValues expression values)⟩ |
| (some ⟨none, BinaryAddMachine.clean ambient, |
| registerTapes slot base |
| (resultOf (commands expression) (initialValues expression values))⟩) |
| (budget (commands expression) (initialValues expression values)) := |
| BinaryRegisterProgram.programInTime slot (commands expression) base |
| (initialValues expression values) (commands_ready expression values) ambient |
| |
| theorem compiled_output_tape {K : Type} (expression : Expr α) |
| (slot : (Register expression ⊕ Fin 6) ↪ K) (base : K → List Bool) |
| (values : α → Nat) : |
| registerTapes slot base (resultOf (commands expression) (initialValues expression values)) |
| (slot (.inl (nodeRegister expression (root expression)))) = |
| (eval values expression).bits := by |
| rw [registerTapes_reg, commands_output] |
| |
| theorem compiled_input_tape {K : Type} (expression : Expr α) |
| (slot : (Register expression ⊕ Fin 6) ↪ K) (base : K → List Bool) |
| (values : α → Nat) (a : α) : |
| registerTapes slot base (resultOf (commands expression) (initialValues expression values)) |
| (slot (.inl (inputRegister expression a))) = (values a).bits := by |
| rw [registerTapes_reg, commands_preserve_input] |
| |
| end BinPackingGap.NatExpressionCompiler |
| |
| namespace BinPackingGap.BinaryRegisterProgram |
| |
| open Turing |
| open BinPackingGames.Foundations.Complexity |
| |
| variable {Reg K Λ A : Type} [DecidableEq Reg] [DecidableEq K] |
| |
| def constantSize : Command Reg → Nat |
| | .constant _ n => n.size |
| | _ => 0 |
| |
| def maxConstantSize : List (Command Reg) → Nat |
| | [] => 0 |
| | command :: commands => max (constantSize command) (maxConstantSize commands) |
| |
| omit [DecidableEq Reg] in |
| theorem constantSize_le_maxConstantSize (commands : List (Command Reg)) |
| (command : Command Reg) (member : command ∈ commands) : |
| constantSize command ≤ maxConstantSize commands := by |
| induction commands with |
| | nil => simp at member |
| | cons head tail ih => |
| rcases List.mem_cons.mp member with rfl | ht |
| · exact Nat.le_max_left _ _ |
| · exact (ih ht).trans (Nat.le_max_right _ _) |
| |
| theorem result_size_le (command : Command Reg) (values : Reg → Nat) (width : Nat) |
| (positive : 0 < width) (initial : ∀ r, (values r).size ≤ width) |
| (literal : constantSize command ≤ width) : |
| ∀ r, (result command values r).size ≤ 2 * width := by |
| have hv : (value command values).size ≤ 2 * width := by |
| cases command with |
| | add op => |
| have ha := nat_size_add_le_max (values op.left) (values op.right) |
| have hl := initial op.left |
| have hr := initial op.right |
| change (values op.left + values op.right).size ≤ 2 * width |
| omega |
| | mul op => |
| have hm := nat_size_mul_le (values op.left) (values op.right) |
| have hl := initial op.left |
| have hr := initial op.right |
| change (values op.left * values op.right).size ≤ 2 * width |
| omega |
| | monus op => |
| have hm := nat_size_sub_le (values op.left) (values op.right) |
| have hl := initial op.left |
| change (values op.left - values op.right).size ≤ 2 * width |
| omega |
| | constant dst n => |
| change n.size ≤ width at literal |
| change n.size ≤ 2 * width |
| omega |
| | clear dst => simp [value, Nat.size_zero] |
| | copy dst src different => |
| have hs := initial src |
| change (values src).size ≤ 2 * width |
| omega |
| intro r |
| by_cases heq : r = destination command |
| · subst r |
| simpa only [result_destination] using hv |
| · rw [result_other command values r heq] |
| exact (initial r).trans (by omega) |
| |
| theorem bitBounded_of_positive_width (commands : List (Command Reg)) |
| (values : Reg → Nat) (width : Nat) (positive : 0 < width) |
| (initial : ∀ r, (values r).size ≤ width) |
| (constants : ∀ command ∈ commands, constantSize command ≤ width) : |
| BitBounded (2 ^ commands.length * width) commands values := by |
| induction commands generalizing values width with |
| | nil => simpa [BitBounded] using initial |
| | cons command commands ih => |
| have nextInitial := result_size_le command values width positive initial |
| (constants command (by simp)) |
| have nextConstants : ∀ c ∈ commands, constantSize c ≤ 2 * width := by |
| intro c hc |
| have h := constants c (by simp [hc]) |
| omega |
| have tailBound := ih (result command values) (2 * width) (by omega) |
| nextInitial nextConstants |
| have scale : 2 ^ commands.length * (2 * width) = |
| 2 ^ (commands.length + 1) * width := by |
| rw [Nat.pow_succ] |
| ring |
| change (∀ r, (values r).size ≤ 2 ^ (commands.length + 1) * width) ∧ _ |
| constructor |
| · intro r |
| have hp : 0 < (2 : Nat) ^ (commands.length + 1) := pow_pos (by decide) _ |
| have hr := initial r |
| nlinarith |
| · simpa only [scale, List.length_cons] using tailBound |
| |
| def staticWidth (commands : List (Command Reg)) (inputWidth : Nat) : Nat := |
| 2 ^ commands.length * (inputWidth + maxConstantSize commands + 1) |
| |
| theorem bitBounded_from_input (commands : List (Command Reg)) (values : Reg → Nat) |
| (inputWidth : Nat) (initial : ∀ r, (values r).size ≤ inputWidth) : |
| BitBounded (staticWidth commands inputWidth) commands values := by |
| apply bitBounded_of_positive_width commands values |
| (inputWidth + maxConstantSize commands + 1) |
| · omega |
| · intro r |
| have hr := initial r |
| omega |
| · intro command hc |
| have h := constantSize_le_maxConstantSize commands command hc |
| omega |
| |
| noncomputable def runtimePolynomial (commands : List (Command Reg)) : Polynomial Nat := |
| let scale : Polynomial Nat := Polynomial.C (2 ^ commands.length) * |
| (Polynomial.X + Polynomial.C (maxConstantSize commands + 1)) |
| Polynomial.C commands.length * |
| (Polynomial.C 16 * scale ^ 2 + Polynomial.C 28 * scale + Polynomial.C 12) |
| |
| omit [DecidableEq Reg] in |
| theorem runtimePolynomial_eval (commands : List (Command Reg)) (inputWidth : Nat) : |
| (runtimePolynomial commands).eval inputWidth = |
| commands.length * commandBound (staticWidth commands inputWidth) := by |
| simp only [runtimePolynomial, Polynomial.eval_add, Polynomial.eval_mul, |
| Polynomial.eval_C, Polynomial.eval_pow, Polynomial.eval_X, commandBound, staticWidth] |
| ring |
| |
| noncomputable def programInPolynomialTime (slot : (Reg ⊕ Fin 6) ↪ K) |
| (commands : List (Command Reg)) (base : K → List Bool) (values : Reg → Nat) |
| (ready : Ready commands values) (ambient : A) (inputWidth : Nat) |
| (initial : ∀ r, (values r).size ≤ inputWidth) : |
| StateTransition.EvalsToInTime (TM2.step (program (A := A) slot commands)) |
| ⟨entry commands id none, BinaryAddMachine.clean ambient, registerTapes slot base values⟩ |
| (some ⟨none, BinaryAddMachine.clean ambient, |
| registerTapes slot base (resultOf commands values)⟩) |
| ((runtimePolynomial commands).eval inputWidth) := by |
| rw [runtimePolynomial_eval] |
| exact programInQuadraticTime slot commands base values ready ambient |
| (staticWidth commands inputWidth) (bitBounded_from_input commands values inputWidth initial) |
| |
| noncomputable def runInPolynomialTime (slot : (Reg ⊕ Fin 6) ↪ K) |
| (commands : List (Command Reg)) (labels : Label commands → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (BinaryAddMachine.State A)) |
| (atLabels : ∀ l, p (labels l) = instruction slot commands labels exit l) |
| (base : K → List Bool) (values : Reg → Nat) (ready : Ready commands values) |
| (ambient : A) (inputWidth : Nat) (initial : ∀ r, (values r).size ≤ inputWidth) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨entry commands labels exit, BinaryAddMachine.clean ambient, registerTapes slot base values⟩ |
| (some ⟨exit, BinaryAddMachine.clean ambient, |
| registerTapes slot base (resultOf commands values)⟩) |
| ((runtimePolynomial commands).eval inputWidth) := by |
| rw [runtimePolynomial_eval] |
| exact runInQuadraticTime slot commands labels exit p atLabels base values ready ambient |
| (staticWidth commands inputWidth) (bitBounded_from_input commands values inputWidth initial) |
| |
| end BinPackingGap.BinaryRegisterProgram |
| |
| namespace BinPackingGap.NatExpressionCompiler |
| |
| open Turing |
| open BinaryRegisterProgram |
| |
| variable {α : Type} [DecidableEq α] |
| |
| omit [DecidableEq α] in |
| theorem initialValues_size_le (expression : Expr α) (values : α → Nat) (width : Nat) |
| (inputBound : ∀ a, (values a).size ≤ width) : |
| ∀ r, (initialValues expression values r).size ≤ width := by |
| intro r |
| cases r with |
| | inl a => exact inputBound a |
| | inr node => simp [initialValues] |
| |
| noncomputable def timePolynomial (expression : Expr α) : Polynomial Nat := |
| runtimePolynomial (commands expression) |
| |
| def outputWidth (expression : Expr α) (inputWidth : Nat) : Nat := |
| staticWidth (commands expression) inputWidth |
| |
| private theorem final_size_le {Reg : Type} [DecidableEq Reg] |
| (program : List (Command Reg)) (values : Reg → Nat) (width : Nat) |
| (bounded : BitBounded width program values) : |
| ∀ r, (resultOf program values r).size ≤ width := by |
| induction program generalizing values with |
| | nil => exact bounded |
| | cons command program ih => |
| exact ih (result command values) bounded.2 |
| |
| theorem eval_size_le (expression : Expr α) (values : α → Nat) (inputWidth : Nat) |
| (inputBound : ∀ a, (values a).size ≤ inputWidth) : |
| (eval values expression).size ≤ outputWidth expression inputWidth := by |
| have bounded := bitBounded_from_input (commands expression) |
| (initialValues expression values) inputWidth |
| (initialValues_size_le expression values inputWidth inputBound) |
| have final := final_size_le (commands expression) (initialValues expression values) |
| (outputWidth expression inputWidth) bounded |
| (nodeRegister expression (root expression)) |
| simpa only [commands_output] using final |
| |
| noncomputable def compiledProgramInPolynomialTime {K A : Type} [DecidableEq K] |
| (expression : Expr α) (slot : (Register expression ⊕ Fin 6) ↪ K) |
| (base : K → List Bool) (values : α → Nat) (ambient : A) (inputWidth : Nat) |
| (inputBound : ∀ a, (values a).size ≤ inputWidth) : |
| StateTransition.EvalsToInTime |
| (TM2.step (BinaryRegisterProgram.program (A := A) slot (commands expression))) |
| ⟨BinaryRegisterProgram.entry (commands expression) id none, |
| BinaryAddMachine.clean ambient, |
| registerTapes slot base (initialValues expression values)⟩ |
| (some ⟨none, BinaryAddMachine.clean ambient, |
| registerTapes slot base |
| (resultOf (commands expression) (initialValues expression values))⟩) |
| ((timePolynomial expression).eval inputWidth) := |
| BinaryRegisterProgram.programInPolynomialTime slot (commands expression) base |
| (initialValues expression values) (commands_ready expression values) ambient inputWidth |
| (initialValues_size_le expression values inputWidth inputBound) |
| |
| noncomputable def compiledRunInPolynomialTime {K Λ A : Type} [DecidableEq K] |
| (expression : Expr α) (slot : (Register expression ⊕ Fin 6) ↪ K) |
| (labels : BinaryRegisterProgram.Label (commands expression) → Λ) (exit : Option Λ) |
| (p : Λ → TM2.Stmt (BinaryAddMachine.Alphabet (K := K)) Λ (BinaryAddMachine.State A)) |
| (atLabels : ∀ label, p (labels label) = |
| BinaryRegisterProgram.instruction slot (commands expression) labels exit label) |
| (base : K → List Bool) (values : α → Nat) (ambient : A) (inputWidth : Nat) |
| (inputBound : ∀ a, (values a).size ≤ inputWidth) : |
| StateTransition.EvalsToInTime (TM2.step p) |
| ⟨BinaryRegisterProgram.entry (commands expression) labels exit, |
| BinaryAddMachine.clean ambient, |
| registerTapes slot base (initialValues expression values)⟩ |
| (some ⟨exit, BinaryAddMachine.clean ambient, |
| registerTapes slot base |
| (resultOf (commands expression) (initialValues expression values))⟩) |
| ((timePolynomial expression).eval inputWidth) := |
| BinaryRegisterProgram.runInPolynomialTime slot (commands expression) labels exit p atLabels |
| base (initialValues expression values) (commands_ready expression values) ambient inputWidth |
| (initialValues_size_le expression values inputWidth inputBound) |
| |
| end BinPackingGap.NatExpressionCompiler |
| |
| end OAI |
| |
