| import OAI.Computability.BinPacking.Machines.PackingJobLoop |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace BinPackingGap.PackingConstantPool |
|
|
| open FiniteTapeProgram BinaryRegisterProgram NatExpressionCompiler PairExpressionCompiler |
| open PackingMachineBlocks |
| open PackingItemBlockMachine (outputTapes) |
| open PackingCountedProgram (counterTapes guardState) |
|
|
| variable {α δ K : Type} [DecidableEq α] [DecidableEq K] |
|
|
| def repeatRecords (word : List Bool) : Nat → List Bool |
| | 0 => [] |
| | n + 1 => word ++ repeatRecords word n |
|
|
| def code (numerator : δ → Expr α) (denominator : Expr α) |
| (slot : (d : δ) → (Reg (numerator d) denominator ⊕ Fin 6) ↪ K) |
| (output counter : K) (descriptors : List δ) : Code (K := K) (S := State) := |
| PackingCountedProgram.loop counter |
| (PackingArithmeticProgram.code |
| (PackingChunkMachine.code numerator denominator slot output descriptors)) |
|
|
| theorem output_counter_comm (output counter : K) (different : counter ≠ output) |
| (base : K → List Bool) (n : Nat) (word : List Bool) : |
| outputTapes output (counterTapes counter base n) word = |
| counterTapes counter (outputTapes output base word) n := by |
| funext k |
| by_cases ho : k = output |
| · subst k |
| simp [outputTapes, counterTapes, Ne.symm different] |
| · by_cases hc : k = counter |
| · subst k |
| simp [outputTapes, counterTapes, different] |
| · simp [outputTapes, counterTapes, ho, hc, Ne.symm different] |
|
|
| theorem shape_after_counter {R : Type} (slot : (R ⊕ Fin 6) ↪ K) |
| (counter : K) (outside : ∀ i, slot i ≠ counter) (base : K → List Bool) |
| (values : R → Nat) (shape : registerTapes slot base values = base) (n : Nat) : |
| registerTapes slot (counterTapes counter base n) values = counterTapes counter base n := by |
| classical |
| unfold counterTapes |
| rw [RegisterFrameEmission.external_update slot base values counter outside, shape] |
|
|
| theorem exec (numerator : δ → Expr α) (denominator : Expr α) |
| (slot : (d : δ) → (Reg (numerator d) denominator ⊕ Fin 6) ↪ K) |
| (output counter : K) (different : counter ≠ output) |
| (outsideOutput : ∀ d i, slot d i ≠ output) |
| (outsideCounter : ∀ d i, slot d i ≠ counter) |
| (descriptors : List δ) (base : K → List Bool) (values : δ → α → Nat) |
| (state : State) (width n : Nat) |
| (shape : ∀ d ∈ descriptors, |
| registerTapes (slot d) base (initial (numerator d) denominator (values d)) = base) |
| (hwidth : ∀ d ∈ descriptors, ∀ a, (values d a).size ≤ width) : |
| ∃ steps ≤ n * ((PackingChunkMachine.timePolynomial numerator denominator descriptors).eval width + 2) + 1, |
| Exec (code numerator denominator slot output counter descriptors) |
| ⟨state, counterTapes counter base n⟩ steps |
| ⟨guardState none, outputTapes output (counterTapes counter base 0) |
| (repeatRecords (PackingChunkMachine.records numerator denominator values descriptors) n)⟩ := by |
| induction n generalizing base state with |
| | zero => |
| refine ⟨1, by simp, ?_⟩ |
| have h : PackingCountedProgram.more ((PackingCountedProgram.guard counter).eval |
| ⟨state, counterTapes counter base 0⟩).state = false := by |
| rw [PackingCountedProgram.guard_zero] |
| rfl |
| simpa only [code, PackingCountedProgram.loop, PackingCountedProgram.guard_zero, |
| repeatRecords, PackingChunkMachine.outputTapes_nil] using |
| (Exec.loop_false (a := PackingArithmeticProgram.code |
| (PackingChunkMachine.code numerator denominator slot output descriptors)) h) |
| | succ n ih => |
| let word := PackingChunkMachine.records numerator denominator values descriptors |
| let middle := outputTapes output base word |
| have counterShape : ∀ d ∈ descriptors, |
| registerTapes (slot d) (counterTapes counter base n) |
| (initial (numerator d) denominator (values d)) = counterTapes counter base n := by |
| intro d hd |
| exact shape_after_counter (slot d) counter (outsideCounter d) base _ (shape d hd) n |
| have chunkRun := PackingChunkMachine.exec numerator denominator slot output outsideOutput |
| descriptors (counterTapes counter base n) values () width counterShape hwidth |
| obtain ⟨bodySteps, bodyBound, bodyRun⟩ := PackingArithmeticProgram.exec_in_time |
| (PackingChunkMachine.code numerator denominator slot output descriptors) |
| (counterTapes counter base n) (outputTapes output (counterTapes counter base n) word) |
| ((PackingChunkMachine.timePolynomial numerator denominator descriptors).eval width) |
| (guardState (some true)) chunkRun |
| have middleShape : ∀ d ∈ descriptors, |
| registerTapes (slot d) middle |
| (initial (numerator d) denominator (values d)) = middle := by |
| intro d hd |
| exact PackingChunkMachine.shape_after_output (slot d) output (outsideOutput d) |
| base _ (shape d hd) word |
| obtain ⟨tailSteps, tailBound, tailRun⟩ := |
| ih middle (.arithmetic (BinaryAddMachine.clean ())) middleShape |
| have guardTrue : PackingCountedProgram.more ((PackingCountedProgram.guard counter).eval |
| ⟨state, counterTapes counter base (n + 1)⟩).state = true := by |
| rw [PackingCountedProgram.guard_succ] |
| rfl |
| have bodyRun' : Exec |
| (PackingArithmeticProgram.code |
| (PackingChunkMachine.code numerator denominator slot output descriptors)) |
| ((PackingCountedProgram.guard counter).eval |
| ⟨state, counterTapes counter base (n + 1)⟩) bodySteps |
| ⟨.arithmetic (BinaryAddMachine.clean ()), counterTapes counter middle n⟩ := by |
| rw [PackingCountedProgram.guard_succ] |
| simpa only [output_counter_comm output counter different, middle] using bodyRun |
| refine ⟨bodySteps + tailSteps + 1, ?_, ?_⟩ |
| · simp only [Nat.add_mul, Nat.one_mul] |
| omega |
| · have combined := Exec.loop_true guardTrue bodyRun' tailRun |
| have finalFrame : outputTapes output (counterTapes counter middle 0) |
| (repeatRecords word n) = |
| outputTapes output (counterTapes counter base 0) (repeatRecords word (n + 1)) := by |
| change outputTapes output (counterTapes counter (outputTapes output base word) 0) |
| (repeatRecords word n) = _ |
| rw [← output_counter_comm output counter different, |
| PackingChunkMachine.outputTapes_append] |
| rfl |
| simpa only [code, PackingCountedProgram.loop, finalFrame, word] using combined |
|
|
| theorem exec_from_tapes (numerator : δ → Expr α) (denominator : Expr α) |
| (slot : (d : δ) → (Reg (numerator d) denominator ⊕ Fin 6) ↪ K) |
| (output counter : K) (different : counter ≠ output) |
| (outsideOutput : ∀ d i, slot d i ≠ output) |
| (outsideCounter : ∀ d i, slot d i ≠ counter) |
| (descriptors : List δ) (base : K → List Bool) (values : δ → α → Nat) |
| (state : State) (width n : Nat) |
| (counterWord : base counter = List.replicate n true) |
| (shape : ∀ d ∈ descriptors, |
| registerTapes (slot d) base (initial (numerator d) denominator (values d)) = base) |
| (hwidth : ∀ d ∈ descriptors, ∀ a, (values d a).size ≤ width) : |
| ∃ steps ≤ n * ((PackingChunkMachine.timePolynomial numerator denominator descriptors).eval width + 2) + 1, |
| Exec (code numerator denominator slot output counter descriptors) |
| ⟨state, base⟩ steps |
| ⟨guardState none, outputTapes output (counterTapes counter base 0) |
| (repeatRecords (PackingChunkMachine.records numerator denominator values descriptors) n)⟩ := by |
| have initialCounter : counterTapes counter base n = base := by |
| unfold counterTapes |
| rw [← counterWord, Function.update_eq_self] |
| simpa only [initialCounter] using exec numerator denominator slot output counter different |
| outsideOutput outsideCounter descriptors base values state width n shape hwidth |
|
|
| theorem final_frame (output counter : K) (base : K → List Bool) (word : List Bool) |
| (k : K) (notOutput : k ≠ output) (notCounter : k ≠ counter) : |
| outputTapes output (counterTapes counter base 0) word k = base k := by |
| simp [outputTapes, counterTapes, notOutput, notCounter] |
|
|
| end BinPackingGap.PackingConstantPool |
|
|
| end |
|
|
| end OAI |
|
|
