| import OAI.Computability.StarHeight.MarkerSearch |
|
|
| namespace OAI |
|
|
| namespace GeneralizedStarHeight |
|
|
| universe u |
| universe uι uι2 uι3 uι4 uQ uP uP2 uQ2 |
| universe uJ uKind uP3 uP4 uP5 |
|
|
| namespace EndSearch |
|
|
| open scoped Classical |
|
|
| def width (B S a x : ℤ) : ℤ := a + x % B * S |
|
|
| def Eligible (markers : Set ℤ) (B S a z m : ℤ) : Prop := |
| m ∈ markers ∧ |m - z| ≤ width B S a (m - z) |
|
|
| lemma width_bounds (hB : 0 < B) (hS : 0 ≤ S) : |
| a ≤ width B S a x ∧ width B S a x ≤ a + (B - 1) * S := by |
| have hlo := Int.emod_nonneg x (ne_of_gt hB) |
| have hhi := Int.emod_lt_of_pos x hB |
| dsimp [width] |
| constructor |
| · nlinarith |
| · nlinarith |
|
|
| noncomputable def eligibleSet (markers : Set ℤ) (B S a z : ℤ) : Finset ℤ := |
| (Finset.Icc (z - (a + (B - 1) * S)) (z + (a + (B - 1) * S))).filter |
| (Eligible markers B S a z) |
|
|
| lemma mem_eligibleSet |
| (hB : 0 < B) (hS : 0 ≤ S) : |
| m ∈ eligibleSet markers B S a z ↔ Eligible markers B S a z m := by |
| constructor |
| · exact fun h => (Finset.mem_filter.mp h).2 |
| · intro hm |
| have hb := abs_le.mp (hm.2.trans (width_bounds hB hS).2) |
| exact Finset.mem_filter.mpr ⟨Finset.mem_Icc.mpr ⟨by omega, by omega⟩, hm⟩ |
|
|
| noncomputable def search (markers : Set ℤ) (B S a z : ℤ) : Option ℤ := |
| let F := eligibleSet markers B S a z |
| if h : F.Nonempty then some (F.min' h) else none |
| |
| lemma search_none {markers : Set ℤ} {B S a z : ℤ} (hB : 0 < B) (hS : 0 ≤ S) : |
| search markers B S a z = none ↔ ∀ m, ¬Eligible markers B S a z m := by |
| dsimp only [search] |
| split_ifs with h |
| · simp only [false_iff] |
| obtain ⟨m, hm⟩ := h |
| exact fun hn => hn m ((mem_eligibleSet hB hS).mp hm) |
| · simp only [true_iff] |
| exact fun m hm => h ⟨m, (mem_eligibleSet hB hS).mpr hm⟩ |
| |
| lemma search_some {markers : Set ℤ} {B S a z m : ℤ} (hB : 0 < B) (hS : 0 ≤ S) : |
| search markers B S a z = some m ↔ Eligible markers B S a z m ∧ |
| ∀ m', Eligible markers B S a z m' → m ≤ m' := by |
| dsimp only [search] |
| split_ifs with h |
| · constructor |
| · intro he |
| obtain rfl := Option.some.inj he |
| exact ⟨(mem_eligibleSet hB hS).mp (Finset.min'_mem _ h), |
| fun m' hm' => Finset.min'_le _ _ ((mem_eligibleSet hB hS).mpr hm')⟩ |
| · rintro ⟨hm, hmin⟩ |
| congr 1 |
| exact le_antisymm (Finset.min'_le _ _ ((mem_eligibleSet hB hS).mpr hm)) |
| (hmin _ ((mem_eligibleSet hB hS).mp (Finset.min'_mem _ h))) |
| · constructor |
| · intro he |
| cases he |
| · rintro ⟨hm, _⟩ |
| exact False.elim (h ⟨m, (mem_eligibleSet hB hS).mpr hm⟩) |
| |
| lemma width_shift {B S a x v : ℤ} (hv : B ∣ v) : |
| width B S a (x - v) = width B S a x := by |
| dsimp [width] |
| rw [Int.sub_emod, Int.emod_eq_zero_of_dvd hv, sub_zero, Int.emod_emod] |
| |
| lemma changed_eligibility {markers : Set ℤ} {B S a z v : ℤ} |
| (hB : 0 < B) (hS : 0 ≤ S) |
| (hne : search markers B S a z ≠ search markers B S a (z + v)) : |
| ∃ m, ¬(Eligible markers B S a z m ↔ Eligible markers B S a (z + v) m) := by |
| by_contra! hn |
| apply hne |
| have he : eligibleSet markers B S a z = eligibleSet markers B S a (z + v) := by |
| ext m |
| exact (mem_eligibleSet hB hS).trans ((hn m).trans (mem_eligibleSet hB hS).symm) |
| simp only [search, he] |
| |
| lemma crossing {x D v w : ℤ} (hv : |v| ≤ w) |
| (hne : ¬(|x| ≤ D ↔ |x - v| ≤ D)) : |
| |x - D| ≤ w ∨ |x + D| ≤ w := by |
| have hv' := abs_le.mp hv |
| by_cases hx : |x| ≤ D |
| · have hx' := abs_le.mp hx |
| have hn : ¬ |x - v| ≤ D := fun h => hne ⟨fun _ => h, fun _ => hx⟩ |
| have hn' : ¬(-D ≤ x - v ∧ x - v ≤ D) := by simpa only [abs_le] using hn |
| rw [abs_le, abs_le] |
| omega |
| · have hx' : |x - v| ≤ D := by |
| by_contra hh |
| exact hne ⟨fun h => False.elim (hx h), fun h => False.elim (hh h)⟩ |
| have hx'' := abs_le.mp hx' |
| have hn' : ¬(-D ≤ x ∧ x ≤ D) := by simpa only [abs_le] using hx |
| rw [abs_le, abs_le] |
| omega |
| |
| lemma instability_charge {markers : Set ℤ} {B S a z v w : ℤ} |
| (hB : 0 < B) (hS : 0 ≤ S) (hvB : B ∣ v) (hv : |v| ≤ w) |
| (hne : search markers B S a z ≠ search markers B S a (z + v)) : |
| ∃ m ∈ markers, |
| |m - (z + width B S a (m - z))| ≤ w ∨ |
| |m - (z - width B S a (m - z))| ≤ w := by |
| obtain ⟨m, hm⟩ := changed_eligibility hB hS hne |
| have hmS : m ∈ markers := by |
| by_contra hn |
| exact hm (by simp [Eligible, hn]) |
| have he : width B S a (m - (z + v)) = width B S a (m - z) := by |
| rw [show m - (z + v) = (m - z) - v by ring] |
| exact width_shift hvB |
| have hc : ¬(|m - z| ≤ width B S a (m - z) ↔ |
| |(m - z) - v| ≤ width B S a (m - z)) := by |
| simp only [Eligible, hmS, true_and] at hm |
| rw [he] at hm |
| simpa only [show m - (z + v) = (m - z) - v by ring] using hm |
| refine ⟨m, hmS, ?_⟩ |
| rw [show m - (z + width B S a (m - z)) = (m - z) - width B S a (m - z) by ring, |
| show m - (z - width B S a (m - z)) = (m - z) + width B S a (m - z) by ring] |
| exact crossing hv hc |
| |
| end EndSearch |
| |
| namespace EndSearch |
| |
| open scoped Classical |
| |
| def Boundary (B S a z m : ℤ) (positive : Bool) : ℤ := |
| if positive then z + width B S a (m - z) else z - width B S a (m - z) |
| |
| lemma boundary_charge_card {ι : Type uι} (s : Finset ι) {markers : Set ℤ} |
| {B S a z h w d : ℤ} (δ : ι → ℤ) (positive : Bool) |
| (hB : 0 < B) (hS : 2 * h + 2 * w < S) (hSn : 0 ≤ S) |
| (hmarkers : MarkerSearch.Separated markers d) |
| (hlen : 2 * h + (B - 1) * S + 2 * w < d) |
| (hδ : ∀ i ∈ s, |δ i| ≤ h) |
| (hmod : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → δ i % B ≠ δ j % B) : |
| (s.filter fun i => ∃ m ∈ markers, |m - Boundary B S a (z + δ i) m positive| ≤ w).card ≤ 1 := by |
| apply Finset.card_le_one.mpr |
| intro i hi j hj |
| obtain ⟨hi, m, hm, hc⟩ := Finset.mem_filter.mp hi |
| obtain ⟨hj, m', hm', hc'⟩ := Finset.mem_filter.mp hj |
| have hiδ := abs_le.mp (hδ i hi) |
| have hjδ := abs_le.mp (hδ j hj) |
| have hmi := width_bounds (x := m - (z + δ i)) (a := a) hB hSn |
| have hmj := width_bounds (x := m' - (z + δ j)) (a := a) hB hSn |
| have hcb := abs_le.mp hc |
| have hcb' := abs_le.mp hc' |
| have he : m = m' := by |
| cases positive |
| · dsimp [Boundary] at hcb hcb' |
| exact MarkerSearch.separated_interval_unique hmarkers (by omega) hm hm' |
| (show z - a - h - (B - 1) * S - w ≤ m by omega) |
| (show m ≤ z - a + h + w by omega) (by omega) (by omega) |
| · dsimp [Boundary] at hcb hcb' |
| exact MarkerSearch.separated_interval_unique hmarkers (by omega) hm hm' |
| (show z + a - h - w ≤ m by omega) |
| (show m ≤ z + a + h + (B - 1) * S + w by omega) (by omega) (by omega) |
| subst m' |
| by_contra hij |
| have hidx : (m - (z + δ i)) % B ≠ (m - (z + δ j)) % B := by |
| intro he |
| have hh := (show Int.ModEq B (m - (z + δ i)) (m - (z + δ j)) from he).sub_left (m - z) |
| apply hmod i hi j hj hij |
| change Int.ModEq B (δ i) (δ j) |
| convert hh using 1 <;> ring |
| have hidx' := lt_or_gt_of_ne hidx |
| cases positive <;> dsimp [Boundary, width] at hcb hcb' |
| all_goals rcases hidx' with hlt | hlt <;> nlinarith |
|
|
| def Unstable (markers : Set ℤ) (B S a z w : ℤ) : Prop := |
| ∃ v, B ∣ v ∧ |v| ≤ w ∧ search markers B S a z ≠ search markers B S a (z + v) |
|
|
| lemma unstable_card (s : Finset ι) |
| (δ : ι → ℤ) |
| (hB : 0 < B) (hS : 2 * h + 2 * w < S) (hSn : 0 ≤ S) |
| (hmarkers : MarkerSearch.Separated markers d) |
| (hlen : 2 * h + (B - 1) * S + 2 * w < d) |
| (hδ : ∀ i ∈ s, |δ i| ≤ h) |
| (hmod : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → δ i % B ≠ δ j % B) : |
| (s.filter fun i => Unstable markers B S a (z + δ i) w).card ≤ 2 := by |
| let F := fun b => s.filter fun i => |
| ∃ m ∈ markers, |m - Boundary B S a (z + δ i) m b| ≤ w |
| have hsub : (s.filter fun i => Unstable markers B S a (z + δ i) w) ⊆ |
| F true ∪ F false := by |
| intro i hi |
| obtain ⟨hi, v, hvB, hv, hn⟩ := Finset.mem_filter.mp hi |
| obtain ⟨m, hm, hc | hc⟩ := instability_charge hB hSn hvB hv hn |
| · exact Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨hi, m, hm, hc⟩) |
| · exact Finset.mem_union_right _ (Finset.mem_filter.mpr ⟨hi, m, hm, hc⟩) |
| have ht : (F true).card ≤ 1 := boundary_charge_card s δ true hB hS hSn hmarkers hlen hδ hmod |
| have hf : (F false).card ≤ 1 := boundary_charge_card s δ false hB hS hSn hmarkers hlen hδ hmod |
| exact (Finset.card_le_card hsub).trans ((Finset.card_union_le _ _).trans (by omega)) |
|
|
| lemma two_searches_card (s : Finset ι) |
| (δ : ι → ℤ) |
| (hB : 0 < B) (hS : 2 * h + 2 * w < S) (hSn : 0 ≤ S) |
| (hmarkers : MarkerSearch.Separated markers d) |
| (hlen : 2 * h + (B - 1) * S + 2 * w < d) |
| (hδ : ∀ i ∈ s, |δ i| ≤ h) |
| (hmod : ∀ i ∈ s, ∀ j ∈ s, i ≠ j → δ i % B ≠ δ j % B) : |
| (s.filter fun i => Unstable markers B S a₀ (z + δ i) w ∨ |
| Unstable markers B S a₁ (z + δ i) w).card ≤ 4 := by |
| rw [Finset.filter_or] |
| have h₀ := unstable_card (a := a₀) (z := z) s δ hB hS hSn hmarkers hlen hδ hmod |
| have h₁ := unstable_card (a := a₁) (z := z) s δ hB hS hSn hmarkers hlen hδ hmod |
| exact (Finset.card_union_le _ _).trans (by omega) |
|
|
| end EndSearch |
|
|
| namespace MarkerSearch |
|
|
| lemma interval_card (F : Finset ℤ) (N : ℕ) |
| (hS : Separated S d) (hd : 0 < d) (hlen : r - l < N * d) |
| (hF : ∀ m ∈ F, m ∈ S ∧ l ≤ m ∧ m ≤ r) : F.card ≤ N := by |
| classical |
| have hb : ∀ m : , 0 ≤ (m.val - l) / d ∧ (m.val - l) / d < N := by |
| intro m |
| obtain ⟨_, hl, hr⟩ := hF m.val m.2 |
| exact ⟨Int.ediv_nonneg (by omega) (le_of_lt hd), |
| (Int.ediv_lt_iff_lt_mul hd).mpr (by omega)⟩ |
| let f : → Fin N := fun m => |
| ⟨((m.val - l) / d).toNat, (Int.toNat_lt (hb m).1).mpr (hb m).2⟩ |
| have hinj : Function.Injective f := by |
| intro m m' he |
| have hh := congrArg Fin.val he |
| have hq : (m.val - l) / d = (m'.val - l) / d := by |
| dsimp [f] at hh |
| have h₀ := Int.toNat_of_nonneg (hb m).1 |
| have h₁ := Int.toNat_of_nonneg (hb m').1 |
| omega |
| apply Subtype.ext |
| by_contra hn |
| have hsep := hS m.val (hF m.val m.2).1 m'.val (hF m'.val m'.2).1 hn |
| have hmod₀ := Int.emod_nonneg (m.val - l) (ne_of_gt hd) |
| have hmod₁ := Int.emod_nonneg (m'.val - l) (ne_of_gt hd) |
| have hlt₀ := Int.emod_lt_of_pos (m.val - l) hd |
| have hlt₁ := Int.emod_lt_of_pos (m'.val - l) hd |
| have he₀ := Int.mul_ediv_add_emod (m.val - l) d |
| have he₁ := Int.mul_ediv_add_emod (m'.val - l) d |
| rw [hq] at he₀ |
| have habs : |m.val - m'.val| < d := abs_lt.mpr ⟨by omega, by omega⟩ |
| omega |
| simpa using Fintype.card_le_of_injective f hinj |
|
|
| end MarkerSearch |
|
|
| namespace EndSearch |
|
|
| open scoped Classical |
|
|
| lemma nested |
| (hB : 0 < B) (hS : 0 ≤ S) (hwidth : a₀ + (B - 1) * S + H ≤ a₁) |
| (hzz : |z - z'| ≤ H) (hne : search markers B S a₀ z' ≠ none) : |
| search markers B S a₁ z ≠ none := by |
| intro hn |
| cases he : search markers B S a₀ z' with |
| | none => exact hne he |
| | some m => |
| have hm := (search_some hB hS).mp he |
| apply (search_none hB hS).mp hn m |
| refine ⟨hm.1.1, ?_⟩ |
| have hdist : |m - z| ≤ |m - z'| + |z - z'| := by |
| simpa only [abs_sub_comm z' z] using abs_sub_le m z' z |
| exact (hdist.trans (add_le_add (hm.1.2.trans (width_bounds hB hS).2) hzz)).trans |
| (hwidth.trans (width_bounds hB hS).1) |
| |
| lemma anchor_card {ι : Type uι4} (s : Finset ι) {markers : Set ℤ} |
| {B S d z h q₀ : ℤ} (δ : ι → ℤ) |
| (hB : 0 < B) (hS : 0 ≤ S) (hd : 0 < d) |
| (hmarkers : MarkerSearch.Separated markers d) |
| (hlen : 2 * h + 2 * (B - 1) * S < d) |
| (hδ : ∀ i ∈ s, |δ i| ≤ h) : |
| (s.image fun i => (search markers B S (3 * d) (z + δ i)).getD q₀).card ≤ 8 := by |
| classical |
| let l := z - h - (3 * d + (B - 1) * S) |
| let r := z + h + (3 * d + (B - 1) * S) |
| let F := (Finset.Icc l r).filter (· ∈ markers) |
| have hFc : F.card ≤ 7 := MarkerSearch.interval_card (l := l) (r := r) F 7 hmarkers hd (by dsimp [l, r]; nlinarith [hlen]) |
| (fun m hm => by |
| obtain ⟨hb, hm⟩ := Finset.mem_filter.mp hm |
| obtain ⟨hl, hr⟩ := Finset.mem_Icc.mp hb |
| exact ⟨hm, hl, hr⟩) |
| have hsub : (s.image fun i => (search markers B S (3 * d) (z + δ i)).getD q₀) ⊆ |
| insert q₀ F := by |
| intro q hq |
| obtain ⟨i, hi, rfl⟩ := Finset.mem_image.mp hq |
| cases he : search markers B S (3 * d) (z + δ i) with |
| | none => simp |
| | some m => |
| simp only [Option.getD_some, Finset.mem_insert] |
| right |
| have hm := (search_some hB hS).mp he |
| have hb := abs_le.mp (hm.1.2.trans (width_bounds hB hS).2) |
| have hiδ := abs_le.mp (hδ i hi) |
| exact Finset.mem_filter.mpr ⟨Finset.mem_Icc.mpr ⟨by dsimp [l]; omega, |
| by dsimp [r]; omega⟩, hm.1.1⟩ |
| exact (Finset.card_le_card hsub).trans ((Finset.card_insert_le _ _).trans (by omega)) |
| |
| end EndSearch |
| |
| namespace StencilSparsity |
| |
| open scoped Classical |
| |
| lemma biUnion_card_real {Q : Type uQ} {P : Type uP} (s : Finset Q) (F : Q → Finset P) |
| (c : ℝ) (h : ∀ q ∈ s, ((F q).card : ℝ) ≤ c) : |
| ((s.biUnion F).card : ℝ) ≤ s.card * c := by |
| classical |
| calc |
| ((s.biUnion F).card : ℝ) ≤ ((∑ q ∈ s, (F q).card : ℕ) : ℝ) := by |
| exact_mod_cast (Finset.card_biUnion_le (s := s) (t := F)) |
| _ = ∑ q ∈ s, ((F q).card : ℝ) := by simp |
| _ ≤ ∑ _q ∈ s, c := Finset.sum_le_sum h |
| _ = s.card * c := by simp |
| |
| lemma whole_stencil {P : Type uP2} {Q : Type uQ2} {J : Type uJ} (bad instability : Finset P) |
| (anchors : Finset Q) (labels : Finset J) (clock : Q → Finset P) |
| (inner : Q → J → Finset P) (c : ℝ) (μ : ℕ) |
| (hc : 0 ≤ c) (hanchor : anchors.card ≤ 20) |
| (hunstable : instability.card ≤ 4) |
| (hclock : ∀ q ∈ anchors, ((clock q).card : ℝ) ≤ c) |
| (hinner : ∀ q ∈ anchors, ∀ j ∈ labels, (inner q j).card ≤ 3) |
| (hcover : bad ⊆ instability ∪ anchors.biUnion |
| (fun q => clock q ∪ labels.biUnion (inner q))) |
| (hμ : 20 * (c + 4 * labels.card) + 10 < μ) : bad.card < μ := by |
| classical |
| have hrow : ∀ q ∈ anchors, |
| (((clock q ∪ labels.biUnion (inner q)).card : ℕ) : ℝ) ≤ c + 3 * labels.card := by |
| intro q hq |
| have ht := Finset.card_union_le (clock q) (labels.biUnion (inner q)) |
| have ht' : (((clock q ∪ labels.biUnion (inner q)).card : ℕ) : ℝ) ≤ |
| (clock q).card + (labels.biUnion (inner q)).card := by exact_mod_cast ht |
| have hi := biUnion_card_real labels (inner q) 3 (fun j hj => by |
| exact_mod_cast hinner q hq j hj) |
| nlinarith [hclock q hq] |
| have hall := biUnion_card_real anchors |
| (fun q => clock q ∪ labels.biUnion (inner q)) (c + 3 * labels.card) hrow |
| have hu := Finset.card_union_le instability |
| (anchors.biUnion (fun q => clock q ∪ labels.biUnion (inner q))) |
| have hb := (Finset.card_le_card hcover).trans hu |
| have hb' : (bad.card : ℝ) ≤ instability.card + |
| (anchors.biUnion (fun q => clock q ∪ labels.biUnion (inner q))).card := by |
| exact_mod_cast hb |
| have ha : (anchors.card : ℝ) ≤ 20 := by exact_mod_cast hanchor |
| have hz : (instability.card : ℝ) ≤ 4 := by exact_mod_cast hunstable |
| have hm : (bad.card : ℝ) < μ := by |
| have hnon : 0 ≤ (labels.card : ℝ) := Nat.cast_nonneg _ |
| nlinarith [mul_le_mul_of_nonneg_right ha (show 0 ≤ c + 3 * labels.card by positivity)] |
| exact_mod_cast hm |
| |
| lemma good_copy {Kind : Type uKind} [Fintype Kind] (μ : ℕ) |
| (bad : Finset ((Kind × Fin μ) × (Kind × Fin μ))) (hbad : bad.card < μ) : |
| ∀ kind : Kind, ∃ copy : Fin μ, ∀ q, ((kind, copy), q) ∉ bad := by |
| classical |
| intro kind |
| by_contra! hn |
| choose q hq using hn |
| let f : Fin μ → {p // p ∈ bad} := fun copy => ⟨((kind, copy), q copy), hq copy⟩ |
| have hf : Function.Injective f := by |
| intro i j he |
| exact congrArg (fun p : {p // p ∈ bad} => p.val.1.2) he |
| have hc := Fintype.card_le_of_injective f hf |
| simp only [Fintype.card_fin, Fintype.card_coe] at hc |
| omega |
| |
| noncomputable def decode {P : Type uP3} (witness : P → Prop) : Option P := |
| if h : ∃! p, witness p then some h.choose else none |
| |
| lemma decode_eq_some {P : Type uP4} {witness : P → Prop} {p : P} : |
| decode witness = some p ↔ witness p ∧ ∀ q, witness q → q = p := by |
| classical |
| dsimp only [decode] |
| split_ifs with h |
| · constructor |
| · intro he |
| have hp := Option.some.inj he |
| exact hp ▸ h.choose_spec |
| · rintro ⟨hp, huniq⟩ |
| exact congrArg some (huniq _ h.choose_spec.1) |
| · constructor |
| · intro he |
| cases he |
| · rintro ⟨hp, huniq⟩ |
| exact False.elim (h ⟨p, hp, huniq⟩) |
| |
| lemma decode_sound {P : Type uP5} {witness : P → Prop} {actual decoded : P} |
| (hactual : witness actual) (hdecode : decode witness = some decoded) : decoded = actual := by |
| exact ((decode_eq_some.mp hdecode).2 actual hactual).symm |
| |
| end StencilSparsity |
| |
| end GeneralizedStarHeight |
| |
| end OAI |
| |
