| import OAI.Computability.BinPacking.Machines.PackingJobLoop |
| import OAI.Computability.BinPacking.Machines.PackingSetupGraph |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace BinPackingGap.GraphPackingRegisters |
|
|
| open PackingItemExpression PackingInventoryDescriptors |
| open PackingMachineLayout PackingRegisterFrame |
|
|
| def parameters (fixed : InventoryData) (K : Nat) : PackingSetupExpression.Parameters := |
| ⟨fixed.P, K, fixed.d, fixed.tPlus, fixed.tMinus⟩ |
|
|
| inductive Work |
| | leftEndpoint | rightEndpoint | leftPower | rightPower |
| | counter | one | temporary | reverse | geometryFactor | header |
| deriving DecidableEq |
|
|
| instance : Fintype Work where |
| elems := {.leftEndpoint, .rightEndpoint, .leftPower, .rightPower, .counter, |
| .one, .temporary, .reverse, .geometryFactor, .header} |
| complete w := by cases w <;> simp |
|
|
| inductive Extra |
| | input | scanScratch | scanTemporary | threshold | endpoints | vertices | edges |
| | vertexCounter | edgeCounter | repetitionCounter | poolCounter | powerCounter |
| | decodeScratch | reverseOutput | output |
| deriving DecidableEq |
|
|
| instance : Fintype Extra where |
| elems := {.input, .scanScratch, .scanTemporary, .threshold, .endpoints, |
| .vertices, .edges, .vertexCounter, .edgeCounter, .repetitionCounter, |
| .poolCounter, .powerCounter, .decodeScratch, .reverseOutput, .output} |
| complete e := by cases e <;> simp |
|
|
| abbrev Numerator (fixed : InventoryData) := PackingDescriptorExpression.numerator fixed |
| abbrev Other (fixed : InventoryData) (K : Nat) := PackingSetupMachine.Reg (parameters fixed K) ⊕ Work |
| abbrev Register (fixed : InventoryData) (K : Nat) := |
| PackingMachineLayout.Reg (Numerator fixed) denominator (Other fixed K) |
| abbrev Tape (fixed : InventoryData) (K : Nat) := |
| PackingMachineLayout.Tape (Numerator fixed) denominator (Other fixed K) Extra |
|
|
| def slots (fixed : InventoryData) (K : Nat) : |
| (Register fixed K ⊕ Fin 6) ↪ Tape fixed K := registers (Numerator fixed) denominator |
|
|
| def item (fixed : InventoryData) (K : Nat) : Variable ↪ Register fixed K := |
| inputs (Numerator fixed) denominator |
|
|
| def setup (fixed : InventoryData) (K : Nat) : |
| PackingSetupMachine.Reg (parameters fixed K) ↪ Register fixed K := |
| (Function.Embedding.inl : PackingSetupMachine.Reg (parameters fixed K) ↪ Other fixed K).trans |
| (others (Numerator fixed) denominator) |
|
|
| def work (fixed : InventoryData) (K : Nat) : Work ↪ Register fixed K := |
| (Function.Embedding.inr : Work ↪ Other fixed K).trans |
| (others (Numerator fixed) denominator) |
|
|
| def input (fixed : InventoryData) (K : Nat) (i : PackingSetupExpression.Input) : Register fixed K := |
| setup fixed K (PackingSetupMachine.input (parameters fixed K) i) |
|
|
| def output (fixed : InventoryData) (K : Nat) (o : PackingSetupExpression.Output) : Register fixed K := |
| setup fixed K (PackingSetupMachine.output (parameters fixed K) o) |
|
|
| def setupSlots (fixed : InventoryData) (K : Nat) : |
| (PackingSetupMachine.Reg (parameters fixed K) ⊕ Fin 6) ↪ Tape fixed K := |
| localSlots (slots fixed K) (setup fixed K) |
|
|
| def graphSlots (fixed : InventoryData) (K : Nat) : Fin 7 ↪ Tape fixed K where |
| toFun := ![.inr .input, .inr .scanScratch, .inr .scanTemporary, |
| .inr .threshold, .inr .endpoints, .inr .vertices, .inr .edges] |
| inj' := by |
| intro i j h |
| fin_cases i <;> fin_cases j <;> simp_all |
|
|
| inductive CountSource |
| | input (i : PackingSetupExpression.Input) |
| | output (o : PackingSetupExpression.Output) |
| | endpoint (right : Bool) |
| deriving DecidableEq, Fintype |
|
|
| def countRegister (fixed : InventoryData) (K : Nat) : CountSource → Register fixed K |
| | .input i => input fixed K i |
| | .output o => output fixed K o |
| | .endpoint right => work fixed K (if right then .rightEndpoint else .leftEndpoint) |
|
|
| def tallyRegisters (fixed : InventoryData) (K : Nat) (source : CountSource) : |
| BinaryToTallyMachine.Reg ↪ Register fixed K where |
| toFun |
| | .source => countRegister fixed K source |
| | .counter => work fixed K .counter |
| | .one => work fixed K .one |
| | .temporary => work fixed K .temporary |
| inj' := by |
| intro a b h |
| cases source with |
| | input i => |
| cases a <;> cases b <;> |
| simp_all [countRegister, input, setup, work, others, PackingSetupMachine.input] |
| | output o => |
| cases a <;> cases b <;> |
| simp_all [countRegister, output, setup, work, others, PackingSetupMachine.output] |
| | endpoint right => |
| cases right <;> cases a <;> cases b <;> |
| simp_all [countRegister, work, others] |
|
|
| def tallySlots (fixed : InventoryData) (K : Nat) (source : CountSource) : |
| (BinaryToTallyMachine.Reg ⊕ Fin 6) ↪ Tape fixed K := |
| localSlots (slots fixed K) (tallyRegisters fixed K source) |
|
|
| theorem tally_outside (fixed : InventoryData) (K : Nat) (source : CountSource) |
| (tape : Extra) (i : BinaryToTallyMachine.Reg ⊕ Fin 6) : |
| tallySlots fixed K source i ≠ Sum.inr tape := by |
| simp [tallySlots, localSlots, slots, registers] |
|
|
| def endpointRegisters (fixed : InventoryData) (K : Nat) (right : Bool) : |
| Fin 7 ↪ Register fixed K where |
| toFun := ![countRegister fixed K (.endpoint right), output fixed K .three, |
| work fixed K (if right then .rightPower else .leftPower), work fixed K .counter, |
| work fixed K .one, work fixed K .temporary, work fixed K .reverse] |
| inj' := by |
| intro i j h |
| cases right <;> fin_cases i <;> fin_cases j <;> |
| simp_all [countRegister, output, setup, work, others, PackingSetupMachine.output] |
|
|
| def endpointSlots (fixed : InventoryData) (K : Nat) (right : Bool) : |
| (Fin 7 ⊕ Fin 6) ↪ Tape fixed K := |
| localSlots (slots fixed K) (endpointRegisters fixed K right) |
|
|
| theorem endpoint_outside (fixed : InventoryData) (K : Nat) (right : Bool) |
| (tape : Extra) (i : Fin 7 ⊕ Fin 6) : |
| endpointSlots fixed K right i ≠ Sum.inr tape := by |
| simp [endpointSlots, localSlots, slots, registers] |
|
|
| def powerSlots (fixed : InventoryData) (K : Nat) (source : CountSource) |
| (destination : Variable) : Fin 11 ↪ Tape fixed K where |
| toFun := ![slots fixed K (.inl (countRegister fixed K source)), |
| slots fixed K (.inl (item fixed K destination)), |
| slots fixed K (.inl (work fixed K .temporary)), |
| slots fixed K (.inr 0), slots fixed K (.inr 1), slots fixed K (.inr 2), |
| slots fixed K (.inr 3), slots fixed K (.inr 4), slots fixed K (.inr 5), |
| .inr .powerCounter, slots fixed K (.inl (work fixed K .reverse))] |
| inj' := by |
| intro i j h |
| cases source with |
| | input a => |
| fin_cases i <;> fin_cases j <;> |
| simp_all [countRegister, input, setup, work, item, inputs, others, |
| slots, registers, PackingSetupMachine.input] |
| all_goals |
| first |
| | change (Sum.inl (Sum.inr _) : Register fixed K) = Sum.inl (Sum.inl _) at h |
| | change (Sum.inl (Sum.inl _) : Register fixed K) = Sum.inl (Sum.inr _) at h |
| simp at h |
| | output a => |
| fin_cases i <;> fin_cases j <;> |
| simp_all [countRegister, output, setup, work, item, inputs, others, |
| slots, registers, PackingSetupMachine.output] |
| all_goals |
| first |
| | change (Sum.inl (Sum.inr _) : Register fixed K) = Sum.inl (Sum.inl _) at h |
| | change (Sum.inl (Sum.inl _) : Register fixed K) = Sum.inl (Sum.inr _) at h |
| simp at h |
| | endpoint right => |
| cases right <;> fin_cases i <;> fin_cases j <;> |
| simp_all [countRegister, work, item, inputs, others, slots, registers] |
| all_goals |
| first |
| | change (Sum.inl (Sum.inr _) : Register fixed K) = Sum.inl (Sum.inl _) at h |
| | change (Sum.inl (Sum.inl _) : Register fixed K) = Sum.inl (Sum.inr _) at h |
| simp at h |
|
|
| def decoderSlots (fixed : InventoryData) (K : Nat) (right : Bool) : Fin 3 ↪ Tape fixed K where |
| toFun := ![.inr .endpoints, .inr .decodeScratch, |
| slots fixed K (.inl (countRegister fixed K (.endpoint right)))] |
| inj' := by |
| intro i j h |
| fin_cases i <;> fin_cases j <;> simp_all [slots, registers] |
|
|
| def thresholdSlots (fixed : InventoryData) (K : Nat) : Fin 3 ↪ Tape fixed K where |
| toFun := ![.inr .threshold, .inr .decodeScratch, slots fixed K (.inl (input fixed K .k))] |
| inj' := by |
| intro i j h |
| fin_cases i <;> fin_cases j <;> simp_all [slots, registers] |
|
|
| end BinPackingGap.GraphPackingRegisters |
|
|
| end |
|
|
| end OAI |
|
|
