| import OAI.Probability.CriticalZ3.LatticeGraph |
|
|
| namespace OAI |
|
|
| open MeasureTheory ProbabilityTheory Classical Filter |
|
|
| open scoped ENNReal BigOperators Matrix |
|
|
| namespace CriticalZ3 |
|
|
| open Classical |
|
|
| structure Box where |
| lower : Vertex |
| upper : Vertex |
| ordered : lower ≤ upper |
|
|
| namespace Box |
| |
| @[ext] theorem ext {B C : Box} (hl : B.lower = C.lower) (hu : B.upper = C.upper) : B = C := by |
| cases B; cases C |
|
|
| noncomputable def vertices (B : Box) : Finset Vertex := Finset.Icc B.lower B.upper |
| |
| def Contains (B : Box) (x : Vertex) : Prop := ∀ i, B.lower i ≤ x i ∧ x i ≤ B.upper i |
|
|
| @[simp] theorem mem_vertices (B : Box) (x : Vertex) : x ∈ B.vertices ↔ B.Contains x := by |
| simp only [vertices, Finset.mem_Icc, Pi.le_def, Contains] |
| exact ⟨fun h i => ⟨h.1 i,h.2 i⟩,fun h => ⟨fun i => (h i).1,fun i => (h i).2⟩⟩ |
|
|
| noncomputable def bonds (B : Box) : Finset Bond := |
| (B.vertices ×ˢ Finset.univ).filter (fun e => B.Contains (step e.1 e.2)) |
|
|
| @[simp] theorem mem_bonds (B : Box) (e : Bond) : |
| e ∈ B.bonds ↔ B.Contains e.1 ∧ B.Contains (step e.1 e.2) := by |
| simp [bonds] |
| |
| def expand (B : Box) (j : ℕ) : Box where |
| lower := fun i => B.lower i-j |
| upper := fun i => B.upper i+j |
| ordered := fun i => by |
| have h : B.lower i ≤ B.upper i := B.ordered i |
| dsimp |
| omega |
|
|
| def cube (c : Vertex) (m : ℕ) : Box where |
| lower := fun i => c i-m |
| upper := fun i => c i+m |
| ordered := fun i => by dsimp |
|
|
| @[simp] theorem contains_cube (c x : Vertex) (m : ℕ) : |
| (cube c m).Contains x ↔ ∀ i, |x i-c i| ≤ (m : ℤ) := by |
| simp only [Contains,cube,abs_le] |
| constructor < |
|
|
| theorem contains_expand (B : Box) (j : ℕ) {x : Vertex} (h : B.Contains x) : |
| (B.expand j).Contains x := by |
| intro i |
| have hi := h i |
| change B.lower i-j ≤ x i ∧ x i ≤ B.upper i+j |
| omega |
|
|
| theorem expand_mono (B : Box) {j k : ℕ} (hjk : j ≤ k) {x : Vertex} |
| (h : (B.expand j).Contains x) : (B.expand k).Contains x := by |
| intro i |
| have hi := h i |
| change B.lower i-j ≤ x i ∧ x i ≤ B.upper i+j at hi |
| change B.lower i-k ≤ x i ∧ x i ≤ B.upper i+k |
| omega |
|
|
| @[simp] theorem expand_expand (B : Box) (j k : ℕ) : (B.expand j).expand k = B.expand (j+k) := by |
| apply Box.ext < |
|
|
| theorem neighbor_coordinates {x y : Vertex} (h : NearestNeighbor x y) : |
| ∃ i, |y i-x i| = 1 ∧ ∀ k, k ≠ i → y k = x k := by |
| obtain ⟨i, h | h⟩ := h |
| · subst y |
| refine ⟨i,by simp [step],?_⟩ |
| intro k hk |
| simp [step,Ne.symm hk] |
| · subst x |
| refine ⟨i,by simp [step],?_⟩ |
| intro k hk |
| simp [step,Ne.symm hk] |
| |
| theorem neighbor_distance {x y : Vertex} (h : NearestNeighbor x y) (i : Fin 3) : |
| |y i-x i| ≤ 1 := by |
| obtain ⟨k,hk,he⟩ := neighbor_coordinates h |
| by_cases hik : i = k |
| · simp [hik,hk] |
| · simp [he i hik] |
| |
| theorem neighbor_in_expand (B : Box) {x y : Vertex} |
| (hx : B.Contains x) (hxy : NearestNeighbor x y) : (B.expand 1).Contains y := by |
| intro i |
| have hi := hx i |
| have hd := neighbor_distance hxy i |
| rw [abs_le] at hd |
| change B.lower i-1 ≤ y i ∧ y i ≤ B.upper i+1 |
| omega |
| |
| /-- The uniqueness used by the shell-closing argument, including corners. -/ |
| theorem exterior_neighbor_unique (B : Box) {y z z' : Vertex} |
| (hy : ¬ B.Contains y) (hz : B.Contains z) (hz' : B.Contains z') |
| (hyz : NearestNeighbor y z) (hyz' : NearestNeighbor y z') : z = z' := by |
| obtain ⟨i,hi⟩ : ∃ i, ¬ (B.lower i ≤ y i ∧ y i ≤ B.upper i) := by |
| simpa only [Contains,not_forall] using hy |
| obtain ⟨j,hj,hej⟩ := neighbor_coordinates hyz |
| obtain ⟨k,hk,hek⟩ := neighbor_coordinates hyz' |
| have hij : i = j := by |
| by_contra h |
| have hh := hej i h |
| have hh' := hz i |
| omega |
| have hik : i = k := by |
| by_contra h |
| have hh := hek i h |
| have hh' := hz' i |
| omega |
| subst j; subst k |
| funext l |
| by_cases hl : l = i |
| · subst l |
| have hz0 := hz i |
| have hz1 := hz' i |
| have hj0 := hj.le |
| have hk0 := hk.le |
| rw [abs_le] at hj0 hk0 |
| omega |
| · rw [hej l hl,hek l hl] |
| |
| def seedCenter (C : Box) (m : ℕ) (z : Vertex) : Vertex := |
| fun i => max (C.lower i+m) (min (C.upper i-m) (z i)) |
| |
| theorem seedCenter_bounds (C : Box) (m : ℕ) |
| (hw : ∀ i, C.lower i+m ≤ C.upper i-m) (z : Vertex) (i : Fin 3) : |
| C.lower i+m ≤ C.seedCenter m z i ∧ C.seedCenter m z i ≤ C.upper i-m := by |
| exact ⟨le_max_left _ _,max_le (hw i) (min_le_left _ _)⟩ |
| |
| theorem seed_contained (C : Box) (m : ℕ) |
| (hw : ∀ i, C.lower i+m ≤ C.upper i-m) (z : Vertex) : |
| ∀ x, (cube (C.seedCenter m z) m).Contains x → C.Contains x := by |
| intro x hx i |
| have hb := C.seedCenter_bounds m hw z i |
| have hx0 := (contains_cube _ _ _).mp hx i |
| rw [abs_le] at hx0 |
| omega |
| |
| theorem seed_contains_entry (C : Box) (m : ℕ) |
| (hw : ∀ i, C.lower i+m ≤ C.upper i-m) {z : Vertex} (hz : C.Contains z) : |
| (cube (C.seedCenter m z) m).Contains z := by |
| rw [contains_cube] |
| intro i |
| have hi := hz i |
| have hwi := hw i |
| dsimp [seedCenter] |
| rw [abs_le] |
| omega |
| |
| theorem seed_center_near (C : Box) (m : ℕ) |
| (hw : ∀ i, C.lower i+m ≤ C.upper i-m) {z y : Vertex} |
| (hz : C.Contains z) (hyz : NearestNeighbor y z) (i : Fin 3) : |
| |C.seedCenter m z i-y i| ≤ (m : ℤ)+1 := by |
| have h1 := (contains_cube _ _ _).mp (C.seed_contains_entry m hw hz) i |
| have h2 := neighbor_distance hyz i |
| rw [abs_le] at h1 h2 ⊢ |
| omega |
| |
| theorem expanded_seed_width (B : Box) {m j : ℕ} (hmj : m ≤ j) (i : Fin 3) : |
| (B.expand j).lower i+m ≤ (B.expand j).upper i-m := by |
| have h : B.lower i ≤ B.upper i := B.ordered i |
| dsimp [expand] |
| omega |
| |
| /-- The exact number of candidates excluded in one greedy selection. -/ |
| theorem card_cube (c : Vertex) (m : ℕ) : (cube c m).vertices.card = (2*m+1)^3 := by |
| rw [vertices,Pi.card_Icc] |
| have he (i : Fin 3) : (Finset.Icc ((cube c m).lower i) ((cube c m).upper i)).card = 2*m+1 := by |
| rw [Int.card_Icc] |
| dsimp [cube] |
| omega |
| simp only [he,Finset.prod_const,Finset.card_univ,Fintype.card_fin] |
| |
| theorem disjoint_seeds {a b : Vertex} {m : ℕ} |
| (h : ∃ i, (2*m : ℤ) < |a i-b i|) : |
| Disjoint (cube a m).vertices (cube b m).vertices := by |
| rw [Finset.disjoint_left] |
| intro x hxa hxb |
| obtain ⟨i,hi⟩ := h |
| have ha := (contains_cube _ _ _).mp ((mem_vertices _ _).mp hxa) i |
| have hb := (contains_cube _ _ _).mp ((mem_vertices _ _).mp hxb) i |
| rw [abs_le] at ha hb |
| have hab : |a i-b i| ≤ 2*m := by rw [abs_le]; omega |
| omega |
| |
| theorem separated_subset (s : Finset Vertex) (m K : ℕ) |
| (hcard : K*(8*m+5)^3 ≤ s.card) : |
| ∃ t ⊆ s, t.card = K ∧ |
| ∀ a ∈ t, ∀ b ∈ t, a ≠ b → ∃ i, (4*m+2 : ℤ) < |a i-b i| := by |
| induction K generalizing s with |
| | zero => exact ⟨∅,Finset.empty_subset s,rfl,by simp⟩ |
| | succ K ih => |
| have hcpos : 0 < (8*m+5)^3 := by positivity |
| have hspos : 0 < s.card := by nlinarith |
| obtain ⟨a,ha⟩ := Finset.card_pos.mp hspos |
| let U := (cube a (4*m+2)).vertices |
| have hU : U.card = (8*m+5)^3 := by |
| rw [card_cube] |
| congr 1 |
| omega |
| have hc : (s ∩ U).card ≤ (8*m+5)^3 := by |
| rw [←hU] |
| exact Finset.card_le_card Finset.inter_subset_right |
| have hdiff : K*(8*m+5)^3 ≤ (s \ U).card := by |
| have he := Finset.card_sdiff_add_card_inter s U |
| rw [Nat.succ_mul] at hcard |
| omega |
| obtain ⟨t,ht,htc,hts⟩ := ih (s \ U) hdiff |
| have hat : a ∉ t := by |
| intro hat |
| have haa := (Finset.mem_sdiff.mp (ht hat)).2 |
| apply haa |
| apply (mem_vertices _ _).mpr |
| rw [contains_cube] |
| intro i |
| simp only [sub_self,abs_zero] |
| positivity |
| have has (b : Vertex) (hb : b ∈ t) : ∃ i, (4*m+2 : ℤ) < |a i-b i| := by |
| have hn := (Finset.mem_sdiff.mp (ht hb)).2 |
| have hn' : ¬ ∀ i, |b i-a i| ≤ (4*m+2 : ℤ) := by |
| simpa [U,contains_cube] using hn |
| push Not at hn' |
| simpa only [abs_sub_comm] using hn' |
| refine ⟨insert a t,?_,by simp [hat,htc],?_⟩ |
| · intro b hb |
| rcases Finset.mem_insert.mp hb with rfl | hb |
| · exact ha |
| · exact (Finset.mem_sdiff.mp (ht hb)).1 |
| · intro b hb c hc hbc |
| rcases Finset.mem_insert.mp hb with rfl | hb |
| · rcases Finset.mem_insert.mp hc with rfl | hc |
| · exact (hbc rfl).elim |
| · exact has c hc |
| · rcases Finset.mem_insert.mp hc with hca | hc |
| · subst c |
| simpa only [abs_sub_comm] using has b hb |
| · exact hts b hb c hc hbc |
| |
| theorem separated_centers (C : Box) (m : ℕ) |
| (hw : ∀ i, C.lower i+m ≤ C.upper i-m) {y y' z z' : Vertex} |
| (hz : C.Contains z) (hz' : C.Contains z') |
| (hy : NearestNeighbor y z) (hy' : NearestNeighbor y' z') |
| (hsep : ∃ i, (4*m+2 : ℤ) < |y i-y' i|) : |
| ∃ i, (2*m : ℤ) < |C.seedCenter m z i-C.seedCenter m z' i| := by |
| obtain ⟨i,hi⟩ := hsep |
| refine ⟨i,?_⟩ |
| have h1 := C.seed_center_near m hw hz hy i |
| have h2 := C.seed_center_near m hw hz' hy' i |
| by_contra! hbad |
| rw [abs_le] at h1 h2 hbad |
| have hh : |y i-y' i| ≤ 4*m+2 := by rw [abs_le]; omega |
| omega |
| |
| def translateVertex (c x : Vertex) : Vertex := fun i => x i+c i |
| |
| def translateBond (c : Vertex) (e : Bond) : Bond := (translateVertex c e.1,e.2) |
| |
| theorem translateVertex_injective (c : Vertex) : Function.Injective (translateVertex c) := by |
| intro x y h |
| funext i |
| have hi := congrFun h i |
| dsimp [translateVertex] at hi |
| omega |
| |
| theorem translateBond_injective (c : Vertex) : Function.Injective (translateBond c) := by |
| intro e e' h |
| have h1 : e.1 = e'.1 := translateVertex_injective c (congrArg Prod.fst h) |
| have h2 : e.2 = e'.2 := by simpa only [translateBond] using congrArg Prod.snd h |
| exact Prod.ext h1 h2 |
|
|
| @[simp] theorem step_translate (c x : Vertex) (i : Fin 3) : |
| step (translateVertex c x) i = translateVertex c (step x i) := by |
| funext j |
| dsimp [step,translateVertex] |
| omega |
|
|
| @[simp] theorem cube_contains_translate (c x : Vertex) (m : ℕ) : |
| (cube c m).Contains (translateVertex c x) ↔ (cube 0 m).Contains x := by |
| simp [contains_cube,translateVertex] |
|
|
| theorem cube_vertices_translate (c : Vertex) (m : ℕ) : |
| (cube c m).vertices = (cube 0 m).vertices.image (translateVertex c) := by |
| ext x |
| constructor |
| · intro hx |
| refine Finset.mem_image.mpr ⟨fun i => x i-c i,?_,?_⟩ |
| · rw [mem_vertices,contains_cube] |
| simpa using (contains_cube _ _ _).mp ((mem_vertices _ _).mp hx) |
| · funext i |
| · rintro hx |
| obtain ⟨y,hy,rfl⟩ := Finset.mem_image.mp hx |
| simpa [translateVertex] using hy |
|
|
| theorem cube_bonds_translate (c : Vertex) (m : ℕ) : |
| (cube c m).bonds = (cube 0 m).bonds.image (translateBond c) := by |
| ext e |
| constructor |
| · intro he |
| let e' : Bond := (fun i => e.1 i-c i,e.2) |
| have heq : translateBond c e' = e := by |
| apply Prod.ext |
| · funext i |
| · rfl |
| refine Finset.mem_image.mpr ⟨e',?_,heq⟩ |
| rw [←heq,mem_bonds] at he |
| simpa [translateBond,translateVertex] using he |
| · intro he |
| obtain ⟨e',he',rfl⟩ := Finset.mem_image.mp he |
| simpa [translateBond,translateVertex] using he' |
|
|
| theorem cube_bonds_card (c : Vertex) (m : ℕ) : |
| (cube c m).bonds.card = (cube 0 m).bonds.card := by |
| rw [cube_bonds_translate,Finset.card_image_of_injective _ (translateBond_injective c)] |
|
|
| def Within (B : Box) (x y : Vertex) : Prop := |
| NearestNeighbor x y ∧ B.Contains x ∧ B.Contains y |
|
|
| theorem within_symm (B : Box) {x y : Vertex} (h : B.Within x y) : B.Within y x := by |
| obtain ⟨⟨i,hi⟩,hx,hy⟩ := h |
| exact ⟨⟨i,hi.symm⟩,hy,hx⟩ |
|
|
| theorem within_path_symm (B : Box) {x y : Vertex} |
| (h : Relation.ReflTransGen B.Within x y) : Relation.ReflTransGen B.Within y x := by |
| induction h with |
| | refl => exact .refl |
| | tail _ hab ih => exact .head (B.within_symm hab) ih |
|
|
| theorem line_step (x : Vertex) (i : Fin 3) (n : ℤ) : |
| Function.update x i (n+1) = step (Function.update x i n) i := by |
| funext j |
| by_cases hj : j = i |
| · subst j; simp [step] |
| · simp [step,hj,Ne.symm hj] |
|
|
| theorem line_contains (B : Box) {x : Vertex} (hx : B.Contains x) (i : Fin 3) |
| (n : ℤ) (hn : B.lower i ≤ n ∧ n ≤ B.upper i) : B.Contains (Function.update x i n) := by |
| intro j |
| by_cases hj : j = i |
| · subst j; simpa using hn |
| · simpa [Function.update_of_ne hj] using hx j |
| |
| theorem line_path_le (B : Box) {x : Vertex} (hx : B.Contains x) (i : Fin 3) |
| {a b : ℤ} (ha : B.lower i ≤ a) (hb : b ≤ B.upper i) (hab : a ≤ b) : |
| Relation.ReflTransGen B.Within (Function.update x i a) (Function.update x i b) := by |
| have hh (n : ℤ) (han : a ≤ n) : n ≤ b → |
| Relation.ReflTransGen B.Within (Function.update x i a) (Function.update x i n) := by |
| induction n,han using Int.leInduction with |
| | base => intro _; exact .refl |
| | succ n han ih => |
| intro hn |
| apply (ih (by omega)).tail |
| exact ⟨⟨i,Or.inl (line_step x i n)⟩, |
| B.line_contains hx i n ⟨by omega,by omega⟩, |
| B.line_contains hx i (n+1) ⟨by omega,by omega⟩⟩ |
| exact hh b hab le_rfl |
|
|
| theorem line_path (B : Box) {x : Vertex} (hx : B.Contains x) (i : Fin 3) |
| {b : ℤ} (hb : B.lower i ≤ b ∧ b ≤ B.upper i) : |
| Relation.ReflTransGen B.Within x (Function.update x i b) := by |
| have hx' := hx i |
| by_cases h : x i ≤ b |
| · simpa using B.line_path_le hx i hx'.1 hb.2 h |
| · apply B.within_path_symm |
| simpa using B.line_path_le hx i hb.1 hx'.2 (le_of_not_ge h) |
| |
| /-- Every nonempty integer rectangle is nearest-neighbor connected internally. -/ |
| theorem connected (B : Box) {x y : Vertex} (hx : B.Contains x) (hy : B.Contains y) : |
| Relation.ReflTransGen B.Within x y := by |
| let patch (s : Finset (Fin 3)) : Vertex := fun i => if i ∈ s then y i else x i |
| have hp (s : Finset (Fin 3)) : B.Contains (patch s) := by |
| intro i |
| by_cases hi : i ∈ s |
| · simpa [patch,hi] using hy i |
| · simpa [patch,hi] using hx i |
| have hc (s : Finset (Fin 3)) : Relation.ReflTransGen B.Within x (patch s) := by |
| induction s using Finset.induction_on with |
| | empty => simpa only [patch,Finset.notMem_empty,ite_false] using |
| (Relation.ReflTransGen.refl : Relation.ReflTransGen B.Within x x) |
| | @insert i s hi ih => |
| have he : patch (insert i s) = Function.update (patch s) i (y i) := by |
| funext j |
| by_cases hj : j = i |
| · subst j; simp [patch] |
| · simp [patch,hj] |
| rw [he] |
| exact ih.trans (B.line_path (hp s) i (hy i)) |
| simpa only [patch,Finset.mem_univ,ite_true] using hc Finset.univ |
| |
| end Box |
| end CriticalZ3 |
| |
| end OAI |
| |
