| import Mathlib.Data.List.FinRange |
| import Mathlib.Data.List.NodupEquivFin |
| import OAI.Computability.BinPacking.Inventory.InventoryScores |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| namespace BinPackingGap.InventoryData |
|
|
| variable (D : InventoryData) |
|
|
| private theorem length_flatMap_constant {α β : Type*} (l : List α) |
| (f : α → List β) (n : ℕ) (hf : ∀ a, (f a).length = n) : |
| (l.flatMap f).length = l.length * n := by |
| induction l with |
| | nil => simp |
| | cons a l ih => simp [hf, ih, Nat.add_mul, Nat.add_comm] |
|
|
| def treeRowList : List D.TreeRow := |
| ((Finset.univ : Finset D.plus.Node).toList.flatMap fun v => |
| (List.finRange D.d).map fun j => Sum.inl (v, j)) ++ |
| ((Finset.univ : Finset D.minus.Node).toList.flatMap fun v => |
| (List.finRange D.d).map fun j => Sum.inr (Sum.inl (v, j))) ++ |
| (List.finRange D.P).map (fun j => Sum.inr (Sum.inr j)) |
|
|
| def positiveLocalList : List D.PositiveLocal := |
| (Finset.univ : Finset D.PositiveLocal).toList |
|
|
| theorem mem_treeRowList (r : D.TreeRow) : r ∈ D.treeRowList := by |
| classical |
| rcases r with ⟨v, j⟩ | (⟨v, j⟩ | j) <;> |
| simp [treeRowList] |
| |
| theorem mem_positiveLocalList (r : D.PositiveLocal) : r ∈ D.positiveLocalList := by |
| classical |
| simp [positiveLocalList] |
|
|
| theorem treeRowList_length : D.treeRowList.length = D.t := by |
| classical |
| have hp := length_flatMap_constant (Finset.univ : Finset D.plus.Node).toList |
| (fun v => (List.finRange D.d).map fun j => (Sum.inl (v, j) : D.TreeRow)) D.d |
| (fun _ => by simp) |
| have hm := length_flatMap_constant (Finset.univ : Finset D.minus.Node).toList |
| (fun v => (List.finRange D.d).map fun j => |
| (Sum.inr (Sum.inl (v, j)) : D.TreeRow)) D.d (fun _ => by simp) |
| simp only [treeRowList, List.length_append, hp, hm, List.length_map, |
| List.length_finRange, Finset.length_toList, Finset.card_univ] |
| dsimp [t, tPlus, tMinus] |
| ring |
|
|
| theorem positiveLocalList_length : D.positiveLocalList.length = D.P := by |
| classical |
| simpa only [positiveLocalList, Finset.length_toList, Finset.card_univ] using |
| D.card_positiveLocal |
|
|
| def vertexChunk (v : D.Vertex) : List D.Item := |
| (D.treeRowList.map fun r => ⟨.x, ⟨v, .inl r⟩⟩) ++ |
| (D.treeRowList.map fun r => ⟨.anchor, ⟨v, .inl (.inl r)⟩⟩) ++ |
| (D.positiveLocalList.map fun r => ⟨.«local», ⟨v, .inl (.inl r)⟩⟩) ++ |
| ((List.finRange (D.t - D.P)).map fun j => |
| ⟨.«local», ⟨v, .inl (.inr (.inl j))⟩⟩) |
|
|
| def vertexItems : List D.Item := |
| (List.finRange D.graph.n).flatMap D.vertexChunk |
|
|
| def listedJobCopy (e : D.Edge) (j : Fin D.R) (s : Fin 2) (r : Fin D.d) : |
| D.JobCopy (D.graph.endpoint e s) := |
| ((⟨(e, s), rfl⟩, j), r) |
|
|
| def jobChunk (e : D.Edge) (j : Fin D.R) (s : Fin 2) : List D.Item := |
| let v := D.graph.endpoint e s |
| let copy := D.listedJobCopy e j s |
| ((List.finRange D.d).map fun r => ⟨.x, ⟨v, .inr (true, copy r)⟩⟩) ++ |
| ((List.finRange D.d).map fun r => ⟨.x, ⟨v, .inr (false, copy r)⟩⟩) ++ |
| ((List.finRange D.d).map fun r => ⟨.anchor, ⟨v, .inl (.inr (copy r))⟩⟩) ++ |
| ((List.finRange D.d).map fun r => ⟨.anchor, ⟨v, .inr (copy r)⟩⟩) ++ |
| ((List.finRange D.d).map fun r => |
| ⟨.«local», ⟨v, .inl (.inr (.inr (copy r)))⟩⟩) ++ |
| ((List.finRange D.d).map fun r => ⟨.«local», ⟨v, .inr (copy r)⟩⟩) |
|
|
| def jobItems : List D.Item := |
| (List.finRange D.graph.edges.length).flatMap fun e => |
| (List.finRange D.R).flatMap fun j => |
| (List.finRange 2).flatMap fun s => D.jobChunk e j s |
|
|
| def globalPool (s : GlobalSpecies D.graph) : List D.Item := |
| (List.finRange (D.globalStock s)).map fun r => ⟨.«global», ⟨s, r⟩⟩ |
|
|
| def globalItems : List D.Item := |
| D.globalPool (.up true) ++ D.globalPool (.up false) ++ |
| D.globalPool (.um true) ++ D.globalPool (.um false) ++ |
| (List.finRange D.graph.edges.length).flatMap fun e => |
| D.globalPool (.edge e true) ++ D.globalPool (.edge e false) |
|
|
| def flagPool (s : FlagSpecies) : List D.Item := |
| (List.finRange (D.flagStock s)).map fun r => ⟨.flag, ⟨s, r⟩⟩ |
|
|
| def flagItems : List D.Item := |
| D.flagPool .tree ++ D.flagPool .main ++ D.flagPool .edge |
|
|
| def itemList : List D.Item := |
| D.vertexItems ++ D.jobItems ++ D.globalItems ++ D.flagItems |
|
|
| theorem vertexChunk_length (v : D.Vertex) : (D.vertexChunk v).length = 3 * D.t := by |
| simp only [vertexChunk, List.length_append, List.length_map, D.treeRowList_length, |
| D.positiveLocalList_length, List.length_finRange] |
| have h := D.P_le_t |
| omega |
|
|
| theorem vertexItems_length : D.vertexItems.length = 3 * D.graph.n * D.t := by |
| rw [vertexItems, length_flatMap_constant _ _ _ D.vertexChunk_length, |
| List.length_finRange] |
| ring |
|
|
| theorem jobChunk_length (e : D.Edge) (j : Fin D.R) (s : Fin 2) : |
| (D.jobChunk e j s).length = 6 * D.d := by |
| simp only [jobChunk, List.length_append, List.length_map, List.length_finRange] |
| omega |
|
|
| theorem jobItems_length : |
| D.jobItems.length = 12 * D.d * D.graph.edges.length * D.R := by |
| have hs (e : D.Edge) (j : Fin D.R) : |
| ((List.finRange 2).flatMap fun s => D.jobChunk e j s).length = 2 * (6 * D.d) := by |
| rw [length_flatMap_constant _ _ _ (D.jobChunk_length e j), List.length_finRange] |
| have hj (e : D.Edge) : |
| ((List.finRange D.R).flatMap fun j => |
| (List.finRange 2).flatMap fun s => D.jobChunk e j s).length = |
| D.R * (2 * (6 * D.d)) := by |
| rw [length_flatMap_constant _ _ _ (hs e), List.length_finRange] |
| rw [jobItems, length_flatMap_constant _ _ _ hj, List.length_finRange] |
| ring |
|
|
| theorem globalPool_length (s : GlobalSpecies D.graph) : |
| (D.globalPool s).length = D.globalStock s := by simp [globalPool] |
|
|
| theorem globalItems_length (hk : D.k ≤ D.graph.n) : D.globalItems.length = D.B := by |
| have he (e : D.Edge) : |
| (D.globalPool (.edge e true) ++ D.globalPool (.edge e false)).length = |
| 2 * (D.d * D.R) := by simp [globalPool_length, globalStock, two_mul] |
| have hu := D.up_species_total hk |
| have hm := D.um_species_total |
| have hlen : D.globalItems.length = D.plusSlots + D.minusSlots + |
| D.graph.edges.length * (2 * (D.d * D.R)) := by |
| simp only [globalItems, List.length_append, D.globalPool_length, |
| length_flatMap_constant _ _ _ he, List.length_finRange] |
| omega |
| rw [hlen, D.plusSlots_eq, D.sum_J, D.B_closed] |
| dsimp [minusSlots, t] |
| ring |
|
|
| theorem flagPool_length (s : FlagSpecies) : |
| (D.flagPool s).length = D.flagStock s := by simp [flagPool] |
|
|
| theorem flagItems_length : D.flagItems.length = D.B := by |
| simp only [flagItems, List.length_append, D.flagPool_length, flagStock, |
| treeFlags, jobFlags, D.B_eq] |
| omega |
|
|
| theorem itemList_length (hk : D.k ≤ D.graph.n) : D.itemList.length = 5 * D.B := by |
| simp only [itemList, List.length_append, D.vertexItems_length, D.jobItems_length, |
| D.globalItems_length hk, D.flagItems_length] |
| rw [D.B_closed] |
| ring |
|
|
| private theorem mem_itemList_of_vertex {v : D.Vertex} {i : D.Item} |
| (hi : i ∈ D.vertexChunk v) : i ∈ D.itemList := by |
| have hv : i ∈ D.vertexItems := |
| List.mem_flatMap.mpr ⟨v, List.mem_finRange v, hi⟩ |
| simp only [itemList, List.mem_append] |
| exact Or.inl (Or.inl (Or.inl hv)) |
|
|
| private theorem mem_itemList_of_job {e : D.Edge} {j : Fin D.R} {s : Fin 2} {i : D.Item} |
| (hi : i ∈ D.jobChunk e j s) : i ∈ D.itemList := by |
| have hj : i ∈ D.jobItems := List.mem_flatMap.mpr ⟨e, List.mem_finRange e, |
| List.mem_flatMap.mpr ⟨j, List.mem_finRange j, |
| List.mem_flatMap.mpr ⟨s, List.mem_finRange s, hi⟩⟩⟩ |
| simp only [itemList, List.mem_append] |
| exact Or.inl (Or.inl (Or.inr hj)) |
|
|
| private theorem mem_globalItems (g : D.GlobalCopy) : |
| (⟨.«global», g⟩ : D.Item) ∈ D.globalItems := by |
| rcases g with ⟨s, r⟩ |
| cases s with |
| | up b => cases b <;> simp [globalItems, globalPool] |
| | um b => cases b <;> simp [globalItems, globalPool] |
| | edge e b => |
| have hp : (⟨.«global», ⟨.edge e b, r⟩⟩ : D.Item) ∈ |
| D.globalPool (.edge e true) ++ D.globalPool (.edge e false) := by |
| cases b <;> simp [globalPool] |
| have he : (⟨.«global», ⟨.edge e b, r⟩⟩ : D.Item) ∈ |
| (List.finRange D.graph.edges.length).flatMap |
| (fun e => D.globalPool (.edge e true) ++ D.globalPool (.edge e false)) := |
| List.mem_flatMap.mpr ⟨e, List.mem_finRange e, hp⟩ |
| exact List.mem_append_right _ he |
|
|
| private theorem mem_flagItems (g : D.FlagCopy) : (⟨.flag, g⟩ : D.Item) ∈ D.flagItems := by |
| rcases g with ⟨s, r⟩ |
| cases s <;> simp [flagItems, flagPool] |
| |
| theorem mem_itemList (i : D.Item) : i ∈ D.itemList := by |
| classical |
| rcases i with ⟨role, i⟩ |
| cases role with |
| | x => |
| rcases i with ⟨v, tree | ⟨short, job⟩⟩ |
| · apply D.mem_itemList_of_vertex (v := v) |
| simp only [vertexChunk, List.mem_append] |
| exact Or.inl (Or.inl (Or.inl |
| (List.mem_map.mpr ⟨tree, D.mem_treeRowList tree, rfl⟩))) |
| · rcases job with ⟨⟨⟨⟨e, s⟩, hv⟩, j⟩, r⟩ |
| cases hv |
| apply D.mem_itemList_of_job (e := e) (j := j) (s := s) |
| cases short <;> simp [jobChunk, listedJobCopy] |
| | anchor => |
| rcases i with ⟨v, (tree | job) | job⟩ |
| · apply D.mem_itemList_of_vertex (v := v) |
| simp only [vertexChunk, List.mem_append] |
| exact Or.inl (Or.inl (Or.inr |
| (List.mem_map.mpr ⟨tree, D.mem_treeRowList tree, rfl⟩))) |
| · rcases job with ⟨⟨⟨⟨e, s⟩, hv⟩, j⟩, r⟩ |
| cases hv |
| apply D.mem_itemList_of_job (e := e) (j := j) (s := s) |
| simp [jobChunk, listedJobCopy] |
| · rcases job with ⟨⟨⟨⟨e, s⟩, hv⟩, j⟩, r⟩ |
| cases hv |
| apply D.mem_itemList_of_job (e := e) (j := j) (s := s) |
| simp [jobChunk, listedJobCopy] |
| | «global» => |
| simp only [itemList, List.mem_append] |
| exact Or.inl (Or.inr (D.mem_globalItems i)) |
| | «local» => |
| rcases i with ⟨v, (positive | (zero | job)) | job⟩ |
| · apply D.mem_itemList_of_vertex (v := v) |
| simp only [vertexChunk, List.mem_append] |
| exact Or.inl (Or.inr |
| (List.mem_map.mpr ⟨positive, D.mem_positiveLocalList positive, rfl⟩)) |
| · apply D.mem_itemList_of_vertex (v := v) |
| simp [vertexChunk] |
| · rcases job with ⟨⟨⟨⟨e, s⟩, hv⟩, j⟩, r⟩ |
| cases hv |
| apply D.mem_itemList_of_job (e := e) (j := j) (s := s) |
| simp [jobChunk, listedJobCopy] |
| · rcases job with ⟨⟨⟨⟨e, s⟩, hv⟩, j⟩, r⟩ |
| cases hv |
| apply D.mem_itemList_of_job (e := e) (j := j) (s := s) |
| simp [jobChunk, listedJobCopy] |
| | flag => |
| simp only [itemList, List.mem_append] |
| exact Or.inr (D.mem_flagItems i) |
|
|
| open scoped Classical in |
| theorem itemList_toFinset : D.itemList.toFinset = Finset.univ := by |
| classical |
| ext i |
| simp [D.mem_itemList i] |
|
|
| theorem itemList_nodup (hk : D.k ≤ D.graph.n) : D.itemList.Nodup := by |
| classical |
| have hcard : D.itemList.toFinset.card = D.itemList.length := by |
| rw [D.itemList_toFinset, Finset.card_univ, D.card_item hk, D.itemList_length hk] |
| exact (Multiset.toFinset_card_eq_card_iff_nodup |
| (m := (D.itemList : Multiset D.Item))).mp hcard |
|
|
| def itemListEquiv (hk : D.k ≤ D.graph.n) : Fin D.itemList.length ≃ D.Item := by |
| classical |
| exact List.Nodup.getEquivOfForallMemList D.itemList (D.itemList_nodup hk) D.mem_itemList |
|
|
| @[simp] theorem itemListEquiv_apply (hk : D.k ≤ D.graph.n) |
| (i : Fin D.itemList.length) : D.itemListEquiv hk i = D.itemList.get i := rfl |
|
|
| end BinPackingGap.InventoryData |
|
|
| end |
|
|
| end OAI |
|
|
