File size: 5,346 Bytes
8df23f4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 | import OAI.Computability.BinPacking.Trees.TreeColorCounts
namespace OAI
namespace BinPackingGap
def pullMarks (stem : List ℕ) (marks : Finset (List ℕ)) : Finset (List ℕ) :=
(marks.filter (fun w => stem.IsPrefix w)).image (fun w => w.drop stem.length)
@[simp] theorem mem_pullMarks (stem word : List ℕ) (marks : Finset (List ℕ)) :
word ∈ pullMarks stem marks ↔ stem ++ word ∈ marks := by
constructor
· intro hw
obtain ⟨v, hv, hdrop⟩ := Finset.mem_image.mp hw
obtain ⟨hvA, hpref⟩ := Finset.mem_filter.mp hv
have heq : stem ++ word = v := by
calc
stem ++ word = stem ++ v.drop stem.length :=
congrArg (fun t => stem ++ t) hdrop.symm
_ = v.take stem.length ++ v.drop stem.length :=
congrArg (fun t => t ++ v.drop stem.length) (List.prefix_iff_eq_take.mp hpref)
_ = v := List.take_append_drop stem.length v
exact heq.symm ▸ hvA
· intro hw
exact Finset.mem_image.mpr
⟨stem ++ word, Finset.mem_filter.mpr ⟨hw, List.prefix_append stem word⟩,
by simp⟩
@[simp] theorem nil_mem_pullMarks (stem : List ℕ) (marks : Finset (List ℕ)) :
[] ∈ pullMarks stem marks ↔ stem ∈ marks := by
simpa only [List.append_nil] using mem_pullMarks stem [] marks
theorem levelCount_pullMarks_le (stem : List ℕ) (marks : Finset (List ℕ)) (j : ℕ) :
levelCount (pullMarks stem marks) j ≤ levelCount marks (stem.length + j) := by
have hsub : (pullMarks stem marks).filter (fun w => w.length = j) ⊆
(marks.filter (fun w => w.length = stem.length + j)).image
(fun w => w.drop stem.length) := by
intro w hw
obtain ⟨hw, hlen⟩ := Finset.mem_filter.mp hw
refine Finset.mem_image.mpr ⟨stem ++ w, ?_, by simp⟩
exact Finset.mem_filter.mpr
⟨(mem_pullMarks stem w marks).mp hw, by simp only [List.length_append, hlen]⟩
exact (Finset.card_le_card hsub).trans (Finset.card_image_le)
theorem disjoint_prefixes_append_of_pull (stem word : List ℕ)
(marks : Finset (List ℕ))
(hold : Disjoint marks (UniformTree.prefixes stem))
(hnew : Disjoint (pullMarks stem marks) (UniformTree.prefixes word)) :
Disjoint marks (UniformTree.prefixes (stem ++ word)) := by
apply Finset.disjoint_left.mpr
intro v hv hprefix
rw [prefixes_append_eq] at hprefix
rcases Finset.mem_union.mp hprefix with hprefix | hprefix
· exact Finset.disjoint_left.mp hold hv hprefix
· obtain ⟨w, _, hw, heq⟩ := mem_prefixesAfter_iff.mp hprefix
apply Finset.disjoint_left.mp hnew
· exact (mem_pullMarks stem w marks).mpr (heq.symm ▸ hv)
· exact UniformTree.mem_prefixes_iff.mpr hw
def extendPhaseQuota (height : ℕ) (old : ℕ → ℕ) (depth : ℕ) : ℕ :=
if depth ≤ height then old depth else phaseQuota (depth - height)
theorem extendPhaseQuota_old (height : ℕ) (old : ℕ → ℕ) {depth : ℕ}
(hdepth : depth ≤ height) : extendPhaseQuota height old depth = old depth := by
simp only [extendPhaseQuota, ite_eq_left hdepth]
theorem extendPhaseQuota_new (height : ℕ) (old : ℕ → ℕ) {j : ℕ}
(hj : 0 < j) : extendPhaseQuota height old (height + j) = phaseQuota j := by
have hnot : ¬ height + j ≤ height := by omega
simp only [extendPhaseQuota, ite_eq_right hnot, Nat.add_sub_cancel_left]
theorem graft_avoids {n : ℕ} (old : AuxiliaryTree n)
(G : old.tree.leaves → AuxiliaryTree 1) (N : ℕ)
(hG : ∀ l, (G l).tree.height = N)
(hquota : ∀ l, (G l).quota = phaseQuota)
(marks : Finset (List ℕ))
(hmarks : RespectsTreeQuota
(UniformTree.graft old.tree (fun l => (G l).tree) N hG)
(extendPhaseQuota old.tree.height old.quota) marks) :
∃ leaf ∈ (UniformTree.graft old.tree (fun l => (G l).tree) N hG).leaves,
Disjoint marks (UniformTree.prefixes leaf) := by
have hold : RespectsTreeQuota old.tree old.quota marks := by
refine ⟨hmarks.1, ?_⟩
intro j hj hbound
have hglobal := hmarks.2 j hj (by
change j ≤ old.tree.height + N
omega)
simpa only [extendPhaseQuota_old old.tree.height old.quota hbound] using hglobal
obtain ⟨l, hl, havoidOld⟩ := old.avoids marks hold
let oldLeaf : old.tree.leaves := ⟨l, hl⟩
have hlocal : RespectsTreeQuota (G oldLeaf).tree (G oldLeaf).quota
(pullMarks l marks) := by
constructor
· rw [nil_mem_pullMarks]
intro hmarked
exact Finset.disjoint_left.mp havoidOld hmarked
(UniformTree.mem_prefixes_iff.mpr (List.prefix_refl l))
· intro j hj hbound
have hjpos : 0 < j := by omega
have hlocalBound : j ≤ N := by simpa only [hG oldLeaf] using hbound
have hglobal := hmarks.2 (old.tree.height + j) (by omega) (by
change old.tree.height + j ≤ old.tree.height + N
omega)
have hpull := levelCount_pullMarks_le l marks j
rw [old.tree.length_leaf l hl] at hpull
rw [hquota oldLeaf]
exact hpull.trans (by
simpa only [extendPhaseQuota_new old.tree.height old.quota hjpos] using hglobal)
obtain ⟨w, hw, havoidNew⟩ := (G oldLeaf).avoids (pullMarks l marks) hlocal
refine ⟨l ++ w, ?_, disjoint_prefixes_append_of_pull l w marks havoidOld havoidNew⟩
exact (UniformTree.mem_graft_leaves old.tree (fun l => (G l).tree) N hG).mpr
⟨oldLeaf, w, hw, rfl⟩
end BinPackingGap
end OAI
|