Download data/lean/OAI/Computability/BinPacking/Inventory/CurrentMatches.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 46.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/BinPacking/Inventory/CurrentMatches.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/BinPacking/Inventory/CurrentMatches.lean
-
curl -L -o CurrentMatches.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/BinPacking/Inventory/CurrentMatches.lean
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