| import OAI.Computability.BinPacking.Machines.GraphPackingPreparationFinish | |
| namespace OAI | |
| noncomputable section | |
| namespace BinPackingGap.GraphPackingJobs | |
| open FiniteTapeProgram PackingMachineBlocks GraphPackingRegisters | |
| open GraphPackingPreparation PackingItemExpression | |
| open GraphPackingProgram (PhaseRuns) | |
| open PackingMachineLayout (tapes) | |
| variable (fixed : InventoryData) (K : Nat) | |
| def cleanupPhases : List (GraphPackingProgram.Program fixed K) := | |
| [GraphPackingProgram.incrementEdge fixed K, | |
| GraphPackingProgram.setWork fixed K .leftEndpoint 0, | |
| GraphPackingProgram.setWork fixed K .rightEndpoint 0, | |
| GraphPackingProgram.setWork fixed K .leftPower 0, | |
| GraphPackingProgram.setWork fixed K .rightPower 0, | |
| GraphPackingProgram.setItem fixed K .labelPower 0, | |
| GraphPackingProgram.setItem fixed K .repetitionOne 0] | |
| private def cleanupWidthTimePolynomial : Polynomial Nat := | |
| 64 * (2 * Polynomial.X + 1) ^ 2 + | |
| PackingLayoutCommands.setOtherTime (Numerator fixed) denominator | |
| (Other := Other fixed K) (.inr .leftEndpoint) 0 + | |
| PackingLayoutCommands.setOtherTime (Numerator fixed) denominator | |
| (Other := Other fixed K) (.inr .rightEndpoint) 0 + | |
| PackingLayoutCommands.setOtherTime (Numerator fixed) denominator | |
| (Other := Other fixed K) (.inr .leftPower) 0 + | |
| PackingLayoutCommands.setOtherTime (Numerator fixed) denominator | |
| (Other := Other fixed K) (.inr .rightPower) 0 + | |
| PackingLayoutCommands.setInputTime (Numerator fixed) denominator | |
| (Other := Other fixed K) .labelPower 0 + | |
| PackingLayoutCommands.setInputTime (Numerator fixed) denominator | |
| (Other := Other fixed K) .repetitionOne 0 | |
| def cleanupTimePolynomial : Polynomial Nat := | |
| (cleanupWidthTimePolynomial fixed K).comp (GraphPackingWidths.polynomial fixed K) | |
| theorem cleanup_exec (x : GraphReductionInput) (e : x.graph.Edge) | |
| (base : Tape fixed K → List Bool) (state : State) : | |
| ∃ steps ≤ (cleanupTimePolynomial fixed K).eval (graphBits x).length, | |
| PhaseRuns (cleanupPhases fixed K) | |
| ⟨state, tapes (Numerator fixed) denominator base | |
| (completedInputs fixed K x e.val (x.graph.right e).val) | |
| (loadedOther fixed K x (x.graph.left e).val (x.graph.right e).val)⟩ steps | |
| ⟨.arithmetic (BinaryAddMachine.clean ()), | |
| tapes (Numerator fixed) denominator base (inputs fixed K x (e.val + 1)) | |
| (preparedOther fixed K x)⟩ := by | |
| let width := GraphPackingWidths.width fixed K x | |
| let initialInput := completedInputs fixed K x e.val (x.graph.right e).val | |
| let initialOther := loadedOther fixed K x (x.graph.left e).val (x.graph.right e).val | |
| let nextPower := (GraphPackingPreparation.repetitions fixed K x + 1) ^ (e.val + 1) | |
| let advancedInput := Function.update initialInput .edgePower nextPower | |
| let other₁ := Function.update initialOther (.inr Work.leftEndpoint) 0 | |
| let other₂ := Function.update other₁ (.inr Work.rightEndpoint) 0 | |
| let other₃ := Function.update other₂ (.inr Work.leftPower) 0 | |
| let other₄ := Function.update other₃ (.inr Work.rightPower) 0 | |
| let input₁ := Function.update advancedInput .labelPower 0 | |
| let input₂ := Function.update input₁ .repetitionOne 0 | |
| let clean : State := .arithmetic (BinaryAddMachine.clean ()) | |
| have initialInputWidth : ∀ a, (initialInput a).size ≤ width := | |
| completedInputs_width fixed K x e.val (x.graph.right e).val | |
| (Nat.le_of_lt e.isLt) (x.graph.right e).isLt | |
| have initialOtherWidth : ∀ r, (initialOther r).size ≤ width := | |
| loadedOther_width fixed K x (x.graph.left e).val (x.graph.right e).val | |
| (x.graph.left e).isLt (x.graph.right e).isLt | |
| have zeroWidth : (0 : Nat).size ≤ width := by simp | |
| have advancedInputWidth : ∀ a, (advancedInput a).size ≤ width := | |
| GraphPackingWidths.update_width fixed K x initialInput initialInputWidth .edgePower | |
| nextPower (GraphPackingWidths.edge_power_width fixed K x (e.val + 1) | |
| (Nat.succ_le_of_lt e.isLt)) | |
| have other₁Width : ∀ r, (other₁ r).size ≤ width := | |
| GraphPackingWidths.update_width fixed K x initialOther initialOtherWidth _ 0 zeroWidth | |
| have other₂Width : ∀ r, (other₂ r).size ≤ width := | |
| GraphPackingWidths.update_width fixed K x other₁ other₁Width _ 0 zeroWidth | |
| have other₃Width : ∀ r, (other₃ r).size ≤ width := | |
| GraphPackingWidths.update_width fixed K x other₂ other₂Width _ 0 zeroWidth | |
| have other₄Width : ∀ r, (other₄ r).size ≤ width := | |
| GraphPackingWidths.update_width fixed K x other₃ other₃Width _ 0 zeroWidth | |
| have input₁Width : ∀ a, (input₁ a).size ≤ width := | |
| GraphPackingWidths.update_width fixed K x advancedInput advancedInputWidth _ 0 zeroWidth | |
| have temporaryZero : initialOther (.inr Work.temporary) = 0 := | |
| loaded_helper_zero fixed K x (x.graph.left e).val (x.graph.right e).val | |
| .temporary (Or.inr (Or.inr (Or.inl rfl))) | |
| have baseValue : initialOther (GraphPackingProgram.otherSetup fixed K .base) = | |
| GraphPackingPreparation.repetitions fixed K x + 1 := by | |
| change loadedOther fixed K x (x.graph.left e).val (x.graph.right e).val | |
| (.inl (PackingSetupMachine.output (parameters fixed K) .base)) = _ | |
| rw [loaded_setup] | |
| rfl | |
| have edgeValue : initialInput .edgePower = | |
| (GraphPackingPreparation.repetitions fixed K x + 1) ^ e.val := by | |
| simp [initialInput, completedInputs, inputs] | |
| have productValue : PackingRegisterUpdate.operation .multiply | |
| (initialOther (GraphPackingProgram.otherSetup fixed K .base)) | |
| (initialInput .edgePower) = nextPower := by | |
| simp only [PackingRegisterUpdate.operation, baseValue, edgeValue] | |
| exact (Nat.mul_comm _ _).trans (Nat.pow_succ _ _).symm | |
| obtain ⟨n₀, b₀, r₀⟩ := PackingVertexUpdate.general_exec | |
| (Numerator fixed) denominator .edgePower | |
| (GraphPackingProgram.otherSetup fixed K .base) (.inr Work.temporary) | |
| (by simp [GraphPackingProgram.otherSetup]) .multiply | |
| base initialInput initialOther temporaryZero state | |
| rw [productValue] at r₀ | |
| change Exec (GraphPackingProgram.incrementEdge fixed K) | |
| ⟨state, tapes (Numerator fixed) denominator base initialInput initialOther⟩ n₀ | |
| ⟨clean, tapes (Numerator fixed) denominator base advancedInput initialOther⟩ at r₀ | |
| have multiplicationBound : n₀ ≤ 64 * (2 * width + 1) ^ 2 := by | |
| apply b₀.trans | |
| apply Nat.mul_le_mul_left 64 | |
| apply Nat.pow_le_pow_left | |
| have hb := initialOtherWidth (GraphPackingProgram.otherSetup fixed K .base) | |
| have he := initialInputWidth .edgePower | |
| omega | |
| obtain ⟨n₁, b₁, r₁⟩ := PackingLayoutCommands.setOther_exec | |
| (Numerator fixed) denominator (.inr Work.leftEndpoint) 0 | |
| base advancedInput initialOther clean width advancedInputWidth initialOtherWidth | |
| obtain ⟨n₂, b₂, r₂⟩ := PackingLayoutCommands.setOther_exec | |
| (Numerator fixed) denominator (.inr Work.rightEndpoint) 0 | |
| base advancedInput other₁ clean width advancedInputWidth other₁Width | |
| obtain ⟨n₃, b₃, r₃⟩ := PackingLayoutCommands.setOther_exec | |
| (Numerator fixed) denominator (.inr Work.leftPower) 0 | |
| base advancedInput other₂ clean width advancedInputWidth other₂Width | |
| obtain ⟨n₄, b₄, r₄⟩ := PackingLayoutCommands.setOther_exec | |
| (Numerator fixed) denominator (.inr Work.rightPower) 0 | |
| base advancedInput other₃ clean width advancedInputWidth other₃Width | |
| obtain ⟨n₅, b₅, r₅⟩ := PackingLayoutCommands.setInput_exec | |
| (Numerator fixed) denominator .labelPower 0 | |
| base advancedInput other₄ clean width advancedInputWidth other₄Width | |
| obtain ⟨n₆, b₆, r₆⟩ := PackingLayoutCommands.setInput_exec | |
| (Numerator fixed) denominator .repetitionOne 0 | |
| base input₁ other₄ clean width input₁Width other₄Width | |
| have finalOther : other₄ = preparedOther fixed K x := | |
| clearedOther_eq fixed K x (x.graph.left e).val (x.graph.right e).val | |
| have finalInput : input₂ = inputs fixed K x (e.val + 1) := | |
| clearedInputs_eq fixed K x e.val (x.graph.right e).val | |
| have runs := PhaseRuns.cons r₀ (PhaseRuns.cons r₁ (PhaseRuns.cons r₂ | |
| (PhaseRuns.cons r₃ (PhaseRuns.cons r₄ (PhaseRuns.cons r₅ (PhaseRuns.single r₆)))))) | |
| refine ⟨n₀ + (n₁ + (n₂ + (n₃ + (n₄ + (n₅ + n₆))))), ?_, ?_⟩ | |
| · rw [cleanupTimePolynomial, Polynomial.eval_comp] | |
| change _ ≤ (cleanupWidthTimePolynomial fixed K).eval width | |
| simp only [cleanupWidthTimePolynomial, Polynomial.eval_add, Polynomial.eval_mul, | |
| Polynomial.eval_pow, Polynomial.eval_ofNat, Polynomial.eval_X, Polynomial.eval_one] | |
| omega | |
| · change PhaseRuns (cleanupPhases fixed K) | |
| ⟨state, tapes (Numerator fixed) denominator base initialInput initialOther⟩ _ | |
| ⟨clean, tapes (Numerator fixed) denominator base | |
| (inputs fixed K x (e.val + 1)) (preparedOther fixed K x)⟩ | |
| rw [← finalOther, ← finalInput] | |
| simpa only [cleanupPhases, GraphPackingProgram.setWork, GraphPackingProgram.setItem] | |
| using runs | |
| end BinPackingGap.GraphPackingJobs | |
| end | |
| end OAI | |