| import OAI.Computability.BinPacking.Arithmetic.GraphTallyMachine |
| import OAI.Computability.BinPacking.Packing.ExtractedCover |
| import OAI.Computability.BinPacking.Packing.ItemEnumeration |
| import OAI.Computability.BinPacking.Packing.PackingScalarExpression |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace BinPackingGap.InventoryData |
|
|
| variable (D : InventoryData) |
|
|
| def rawItemList : RawInstance := D.itemList.map D.itemRawPair |
|
|
| theorem rawItemList_length_items : D.rawItemList.length = D.itemList.length := by |
| simp [rawItemList] |
|
|
| theorem rawItemList_length (hk : D.k ≤ D.graph.n) : |
| D.rawItemList.length = 5 * D.B := by |
| rw [D.rawItemList_length_items, D.itemList_length hk] |
|
|
| theorem rawItemList_valid (hplus : D.plus.height ≤ D.L) |
| (hminus : D.minus.height ≤ D.L) : D.rawItemList.Valid := by |
| intro q hq |
| obtain ⟨i, _, rfl⟩ := List.mem_map.mp hq |
| have hi := D.itemRawPair_valid hplus hminus i |
| exact ⟨hi.1, hi.2.le⟩ |
|
|
| def rawItemListEquiv (hk : D.k ≤ D.graph.n) : Fin D.rawItemList.length ≃ D.Item := |
| (finCongr D.rawItemList_length_items).trans (D.itemListEquiv hk) |
|
|
| @[simp] theorem rawItemListEquiv_apply (hk : D.k ≤ D.graph.n) |
| (i : Fin D.rawItemList.length) : |
| D.rawItemListEquiv hk i = |
| D.itemList.get (Fin.cast D.rawItemList_length_items i) := rfl |
|
|
| theorem rawItemList_get (i : Fin D.rawItemList.length) : |
| D.rawItemList.get i = |
| D.itemRawPair (D.itemList.get (Fin.cast D.rawItemList_length_items i)) := by |
| rcases i with ⟨i, hi⟩ |
| change i < (D.itemList.map D.itemRawPair).length at hi |
| change (D.itemList.map D.itemRawPair)[i]'hi = |
| D.itemRawPair (D.itemList[i]'(by simpa [rawItemList] using hi)) |
| simp only [List.getElem_map] |
|
|
| theorem rawItemList_get_ratio (hplus : D.plus.height ≤ D.L) |
| (hminus : D.minus.height ≤ D.L) (i : Fin D.rawItemList.length) : |
| RawInstance.ratValue (D.rawItemList.get i) = |
| D.itemSize (D.itemList.get (Fin.cast D.rawItemList_length_items i)) := by |
| rw [D.rawItemList_get] |
| exact D.itemRawPair_ratio hplus hminus _ |
|
|
| def rawItemListReindexing (hk : D.k ≤ D.graph.n) |
| (hplus : D.plus.height ≤ D.L) (hminus : D.minus.height ≤ D.L) : |
| Instance.Reindexing (D.rawItemList.toInstance (D.rawItemList_valid hplus hminus)) |
| D.packingInstance where |
| equiv := (D.rawItemListEquiv hk).trans D.itemEquiv |
| size_eq i := by |
| change Fin D.rawItemList.length at i |
| change RawInstance.ratValue (D.rawItemList.get i) = |
| D.itemSize (D.itemEquiv.symm (D.itemEquiv (D.rawItemListEquiv hk i))) |
| rw [Equiv.symm_apply_apply, D.rawItemListEquiv_apply] |
| exact D.rawItemList_get_ratio hplus hminus i |
|
|
| theorem rawItemList_hasPacking_iff (hk : D.k ≤ D.graph.n) |
| (hplus : D.plus.height ≤ D.L) (hminus : D.minus.height ≤ D.L) (b : ℕ) : |
| HasPacking (D.rawItemList.toInstance (D.rawItemList_valid hplus hminus)) b ↔ |
| HasPacking D.packingInstance b := |
| (D.rawItemListReindexing hk hplus hminus).hasPacking_iff b |
|
|
| theorem rawItemList_opt_eq (hk : D.k ≤ D.graph.n) |
| (hplus : D.plus.height ≤ D.L) (hminus : D.minus.height ≤ D.L) : |
| opt (D.rawItemList.toInstance (D.rawItemList_valid hplus hminus)) = |
| opt D.packingInstance := |
| (D.rawItemListReindexing hk hplus hminus).opt_eq |
|
|
| def rawOutput : RawReductionOutput := (D.B, D.rawItemList) |
|
|
| @[simp] theorem rawOutput_bins : D.rawOutput.1 = D.B := rfl |
|
|
| @[simp] theorem rawOutput_items : D.rawOutput.2 = D.rawItemList := rfl |
|
|
| theorem rawOutput_valid (hplus : D.plus.height ≤ D.L) |
| (hminus : D.minus.height ≤ D.L) : D.rawOutput.2.Valid := |
| D.rawItemList_valid hplus hminus |
|
|
| theorem rawOutput_length (hk : D.k ≤ D.graph.n) : |
| D.rawOutput.2.length = 5 * D.rawOutput.1 := D.rawItemList_length hk |
|
|
| end BinPackingGap.InventoryData |
|
|
| namespace BinPackingGap |
|
|
| def graphPackingOutput (c : ℕ) (ρ : ℝ) (x : GraphReductionInput) : RawReductionOutput := |
| (reductionInventory c ρ x.graph x.k).rawOutput |
|
|
| @[simp] theorem graphPackingOutput_bins (c : ℕ) (ρ : ℝ) (x : GraphReductionInput) : |
| (graphPackingOutput c ρ x).1 = reductionBinBound c ρ x.graph x.k := rfl |
|
|
| theorem graphPackingOutput_valid (c : ℕ) (ρ : ℝ) (x : GraphReductionInput) : |
| (graphPackingOutput c ρ x).2.Valid := |
| (reductionInventory c ρ x.graph x.k).rawOutput_valid |
| (reductionInventory_plus_height c ρ x.graph x.k).le |
| (reductionInventory_minus_height c ρ x.graph x.k).le |
|
|
| theorem graphPackingOutput_length (c : ℕ) (ρ : ℝ) (x : GraphReductionInput) : |
| (graphPackingOutput c ρ x).2.length = 5 * (graphPackingOutput c ρ x).1 := |
| (reductionInventory c ρ x.graph x.k).rawOutput_length x.k_le |
|
|
| def graphPackingOutputInstance (c : ℕ) (ρ : ℝ) (x : GraphReductionInput) : Instance := |
| (graphPackingOutput c ρ x).2.toInstance (graphPackingOutput_valid c ρ x) |
|
|
| def graphPackingOutputReindexing (c : ℕ) (ρ : ℝ) (x : GraphReductionInput) : |
| Instance.Reindexing (graphPackingOutputInstance c ρ x) |
| (reductionInstance c ρ x.graph x.k) := |
| (reductionInventory c ρ x.graph x.k).rawItemListReindexing x.k_le |
| (reductionInventory_plus_height c ρ x.graph x.k).le |
| (reductionInventory_minus_height c ρ x.graph x.k).le |
|
|
| theorem graphPackingOutput_count (c : ℕ) (ρ : ℝ) (x : GraphReductionInput) : |
| (graphPackingOutputInstance c ρ x).n = 5 * (graphPackingOutput c ρ x).1 := |
| graphPackingOutput_length c ρ x |
|
|
| theorem graphPackingOutput_size_bounds (c : ℕ) (ρ : ℝ) (x : GraphReductionInput) |
| (i : (graphPackingOutputInstance c ρ x).Item) : |
| (1 / 6 : ℚ) < (graphPackingOutputInstance c ρ x).size i ∧ |
| (graphPackingOutputInstance c ρ x).size i < 1 := by |
| rw [(graphPackingOutputReindexing c ρ x).size_eq i] |
| exact reductionInstance_size_bounds c ρ x.graph x.k _ |
|
|
| theorem graphPackingOutput_hasPacking_iff (c : ℕ) (ρ : ℝ) |
| (x : GraphReductionInput) (b : ℕ) : |
| HasPacking (graphPackingOutputInstance c ρ x) b ↔ |
| HasPacking (reductionInstance c ρ x.graph x.k) b := |
| (graphPackingOutputReindexing c ρ x).hasPacking_iff b |
|
|
| theorem graphPackingOutput_opt_eq (c : ℕ) (ρ : ℝ) (x : GraphReductionInput) : |
| opt (graphPackingOutputInstance c ρ x) = |
| opt (reductionInstance c ρ x.graph x.k) := |
| (graphPackingOutputReindexing c ρ x).opt_eq |
|
|
| end BinPackingGap |
|
|
| end |
|
|
| end OAI |
|
|
