| import Mathlib.Tactic.FinCases |
| import OAI.Computability.BinPacking.Machines.GraphPackingPreparationFinish |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace BinPackingGap.GraphPackingPreparation |
|
|
| section |
|
|
| open Turing BinPackingGames.Foundations.Complexity |
| open GraphPackingRegisters GraphPackingProgram PackingMachineBlocks |
| open FiniteTapeProgram BinaryRegisterProgram |
|
|
| variable (fixed : InventoryData) (K : Nat) |
|
|
| @[simp] private theorem graphSlots_apply (i : Fin 7) : graphSlots fixed K i = |
| ![.inr .input, .inr .scanScratch, .inr .scanTemporary, |
| .inr .threshold, .inr .endpoints, .inr .vertices, .inr .edges] i := by |
| simp only [graphSlots] |
| rfl |
|
|
| @[simp] private theorem thresholdSlots_apply (i : Fin 3) : thresholdSlots fixed K i = |
| ![.inr .threshold, .inr .decodeScratch, slots fixed K (.inl (input fixed K .k))] i := by |
| simp only [thresholdSlots] |
| rfl |
|
|
| @[simp] private theorem setup_apply (r : PackingSetupMachine.Reg (parameters fixed K)) : |
| setup fixed K r = .inl (.inr (.inl r)) := rfl |
|
|
| def parsePhases : List (Program fixed K) := |
| [prepareGraph (graphSlots fixed K), |
| tallyToBinary fixed K .vertices .n, |
| tallyToBinary fixed K .edges .m, |
| PackingArithmeticProgram.code (PackingFieldDecodeMachine.code (thresholdSlots fixed K))] |
|
|
| def parsePolynomial (_fixed : InventoryData) (_K : Nat) : Polynomial Nat := |
| Polynomial.C 6 * (Polynomial.X + 1) ^ 2 + Polynomial.C 15 * Polynomial.X + Polynomial.C 15 |
|
|
| private def fieldTapes (x : GraphReductionInput) : Tape fixed K → List Bool |
| | .inr .input => graphBits x |
| | .inr .threshold => BinaryEncoding.natBits x.k |
| | .inr .endpoints => GraphFieldMachine.fieldBits .endpoints x |
| | .inr .vertices => List.replicate x.graph.n true |
| | .inr .edges => List.replicate x.graph.edges.length true |
| | _ => [] |
|
|
| private theorem preparation_frame (x : GraphReductionInput) : |
| GraphPreparationMachine.preparedTapes (graphSlots fixed K) (initialTapes fixed K x) x = |
| fieldTapes fixed K x := by |
| have atSlot (j : Fin 7) : |
| GraphPreparationMachine.preparedTapes (graphSlots fixed K) (initialTapes fixed K x) x |
| (graphSlots fixed K j) = fieldTapes fixed K x (graphSlots fixed K j) := by |
| rw [GraphPreparationMachine.preparedTapes_register] |
| fin_cases j <;> simp [initialTapes, fieldTapes] |
| funext tape |
| cases tape with |
| | inl r => |
| simpa only [initialTapes, fieldTapes] using |
| GraphPreparationMachine.preparedTapes_other (graphSlots fixed K) |
| (initialTapes fixed K x) x (.inl r) |
| (by simp) (by simp) |
| (by simp) (by simp) |
| | inr extra => |
| by_cases h₃ : extra = .threshold |
| · subst extra; exact atSlot 3 |
| by_cases h₄ : extra = .endpoints |
| · subst extra; exact atSlot 4 |
| by_cases h₅ : extra = .vertices |
| · subst extra; exact atSlot 5 |
| by_cases h₆ : extra = .edges |
| · subst extra; exact atSlot 6 |
| rw [GraphPreparationMachine.preparedTapes_other (graphSlots fixed K) |
| (initialTapes fixed K x) x (.inr extra) |
| (by simpa using h₃) (by simpa using h₄) |
| (by simpa using h₅) (by simpa using h₆)] |
| cases extra <;> simp_all [initialTapes, fieldTapes] |
|
|
| private def vertexTapes (x : GraphReductionInput) : Tape fixed K → List Bool := |
| Function.update (Function.update (fieldTapes fixed K x) (.inr .vertices) []) |
| (regTape fixed K (input fixed K .n)) x.graph.n.bits |
|
|
| private def edgeTapes (x : GraphReductionInput) : Tape fixed K → List Bool := |
| Function.update (Function.update (vertexTapes fixed K x) (.inr .edges) []) |
| (regTape fixed K (input fixed K .m)) x.graph.edges.length.bits |
|
|
| private theorem decoded_frame (x : GraphReductionInput) : |
| PackingFieldDecodeMachine.decodedTapes (thresholdSlots fixed K) (edgeTapes fixed K x) |
| x.k.bits [] = parsedTapes fixed K x := by |
| funext tape |
| rcases tape with (r | scratch) | extra |
| · change _ = registerTapes (slots fixed K) (baseTapes fixed K x) |
| (PackingMachineLayout.values (Numerator fixed) PackingItemExpression.denominator |
| (fun _ => 0) (parsedOther fixed K x)) (slots fixed K (.inl r)) |
| rw [registerTapes_reg] |
| rcases r with (v | (setupReg | workReg)) | node |
| · simp [PackingFieldDecodeMachine.decodedTapes, edgeTapes, |
| vertexTapes, fieldTapes, regTape, slots, input, |
| PackingMachineLayout.registers, |
| PackingMachineLayout.values, PackingSetupMachine.input] |
| · rcases setupReg with i | (o | node) |
| · cases i <;> simp [PackingFieldDecodeMachine.decodedTapes, |
| edgeTapes, vertexTapes, fieldTapes, regTape, slots, input, |
| PackingMachineLayout.registers, |
| PackingMachineLayout.values, parsedOther, PackingSetupMachine.frame, |
| PackingSetupMachine.input, PackingSetupExpression.inputs] |
| change Function.update (β := fun _ => List Bool) _ (thresholdSlots fixed K 2) x.k.bits |
| (thresholdSlots fixed K 2) = x.k.bits |
| exact Function.update_self _ _ _ |
| · simp [PackingFieldDecodeMachine.decodedTapes, edgeTapes, |
| vertexTapes, fieldTapes, regTape, slots, input, |
| PackingMachineLayout.registers, |
| PackingMachineLayout.values, parsedOther, PackingSetupMachine.frame, |
| PackingSetupMachine.input] |
| · simp [PackingFieldDecodeMachine.decodedTapes, edgeTapes, |
| vertexTapes, fieldTapes, regTape, slots, input, |
| PackingMachineLayout.registers, |
| PackingMachineLayout.values, parsedOther, PackingSetupMachine.frame, |
| PackingSetupMachine.input] |
| · simp [PackingFieldDecodeMachine.decodedTapes, edgeTapes, |
| vertexTapes, fieldTapes, regTape, slots, input, |
| PackingMachineLayout.registers, |
| PackingMachineLayout.values, parsedOther, PackingSetupMachine.input] |
| · simp [PackingFieldDecodeMachine.decodedTapes, edgeTapes, |
| vertexTapes, fieldTapes, regTape, slots, input, |
| PackingMachineLayout.registers, |
| PackingMachineLayout.values, PackingSetupMachine.input] |
| · change _ = registerTapes (slots fixed K) (baseTapes fixed K x) |
| (PackingMachineLayout.values (Numerator fixed) PackingItemExpression.denominator |
| (fun _ => 0) (parsedOther fixed K x)) (slots fixed K (.inr scratch)) |
| rw [registerTapes_scratch] |
| simp [PackingFieldDecodeMachine.decodedTapes, edgeTapes, |
| vertexTapes, fieldTapes, regTape, slots, PackingMachineLayout.registers] |
| · change _ = PackingMachineLayout.tapes (Numerator fixed) PackingItemExpression.denominator |
| (baseTapes fixed K x) (fun _ => 0) (parsedOther fixed K x) (.inr extra) |
| rw [PackingMachineLayout.tapes_extra] |
| cases extra <;> simp [PackingFieldDecodeMachine.decodedTapes, |
| edgeTapes, vertexTapes, fieldTapes, regTape, slots, PackingMachineLayout.registers, |
| baseTapes] |
|
|
| private theorem tally_exec (source : Extra) (destination : PackingSetupExpression.Input) |
| (different : source ≠ .scanScratch) (base : Tape fixed K → List Bool) |
| (n : Nat) (state : State) |
| (sourceWord : base (.inr source) = List.replicate n true) |
| (outputEmpty : base (regTape fixed K (input fixed K destination)) = []) |
| (scratchEmpty : base (.inr .scanScratch) = []) : |
| ∃ steps ≤ 3 * (n + 1) ^ 2 + 1, |
| Exec (tallyToBinary fixed K source destination) ⟨state, base⟩ steps |
| ⟨.arithmetic (BinaryAddMachine.clean ()), |
| Function.update (Function.update base (.inr source) []) |
| (regTape fixed K (input fixed K destination)) n.bits⟩ := by |
| have hSO : (Sum.inr source : Tape fixed K) ≠ regTape fixed K (input fixed K destination) := by |
| simp [regTape, slots, PackingMachineLayout.registers] |
| have hSC : (Sum.inr source : Tape fixed K) ≠ .inr .scanScratch := by simpa using different |
| have hOC : regTape fixed K (input fixed K destination) ≠ Sum.inr Extra.scanScratch := by |
| simp [regTape, slots, PackingMachineLayout.registers] |
| have run := BinaryTallyMachine.plainTallyFromTapesInTime (.inr source) |
| (regTape fixed K (input fixed K destination)) (.inr .scanScratch) hSO hSC hOC |
| id none (BinaryTallyMachine.instruction (.inr source) |
| (regTape fixed K (input fixed K destination)) (.inr .scanScratch) id none) |
| (fun _ => rfl) base () n sourceWord outputEmpty scratchEmpty |
| simpa only [tallyToBinary, arithmeticControl] using |
| invokeExecInTime arithmeticControl (BinaryAddMachine.clean ()) .scan |
| (BinaryTallyMachine.instruction (.inr source) |
| (regTape fixed K (input fixed K destination)) (.inr .scanScratch) id none) |
| ⟨state, base⟩ (BinaryAddMachine.clean ()) _ _ run |
|
|
| theorem parse_exec (x : GraphReductionInput) (state : State) : |
| ∃ steps ≤ (parsePolynomial fixed K).eval (graphBits x).length, |
| PhaseRuns (parsePhases fixed K) ⟨state, initialTapes fixed K x⟩ steps |
| ⟨.arithmetic (BinaryAddMachine.clean ()), parsedTapes fixed K x⟩ := by |
| have first := prepareGraph_exec (graphSlots fixed K) ⟨state, initialTapes fixed K x⟩ x |
| (by rfl) (by rfl) (by rfl) |
| rw [preparation_frame fixed K x] at first |
| obtain ⟨a, ha, second⟩ := tally_exec fixed K .vertices .n (by decide) |
| (fieldTapes fixed K x) x.graph.n (.graph (GraphFieldMachine.clean ())) |
| rfl rfl rfl |
| change Exec (tallyToBinary fixed K .vertices .n) |
| ⟨.graph (GraphFieldMachine.clean ()), fieldTapes fixed K x⟩ a |
| ⟨.arithmetic (BinaryAddMachine.clean ()), vertexTapes fixed K x⟩ at second |
| obtain ⟨b, hb, third⟩ := tally_exec fixed K .edges .m (by decide) |
| (vertexTapes fixed K x) x.graph.edges.length (.arithmetic (BinaryAddMachine.clean ())) |
| (by simp [vertexTapes, fieldTapes, regTape, slots, PackingMachineLayout.registers]) |
| (by simp [vertexTapes, fieldTapes, regTape, slots, input, |
| PackingMachineLayout.registers, PackingSetupMachine.input]) |
| (by simp [vertexTapes, fieldTapes, regTape, slots, PackingMachineLayout.registers]) |
| change Exec (tallyToBinary fixed K .edges .m) |
| ⟨.arithmetic (BinaryAddMachine.clean ()), vertexTapes fixed K x⟩ b |
| ⟨.arithmetic (BinaryAddMachine.clean ()), edgeTapes fixed K x⟩ at third |
| have decoded := PackingFieldDecodeMachine.decodeNat_exec (thresholdSlots fixed K) |
| (edgeTapes fixed K x) () x.k [] |
| (by simp [ edgeTapes, vertexTapes, fieldTapes, regTape, slots, |
| PackingMachineLayout.registers]) |
| (by simp [ edgeTapes, vertexTapes, fieldTapes, regTape, slots, |
| PackingMachineLayout.registers]) |
| rw [decoded_frame fixed K x] at decoded |
| have fourth := PackingArithmeticProgram.exec _ _ _ _ |
| (.arithmetic (BinaryAddMachine.clean ())) decoded |
| refine ⟨(1 + GraphPreparationMachine.steps x) + (a + (b + (1 + (2 * x.k.size + 2)))), ?_, ?_⟩ |
| · have hp := prepareGraph_cost x |
| have hn := Nat.pow_le_pow_left (Nat.add_le_add_right (graph_vertexCount_le_bits x) 1) 2 |
| have hm := Nat.pow_le_pow_left (Nat.add_le_add_right (graph_edgeCount_le_bits x) 1) 2 |
| have hk : 2 * x.k.size + 2 ≤ (graphBits x).length + 1 := by |
| rw [PackingFieldDecodeMachine.decodeNat_steps] |
| simpa only [GraphFieldMachine.thresholdBits] using |
| Nat.add_le_add_right (GraphFieldMachine.fieldBits_length_le .threshold x) 1 |
| simp only [parsePolynomial, Polynomial.eval_add, Polynomial.eval_mul, |
| Polynomial.eval_pow, Polynomial.eval_C, Polynomial.eval_X, Polynomial.eval_one] |
| omega |
| · exact PhaseRuns.cons first (PhaseRuns.cons second |
| (PhaseRuns.cons third (PhaseRuns.single fourth))) |
|
|
| end |
|
|
| section |
|
|
| open BinPackingGames.Foundations.Complexity |
|
|
| variable (fixed : InventoryData) (K : Nat) |
|
|
| def powerPolynomial : Polynomial Nat := |
| 80 * (Polynomial.X + 1) ^ 3 + |
| 2 * BinaryPowerMachine.timePolynomial.comp (2 * GraphPackingWidths.polynomial fixed K) + 4 |
|
|
| private theorem tally_bound {n s : Nat} (h : n ≤ s) : |
| BinaryToTallyMachine.runtimeBound n ≤ 40 * (s + 1) ^ 3 := by |
| have size := (nat_size_le_self n).trans h |
| calc |
| BinaryToTallyMachine.runtimeBound n = 40 * (n + 1) * (n.size + 1) ^ 2 := rfl |
| _ ≤ 40 * (s + 1) * (s + 1) ^ 2 := |
| Nat.mul_le_mul (Nat.mul_le_mul_left 40 (by omega)) |
| (Nat.pow_le_pow_left (by omega) 2) |
| _ = _ := by ring |
|
|
| theorem powerBudget_le (x : GraphReductionInput) : |
| powerBudget fixed K x ≤ (powerPolynomial fixed K).eval (graphBits x).length := by |
| let w := GraphPackingWidths.width fixed K x |
| have ns : x.graph.n ≤ (graphBits x).length := graph_vertexCount_le_bits x |
| have ms : x.graph.edges.length ≤ (graphBits x).length := graph_edgeCount_le_bits x |
| have sw : (graphBits x).length + 1 ≤ w := GraphPackingWidths.input_length_le_width fixed K x |
| have three : (3 : Nat).size ≤ w := |
| (nat_size_le_self 3).trans (GraphPackingWidths.small_constant_width fixed K x) |
| have radix : (repetitions fixed K x + 1).size ≤ w := |
| (nat_size_le_self _).trans (GraphPackingWidths.repetitions_width fixed K x) |
| have vertex := MachineComposition.natPolynomial_eval_mono BinaryPowerMachine.timePolynomial |
| (show (3 : Nat).size + x.graph.n ≤ 2 * w by omega) |
| have edge := MachineComposition.natPolynomial_eval_mono BinaryPowerMachine.timePolynomial |
| (show (repetitions fixed K x + 1).size + x.graph.edges.length ≤ 2 * w by omega) |
| have tn := tally_bound ns |
| have tm := tally_bound ms |
| simp only [powerPolynomial, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_pow, |
| Polynomial.eval_ofNat, Polynomial.eval_one, Polynomial.eval_X, Polynomial.eval_comp] |
| change _ ≤ 80 * ((graphBits x).length + 1) ^ 3 + |
| 2 * BinaryPowerMachine.timePolynomial.eval (2 * w) + 4 |
| unfold powerBudget PackingPowerProgram.budget |
| omega |
|
|
| def arithmeticPolynomial : Polynomial Nat := |
| PackingSetupMachine.timePolynomial (GraphPackingRegisters.parameters fixed K) + |
| powerPolynomial fixed K + 1 |
|
|
| end |
|
|
| open GraphPackingRegisters BinaryRegisterProgram FiniteTapeProgram PackingMachineBlocks |
| open GraphPackingProgram |
|
|
| variable (fixed : InventoryData) (K : Nat) |
|
|
| def timePolynomial : Polynomial Nat := |
| parsePolynomial fixed K + arithmeticPolynomial fixed K + finishPolynomial fixed K + 1 |
|
|
| theorem prepare_exec (x : GraphReductionInput) (state : State) : |
| ∃ steps ≤ (timePolynomial fixed K).eval (graphBits x).length, |
| Exec (prepare fixed K) ⟨state, initialTapes fixed K x⟩ steps |
| ⟨.arithmetic (BinaryAddMachine.clean ()), preparedTapes fixed K x⟩ := by |
| obtain ⟨a, ha, arun⟩ := parse_exec fixed K x state |
| obtain ⟨b, hb, brun⟩ := setup_exec fixed K x (.arithmetic (BinaryAddMachine.clean ())) |
| obtain ⟨c, hc, crun⟩ := powers_exec fixed K x (.arithmetic (BinaryAddMachine.clean ())) |
| obtain ⟨d, hd, drun⟩ := finish_exec fixed K x (.arithmetic (BinaryAddMachine.clean ())) |
| have middle := PhaseRuns.cons brun crun |
| have whole := arun.append (middle.append drun) |
| have actual := whole.toExec |
| refine ⟨a + (b + c + d) + 1, ?_, ?_⟩ |
| · have powers := powerBudget_le fixed K x |
| simp only [timePolynomial, arithmeticPolynomial, Polynomial.eval_add, |
| Polynomial.eval_one] at ⊢ |
| omega |
| · simpa only [prepare, parsePhases, powerPhases, List.cons_append, List.nil_append] using actual |
|
|
| end BinPackingGap.GraphPackingPreparation |
|
|
| end |
|
|
| end OAI |
|
|
