math / data /lean /OAI /Computability /BinPacking /Inventory /CurrentMatches.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
46.7 kB
import Lean.Elab.Tactic.Omega import Mathlib.Data.Finset.Card import Mathlib.Data.Finset.Max import Mathlib.Data.Finset.Prod import Mathlib.Data.Fintype.EquivFin import Mathlib.Order.Interval.Set.Disjoint import OAI.Computability.BinPacking.Packing.FiniteHall import OAI.Computability.BinPacking.Packing.PackingScalar import OAI.Computability.BinPacking.Trees.CompletionGeometry namespace OAI noncomputable section namespace BinPackingGap namespace CoverageCounts section FiniteCounts variable {α β γ : Type*} [DecidableEq α] [DecidableEq β] theorem interval_prefix_card [LinearOrder γ] (s : Finset α) (h b : α → γ) (hle : ∀ i ∈ s, h i ≤ b i) (a : γ) : (s.filter fun i => h i ≤ a).card = (s.filter fun i => b i ≤ a).card + (s.filter fun i => h i ≤ a ∧ a < b i).card := by classical have hunion : (s.filter fun i => h i ≤ a) = (s.filter fun i => b i ≤ a) ∪ (s.filter fun i => h i ≤ a ∧ a < b i) := by ext i simp only [Finset.mem_filter, Finset.mem_union] constructor · rintro ⟨his, hia⟩ by_cases hba : b i ≤ a · exact Or.inl ⟨his, hba⟩ · exact Or.inr ⟨his, hia, lt_of_not_ge hba⟩ · rintro (⟨his, hba⟩ | ⟨his, hia, _⟩) · exact ⟨his, (hle i his).trans hba⟩ · exact ⟨his, hia⟩ have hdis : Disjoint (s.filter fun i => b i ≤ a) (s.filter fun i => h i ≤ a ∧ a < b i) := by apply Finset.disjoint_left.mpr intro i hi hj exact (not_lt_of_ge (Finset.mem_filter.mp hi).2) (Finset.mem_filter.mp hj).2.2 rw [hunion, Finset.card_union_of_disjoint hdis] omit [DecidableEq α] in theorem ordered_short_long_partition [LinearOrder γ] (s : Finset α) (position : α → γ) (current : γ) (short : α → Prop) [DecidablePred short] (horder : ∀ i ∈ s, position i ≤ current) : s.card = (s.filter fun i => position i < current).card + (s.filter fun i => position i = current ∧ short i).card + (s.filter fun i => position i = current ∧ ¬ short i).card := by classical have hexact : (s.filter fun i => ¬ position i < current) = (s.filter fun i => position i = current) := by ext i simp only [Finset.mem_filter] constructor · rintro ⟨his, hi⟩ exact ⟨his, le_antisymm (horder i his) (le_of_not_gt hi)⟩ · rintro ⟨his, hi⟩ exact ⟨his, by rw [hi]; exact lt_irrefl _⟩ have hpositions := Finset.card_filter_add_card_filter_not (s := s) (fun i => position i < current) rw [hexact] at hpositions have hlengths := Finset.card_filter_add_card_filter_not (s := s.filter fun i => position i = current) short simp only [Finset.filter_filter] at hlengths omega theorem card_le_good_card_add {s bad : Finset α} {K : ℕ} (hbad : bad.card ≤ K) : s.card ≤ (s \ bad).card + K := by have hinter : (s ∩ bad).card ≤ K := (Finset.card_le_card Finset.inter_subset_right).trans hbad have hsplit := Finset.card_sdiff_add_card_inter s bad omega omit [DecidableEq β] in theorem card_le_target_add_loss {s bad : Finset α} {t : Finset β} {K : ℕ} (f : α → β) (hbad : bad.card ≤ K) (hmap : ∀ i ∈ s \ bad, f i ∈ t) (hinj : Set.InjOn f (↑(s \ bad : Finset α) : Set α)) : s.card ≤ t.card + K := by have hgood := Finset.card_le_card_of_injOn f hmap hinj have htotal := card_le_good_card_add (s := s) hbad omega omit [DecidableEq β] in theorem card_add_card_le_of_disjoint_injections (s t : Finset α) (resources : Finset β) (row : α → β) (hdis : Disjoint s t) (hmap : ∀ i ∈ s ∪ t, row i ∈ resources) (hinj : Set.InjOn row (↑(s ∪ t : Finset α) : Set α)) : s.card + t.card ≤ resources.card := by rw [← Finset.card_union_of_disjoint hdis] exact Finset.card_le_card_of_injOn row hmap hinj omit [DecidableEq β] in theorem card_three_le_of_disjoint_injections (s t u : Finset α) (resources : Finset β) (row : α → β) (hst : Disjoint s t) (hsu : Disjoint s u) (htu : Disjoint t u) (hmap : ∀ i ∈ (s ∪ t) ∪ u, row i ∈ resources) (hinj : Set.InjOn row (↑((s ∪ t) ∪ u : Finset α) : Set α)) : s.card + t.card + u.card ≤ resources.card := by have hdis : Disjoint (s ∪ t) u := by apply Finset.disjoint_left.mpr intro i hi hu rcases Finset.mem_union.mp hi with hs | ht · exact Finset.disjoint_left.mp hsu hs hu · exact Finset.disjoint_left.mp htu ht hu have hcount := card_add_card_le_of_disjoint_injections (s ∪ t) u resources row hdis hmap hinj rwa [Finset.card_union_of_disjoint hst] at hcount theorem card_le_add_of_subset_union (s t u : Finset α) (h : s ⊆ t ∪ u) : s.card ≤ t.card + u.card := (Finset.card_le_card h).trans (Finset.card_union_le _ _) end FiniteCounts theorem displaced_baseline_bound {A B tree jobs used goodEarlier ξ K : ℕ} (hA : A ≤ tree + used) (hB : B = tree + jobs) (hrows : used + goodEarlier + ξ ≤ 2 * jobs) (hkeys : jobs ≤ goodEarlier + 3 * K) : A + ξ ≤ B + 3 * K := by omega theorem coverage_lower_bound {A B C I d K : ℕ} (hpartition : C = A + I) (hdeadline : B + d ≤ C + 3 * K) (hbaseline : A ≤ B + 3 * K) : d ≤ I + 6 * K := by omega theorem displaced_short_correction {A B C I d K ξ xplus shortM : ℕ} (hpartition : C = A + I) (hdeadline : B + d ≤ C + 3 * K) (hbaseline : A + ξ ≤ B + 3 * K) (hcoverage : I ≤ xplus + shortM) : d + ξ ≤ xplus + shortM + 6 * K := by omega theorem short_le_displaced_add_long {d K ξ goodCurrent shortM shortG longG : ℕ} (hkeys : d ≤ goodCurrent + 3 * K) (hpartition : goodCurrent = ξ + shortG + longG) (hshort : shortM + shortG ≤ d) : shortM ≤ ξ + longG + 3 * K := by omega theorem long_match_lower_bound {d K ξ xplus shortM longG : ℕ} (hcorrection : d + ξ ≤ xplus + shortM + 6 * K) (hshort : shortM ≤ ξ + longG + 3 * K) : d ≤ longG + xplus + 9 * K := by omega end CoverageCounts end BinPackingGap namespace BinPackingGap.IntervalCoverage variable {ι κ τ α : Type*} [LinearOrder α] def prefixSet [Fintype ι] (f : ι → α) (a : α) : Finset ι := by classical exact Finset.univ.filter fun i => f i ≤ a def prefixCount [Fintype ι] (f : ι → α) (a : α) : ℕ := (prefixSet f a).card def coverageSet [Fintype ι] (h b : ι → α) (a : α) : Finset ι := by classical exact Finset.univ.filter fun i => h i ≤ a ∧ a < b i def coverageCount [Fintype ι] (h b : ι → α) (a : α) : ℕ := (coverageSet h b a).card @[simp] theorem mem_prefixSet [Fintype ι] (f : ι → α) (a : α) (i : ι) : i ∈ prefixSet f a ↔ f i ≤ a := by classical simp [prefixSet] @[simp] theorem mem_coverageSet [Fintype ι] (h b : ι → α) (a : α) (i : ι) : i ∈ coverageSet h b a ↔ h i ≤ a ∧ a < b i := by classical simp [coverageSet] theorem completion_prefix_identity [Fintype ι] (h b : ι → α) (hle : ∀ i, h i ≤ b i) (a : α) : prefixCount h a = prefixCount b a + coverageCount h b a := by classical simpa only [prefixCount, coverageCount, prefixSet, coverageSet] using CoverageCounts.interval_prefix_card Finset.univ h b (fun i _ => hle i) a structure ShiftData (Copy Test : Type*) (d : ℕ) (Coordinate : Type*) [LinearOrder Coordinate] where baseline : Copy → Coordinate left : Test → Coordinate right : Test → Coordinate designated : (Test × Fin d) ↪ Copy baseline_designated : ∀ q, baseline (designated q) = right q.1 left_le_right : ∀ t, left t ≤ right t namespace ShiftData variable {d : ℕ} (D : ShiftData ι τ d α) local instance : DecidableEq ι := Classical.decEq ι def deadline (i : ι) : α := by classical exact if hi : ∃ q, D.designated q = i then D.left (Classical.choose hi).1 else D.baseline i @[simp] theorem deadline_designated (q : τ × Fin d) : D.deadline (D.designated q) = D.left q.1 := by classical have hi : ∃ q', D.designated q' = D.designated q := ⟨q, rfl⟩ have heq : Classical.choose hi = q := D.designated.injective (Classical.choose_spec hi) simp only [deadline, dite_eq_left hi, heq] theorem deadline_undesignated (i : ι) (hi : ∀ q, D.designated q ≠ i) : D.deadline i = D.baseline i := by classical have hn : ¬ ∃ q, D.designated q = i := by rintro ⟨q, hq⟩ exact hi q hq simp only [deadline, dite_eq_right hn] theorem designated_block_card (t : τ) : ((Finset.univ : Finset (Fin d)).image (fun j => D.designated (t, j))).card = d := by classical rw [Finset.card_image_of_injective] · exact Fintype.card_fin d · intro j k hjk exact congrArg Prod.snd (D.designated.injective hjk) def activeTests [Fintype τ] (a : α) : Finset τ := by classical exact Finset.univ.filter fun t => D.left t ≤ a ∧ a < D.right t @[simp] theorem mem_activeTests [Fintype τ] (a : α) (t : τ) : t ∈ D.activeTests a ↔ D.left t ≤ a ∧ a < D.right t := by classical simp [activeTests] theorem deadline_prefix_of_agrees [Fintype ι] [Fintype τ] (z : ι → α) (hdesignated : ∀ q, z (D.designated q) = D.left q.1) (hother : ∀ i, (∀ q, D.designated q ≠ i) → z i = D.baseline i) (a : α) : prefixCount z a = prefixCount D.baseline a + d * (D.activeTests a).card := by classical have hle : ∀ i, z i ≤ D.baseline i := by intro i by_cases hi : ∃ q, D.designated q = i · obtain ⟨q, rfl⟩ := hi rw [hdesignated, D.baseline_designated] exact D.left_le_right q.1 · rw [hother i (by simpa only [not_exists] using hi)] have hset : coverageSet z D.baseline a = ((D.activeTests a).product (Finset.univ : Finset (Fin d))).map D.designated := by ext i simp only [mem_coverageSet, Finset.mem_map, Finset.product_eq_sprod, Finset.mem_product, mem_activeTests, Finset.mem_univ, and_true] constructor · intro hi have hex : ∃ q, D.designated q = i := by by_contra hn have he := hother i (by simpa only [not_exists] using hn) exact (not_lt_of_ge (he ▸ hi.1)) hi.2 obtain ⟨q, rfl⟩ := hex exact ⟨q, by simpa only [hdesignated, D.baseline_designated] using hi, rfl⟩ · rintro ⟨q, hq, rfl⟩ simpa only [hdesignated, D.baseline_designated] using hq rw [completion_prefix_identity z D.baseline hle a] unfold coverageCount rw [hset, Finset.card_map, Finset.product_eq_sprod, Finset.card_product, Finset.card_univ, Fintype.card_fin] rw [Nat.mul_comm] theorem deadline_prefix [Fintype ι] [Fintype τ] (a : α) : prefixCount D.deadline a = prefixCount D.baseline a + d * (D.activeTests a).card := D.deadline_prefix_of_agrees D.deadline D.deadline_designated D.deadline_undesignated a theorem activeTests_card [Fintype τ] (hdisjoint : ∀ s t, s ≠ t → Disjoint (Set.Ico (D.left s) (D.right s)) (Set.Ico (D.left t) (D.right t))) (a : α) : (D.activeTests a).card = if ∃ t, D.left t ≤ a ∧ a < D.right t then 1 else 0 := by classical have hle : (D.activeTests a).card ≤ 1 := by apply Finset.card_le_one.mpr intro s hs t ht by_contra hst exact Set.disjoint_left.mp (hdisjoint s t hst) (D.mem_activeTests a s |>.mp hs) (D.mem_activeTests a t |>.mp ht) split_ifs with hex · obtain ⟨t, ht⟩ := hex have hpos := Finset.card_pos.mpr ⟨t, (D.mem_activeTests a t).mpr ht⟩ omega · apply Finset.card_eq_zero.mpr apply Finset.eq_empty_iff_forall_notMem.mpr intro t ht exact hex ⟨t, (D.mem_activeTests a t).mp ht⟩ theorem deadline_prefix_disjoint_of_agrees [Fintype ι] [Fintype τ] (z : ι → α) (hdesignated : ∀ q, z (D.designated q) = D.left q.1) (hother : ∀ i, (∀ q, D.designated q ≠ i) → z i = D.baseline i) (hdisjoint : ∀ s t, s ≠ t → Disjoint (Set.Ico (D.left s) (D.right s)) (Set.Ico (D.left t) (D.right t))) (a : α) : prefixCount z a = prefixCount D.baseline a + d * (if ∃ t, D.left t ≤ a ∧ a < D.right t then 1 else 0) := by rw [D.deadline_prefix_of_agrees z hdesignated hother, D.activeTests_card hdisjoint] theorem deadline_prefix_disjoint [Fintype ι] [Fintype τ] (hdisjoint : ∀ s t, s ≠ t → Disjoint (Set.Ico (D.left s) (D.right s)) (Set.Ico (D.left t) (D.right t))) (a : α) : prefixCount D.deadline a = prefixCount D.baseline a + d * (if ∃ t, D.left t ≤ a ∧ a < D.right t then 1 else 0) := D.deadline_prefix_disjoint_of_agrees D.deadline D.deadline_designated D.deadline_undesignated hdisjoint a end ShiftData theorem exists_equiv_of_prefix_dominance [Fintype ι] [Fintype κ] (h : ι → α) (z : κ → α) (hcard : Fintype.card ι = Fintype.card κ) (hprefix : ∀ a, prefixCount z a ≤ prefixCount h a) : ∃ e : ι ≃ κ, ∀ i, h i ≤ z (e i) := by classical let neighbors : ι → Finset κ := fun i => Finset.univ.filter fun j => h i ≤ z j have hall : ∀ s : Finset ι, s.card ≤ (s.biUnion neighbors).card := by intro s let N := s.biUnion neighbors let bad := (Finset.univ : Finset κ) \ N have hpartition : bad.card + N.card = Fintype.card κ := by simpa only [bad, Finset.card_univ] using Finset.card_sdiff_add_card_eq_card (Finset.subset_univ N) by_cases hbad : bad.Nonempty · obtain ⟨j, hj, hmax⟩ := bad.exists_max_image z hbad have hN : j ∉ N := (Finset.mem_sdiff.mp hj).2 have hd : Disjoint s (prefixSet h (z j)) := by apply Finset.disjoint_left.mpr intro i hi hip apply hN exact Finset.mem_biUnion.mpr ⟨i, hi, by simpa only [neighbors, Finset.mem_filter, Finset.mem_univ, true_and, mem_prefixSet] using hip⟩ have hsum : s.card + prefixCount h (z j) ≤ Fintype.card ι := by rw [prefixCount, ← Finset.card_union_of_disjoint hd] exact Finset.card_le_univ _ have hb : bad.card ≤ prefixCount z (z j) := by apply Finset.card_le_card intro k hk exact (mem_prefixSet z (z j) k).mpr (hmax k hk) have hp := hprefix (z j) change s.card ≤ N.card omega · have hb : bad.card = 0 := Finset.card_eq_zero.mpr (Finset.not_nonempty_iff_eq_empty.mp hbad) have hs := Finset.card_le_univ s change s.card ≤ N.card omega obtain ⟨f, hf, hmatch⟩ := (FiniteHall.all_card_le_biUnion_card_iff_existsInjective neighbors).mp hall have hbij : Function.Bijective f := (Fintype.bijective_iff_injective_and_card f).mpr ⟨hf, hcard⟩ refine ⟨Equiv.ofBijective f hbij, ?_⟩ intro i change h i ≤ z (f i) have hi := hmatch i simpa only [neighbors, Finset.mem_filter, Finset.mem_univ, true_and] using hi end BinPackingGap.IntervalCoverage namespace BinPackingGap namespace Coverage variable {I : Instance} {b n : ℕ} def goodTuplesAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) : Finset (p.TableBin cls) := by classical exact Finset.univ.filter fun t => p.IsGoodTableBin cls label t ∧ label (p.itemAtRole cls t .anchor) = some v def mainTuplesAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) : Finset (p.TableBin cls) := by classical exact (goodTuplesAt p cls label v).filter fun t => p.tablePattern cls t ≠ .edgeJob def edgeTuplesAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) : Finset (p.TableBin cls) := by classical exact (goodTuplesAt p cls label v).filter fun t => p.tablePattern cls t = .edgeJob @[simp] theorem mem_goodTuplesAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (t : p.TableBin cls) : t ∈ goodTuplesAt p cls label v ↔ p.IsGoodTableBin cls label t ∧ label (p.itemAtRole cls t .anchor) = some v := by classical simp [goodTuplesAt] @[simp] theorem mem_mainTuplesAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (t : p.TableBin cls) : t ∈ mainTuplesAt p cls label v ↔ p.IsGoodTableBin cls label t ∧ label (p.itemAtRole cls t .anchor) = some v ∧ p.tablePattern cls t ≠ .edgeJob := by classical simp [mainTuplesAt, and_assoc] @[simp] theorem mem_edgeTuplesAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (t : p.TableBin cls) : t ∈ edgeTuplesAt p cls label v ↔ p.IsGoodTableBin cls label t ∧ label (p.itemAtRole cls t .anchor) = some v ∧ p.tablePattern cls t = .edgeJob := by classical simp [edgeTuplesAt, and_assoc] theorem mainTuplesAt_subset_good (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) : mainTuplesAt p cls label v ⊆ goodTuplesAt p cls label v := by classical exact Finset.filter_subset _ _ theorem edgeTuplesAt_subset_good (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) : edgeTuplesAt p cls label v ⊆ goodTuplesAt p cls label v := by classical exact Finset.filter_subset _ _ theorem goodTuplesAt_eq_union (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) : goodTuplesAt p cls label v = mainTuplesAt p cls label v ∪ edgeTuplesAt p cls label v := by classical ext t by_cases h : p.tablePattern cls t = .edgeJob <;> simp [mainTuplesAt, edgeTuplesAt, h] theorem mainTuplesAt_disjoint_edge (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v w : Fin n) : Disjoint (mainTuplesAt p cls label v) (edgeTuplesAt p cls label w) := by apply Finset.disjoint_left.mpr intro t ht hu exact ((mem_mainTuplesAt p cls label v t).mp ht).2.2 (((mem_edgeTuplesAt p cls label w t).mp hu).2.2) theorem goodTuplesAt_disjoint_label (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) {v w : Fin n} (hvw : v ≠ w) : Disjoint (goodTuplesAt p cls label v) (goodTuplesAt p cls label w) := by apply Finset.disjoint_left.mpr intro t ht hu have hv := ((mem_goodTuplesAt p cls label v t).mp ht).2 have hw := ((mem_goodTuplesAt p cls label w t).mp hu).2 exact hvw (Option.some.inj (hv.symm.trans hw)) theorem mainTuplesAt_disjoint_label (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) {v w : Fin n} (hvw : v ≠ w) : Disjoint (mainTuplesAt p cls label v) (mainTuplesAt p cls label w) := (goodTuplesAt_disjoint_label p cls label hvw).mono (mainTuplesAt_subset_good p cls label v) (mainTuplesAt_subset_good p cls label w) theorem edgeTuplesAt_disjoint_label (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) {v w : Fin n} (hvw : v ≠ w) : Disjoint (edgeTuplesAt p cls label v) (edgeTuplesAt p cls label w) := (goodTuplesAt_disjoint_label p cls label hvw).mono (edgeTuplesAt_subset_good p cls label v) (edgeTuplesAt_subset_good p cls label w) def roleItems (p : Packing I b) (cls : I.Item → Subclass) (s : Finset (p.TableBin cls)) (role : Role) : Finset I.Item := s.image fun t => p.itemAtRole cls t role @[simp] theorem roleItems_card (p : Packing I b) (cls : I.Item → Subclass) (s : Finset (p.TableBin cls)) (role : Role) : (roleItems p cls s role).card = s.card := Finset.card_image_of_injective s (p.itemAtRole_injective cls role) def anchorItemsAt (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) : Finset I.Item := by classical exact Finset.univ.filter fun i => (cls i).role = .anchor ∧ label i = some v @[simp] theorem mem_anchorItemsAt (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (i : I.Item) : i ∈ anchorItemsAt (I := I) cls label v ↔ (cls i).role = .anchor ∧ label i = some v := by classical simp [anchorItemsAt] def badAnchorsAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) : Finset I.Item := anchorItemsAt (I := I) cls label v \ roleItems p cls (goodTuplesAt p cls label v) .anchor @[simp] theorem mem_badAnchorsAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (i : I.Item) : i ∈ badAnchorsAt p cls label v ↔ i ∈ anchorItemsAt (I := I) cls label v ∧ i ∉ roleItems p cls (goodTuplesAt p cls label v) .anchor := by simp only [badAnchorsAt, Finset.mem_sdiff] theorem good_anchorItems_subset (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) : roleItems p cls (goodTuplesAt p cls label v) .anchor ⊆ anchorItemsAt (I := I) cls label v := by intro i hi obtain ⟨t, ht, rfl⟩ := Finset.mem_image.mp hi exact (mem_anchorItemsAt cls label v _).mpr ⟨p.itemAtRole_role cls t .anchor, ((mem_goodTuplesAt p cls label v t).mp ht).2⟩ theorem card_le_role_resources (p : Packing I b) (cls : I.Item → Subclass) (s : Finset (p.TableBin cls)) (role : Role) (resources : Finset I.Item) (hmap : ∀ t ∈ s, p.itemAtRole cls t role ∈ resources) : s.card ≤ resources.card := Finset.card_le_card_of_injOn (fun t => p.itemAtRole cls t role) hmap (p.itemAtRole_injective cls role).injOn theorem card_three_le_row_resources (p : Packing I b) (cls : I.Item → Subclass) (s t u : Finset (p.TableBin cls)) (resources : Finset I.Item) (hst : Disjoint s t) (hsu : Disjoint s u) (htu : Disjoint t u) (hmap : ∀ x ∈ (s ∪ t) ∪ u, p.itemAtRole cls x .x ∈ resources) : s.card + t.card + u.card ≤ resources.card := CoverageCounts.card_three_le_of_disjoint_injections s t u resources (fun x => p.itemAtRole cls x .x) hst hsu htu hmap (p.itemAtRole_injective cls .x).injOn def tupleCompletion (p : Packing I b) (cls : I.Item → Subclass) (baseline : I.Item → ℚ) (short : I.Item → Bool) (globalLen localLen : I.Item → ℚ) (delta : ℚ) (t : p.TableBin cls) : ℚ := completion (baseline (p.itemAtRole cls t .x)) (short (p.itemAtRole cls t .x)) (globalLen (p.itemAtRole cls t .«global»)) (localLen (p.itemAtRole cls t .«local»)) delta theorem tupleCompletion_le_baseline (p : Packing I b) (cls : I.Item → Subclass) (baseline : I.Item → ℚ) (short : I.Item → Bool) (globalLen localLen : I.Item → ℚ) (delta : ℚ) (hglobal : ∀ i, 0 ≤ globalLen i) (hlocal : ∀ i, 0 ≤ localLen i) (hdelta : 0 ≤ delta) (t : p.TableBin cls) : tupleCompletion p cls baseline short globalLen localLen delta t ≤ baseline (p.itemAtRole cls t .x) := completion_le_baseline _ _ _ _ _ (hglobal _) (hlocal _) hdelta def baselinePrefixAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (a : ℚ) : Finset (p.TableBin cls) := (mainTuplesAt p cls label v).filter fun t => baseline (p.itemAtRole cls t .x) ≤ a def completionPrefixAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (finish : p.TableBin cls → ℚ) (a : ℚ) : Finset (p.TableBin cls) := (mainTuplesAt p cls label v).filter fun t => finish t ≤ a def coveringTuplesAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (finish : p.TableBin cls → ℚ) (a : ℚ) : Finset (p.TableBin cls) := (mainTuplesAt p cls label v).filter fun t => finish t ≤ a ∧ a < baseline (p.itemAtRole cls t .x) theorem completion_prefix_decomposition (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (finish : p.TableBin cls → ℚ) (hle : ∀ t ∈ mainTuplesAt p cls label v, finish t ≤ baseline (p.itemAtRole cls t .x)) (a : ℚ) : (completionPrefixAt p cls label v finish a).card = (baselinePrefixAt p cls label v baseline a).card + (coveringTuplesAt p cls label v baseline finish a).card := CoverageCounts.interval_prefix_card (mainTuplesAt p cls label v) finish (fun t => baseline (p.itemAtRole cls t .x)) hle a theorem literal_completion_prefix_decomposition (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (short : I.Item → Bool) (globalLen localLen : I.Item → ℚ) (delta a : ℚ) (hglobal : ∀ i, 0 ≤ globalLen i) (hlocal : ∀ i, 0 ≤ localLen i) (hdelta : 0 ≤ delta) : (completionPrefixAt p cls label v (tupleCompletion p cls baseline short globalLen localLen delta) a).card = (baselinePrefixAt p cls label v baseline a).card + (coveringTuplesAt p cls label v baseline (tupleCompletion p cls baseline short globalLen localLen delta) a).card := completion_prefix_decomposition p cls label v baseline _ (fun t _ => tupleCompletion_le_baseline p cls baseline short globalLen localLen delta hglobal hlocal hdelta t) a def deadlinePrefixAt (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (deadline : I.Item → ℚ) (a : ℚ) : Finset I.Item := by classical exact Finset.univ.filter fun i => cls i = .z ∧ label i = some v ∧ deadline i ≤ a @[simp] theorem mem_deadlinePrefixAt (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (deadline : I.Item → ℚ) (a : ℚ) (i : I.Item) : i ∈ deadlinePrefixAt (I := I) cls label v deadline a ↔ cls i = .z ∧ label i = some v ∧ deadline i ≤ a := by classical simp [deadlinePrefixAt] theorem good_deadline_subset_completed_anchor_image (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (deadline : I.Item → ℚ) (finish : p.TableBin cls → ℚ) (a : ℚ) (hfeasible : ∀ t ∈ mainTuplesAt p cls label v, finish t ≤ deadline (p.itemAtRole cls t .anchor)) : deadlinePrefixAt (I := I) cls label v deadline a \ badAnchorsAt p cls label v ⊆ roleItems p cls (completionPrefixAt p cls label v finish a) .anchor := by classical intro i hi obtain ⟨hi, hnotbad⟩ := Finset.mem_sdiff.mp hi obtain ⟨hcls, hlabel, hdeadline⟩ := (mem_deadlinePrefixAt cls label v deadline a i).mp hi have hanchor : i ∈ anchorItemsAt (I := I) cls label v := by apply (mem_anchorItemsAt cls label v i).mpr exact ⟨by rw [hcls]; rfl, hlabel⟩ have hused : i ∈ roleItems p cls (goodTuplesAt p cls label v) .anchor := by by_contra h exact hnotbad ((mem_badAnchorsAt p cls label v i).mpr ⟨hanchor, h⟩) obtain ⟨t, ht, hti⟩ := Finset.mem_image.mp hused have hM : t ∈ mainTuplesAt p cls label v := by have htgood := (mem_goodTuplesAt p cls label v t).mp ht refine (mem_mainTuplesAt p cls label v t).mpr ⟨htgood.1, htgood.2, ?_⟩ intro hedge have hsub := p.itemAtRole_subclass cls t .anchor rw [hedge] at hsub have hnot : (Subclass.z : Subclass) = .y := by calc Subclass.z = cls i := hcls.symm _ = cls (p.itemAtRole cls t .anchor) := congrArg cls hti.symm _ = Subclass.y := hsub cases hnot apply Finset.mem_image.mpr refine ⟨t, ?_, hti⟩ apply Finset.mem_filter.mpr refine ⟨hM, (hfeasible t hM).trans ?_⟩ simpa only [hti] using hdeadline theorem deadline_prefix_le_completion_add_loss (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (deadline : I.Item → ℚ) (finish : p.TableBin cls → ℚ) (a : ℚ) (K : ℕ) (hbad : (badAnchorsAt p cls label v).card ≤ 3 * K) (hfeasible : ∀ t ∈ mainTuplesAt p cls label v, finish t ≤ deadline (p.itemAtRole cls t .anchor)) : (deadlinePrefixAt (I := I) cls label v deadline a).card ≤ (completionPrefixAt p cls label v finish a).card + 3 * K := by have hcount := Finset.card_le_card (good_deadline_subset_completed_anchor_image p cls label v deadline finish a hfeasible) rw [roleItems_card] at hcount have hloss := CoverageCounts.card_le_good_card_add (s := deadlinePrefixAt (I := I) cls label v deadline a) hbad omega def jobRowPrefixAt (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (a : ℚ) : Finset I.Item := by classical exact Finset.univ.filter fun i => cls i = .s ∧ label i = some v ∧ baseline i ≤ a def treeRowPrefixAt (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (a : ℚ) : Finset I.Item := by classical exact Finset.univ.filter fun i => (cls i = .tp ∨ cls i = .tm) ∧ label i = some v ∧ baseline i ≤ a def keyPrefixAt (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (keyBaseline : I.Item → ℚ) (a : ℚ) : Finset I.Item := by classical exact Finset.univ.filter fun i => cls i = .y ∧ label i = some v ∧ keyBaseline i ≤ a def edgePrefixAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (keyBaseline : I.Item → ℚ) (a : ℚ) : Finset (p.TableBin cls) := (edgeTuplesAt p cls label v).filter fun t => keyBaseline (p.itemAtRole cls t .anchor) ≤ a def mainJobPrefixAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (a : ℚ) : Finset (p.TableBin cls) := by classical exact (baselinePrefixAt p cls label v baseline a).filter fun t => cls (p.itemAtRole cls t .x) = .s def mainTreePrefixAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (a : ℚ) : Finset (p.TableBin cls) := by classical exact (baselinePrefixAt p cls label v baseline a).filter fun t => cls (p.itemAtRole cls t .x) ≠ .s theorem baseline_prefix_row_partition (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (a : ℚ) : (baselinePrefixAt p cls label v baseline a).card = (mainTreePrefixAt p cls label v baseline a).card + (mainJobPrefixAt p cls label v baseline a).card := by classical have h := Finset.card_filter_add_card_filter_not (s := baselinePrefixAt p cls label v baseline a) (fun t => cls (p.itemAtRole cls t .x) = .s) simpa only [mainTreePrefixAt, mainJobPrefixAt, Nat.add_comm] using h.symm theorem main_tree_prefix_le_inventory (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (a : ℚ) : (mainTreePrefixAt p cls label v baseline a).card ≤ (treeRowPrefixAt (I := I) cls label v baseline a).card := by classical apply card_le_role_resources p cls _ .x _ intro t ht obtain ⟨ht, hnots⟩ := Finset.mem_filter.mp ht obtain ⟨ht, hbase⟩ := Finset.mem_filter.mp ht obtain ⟨hgood, hlabel, _⟩ := (mem_mainTuplesAt p cls label v t).mp ht have hrole := (role_eq_x_iff (cls (p.itemAtRole cls t .x))).mp (p.itemAtRole_role cls t .x) have htree : cls (p.itemAtRole cls t .x) = .tp ∨ cls (p.itemAtRole cls t .x) = .tm := by rcases hrole with hp | hm | hs · exact Or.inl hp · exact Or.inr hm · exact False.elim (hnots hs) exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, htree, hgood.1.trans hlabel, hbase⟩ theorem good_key_subset_edge_anchor_image (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (keyBaseline : I.Item → ℚ) (a : ℚ) : keyPrefixAt (I := I) cls label v keyBaseline a \ badAnchorsAt p cls label v ⊆ roleItems p cls (edgePrefixAt p cls label v keyBaseline a) .anchor := by classical intro i hi obtain ⟨hi, hnotbad⟩ := Finset.mem_sdiff.mp hi obtain ⟨_, hcls, hlabel, hbase⟩ := Finset.mem_filter.mp hi have hanchor : i ∈ anchorItemsAt (I := I) cls label v := (mem_anchorItemsAt cls label v i).mpr ⟨by rw [hcls]; rfl, hlabel⟩ have hused : i ∈ roleItems p cls (goodTuplesAt p cls label v) .anchor := by by_contra h exact hnotbad ((mem_badAnchorsAt p cls label v i).mpr ⟨hanchor, h⟩) obtain ⟨t, ht, hti⟩ := Finset.mem_image.mp hused have hpattern : p.tablePattern cls t = .edgeJob := by have hsub : patternSubclass (p.tablePattern cls t) .anchor = .y := (p.itemAtRole_subclass cls t .anchor).symm.trans ((congrArg cls hti).trans hcls) cases hp : p.tablePattern cls t <;> simp_all [patternSubclass] have htgood := (mem_goodTuplesAt p cls label v t).mp ht have hG : t ∈ edgeTuplesAt p cls label v := (mem_edgeTuplesAt p cls label v t).mpr ⟨htgood.1, htgood.2, hpattern⟩ apply Finset.mem_image.mpr refine ⟨t, Finset.mem_filter.mpr ⟨hG, ?_⟩, hti⟩ simpa only [hti] using hbase theorem key_prefix_le_edge_prefix_add_loss (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (keyBaseline : I.Item → ℚ) (a : ℚ) (K : ℕ) (hbad : (badAnchorsAt p cls label v).card ≤ 3 * K) : (keyPrefixAt (I := I) cls label v keyBaseline a).card ≤ (edgePrefixAt p cls label v keyBaseline a).card + 3 * K := by have hcount := Finset.card_le_card (good_key_subset_edge_anchor_image p cls label v keyBaseline a) rw [roleItems_card] at hcount have hloss := CoverageCounts.card_le_good_card_add (s := keyPrefixAt (I := I) cls label v keyBaseline a) hbad omega theorem edge_row_mem_job_prefix (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (a : ℚ) {t : p.TableBin cls} (ht : t ∈ edgeTuplesAt p cls label v) (hbase : baseline (p.itemAtRole cls t .x) ≤ a) : p.itemAtRole cls t .x ∈ jobRowPrefixAt (I := I) cls label v baseline a := by obtain ⟨hgood, hlabel, hpattern⟩ := (mem_edgeTuplesAt p cls label v t).mp ht have hcls : cls (p.itemAtRole cls t .x) = .s := by rw [p.itemAtRole_subclass cls t .x, hpattern] rfl exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, hcls, hgood.1.trans hlabel, hbase⟩ theorem displaced_baseline_prefix_le (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline keyBaseline : I.Item → ℚ) (a : ℚ) (extra : Finset (p.TableBin cls)) (B jobs K : ℕ) (hbad : (badAnchorsAt p cls label v).card ≤ 3 * K) (horder : ∀ t ∈ edgeTuplesAt p cls label v, baseline (p.itemAtRole cls t .x) ≤ keyBaseline (p.itemAtRole cls t .anchor)) (hextra : extra ⊆ edgeTuplesAt p cls label v) (hextraRows : ∀ t ∈ extra, baseline (p.itemAtRole cls t .x) ≤ a) (hextraDis : Disjoint (edgePrefixAt p cls label v keyBaseline a) extra) (hjobStock : (jobRowPrefixAt (I := I) cls label v baseline a).card = 2 * jobs) (hkeyStock : (keyPrefixAt (I := I) cls label v keyBaseline a).card = jobs) (hbaselineStock : B = (treeRowPrefixAt (I := I) cls label v baseline a).card + jobs) : (baselinePrefixAt p cls label v baseline a).card + extra.card ≤ B + 3 * K := by classical let M := mainJobPrefixAt p cls label v baseline a let E := edgePrefixAt p cls label v keyBaseline a have hMsub : M ⊆ mainTuplesAt p cls label v := by intro t ht exact (Finset.mem_filter.mp (Finset.mem_filter.mp ht).1).1 have hEsub : E ⊆ edgeTuplesAt p cls label v := Finset.filter_subset _ _ have hME : Disjoint M E := (mainTuplesAt_disjoint_edge p cls label v v).mono hMsub hEsub have hMX : Disjoint M extra := (mainTuplesAt_disjoint_edge p cls label v v).mono hMsub hextra have hmap : ∀ t ∈ (M ∪ E) ∪ extra, p.itemAtRole cls t .x ∈ jobRowPrefixAt (I := I) cls label v baseline a := by intro t ht rcases Finset.mem_union.mp ht with ht | ht · rcases Finset.mem_union.mp ht with ht | ht · obtain ⟨hprefix, hcls⟩ := Finset.mem_filter.mp ht obtain ⟨htM, hbase⟩ := Finset.mem_filter.mp hprefix obtain ⟨hgood, hlabel, _⟩ := (mem_mainTuplesAt p cls label v t).mp htM exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, hcls, hgood.1.trans hlabel, hbase⟩ · obtain ⟨htG, hbase⟩ := Finset.mem_filter.mp ht exact edge_row_mem_job_prefix p cls label v baseline a htG ((horder t htG).trans hbase) · exact edge_row_mem_job_prefix p cls label v baseline a (hextra ht) (hextraRows t ht) have hrows := card_three_le_row_resources p cls M E extra (jobRowPrefixAt (I := I) cls label v baseline a) hME hMX hextraDis hmap rw [hjobStock] at hrows have hkeys := key_prefix_le_edge_prefix_add_loss p cls label v keyBaseline a K hbad rw [hkeyStock] at hkeys have hsplit := baseline_prefix_row_partition p cls label v baseline a have htrees := main_tree_prefix_le_inventory p cls label v baseline a have hmain : (baselinePrefixAt p cls label v baseline a).card ≤ (treeRowPrefixAt (I := I) cls label v baseline a).card + M.card := by dsimp only [M] omega exact CoverageCounts.displaced_baseline_bound hmain hbaselineStock hrows hkeys def currentKeyItemsAt (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (keyBaseline : I.Item → ℚ) (current : ℚ) : Finset I.Item := by classical exact Finset.univ.filter fun i => cls i = .y ∧ label i = some v ∧ keyBaseline i = current def currentEdgeTuplesAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (keyBaseline : I.Item → ℚ) (current : ℚ) : Finset (p.TableBin cls) := (edgeTuplesAt p cls label v).filter fun t => keyBaseline (p.itemAtRole cls t .anchor) = current def displacedTuplesAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline keyBaseline : I.Item → ℚ) (current : ℚ) : Finset (p.TableBin cls) := (currentEdgeTuplesAt p cls label v keyBaseline current).filter fun t => baseline (p.itemAtRole cls t .x) < current def currentShortMainAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (short : I.Item → Bool) (current : ℚ) : Finset (p.TableBin cls) := (mainTuplesAt p cls label v).filter fun t => baseline (p.itemAtRole cls t .x) = current ∧ short (p.itemAtRole cls t .x) = true def currentShortEdgeAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline keyBaseline : I.Item → ℚ) (short : I.Item → Bool) (current : ℚ) : Finset (p.TableBin cls) := (currentEdgeTuplesAt p cls label v keyBaseline current).filter fun t => baseline (p.itemAtRole cls t .x) = current ∧ short (p.itemAtRole cls t .x) = true def currentLongEdgeAt (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline keyBaseline : I.Item → ℚ) (short : I.Item → Bool) (current : ℚ) : Finset (p.TableBin cls) := (currentEdgeTuplesAt p cls label v keyBaseline current).filter fun t => baseline (p.itemAtRole cls t .x) = current ∧ short (p.itemAtRole cls t .x) ≠ true def currentShortItemsAt (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline : I.Item → ℚ) (short : I.Item → Bool) (current : ℚ) : Finset I.Item := by classical exact Finset.univ.filter fun i => cls i = .s ∧ label i = some v ∧ baseline i = current ∧ short i = true theorem key_subset_le_matching_add_loss (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (keys : Finset I.Item) (matchedTuples : Finset (p.TableBin cls)) (K : ℕ) (hkeys : ∀ i ∈ keys, cls i = .y ∧ label i = some v) (hselect : ∀ t ∈ edgeTuplesAt p cls label v, p.itemAtRole cls t .anchor ∈ keys → t ∈ matchedTuples) (hbad : (badAnchorsAt p cls label v).card ≤ 3 * K) : keys.card ≤ matchedTuples.card + 3 * K := by classical have hsubset : keys \ badAnchorsAt p cls label v ⊆ roleItems p cls matchedTuples .anchor := by intro i hi obtain ⟨hi, hnotbad⟩ := Finset.mem_sdiff.mp hi obtain ⟨hcls, hlabel⟩ := hkeys i hi have hanchor : i ∈ anchorItemsAt (I := I) cls label v := (mem_anchorItemsAt cls label v i).mpr ⟨by rw [hcls]; rfl, hlabel⟩ have hused : i ∈ roleItems p cls (goodTuplesAt p cls label v) .anchor := by by_contra h exact hnotbad ((mem_badAnchorsAt p cls label v i).mpr ⟨hanchor, h⟩) obtain ⟨t, ht, hti⟩ := Finset.mem_image.mp hused have hpattern : p.tablePattern cls t = .edgeJob := by have hsub : patternSubclass (p.tablePattern cls t) .anchor = .y := (p.itemAtRole_subclass cls t .anchor).symm.trans ((congrArg cls hti).trans hcls) cases hp : p.tablePattern cls t <;> simp_all [patternSubclass] have htgood := (mem_goodTuplesAt p cls label v t).mp ht have hG : t ∈ edgeTuplesAt p cls label v := (mem_edgeTuplesAt p cls label v t).mpr ⟨htgood.1, htgood.2, hpattern⟩ refine Finset.mem_image.mpr ⟨t, hselect t hG ?_, hti⟩ simpa only [hti] using hi have hcount := Finset.card_le_card hsubset rw [roleItems_card] at hcount have hloss := CoverageCounts.card_le_good_card_add (s := keys) hbad omega theorem current_key_count_le_matches_add_loss (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (keyBaseline : I.Item → ℚ) (current : ℚ) (K : ℕ) (hbad : (badAnchorsAt p cls label v).card ≤ 3 * K) : (currentKeyItemsAt (I := I) cls label v keyBaseline current).card ≤ (currentEdgeTuplesAt p cls label v keyBaseline current).card + 3 * K := by apply key_subset_le_matching_add_loss p cls label v _ _ K _ _ hbad · intro i hi obtain ⟨_, hcls, hlabel, _⟩ := Finset.mem_filter.mp hi exact ⟨hcls, hlabel⟩ · intro t ht hi exact Finset.mem_filter.mpr ⟨ht, (Finset.mem_filter.mp hi).2.2.2⟩ theorem current_match_partition (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline keyBaseline : I.Item → ℚ) (short : I.Item → Bool) (current : ℚ) (horder : ∀ t ∈ edgeTuplesAt p cls label v, baseline (p.itemAtRole cls t .x) ≤ keyBaseline (p.itemAtRole cls t .anchor)) : (currentEdgeTuplesAt p cls label v keyBaseline current).card = (displacedTuplesAt p cls label v baseline keyBaseline current).card + (currentShortEdgeAt p cls label v baseline keyBaseline short current).card + (currentLongEdgeAt p cls label v baseline keyBaseline short current).card := by apply CoverageCounts.ordered_short_long_partition (currentEdgeTuplesAt p cls label v keyBaseline current) (fun t => baseline (p.itemAtRole cls t .x)) current (fun t => short (p.itemAtRole cls t .x) = true) intro t ht obtain ⟨ht, hcurrent⟩ := Finset.mem_filter.mp ht exact (horder t ht).trans_eq hcurrent theorem current_short_consumption_le_stock (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline keyBaseline : I.Item → ℚ) (short : I.Item → Bool) (current : ℚ) (hshortJob : ∀ i, short i = true → cls i = .s) : (currentShortMainAt p cls label v baseline short current).card + (currentShortEdgeAt p cls label v baseline keyBaseline short current).card ≤ (currentShortItemsAt (I := I) cls label v baseline short current).card := by classical let M := currentShortMainAt p cls label v baseline short current let G := currentShortEdgeAt p cls label v baseline keyBaseline short current have hMsub : M ⊆ mainTuplesAt p cls label v := Finset.filter_subset _ _ have hGsub : G ⊆ edgeTuplesAt p cls label v := by intro t ht exact (Finset.mem_filter.mp (Finset.mem_filter.mp ht).1).1 apply CoverageCounts.card_add_card_le_of_disjoint_injections M G (currentShortItemsAt (I := I) cls label v baseline short current) (fun t => p.itemAtRole cls t .x) ((mainTuplesAt_disjoint_edge p cls label v v).mono hMsub hGsub) _ (p.itemAtRole_injective cls .x).injOn intro t ht rcases Finset.mem_union.mp ht with ht | ht · obtain ⟨ht, hbase, hshort⟩ := Finset.mem_filter.mp ht obtain ⟨hgood, hlabel, _⟩ := (mem_mainTuplesAt p cls label v t).mp ht exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, hshortJob _ hshort, hgood.1.trans hlabel, hbase, hshort⟩ · obtain ⟨ht, hbase, hshort⟩ := Finset.mem_filter.mp ht obtain ⟨ht, _⟩ := Finset.mem_filter.mp ht obtain ⟨hgood, hlabel, _⟩ := (mem_edgeTuplesAt p cls label v t).mp ht exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, hshortJob _ hshort, hgood.1.trans hlabel, hbase, hshort⟩ theorem current_long_matches_from_correction (p : Packing I b) (cls : I.Item → Subclass) (label : I.Item → Option (Fin n)) (v : Fin n) (baseline keyBaseline : I.Item → ℚ) (short : I.Item → Bool) (current : ℚ) (d K xplus : ℕ) (hbad : (badAnchorsAt p cls label v).card ≤ 3 * K) (horder : ∀ t ∈ edgeTuplesAt p cls label v, baseline (p.itemAtRole cls t .x) ≤ keyBaseline (p.itemAtRole cls t .anchor)) (hshortJob : ∀ i, short i = true → cls i = .s) (hkeys : (currentKeyItemsAt (I := I) cls label v keyBaseline current).card = d) (hshortStock : (currentShortItemsAt (I := I) cls label v baseline short current).card = d) (hcorrection : d + (displacedTuplesAt p cls label v baseline keyBaseline current).card ≤ xplus + (currentShortMainAt p cls label v baseline short current).card + 6 * K) : d ≤ (currentLongEdgeAt p cls label v baseline keyBaseline short current).card + xplus + 9 * K := by have hgood := current_key_count_le_matches_add_loss p cls label v keyBaseline current K hbad rw [hkeys] at hgood have hpartition := current_match_partition p cls label v baseline keyBaseline short current horder have hshort := current_short_consumption_le_stock p cls label v baseline keyBaseline short current hshortJob rw [hshortStock] at hshort exact CoverageCounts.long_match_lower_bound hcorrection (CoverageCounts.short_le_displaced_add_long hgood hpartition hshort) end Coverage end BinPackingGap end end OAI
import Lean.Elab.Tactic.Omega
import Mathlib.Data.Finset.Card
import Mathlib.Data.Finset.Max
import Mathlib.Data.Finset.Prod
import Mathlib.Data.Fintype.EquivFin
import Mathlib.Order.Interval.Set.Disjoint
import OAI.Computability.BinPacking.Packing.FiniteHall
import OAI.Computability.BinPacking.Packing.PackingScalar
import OAI.Computability.BinPacking.Trees.CompletionGeometry
namespace OAI
noncomputable section
namespace BinPackingGap
namespace CoverageCounts
section FiniteCounts
variable {α β γ : Type*} [DecidableEq α] [DecidableEq β]
theorem interval_prefix_card [LinearOrder γ] (s : Finset α) (h b : α → γ)
(hle : ∀ i ∈ s, h i ≤ b i) (a : γ) :
(s.filter fun i => h i ≤ a).card =
(s.filter fun i => b i ≤ a).card +
(s.filter fun i => h i ≤ a ∧ a < b i).card := by
classical
have hunion : (s.filter fun i => h i ≤ a) =
(s.filter fun i => b i ≤ a) ∪
(s.filter fun i => h i ≤ a ∧ a < b i) := by
ext i
simp only [Finset.mem_filter, Finset.mem_union]
constructor
· rintro ⟨his, hia⟩
by_cases hba : b i ≤ a
· exact Or.inl ⟨his, hba⟩
· exact Or.inr ⟨his, hia, lt_of_not_ge hba⟩
· rintro (⟨his, hba⟩ | ⟨his, hia, _⟩)
· exact ⟨his, (hle i his).trans hba⟩
· exact ⟨his, hia⟩
have hdis : Disjoint (s.filter fun i => b i ≤ a)
(s.filter fun i => h i ≤ a ∧ a < b i) := by
apply Finset.disjoint_left.mpr
intro i hi hj
exact (not_lt_of_ge (Finset.mem_filter.mp hi).2)
(Finset.mem_filter.mp hj).2.2
rw [hunion, Finset.card_union_of_disjoint hdis]
omit [DecidableEq α] in
theorem ordered_short_long_partition [LinearOrder γ]
(s : Finset α) (position : α → γ) (current : γ) (short : α → Prop)
[DecidablePred short] (horder : ∀ i ∈ s, position i ≤ current) :
s.card = (s.filter fun i => position i < current).card +
(s.filter fun i => position i = current ∧ short i).card +
(s.filter fun i => position i = current ∧ ¬ short i).card := by
classical
have hexact : (s.filter fun i => ¬ position i < current) =
(s.filter fun i => position i = current) := by
ext i
simp only [Finset.mem_filter]
constructor
· rintro ⟨his, hi⟩
exact ⟨his, le_antisymm (horder i his) (le_of_not_gt hi)⟩
· rintro ⟨his, hi⟩
exact ⟨his, by rw [hi]; exact lt_irrefl _⟩
have hpositions := Finset.card_filter_add_card_filter_not
(s := s) (fun i => position i < current)
rw [hexact] at hpositions
have hlengths := Finset.card_filter_add_card_filter_not
(s := s.filter fun i => position i = current) short
simp only [Finset.filter_filter] at hlengths
omega
theorem card_le_good_card_add {s bad : Finset α} {K : ℕ}
(hbad : bad.card ≤ K) : s.card ≤ (s \ bad).card + K := by
have hinter : (s ∩ bad).card ≤ K :=
(Finset.card_le_card Finset.inter_subset_right).trans hbad
have hsplit := Finset.card_sdiff_add_card_inter s bad
omega
omit [DecidableEq β] in
theorem card_le_target_add_loss {s bad : Finset α} {t : Finset β} {K : ℕ}
(f : α → β) (hbad : bad.card ≤ K)
(hmap : ∀ i ∈ s \ bad, f i ∈ t)
(hinj : Set.InjOn f (↑(s \ bad : Finset α) : Set α)) : s.card ≤ t.card + K := by
have hgood := Finset.card_le_card_of_injOn f hmap hinj
have htotal := card_le_good_card_add (s := s) hbad
omega
omit [DecidableEq β] in
theorem card_add_card_le_of_disjoint_injections
(s t : Finset α) (resources : Finset β) (row : α → β)
(hdis : Disjoint s t)
(hmap : ∀ i ∈ s ∪ t, row i ∈ resources)
(hinj : Set.InjOn row (↑(s ∪ t : Finset α) : Set α)) : s.card + t.card ≤ resources.card := by
rw [← Finset.card_union_of_disjoint hdis]
exact Finset.card_le_card_of_injOn row hmap hinj
omit [DecidableEq β] in
theorem card_three_le_of_disjoint_injections