| import OAI.Computability.WitnessedChoice.TreeElimination |
|
|
| namespace OAI |
|
|
|
|
| namespace WitnessedSeparation.Grid |
|
|
| noncomputable section |
|
|
| open Classical Support |
|
|
| variable {n : ℕ} |
|
|
| def facePlane : Face n → Fin 3 |
| | .inl _ => 0 |
| | .inr (.inl _) => 1 |
| | .inr (.inr _) => 2 |
|
|
| def faceSide : Face n → Fin 4 → Edge n |
| | .inl (i,j,k) => ![ex i j.castSucc k, ey i.succ j k, ex i j.succ k, ey i.castSucc j k] |
| | .inr (.inl (i,j,k)) => ![ex i j k.castSucc, ez i.succ j k, ex i j k.succ, ez i.castSucc j k] |
| | .inr (.inr (i,j,k)) => ![ey i j k.castSucc, ez i j.succ k, ey i j k.succ, ez i j.castSucc k] |
|
|
| def sideAxis : Fin 3 → Fin 4 → Fin 3 := |
| ![![0,1,0,1], ![0,2,0,2], ![1,2,1,2]] |
|
|
| lemma faceSide_axis (f : Face n) (i : Fin 4) : |
| edgeAxis (faceSide f i) = sideAxis (facePlane f) i := by |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> |
| fin_cases i <;> rfl |
|
|
| lemma faceSide_injective {f g : Face n} (hp : facePlane f = facePlane g) |
| (i : Fin 4) (he : faceSide f i = faceSide g i) : f = g := by |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> |
| rcases g with ⟨a,b,c⟩ | (⟨a,b,c⟩ | ⟨a,b,c⟩) <;> |
| simp only [facePlane] at hp |
| all_goals first | contradiction | skip |
| all_goals fin_cases i <;> simpa [faceSide,ex,ey,ez] using he |
|
|
| lemma support_cycle (f : Face n) (e : Edge n) (h : cycle f e ≠ 0) : |
| ∃ i, faceSide f i = e := by |
| by_contra hn |
| have hh (i : Fin 4) : e ≠ faceSide f i := fun he => hn ⟨i,he.symm⟩ |
| apply h |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) |
| all_goals |
| have h0 := hh 0 |
| have h1 := hh 1 |
| have h2 := hh 2 |
| have h3 := hh 3 |
| simp [faceSide] at h0 h1 h2 h3 |
| simp [cycle,Pi.single_eq_of_ne,h0,h1,h2,h3] |
|
|
| lemma edgeFaces_card_le_four (e : Edge n) : Fintype.card (EdgeFaces e) ≤ 4 := by |
| let chooseSide (f : EdgeFaces e) : Fin 4 := (support_cycle f.val e f.property).choose |
| have hs (f : EdgeFaces e) : faceSide f.val (chooseSide f) = e := |
| (support_cycle f.val e f.property).choose_spec |
| let key (f : EdgeFaces e) : {k : Fin 3 × Fin 4 // sideAxis k.1 k.2 = edgeAxis e} := |
| ⟨(facePlane f.val,chooseSide f), (faceSide_axis f.val (chooseSide f)).symm.trans (congrArg edgeAxis (hs f))⟩ |
| have hi : Function.Injective key := by |
| intro f g h |
| have h' := congrArg Subtype.val h |
| have hp := congrArg Prod.fst h' |
| have hc := congrArg Prod.snd h' |
| apply Subtype.ext |
| apply faceSide_injective hp (chooseSide f) |
| change chooseSide f = chooseSide g at hc |
| exact (hs f).trans (by rw [hc,hs g]) |
| have ht : Fintype.card {k : Fin 3 × Fin 4 // sideAxis k.1 k.2 = edgeAxis e} = 4 := by |
| generalize edgeAxis e = a |
| fin_cases a <;> decide |
| simpa only [ht] using Fintype.card_le_of_injective key hi |
|
|
| def faceCorner : Face n → Fin 4 → Vertex n |
| | .inl (i,j,k) => ![(i.castSucc,j.castSucc,k),(i.succ,j.castSucc,k), |
| (i.succ,j.succ,k),(i.castSucc,j.succ,k)] |
| | .inr (.inl (i,j,k)) => ![(i.castSucc,j,k.castSucc),(i.succ,j,k.castSucc), |
| (i.succ,j,k.succ),(i.castSucc,j,k.succ)] |
| | .inr (.inr (i,j,k)) => ![(i,j.castSucc,k.castSucc),(i,j.succ,k.castSucc), |
| (i,j.succ,k.succ),(i,j.castSucc,k.succ)] |
|
|
| lemma faceCorner_injective {f g : Face n} (hp : facePlane f = facePlane g) |
| (i : Fin 4) (he : faceCorner f i = faceCorner g i) : f = g := by |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> |
| rcases g with ⟨a,b,c⟩ | (⟨a,b,c⟩ | ⟨a,b,c⟩) <;> |
| simp only [facePlane] at hp |
| all_goals first | contradiction | skip |
| all_goals fin_cases i <;> simpa [faceCorner] using he |
|
|
| lemma faceSide_endpoints (f : Face n) (i : Fin 4) (v : Vertex n) |
| (hv : incident v (faceSide f i)) : ∃ j, faceCorner f j = v := by |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> fin_cases i |
| all_goals |
| rcases hv with h | h |
| all_goals first |
| | exact ⟨0,h⟩ |
| | exact ⟨1,h⟩ |
| | exact ⟨2,h⟩ |
| | exact ⟨3,h⟩ |
|
|
| abbrev VertexFaces (v : Vertex n) := |
| {f : Face n // ∃ e : IncidentEdges v, cycle f e.val ≠ 0} |
|
|
| lemma vertexFaces_card_le_twelve (v : Vertex n) : Fintype.card (VertexFaces v) ≤ 12 := by |
| have hc (f : VertexFaces v) : ∃ i, faceCorner f.val i = v := by |
| obtain ⟨e,he⟩ := f.property |
| obtain ⟨i,hi⟩ := support_cycle f.val e.val he |
| exact faceSide_endpoints f.val i v (hi ▸ e.property) |
| let key (f : VertexFaces v) : Fin 3 × Fin 4 := (facePlane f.val,(hc f).choose) |
| have hi : Function.Injective key := by |
| intro f g h |
| have hp := congrArg Prod.fst h |
| have hk := congrArg Prod.snd h |
| apply Subtype.ext |
| apply faceCorner_injective hp (hc f).choose |
| change (hc f).choose = (hc g).choose at hk |
| exact (hc f).choose_spec.trans (by rw [hk,(hc g).choose_spec]) |
| simpa using Fintype.card_le_of_injective key hi |
|
|
| lemma localGroup_card_le_upper (e : Edge n) : Fintype.card (LocalGroup e) ≤ 3^9 := by |
| have hc : Fintype.card (LocalGroup e) = 3 ^ (2 * Fintype.card (EdgeFaces e) + 1) := by |
| rw [← Nat.card_eq_fintype_card,Support.H.ambient_card] |
| congr 1 |
| rw [Module.finrank_pi_fintype] |
| simp [Support.Plane,Support.Scalar,Module.finrank_prod,Nat.mul_comm] |
| rw [hc] |
| exact Nat.pow_le_pow_right (by omega) (by have := edgeFaces_card_le_four e; omega) |
|
|
| lemma exists_incident (hn : 1 ≤ n) (v : Vertex n) : Nonempty (IncidentEdges v) := by |
| rcases v with ⟨i,j,k⟩ |
| by_cases hi : i.val < n |
| · refine ⟨⟨ex ⟨i.val,hi⟩ j k,Or.inr ?_⟩⟩ |
| simp only [ex,tail,Prod.mk.injEq,and_true] |
| exact Fin.ext rfl |
| · refine ⟨⟨ex ⟨n-1,by omega⟩ j k,Or.inl ?_⟩⟩ |
| simp only [ex,head,Prod.mk.injEq,and_true] |
| apply Fin.ext |
| simp only [Fin.val_succ] |
| omega |
|
|
| lemma epsilon_ne_zero (v : Vertex n) (e : IncidentEdges v) : epsilon v e.val ≠ 0 := by |
| by_cases hh : head e.val = v |
| · have ht : tail e.val ≠ v := fun h => head_ne_tail e.val (hh.trans h.symm) |
| simp [epsilon,hh,ht] |
| · have ht := e.property.resolve_left hh |
| simp [epsilon,hh,ht] |
|
|
| variable {b : Vertex n → Scalar} {v : Vertex n} |
|
|
| def Configuration.faceValue (s : Configuration b v) (f : VertexFaces v) : Plane := |
| (s.state f.property.choose).face ⟨f.val,f.property.choose_spec⟩ |
|
|
| lemma Configuration.faceValue_eq (s : Configuration b v) (e : IncidentEdges v) |
| (f : EdgeFaces e.val) : |
| s.faceValue ⟨f.val,⟨e,f.property⟩⟩ = (s.state e).face f := by |
| exact s.compatible _ e f.val _ f.property |
|
|
| def Configuration.code (e0 : IncidentEdges v) (s : Configuration b v) : |
| (VertexFaces v → Plane) × ({e : IncidentEdges v // e ≠ e0} → Scalar) := |
| (s.faceValue,fun e => (s.state e.val).flow) |
|
|
| lemma Configuration.code_injective (e0 : IncidentEdges v) : |
| Function.Injective (Configuration.code (b := b) e0) := by |
| intro s t h |
| have hf (e : IncidentEdges v) : (s.state e).face = (t.state e).face := by |
| funext f |
| rw [←s.faceValue_eq e f,←t.faceValue_eq e f] |
| exact congrFun (congrArg Prod.fst h) ⟨f.val,⟨e,f.property⟩⟩ |
| have hz (e : IncidentEdges v) (he : e ≠ e0) : (s.state e).flow = (t.state e).flow := |
| congrFun (congrArg Prod.snd h) ⟨e,he⟩ |
| have hz0 : (s.state e0).flow = (t.state e0).flow := by |
| have hsum := s.charge.trans t.charge.symm |
| change (∑ e : IncidentEdges v, epsilon v e.val * (s.state e).flow) = |
| ∑ e : IncidentEdges v, epsilon v e.val * (t.state e).flow at hsum |
| rw [← Finset.add_sum_erase _ _ (Finset.mem_univ e0), |
| ← Finset.add_sum_erase _ (fun e : IncidentEdges v => epsilon v e.val * (t.state e).flow) |
| (Finset.mem_univ e0)] at hsum |
| have hr : (∑ e ∈ Finset.univ.erase e0, epsilon v e.val * (s.state e).flow) = |
| ∑ e ∈ Finset.univ.erase e0, epsilon v e.val * (t.state e).flow := by |
| apply Finset.sum_congr rfl |
| intro e he |
| rw [hz e (Finset.ne_of_mem_erase he)] |
| rw [hr] at hsum |
| exact mul_left_cancel₀ (epsilon_ne_zero v e0) (add_right_cancel hsum) |
| apply Configuration.ext |
| intro e |
| apply Support.H.ext (hf e) |
| by_cases he : e = e0 |
| · subst e |
| exact hz0 |
| · exact hz e he |
|
|
| lemma configuration_card_le_upper (hn : 1 ≤ n) (b : Vertex n → Scalar) (v : Vertex n) : |
| Fintype.card (Configuration b v) ≤ 3^29 := by |
| classical |
| let e0 := Classical.choice (exists_incident hn v) |
| rw [← Nat.card_eq_fintype_card] |
| have hcard := Nat.card_le_card_of_injective _ (Configuration.code_injective (b := b) e0) |
| have he : Nat.card {e : IncidentEdges v // e ≠ e0} ≤ 5 := by |
| rw [Nat.card_eq_fintype_card] |
| have hc := Fintype.card_subtype_compl (fun e : IncidentEdges v => e = e0) |
| have hdeg : Fintype.card (IncidentEdges v) ≤ 6 := degree_le_six v |
| have hone : Fintype.card {e : IncidentEdges v // e = e0} = 1 := by simp |
| rw [hone] at hc |
| rw [hc] |
| omega |
| have hc : Nat.card ((VertexFaces v → Plane) × |
| ({e : IncidentEdges v // e ≠ e0} → Scalar)) = |
| 3 ^ (2 * Nat.card (VertexFaces v) + Nat.card {e : IncidentEdges v // e ≠ e0}) := by |
| simp only [Nat.card_prod,Nat.card_fun,Plane,Support.Scalar,Scalar] |
| have hz : Nat.card (ZMod 3) = 3 := by simp [Nat.card_eq_fintype_card] |
| rw [hz] |
| rw [←pow_two,←pow_mul,←pow_add] |
| rw [hc] at hcard |
| exact hcard.trans (Nat.pow_le_pow_right (by omega) (by |
| have hh : Nat.card (VertexFaces v) ≤ 12 := by |
| simpa only [Nat.card_eq_fintype_card] using vertexFaces_card_le_twelve v |
| omega)) |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical WitnessedChoice.TreeTest |
|
|
| variable {n : ℕ} |
|
|
| structure ParentEdges (T : RootedTree (Vertex n)) where |
| edge : (v : Vertex n) → v ≠ T.root → Edge n |
| endpoints : ∀ v h, |
| (head (edge v h) = v ∧ tail (edge v h) = T.parent v) ∨ |
| (tail (edge v h) = v ∧ head (edge v h) = T.parent v) |
|
|
| namespace ParentEdges |
|
|
| variable {T : RootedTree (Vertex n)} (P : ParentEdges T) |
|
|
| def treeEdges : Finset (Edge n) := |
| Finset.univ.image (fun v : {v : Vertex n // v ≠ T.root} => P.edge v.val v.property) |
|
|
| def sign (v : Vertex n) (h : v ≠ T.root) : Scalar := |
| if head (P.edge v h) = v then 1 else -1 |
|
|
| lemma edge_mem (v : Vertex n) (hv : v ≠ T.root) : P.edge v hv ∈ P.treeEdges := by |
| exact Finset.mem_image.mpr ⟨⟨v,hv⟩,Finset.mem_univ _,rfl⟩ |
|
|
| def route (Q : ParentEdges T) (v : Vertex n) : Edge n → Scalar := |
| if hv : v = T.root then 0 else |
| Pi.single (Q.edge v hv) (Q.sign v hv) + route Q (T.parent v) |
| termination_by T.level v |
| decreasing_by exact T.parent_lower v hv |
|
|
| lemma boundary_single (e : Edge n) (a : Scalar) : |
| boundary (Pi.single e a) = a • (Pi.single (head e) 1 - Pi.single (tail e) 1) := by |
| rw [WitnessedSeparation.Grid.boundary_single] |
| simp only [smul_sub,← Pi.single_smul,smul_eq_mul,mul_one] |
|
|
| lemma boundary_parent (v : Vertex n) (hv : v ≠ T.root) : |
| boundary (Pi.single (P.edge v hv) (P.sign v hv)) = |
| Pi.single v 1 - Pi.single (T.parent v) 1 := by |
| rw [boundary_single] |
| rcases P.endpoints v hv with ⟨hh,ht⟩ | ⟨ht,hh⟩ |
| · simp [sign,hh,ht] |
| · have hne : head (P.edge v hv) ≠ v := by |
| intro he |
| have hp : T.parent v = v := hh.symm.trans he |
| have := T.parent_lower v hv |
| rw [hp] at this |
| omega |
| rw [sign,ite_eq_right hne,ht,hh,neg_smul,one_smul] |
| abel |
|
|
| lemma boundary_route (v : Vertex n) : |
| boundary (P.route v) = Pi.single v 1 - Pi.single T.root 1 := by |
| induction v using (measure T.level).wf.induction with |
| | h v ih => |
| rw [route] |
| split_ifs with hv |
| · subst v |
| simp |
| · rw [map_add,P.boundary_parent v hv,ih (T.parent v) (T.parent_lower v hv)] |
| abel |
|
|
| lemma route_zero_off_tree {e : Edge n} (he : e ∉ P.treeEdges) (v : Vertex n) : P.route v e = 0 := by |
| induction v using (measure T.level).wf.induction with |
| | h v ih => |
| rw [route] |
| split_ifs with hv |
| · rfl |
| · have hne : e ≠ P.edge v hv := fun h => he (h.symm ▸ P.edge_mem v hv) |
| simp only [Pi.add_apply,Pi.single_eq_of_ne hne,zero_add] |
| exact ih (T.parent v) (T.parent_lower v hv) |
|
|
| def fundamental (e : Edge n) (a : Scalar) : Edge n → Scalar := |
| Pi.single e a + a • P.route (tail e) - a • P.route (head e) |
|
|
| lemma boundary_fundamental (e : Edge n) (a : Scalar) : boundary (P.fundamental e a) = 0 := by |
| rw [fundamental,map_sub,map_add,map_smul,map_smul,boundary_single, |
| P.boundary_route,P.boundary_route] |
| simp only [smul_sub] |
| abel |
|
|
| def flow (e : Edge n) (a : Scalar) : FlowSpace n := ⟨P.fundamental e a,P.boundary_fundamental e a⟩ |
|
|
| lemma flow_self (e : Edge n) (he : e ∉ P.treeEdges) (a : Scalar) : (P.flow e a).val e = a := by |
| simp [flow,fundamental,P.route_zero_off_tree he] |
|
|
| lemma flow_other (e f : Edge n) (hf : f ∉ P.treeEdges) (hne : f ≠ e) (a : Scalar) : |
| (P.flow e a).val f = 0 := by |
| simp [flow,fundamental,P.route_zero_off_tree hf,Pi.single_eq_of_ne hne] |
|
|
| def solve (r : Vertex n → Scalar) : Edge n → Scalar := ∑ v, r v • P.route v |
|
|
| lemma boundary_solve (r : Vertex n → Scalar) (hr : ∑ v, r v = 0) : |
| boundary (P.solve r) = r := by |
| simp only [solve,map_sum,map_smul,P.boundary_route,smul_sub,Finset.sum_sub_distrib] |
| rw [← Finset.sum_smul,hr,zero_smul,sub_zero] |
| funext v |
| simp [Pi.single_apply] |
|
|
| lemma solve_zero_off_tree (r : Vertex n → Scalar) {e : Edge n} (he : e ∉ P.treeEdges) : |
| P.solve r e = 0 := by |
| simp only [solve,Finset.sum_apply,Pi.smul_apply,P.route_zero_off_tree he,smul_zero,Finset.sum_const_zero] |
|
|
| lemma extend_scalars (b : Vertex n → Scalar) (hb : ∑ v, b v = 0) (z : Edge n → Scalar) : |
| ∃ w : Edge n → Scalar, boundary w = b ∧ ∀ e, e ∉ P.treeEdges → w e = z e := by |
| let r := b - boundary z |
| have hr : ∑ v, r v = 0 := by |
| simp only [r,Pi.sub_apply,Finset.sum_sub_distrib,hb,sum_boundary,sub_self] |
| refine ⟨z + P.solve r, ?_, ?_⟩ |
| · rw [map_add,P.boundary_solve r hr] |
| dsimp [r] |
| abel |
| · intro e he |
| simp only [Pi.add_apply,P.solve_zero_off_tree r he,add_zero] |
|
|
| end ParentEdges |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical Support WitnessedChoice.TreeTest |
|
|
| variable {n : ℕ} |
|
|
| def ConsistentSelection (x : Finset (Σ e : Edge n, LocalGroup e)) : Prop := |
| (∀ r ∈ x, ∀ s ∈ x, r.1 = s.1 → r = s) ∧ |
| ∀ r ∈ x, ∀ s ∈ x, ∀ f : Face n, ∀ hr : cycle f r.1 ≠ 0, ∀ hs : cycle f s.1 ≠ 0, |
| r.2.face ⟨f,hr⟩ = s.2.face ⟨f,hs⟩ |
|
|
| def selectedVectors (x : Finset (Σ e : Edge n, LocalGroup e)) (f : Face n) : Plane := |
| if h : ∃ r ∈ x, cycle f r.1 ≠ 0 then |
| h.choose.2.face ⟨f,h.choose_spec.2⟩ else 0 |
|
|
| def selectedScalars (x : Finset (Σ e : Edge n, LocalGroup e)) (e : Edge n) : Scalar := |
| if h : ∃ r ∈ x, r.1 = e then h.choose.2.flow else 0 |
|
|
| lemma selectedVectors_preserves {x : Finset (Σ e : Edge n, LocalGroup e)} |
| (hx : ConsistentSelection x) {r : Σ e : Edge n, LocalGroup e} (hr : r ∈ x) |
| (f : EdgeFaces r.1) : selectedVectors x f.val = r.2.face f := by |
| have h : ∃ s ∈ x, cycle f.val s.1 ≠ 0 := ⟨r,hr,f.property⟩ |
| rw [selectedVectors,dite_eq_left h] |
| exact hx.2 h.choose h.choose_spec.1 r hr f.val h.choose_spec.2 f.property |
|
|
| lemma selectedScalars_preserves {x : Finset (Σ e : Edge n, LocalGroup e)} |
| (hx : ConsistentSelection x) {r : Σ e : Edge n, LocalGroup e} (hr : r ∈ x) : |
| selectedScalars x r.1 = r.2.flow := by |
| have h : ∃ s ∈ x, s.1 = r.1 := ⟨r,hr,rfl⟩ |
| rw [selectedScalars,dite_eq_left h,hx.1 h.choose h.choose_spec.1 r hr h.choose_spec.2] |
|
|
| def globalStates (u : Face n → Plane) (z : Edge n → Scalar) (e : Edge n) : LocalGroup e := |
| ⟨fun f => u f.val,z e⟩ |
|
|
| lemma globalStates_compatible (u : Face n → Plane) (z : Edge n → Scalar) (v : Vertex n) : |
| Compatible (fun e : IncidentEdges v => globalStates u z e.val) := by |
| intro e e' f hf hf' |
| rfl |
|
|
| lemma globalStates_charge (u : Face n → Plane) (z : Edge n → Scalar) (v : Vertex n) : |
| divergence (fun e : IncidentEdges v => globalStates u z e.val) = boundary z v := |
| sum_incident z v |
|
|
| def globalConfiguration (b : Vertex n → Scalar) (u : Face n → Plane) |
| (z : Edge n → Scalar) (hz : boundary z = b) (v : Vertex n) : Configuration b v where |
| state := fun e => globalStates u z e.val |
| compatible := globalStates_compatible u z v |
| charge := (globalStates_charge u z v).trans (congrFun hz v) |
|
|
| theorem extend_consistent_selection {T : RootedTree (Vertex n)} (P : ParentEdges T) |
| (b : Vertex n → Scalar) (hb : ∑ v, b v = 0) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hx : ConsistentSelection x) |
| (hoff : ∀ r ∈ x, r.1 ∉ P.treeEdges) : |
| ∃ (s : (e : Edge n) → LocalGroup e) (t : (v : Vertex n) → Configuration b v), |
| (∀ r ∈ x, s r.1 = r.2) ∧ ∀ v (e : IncidentEdges v), (t v).state e = s e.val := by |
| obtain ⟨z,hz,hkeep⟩ := P.extend_scalars b hb (selectedScalars x) |
| refine ⟨globalStates (selectedVectors x) z,globalConfiguration b (selectedVectors x) z hz,?_,?_⟩ |
| · intro r hr |
| apply H.ext |
| · funext f |
| exact selectedVectors_preserves hx hr f |
| · exact (hkeep r.1 (hoff r hr)).trans (selectedScalars_preserves hx hr) |
| · intro v e |
| rfl |
|
|
| theorem total_charge_of_global_configurations (b : Vertex n → Scalar) |
| (s : (e : Edge n) → LocalGroup e) (t : (v : Vertex n) → Configuration b v) |
| (h : ∀ v (e : IncidentEdges v), (t v).state e = s e.val) : ∑ v, b v = 0 := by |
| have hb : boundary (fun e => (s e).flow) = b := by |
| funext v |
| rw [← sum_incident] |
| exact (show divergence (fun e : IncidentEdges v => s e.val) = b v by |
| have hh : (t v).state = fun e : IncidentEdges v => s e.val := funext (h v) |
| rw [← hh] |
| exact (t v).charge) |
| rw [← hb] |
| exact sum_boundary _ |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical Support |
|
|
| variable {n : ℕ} {v : Vertex n} {b : Vertex n → Scalar} |
|
|
| lemma incident_on_axis (hn : 1 ≤ n) (v : Vertex n) (a : Fin 3) : |
| ∃ e : IncidentEdges v, edgeAxis e.val = a := by |
| rcases v with ⟨i,j,k⟩ |
| fin_cases a |
| · by_cases hi : i.val = 0 |
| · refine ⟨⟨ex ⟨0,by omega⟩ j k,Or.inr ?_⟩,rfl⟩ |
| simp only [ex,tail,Prod.mk.injEq,and_true] |
| apply Fin.ext |
| exact hi.symm |
| · refine ⟨⟨ex ⟨i.val-1,by omega⟩ j k,Or.inl ?_⟩,rfl⟩ |
| simp only [ex,head,Prod.mk.injEq,and_true] |
| apply Fin.ext |
| simp only [Fin.val_succ] |
| omega |
| · by_cases hj : j.val = 0 |
| · refine ⟨⟨ey i ⟨0,by omega⟩ k,Or.inr ?_⟩,rfl⟩ |
| simp only [ey,tail,Prod.mk.injEq,true_and,and_true] |
| apply Fin.ext |
| exact hj.symm |
| · refine ⟨⟨ey i ⟨j.val-1,by omega⟩ k,Or.inl ?_⟩,rfl⟩ |
| simp only [ey,head,Prod.mk.injEq,true_and,and_true] |
| apply Fin.ext |
| simp only [Fin.val_succ] |
| omega |
| · by_cases hk : k.val = 0 |
| · refine ⟨⟨ez i j ⟨0,by omega⟩,Or.inr ?_⟩,rfl⟩ |
| simp only [ez,tail,Prod.mk.injEq,true_and] |
| apply Fin.ext |
| exact hk.symm |
| · refine ⟨⟨ez i j ⟨k.val-1,by omega⟩,Or.inl ?_⟩,rfl⟩ |
| simp only [ez,head,Prod.mk.injEq,true_and] |
| apply Fin.ext |
| simp only [Fin.val_succ] |
| omega |
|
|
| lemma fin_three_other (a b : Fin 3) : ∃ c : Fin 3, c ≠ a ∧ c ≠ b := by |
| fin_cases a <;> fin_cases b |
| all_goals first |
| | exact ⟨0,by decide,by decide⟩ |
| | exact ⟨1,by decide,by decide⟩ |
| | exact ⟨2,by decide,by decide⟩ |
|
|
| lemma other_incident (hn : 1 ≤ n) (e e' : IncidentEdges v) : |
| ∃ h : IncidentEdges v, h ≠ e ∧ h ≠ e' := by |
| obtain ⟨a,ha,ha'⟩ := fin_three_other (edgeAxis e.val) (edgeAxis e'.val) |
| obtain ⟨h,hh⟩ := incident_on_axis hn v a |
| refine ⟨h,?_,?_⟩ |
| · intro he |
| subst h |
| exact ha hh.symm |
| · intro he |
| subst h |
| exact ha' hh.symm |
|
|
| def extendVertexScalars (b : Vertex n → Scalar) (v : Vertex n) (e0 : IncidentEdges v) |
| (z : IncidentEdges v → Scalar) (e : IncidentEdges v) : Scalar := |
| if e = e0 then (epsilon v e0.val)⁻¹ * |
| (b v - ∑ h ∈ Finset.univ.erase e0, epsilon v h.val * z h) |
| else z e |
|
|
| lemma extendVertexScalars_charge (e0 : IncidentEdges v) (z : IncidentEdges v → Scalar) : |
| (∑ e, epsilon v e.val * extendVertexScalars b v e0 z e) = b v := by |
| rw [← Finset.add_sum_erase _ _ (Finset.mem_univ e0)] |
| have he : (∑ e ∈ Finset.univ.erase e0, |
| epsilon v e.val * extendVertexScalars b v e0 z e) = |
| ∑ e ∈ Finset.univ.erase e0, epsilon v e.val * z e := by |
| apply Finset.sum_congr rfl |
| intro e he |
| rw [extendVertexScalars,ite_eq_right (Finset.ne_of_mem_erase he)] |
| rw [he,extendVertexScalars,ite_eq_left rfl,mul_inv_cancel_left₀ (epsilon_ne_zero v e0),sub_add_cancel] |
|
|
| lemma exists_configuration_two (hn : 1 ≤ n) (e e' : IncidentEdges v) (hne : e ≠ e') |
| (s : LocalGroup e.val) (t : LocalGroup e'.val) |
| (hc : ∀ f : Face n, ∀ he : cycle f e.val ≠ 0, ∀ he' : cycle f e'.val ≠ 0, |
| s.face ⟨f,he⟩ = t.face ⟨f,he'⟩) : |
| ∃ c : Configuration b v, c.state e = s ∧ c.state e' = t := by |
| obtain ⟨e0,hr,hr'⟩ := other_incident hn e e' |
| let u (f : Face n) : Plane := if h : cycle f e.val ≠ 0 then s.face ⟨f,h⟩ |
| else if h' : cycle f e'.val ≠ 0 then t.face ⟨f,h'⟩ else 0 |
| let z (h : IncidentEdges v) : Scalar := if h = e then s.flow else if h = e' then t.flow else 0 |
| let c : Configuration b v := |
| { state := fun h => ⟨fun f => u f.val,extendVertexScalars b v e0 z h⟩ |
| compatible := by intro h h' f hf hf'; rfl |
| charge := extendVertexScalars_charge e0 z } |
| refine ⟨c,?_,?_⟩ |
| · apply H.ext |
| · funext f |
| exact dite_eq_left f.property |
| · change extendVertexScalars b v e0 z e = s.flow |
| simp only [extendVertexScalars,ite_eq_right (Ne.symm hr),z,ite_eq_left rfl] |
| · apply H.ext |
| · funext f |
| change u f.val = t.face f |
| dsimp only [u] |
| split_ifs with he he' |
| · exact hc f.val he f.property |
| · rfl |
| · exact (he' f.property).elim |
| · change extendVertexScalars b v e0 z e' = t.flow |
| simp only [extendVertexScalars,ite_eq_right (Ne.symm hr'),z,ite_eq_right (Ne.symm hne),ite_true] |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical Support |
|
|
| variable {n : ℕ} |
|
|
| def vertexCoord (v : Vertex n) : Fin 3 → Fin (n+1) := ![v.1,v.2.1,v.2.2] |
|
|
| def planeAxis (p a : Fin 3) : Prop := ∃ i : Fin 4, sideAxis p i = a |
|
|
| instance (p a : Fin 3) : Decidable (planeAxis p a) := Classical.propDecidable _ |
|
|
| def faceBase (f : Face n) : Fin 3 → Fin (n+1) := vertexCoord (faceCorner f 0) |
|
|
| lemma vertexCoord_injective : Function.Injective (vertexCoord (n := n)) := by |
| intro v w h |
| exact Prod.ext (congrFun h 0) (Prod.ext (congrFun h 1) (congrFun h 2)) |
|
|
| lemma faceBase_injective {f g : Face n} (hp : facePlane f = facePlane g) |
| (h : faceBase f = faceBase g) : f = g := |
| faceCorner_injective hp 0 (vertexCoord_injective h) |
|
|
| lemma two_axes_plane : ∀ p q a b : Fin 3, a ≠ b → |
| planeAxis p a → planeAxis p b → planeAxis q a → planeAxis q b → p = q := by |
| unfold planeAxis |
| decide |
|
|
| lemma plane_axis_exhaust : ∀ p a b c : Fin 3, a ≠ b → planeAxis p a → planeAxis p b → |
| c = a ∨ c = b ∨ ¬ planeAxis p c := by |
| unfold planeAxis |
| decide |
|
|
| lemma side_axis_in_plane (f : Face n) (i : Fin 4) : |
| planeAxis (facePlane f) (edgeAxis (faceSide f i)) := ⟨i,(faceSide_axis f i).symm⟩ |
|
|
| lemma faceBase_on_axis (f : Face n) (i : Fin 4) : |
| faceBase f (edgeAxis (faceSide f i)) = |
| vertexCoord (tail (faceSide f i)) (edgeAxis (faceSide f i)) := by |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> fin_cases i <;> rfl |
|
|
| lemma faceBase_outside (f : Face n) (i : Fin 4) (a : Fin 3) |
| (ha : ¬ planeAxis (facePlane f) a) : |
| faceBase f a = vertexCoord (tail (faceSide f i)) a := by |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> fin_cases a |
| all_goals first |
| | exact (ha ⟨0,rfl⟩).elim |
| | exact (ha ⟨1,rfl⟩).elim |
| | (fin_cases i <;> rfl) |
|
|
| lemma common_face_unique (e e' : Edge n) (hne : edgeAxis e ≠ edgeAxis e') |
| {f g : Face n} (hf : cycle f e ≠ 0) (hf' : cycle f e' ≠ 0) |
| (hg : cycle g e ≠ 0) (hg' : cycle g e' ≠ 0) : f = g := by |
| obtain ⟨i,hi⟩ := support_cycle f e hf |
| obtain ⟨j,hj⟩ := support_cycle f e' hf' |
| obtain ⟨k,hk⟩ := support_cycle g e hg |
| obtain ⟨l,hl⟩ := support_cycle g e' hg' |
| have ha : planeAxis (facePlane f) (edgeAxis e) := hi ▸ side_axis_in_plane f i |
| have hb : planeAxis (facePlane f) (edgeAxis e') := hj ▸ side_axis_in_plane f j |
| have hc : planeAxis (facePlane g) (edgeAxis e) := hk ▸ side_axis_in_plane g k |
| have hd : planeAxis (facePlane g) (edgeAxis e') := hl ▸ side_axis_in_plane g l |
| have hp := two_axes_plane _ _ _ _ hne ha hb hc hd |
| apply faceBase_injective hp |
| funext a |
| rcases plane_axis_exhaust _ _ _ a hne ha hb with rfl|rfl|h |
| · calc |
| faceBase f (edgeAxis e) = vertexCoord (tail e) (edgeAxis e) := by |
| simpa only [hi] using faceBase_on_axis f i |
| _ = faceBase g (edgeAxis e) := by simpa only [hk] using (faceBase_on_axis g k).symm |
| · calc |
| faceBase f (edgeAxis e') = vertexCoord (tail e') (edgeAxis e') := by |
| simpa only [hj] using faceBase_on_axis f j |
| _ = faceBase g (edgeAxis e') := by simpa only [hl] using (faceBase_on_axis g l).symm |
| · calc |
| faceBase f a = vertexCoord (tail e) a := by simpa only [hi] using faceBase_outside f i a h |
| _ = faceBase g a := by simpa only [hk] using (faceBase_outside g k a (hp ▸ h)).symm |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical Support |
|
|
| variable {n : ℕ} {b : Vertex n → Scalar} |
|
|
| @[simp] lemma castSucc_ne_succ_self (i : Fin n) : i.castSucc ≠ i.succ := by |
| intro h |
| have hh := congrArg Fin.val h |
| simp only [Fin.val_castSucc,Fin.val_succ] at hh |
| omega |
|
|
| @[simp] lemma succ_ne_castSucc_self (i : Fin n) : i.succ ≠ i.castSucc := |
| (castSucc_ne_succ_self i).symm |
|
|
| lemma cycle_faceSide (f : Face n) (i : Fin 4) : cycle f (faceSide f i) ≠ 0 := by |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> fin_cases i |
| all_goals simp [cycle,faceSide,ex,ey,ez] |
|
|
| lemma faceSide_injective_index (f : Face n) : Function.Injective (faceSide f) := by |
| intro i j |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> fin_cases i <;> fin_cases j |
| all_goals simp [faceSide,ex,ey,ez] |
|
|
| def AdjacentIndex (i j : Fin 4) : Prop := j = i+1 ∨ i = j+1 |
|
|
| lemma adjacent_axis_ne (f : Face n) (i j : Fin 4) (h : AdjacentIndex i j) : |
| edgeAxis (faceSide f i) ≠ edgeAxis (faceSide f j) := by |
| rw [faceSide_axis,faceSide_axis] |
| generalize facePlane f = p |
| revert h |
| unfold AdjacentIndex |
| fin_cases p <;> decide +revert |
|
|
| lemma adjacent_common_vertex (f : Face n) (i j : Fin 4) (h : AdjacentIndex i j) : |
| ∃ v, incident v (faceSide f i) ∧ incident v (faceSide f j) := by |
| rcases h with rfl | rfl |
| · refine ⟨faceCorner f (i+1),?_,?_⟩ |
| all_goals |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> fin_cases i |
| all_goals first | exact Or.inl rfl | exact Or.inr rfl |
| · refine ⟨faceCorner f (j+1),?_,?_⟩ |
| all_goals |
| rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> fin_cases j |
| all_goals first | exact Or.inl rfl | exact Or.inr rfl |
|
|
| def SideAdjacent (f : Face n) (i j : Fin 4) |
| (s : LocalGroup (faceSide f i)) (t : LocalGroup (faceSide f j)) : Prop := |
| ∃ v, ∃ hi : incident v (faceSide f i), ∃ hj : incident v (faceSide f j), |
| ∃ c : Configuration b v, c.state ⟨faceSide f i,hi⟩ = s ∧ c.state ⟨faceSide f j,hj⟩ = t |
|
|
| lemma sideAdjacent_iff (hn : 1 ≤ n) (f : Face n) (i j : Fin 4) (h : AdjacentIndex i j) |
| (s : LocalGroup (faceSide f i)) (t : LocalGroup (faceSide f j)) : |
| SideAdjacent (b := b) f i j s t ↔ |
| s.face ⟨f,cycle_faceSide f i⟩ = t.face ⟨f,cycle_faceSide f j⟩ := by |
| constructor |
| · rintro ⟨v,hi,hj,c,he,he'⟩ |
| simpa only [he,he'] using c.compatible ⟨_,hi⟩ ⟨_,hj⟩ f (cycle_faceSide f i) (cycle_faceSide f j) |
| · intro hs |
| obtain ⟨v,hi,hj⟩ := adjacent_common_vertex f i j h |
| have he : (⟨faceSide f i,hi⟩ : IncidentEdges v) ≠ ⟨faceSide f j,hj⟩ := by |
| intro hh |
| exact adjacent_axis_ne f i j h (congrArg (edgeAxis ∘ Subtype.val) hh) |
| obtain ⟨c,hc,hc'⟩ := exists_configuration_two (b := b) hn ⟨_,hi⟩ ⟨_,hj⟩ he s t (by |
| intro g hgi hgj |
| have hg := common_face_unique _ _ (adjacent_axis_ne f i j h) |
| (cycle_faceSide f i) (cycle_faceSide f j) hgi hgj |
| subst g |
| exact hs) |
| exact ⟨v,hi,hj,c,hc,hc'⟩ |
|
|
| def SideMatch (f : Face n) (i j : Fin 4) |
| (s : LocalGroup (faceSide f i)) (t : LocalGroup (faceSide f j)) : Prop := |
| if AdjacentIndex i j then SideAdjacent (b := b) f i j s t else |
| ∃ q : LocalGroup (faceSide f (i+1)), |
| SideAdjacent (b := b) f i (i+1) s q ∧ SideAdjacent (b := b) f j (i+1) t q |
|
|
| lemma index_next_adjacent (i : Fin 4) : AdjacentIndex i (i+1) := Or.inl rfl |
|
|
| lemma nonadjacent_next (i j : Fin 4) (h : ¬ AdjacentIndex i j) : AdjacentIndex j (i+1) := by |
| revert i j |
| unfold AdjacentIndex |
| decide |
|
|
| lemma sideMatch_iff (hn : 1 ≤ n) (f : Face n) (i j : Fin 4) |
| (s : LocalGroup (faceSide f i)) (t : LocalGroup (faceSide f j)) : |
| SideMatch (b := b) f i j s t ↔ |
| s.face ⟨f,cycle_faceSide f i⟩ = t.face ⟨f,cycle_faceSide f j⟩ := by |
| unfold SideMatch |
| split_ifs with h |
| · exact sideAdjacent_iff hn f i j h s t |
| · simp only [sideAdjacent_iff hn f i (i+1) (index_next_adjacent i), |
| sideAdjacent_iff hn f j (i+1) (nonadjacent_next i j h)] |
| constructor |
| · rintro ⟨q,hs,ht⟩ |
| exact hs.trans ht.symm |
| · intro he |
| refine ⟨⟨fun _ => s.face ⟨f,cycle_faceSide f i⟩,0⟩,rfl,he.symm⟩ |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical Support WitnessedChoice |
|
|
| variable {n : ℕ} {b : Vertex n → Scalar} |
|
|
| def actionPerm (g : BoxGroup n) : Equiv.Perm (Atom b) := MulAction.toPerm g |
|
|
| @[simp] lemma actionPerm_apply (g : BoxGroup n) (a : Atom b) : actionPerm g a = g • a := rfl |
|
|
| lemma actionPerm_fullAut (g : BoxGroup n) : actionPerm (b := b) g ∈ fullAut (atomInput b) := by |
| intro r x y |
| exact congrArg (fun p => @decide p (Classical.propDecidable p)) |
| (propext (AtomRelation.map_iff g r x y)) |
|
|
| def edgeFootprint (F : Finset (Face n)) : Finset (Edge n) := |
| F.biUnion fun f => Finset.univ.image (faceSide f) |
|
|
| def vertexFootprint (F : Finset (Face n)) : Finset (Vertex n) := |
| F.biUnion fun f => Finset.univ.image (faceCorner f) |
|
|
| lemma edgeFootprint_card (F : Finset (Face n)) : (edgeFootprint F).card ≤ 4*F.card := by |
| calc |
| _ ≤ ∑ f ∈ F, (Finset.univ.image (faceSide f)).card := Finset.card_biUnion_le |
| _ ≤ ∑ _ ∈ F, 4 := Finset.sum_le_sum fun f _ => (Finset.card_image_le).trans (by simp) |
| _ = _ := by simp [Nat.mul_comm] |
|
|
| lemma vertexFootprint_card (F : Finset (Face n)) : (vertexFootprint F).card ≤ 4*F.card := by |
| calc |
| _ ≤ ∑ f ∈ F, (Finset.univ.image (faceCorner f)).card := Finset.card_biUnion_le |
| _ ≤ ∑ _ ∈ F, 4 := Finset.sum_le_sum fun f _ => (Finset.card_image_le).trans (by simp) |
| _ = _ := by simp [Nat.mul_comm] |
|
|
| lemma mem_edgeFootprint {F : Finset (Face n)} {f : Face n} (hf : f ∈ F) |
| {e : Edge n} (he : cycle f e ≠ 0) : e ∈ edgeFootprint F := by |
| obtain ⟨i,hi⟩ := support_cycle f e he |
| exact Finset.mem_biUnion.mpr ⟨f,hf,Finset.mem_image.mpr ⟨i,Finset.mem_univ _,hi⟩⟩ |
|
|
| lemma mem_vertexFootprint {F : Finset (Face n)} {f : Face n} (hf : f ∈ F) |
| {v : Vertex n} (e : IncidentEdges v) (he : cycle f e.val ≠ 0) : v ∈ vertexFootprint F := by |
| obtain ⟨i,hi⟩ := support_cycle f e.val he |
| obtain ⟨j,hj⟩ := faceSide_endpoints f i v (hi ▸ e.property) |
| exact Finset.mem_biUnion.mpr ⟨f,hf,Finset.mem_image.mpr ⟨j,Finset.mem_univ _,hj⟩⟩ |
|
|
| def edgeBlockSet (b : Vertex n → Scalar) (e : Edge n) : Finset (Atom b) := |
| Finset.univ.image (fun s : LocalGroup e => .inl ⟨e,s⟩) |
|
|
| def vertexBlockSet (b : Vertex n → Scalar) (v : Vertex n) : Finset (Atom b) := |
| Finset.univ.image (fun s : Configuration b v => .inr ⟨v,s⟩) |
|
|
| def affectedAtoms (b : Vertex n → Scalar) (E : Finset (Edge n)) (V : Finset (Vertex n)) : Finset (Atom b) := |
| (E.biUnion (edgeBlockSet b)) ∪ (V.biUnion (vertexBlockSet b)) |
|
|
| lemma affectedAtoms_card_le (hn : 1 ≤ n) (E : Finset (Edge n)) (V : Finset (Vertex n)) : |
| (affectedAtoms b E V).card ≤ E.card*3^9 + V.card*3^29 := by |
| apply (Finset.card_union_le _ _).trans |
| apply Nat.add_le_add |
| · calc |
| _ ≤ ∑ e ∈ E, (edgeBlockSet b e).card := Finset.card_biUnion_le |
| _ ≤ ∑ _ ∈ E, 3^9 := Finset.sum_le_sum fun e _ => |
| Finset.card_image_le.trans (by simpa using localGroup_card_le_upper e) |
| _ = _ := by simp |
| · calc |
| _ ≤ ∑ v ∈ V, (vertexBlockSet b v).card := Finset.card_biUnion_le |
| _ ≤ ∑ _ ∈ V, 3^29 := Finset.sum_le_sum fun v _ => |
| Finset.card_image_le.trans (by simpa using configuration_card_le_upper hn b v) |
| _ = _ := by simp |
|
|
| lemma faceTranslation_moved_subset (a : Face n → Plane) (F : Finset (Face n)) |
| (ha : ∀ f, a f ≠ 0 → f ∈ F) : |
| (Finset.univ.filter fun x : Atom b => actionPerm (⟨a,0⟩ : BoxGroup n) x ≠ x) ⊆ |
| affectedAtoms b (edgeFootprint F) (vertexFootprint F) := by |
| intro x hx |
| have hmove := (Finset.mem_filter.mp hx).2 |
| rcases x with ⟨e,s⟩ | ⟨v,s⟩ |
| · have he : e ∈ edgeFootprint F := by |
| by_contra hn |
| have hr : restrictGroup e (⟨a,0⟩ : BoxGroup n) = 1 := by |
| apply Support.H.ext |
| · funext f |
| by_contra h |
| exact hn (mem_edgeFootprint (ha f.val h) f.property) |
| · rfl |
| apply hmove |
| change (Sum.inl ⟨e,restrictGroup e (⟨a,0⟩ : BoxGroup n) * s⟩ : Atom b) = _ |
| simp only [hr,one_mul] |
| exact Finset.mem_union_left _ (Finset.mem_biUnion.mpr |
| ⟨e,he,Finset.mem_image.mpr ⟨s,Finset.mem_univ _,rfl⟩⟩) |
| · have hv : v ∈ vertexFootprint F := by |
| by_contra hn |
| have hr (e : IncidentEdges v) : restrictGroup e.val (⟨a,0⟩ : BoxGroup n) = 1 := by |
| apply Support.H.ext |
| · funext f |
| by_contra h |
| exact hn (mem_vertexFootprint (ha f.val h) e f.property) |
| · rfl |
| apply hmove |
| change (Sum.inr ⟨v,actConfiguration (⟨a,0⟩ : BoxGroup n) s⟩ : Atom b) = _ |
| congr 1 |
| congr 1 |
| apply Configuration.ext |
| intro e |
| change restrictGroup e.val (⟨a,0⟩ : BoxGroup n) * s.state e = s.state e |
| rw [hr e,one_mul] |
| exact Finset.mem_union_right _ (Finset.mem_biUnion.mpr |
| ⟨v,hv,Finset.mem_image.mpr ⟨s,Finset.mem_univ _,rfl⟩⟩) |
|
|
| lemma faceTranslation_in_localPool_bound (B : ℕ) (hB : 16*(3^9+3^29) ≤ B) (hn : 1 ≤ n) (a : Face n → Plane) |
| (F : Finset (Face n)) (hF : F.card ≤ 4) (ha : ∀ f, a f ≠ 0 → f ∈ F) : |
| RelationPools.graph (actionPerm (b := b) (⟨a,0⟩ : BoxGroup n)) ∈ |
| RelationPools.localPool B := by |
| apply RelationPools.localPool_contains |
| calc |
| _ ≤ (affectedAtoms b (edgeFootprint F) (vertexFootprint F)).card := |
| Finset.card_le_card (faceTranslation_moved_subset a F ha) |
| _ ≤ (edgeFootprint F).card*3^9 + (vertexFootprint F).card*3^29 := affectedAtoms_card_le hn _ _ |
| _ ≤ 16*3^9 + 16*3^29 := Nat.add_le_add |
| (Nat.mul_le_mul_right _ ((edgeFootprint_card F).trans (by omega))) |
| (Nat.mul_le_mul_right _ ((vertexFootprint_card F).trans (by omega))) |
| _ = 16*(3^9+3^29) := by rw [Nat.mul_add] |
| _ ≤ B := hB |
|
|
| lemma faceTranslation_in_localPool (hn : 1 ≤ n) (a : Face n → Plane) |
| (F : Finset (Face n)) (hF : F.card ≤ 4) (ha : ∀ f, a f ≠ 0 → f ∈ F) : |
| RelationPools.graph (actionPerm (b := b) (⟨a,0⟩ : BoxGroup n)) ∈ |
| RelationPools.localPool RelationPools.localBound := |
| faceTranslation_in_localPool_bound RelationPools.localBound (by rw [RelationPools.localBound]) hn a F hF ha |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical Support WitnessedChoice |
|
|
| variable {n : ℕ} {b : Vertex n → Scalar} |
|
|
| def AcceptsFaces (x : Finset (Σ e : Edge n, LocalGroup e)) (e : Edge n) (s : LocalGroup e) : Prop := |
| ∀ t ∈ x, ∀ f : Face n, ∀ he : cycle f e ≠ 0, ∀ ht : cycle f t.1 ≠ 0, |
| s.face ⟨f,he⟩ = t.2.face ⟨f,ht⟩ |
|
|
| def faceDelta (e : Edge n) (s t : LocalGroup e) (f : Face n) : Plane := |
| if h : cycle f e ≠ 0 then t.face ⟨f,h⟩ - s.face ⟨f,h⟩ else 0 |
|
|
| lemma faceDelta_support (e : Edge n) (s t : LocalGroup e) : |
| ∀ f, faceDelta e s t f ≠ 0 → f ∈ Finset.univ.filter (fun f => cycle f e ≠ 0) := by |
| intro f hf |
| simpa only [Finset.mem_filter,Finset.mem_univ,true_and] using |
| (show cycle f e ≠ 0 from fun h => hf (by simp [faceDelta,h])) |
|
|
| lemma faceDelta_zero_on_past {x : Finset (Σ e : Edge n, LocalGroup e)} |
| {e : Edge n} {s t : LocalGroup e} (hs : AcceptsFaces x e s) (ht : AcceptsFaces x e t) |
| {r : Σ e : Edge n, LocalGroup e} (hr : r ∈ x) (f : EdgeFaces r.1) : |
| faceDelta e s t f.val = 0 := by |
| by_cases he : cycle f.val e ≠ 0 |
| · rw [faceDelta,dite_eq_left he,ht r hr f.val he f.property,hs r hr f.val he f.property,sub_self] |
| · simp only [faceDelta,dite_eq_right he] |
|
|
| lemma faceDelta_fix_past {x : Finset (Σ e : Edge n, LocalGroup e)} |
| {e : Edge n} {s t : LocalGroup e} (hs : AcceptsFaces x e s) (ht : AcceptsFaces x e t) |
| {r : Σ e : Edge n, LocalGroup e} (hr : r ∈ x) : |
| actionPerm (b := b) (⟨faceDelta e s t,0⟩ : BoxGroup n) (.inl r) = .inl r := by |
| have hg : restrictGroup r.1 (⟨faceDelta e s t,0⟩ : BoxGroup n) = 1 := by |
| apply Support.H.ext |
| · funext f |
| exact faceDelta_zero_on_past hs ht hr f |
| · rfl |
| change (Sum.inl ⟨r.1,restrictGroup r.1 (⟨faceDelta e s t,0⟩ : BoxGroup n) * r.2⟩ : Atom b) = _ |
| rw [hg,one_mul] |
|
|
| lemma faceDelta_hits_vectors (e : Edge n) (s t : LocalGroup e) : |
| (restrictGroup e (⟨faceDelta e s t,0⟩ : BoxGroup n) * s).face = t.face := by |
| funext f |
| change faceDelta e s t f.val + s.face f = t.face f |
| rw [faceDelta,dite_eq_left f.property,sub_add_cancel] |
|
|
| lemma faceDelta_in_localPool (hn : 1 ≤ n) (e : Edge n) (s t : LocalGroup e) : |
| RelationPools.graph (actionPerm (b := b) (⟨faceDelta e s t,0⟩ : BoxGroup n)) ∈ |
| RelationPools.localPool RelationPools.localBound := by |
| have hF : (Finset.univ.filter (fun f => cycle f e ≠ 0)).card ≤ 4 := by |
| simpa only [← Fintype.card_subtype] using edgeFaces_card_le_four e |
| exact faceTranslation_in_localPool hn _ _ hF (faceDelta_support e s t) |
|
|
| lemma central_after_local (e : Edge n) (s t : LocalGroup e) (k : FlowSpace n) |
| (hk : k.val e = t.flow - (restrictGroup e (⟨faceDelta e s t,0⟩ : BoxGroup n) * s).flow) : |
| actionPerm (b := b) (⟨0,k⟩ : BoxGroup n) |
| (actionPerm (⟨faceDelta e s t,0⟩ : BoxGroup n) (.inl ⟨e,s⟩)) = .inl ⟨e,t⟩ := by |
| change (Sum.inl ⟨e, restrictGroup e (⟨0,k⟩ : BoxGroup n) * |
| (restrictGroup e (⟨faceDelta e s t,0⟩ : BoxGroup n) * s)⟩ : Atom b) = _ |
| congr 1 |
| congr 1 |
| apply Support.H.ext |
| · funext f |
| change 0 + (faceDelta e s t f.val + s.face f) = t.face f |
| rw [zero_add] |
| exact congrFun (faceDelta_hits_vectors e s t) f |
| · change k.val e + (restrictGroup e (⟨faceDelta e s t,0⟩ : BoxGroup n) * s).flow + |
| correction (localCycle e) 0 (restrictGroup e (⟨faceDelta e s t,0⟩ : BoxGroup n) * s).face = t.flow |
| rw [correction_zero_left,add_zero,hk,sub_add_cancel] |
|
|
| lemma central_fix_edge (k : FlowSpace n) (e : Edge n) (s : LocalGroup e) (hk : k.val e = 0) : |
| actionPerm (b := b) (⟨0,k⟩ : BoxGroup n) (.inl ⟨e,s⟩) = .inl ⟨e,s⟩ := by |
| have hh : restrictGroup e (⟨0,k⟩ : BoxGroup n) = 1 := by |
| apply Support.H.ext |
| · rfl |
| · exact hk |
| change (Sum.inl ⟨e,restrictGroup e (⟨0,k⟩ : BoxGroup n) * s⟩ : Atom b) = _ |
| rw [hh,one_mul] |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical SimpleGraph |
|
|
| variable {n : ℕ} |
|
|
| lemma path_walk_lower {u v : Fin (n+1)} (w : (pathGraph (n+1)).Walk u v) : |
| Nat.dist u.val v.val ≤ w.length := by |
| induction w with |
| | nil => simp |
| | @cons a b c hab w ih => |
| have ha := pathGraph_adj.mp hab |
| simp only [Walk.length_cons] |
| simp only [Nat.dist] at ih ⊢ |
| omega |
|
|
| lemma path_walk_upper_le (k : ℕ) : ∀ u v : Fin (n+1), u.val ≤ v.val → v.val-u.val = k → |
| ∃ w : (pathGraph (n+1)).Walk u v, w.length = k := by |
| induction k with |
| | zero => |
| intro u v huv he |
| have h : u = v := Fin.ext (by omega) |
| subst v |
| exact ⟨.nil,rfl⟩ |
| | succ k ih => |
| intro u v huv he |
| let u' : Fin (n+1) := ⟨u.val+1,by omega⟩ |
| have hadj : (pathGraph (n+1)).Adj u u' := pathGraph_adj.mpr (Or.inl rfl) |
| obtain ⟨w,hw⟩ := ih u' v (by dsimp [u']; omega) (by dsimp [u']; omega) |
| exact ⟨.cons hadj w,by simp only [Walk.length_cons,hw]⟩ |
|
|
| lemma path_dist (u v : Fin (n+1)) : (pathGraph (n+1)).dist u v = Nat.dist u.val v.val := by |
| apply Nat.le_antisymm |
| · by_cases h : u.val ≤ v.val |
| · obtain ⟨w,hw⟩ := path_walk_upper_le (v.val-u.val) u v h rfl |
| rw [Nat.dist_eq_sub_of_le h,← hw] |
| exact dist_le w |
| · have h' : v.val ≤ u.val := by omega |
| obtain ⟨w,hw⟩ := path_walk_upper_le (u.val-v.val) v u h' rfl |
| rw [Nat.dist_eq_sub_of_le_right h',← hw,← w.length_reverse] |
| exact dist_le w.reverse |
| · obtain ⟨w,hw⟩ := ((pathGraph_connected n).preconnected u v).exists_walk_length_eq_dist |
| rw [← hw] |
| exact path_walk_lower w |
|
|
| lemma path_edist (u v : Fin (n+1)) : (pathGraph (n+1)).edist u v = (Nat.dist u.val v.val : ℕ∞) := by |
| rw [← ((pathGraph_connected n).preconnected u v).coe_dist_eq_edist,path_dist] |
|
|
| def boxGraph (n : ℕ) : SimpleGraph (Vertex n) := |
| (pathGraph (n+1)).boxProd ((pathGraph (n+1)).boxProd (pathGraph (n+1))) |
|
|
| lemma boxGraph_connected (n : ℕ) : (boxGraph n).Connected := by |
| simp only [boxGraph,connected_boxProd,pathGraph_connected,and_self] |
|
|
| lemma boxGraph_dist (u v : Vertex n) : (boxGraph n).dist u v = |
| Nat.dist u.1.val v.1.val + (Nat.dist u.2.1.val v.2.1.val + Nat.dist u.2.2.val v.2.2.val) := by |
| have h := ((boxGraph_connected n).preconnected u v).coe_dist_eq_edist |
| simp only [boxGraph,edist_boxProd,path_edist,← Nat.cast_add] at h |
| exact_mod_cast h |
|
|
| lemma boxGraph_tail_head (e : Edge n) : (boxGraph n).Adj (tail e) (head e) := by |
| rcases e with ⟨i,j,k⟩ | (⟨i,j,k⟩ | ⟨i,j,k⟩) |
| all_goals simp [boxGraph,boxProd_adj,pathGraph_adj,tail,head] |
|
|
| lemma boxGraph_adj_iff (u v : Vertex n) : (boxGraph n).Adj u v ↔ |
| ∃ e : Edge n, (u = tail e ∧ v = head e) ∨ (v = tail e ∧ u = head e) := by |
| constructor |
| · intro h |
| rcases u with ⟨i,j,k⟩ |
| rcases v with ⟨i',j',k'⟩ |
| simp only [boxGraph,boxProd_adj,pathGraph_adj,Prod.mk.injEq] at h |
| rcases h with ⟨h,he⟩ | ⟨h,hi⟩ |
| · rcases he with ⟨rfl,rfl⟩ |
| rcases h with h | h |
| · refine ⟨ex ⟨i.val,by omega⟩ j k,Or.inl ⟨?_,?_⟩⟩ |
| · rfl |
| · apply Prod.ext |
| · apply Fin.ext; exact h.symm |
| · rfl |
| · refine ⟨ex ⟨i'.val,by omega⟩ j k,Or.inr ⟨?_,?_⟩⟩ |
| · rfl |
| · apply Prod.ext |
| · apply Fin.ext; exact h.symm |
| · rfl |
| · subst i' |
| rcases h with ⟨h,hk⟩ | ⟨h,hj⟩ |
| · subst k' |
| rcases h with h | h |
| · refine ⟨ey i ⟨j.val,by omega⟩ k,Or.inl ⟨?_,?_⟩⟩ |
| · rfl |
| · simp only [ey,head,Prod.mk.injEq,true_and,and_true] |
| exact Fin.ext h.symm |
| · refine ⟨ey i ⟨j'.val,by omega⟩ k,Or.inr ⟨?_,?_⟩⟩ |
| · rfl |
| · simp only [ey,head,Prod.mk.injEq,true_and,and_true] |
| exact Fin.ext h.symm |
| · subst j' |
| rcases h with h | h |
| · refine ⟨ez i j ⟨k.val,by omega⟩,Or.inl ⟨?_,?_⟩⟩ |
| · rfl |
| · simp only [ez,head,Prod.mk.injEq,true_and] |
| exact Fin.ext h.symm |
| · refine ⟨ez i j ⟨k'.val,by omega⟩,Or.inr ⟨?_,?_⟩⟩ |
| · rfl |
| · simp only [ez,head,Prod.mk.injEq,true_and] |
| exact Fin.ext h.symm |
| · rintro ⟨e,(⟨rfl,rfl⟩ | ⟨rfl,rfl⟩)⟩ |
| · exact boxGraph_tail_head e |
| · exact (boxGraph_tail_head e).symm |
|
|
| def cornerAnchors (n : ℕ) : Fin 4 → Vertex n := |
| ![(0,0,0),(Fin.last n,0,0),(0,Fin.last n,0),(0,0,Fin.last n)] |
|
|
| lemma cornerAnchors_resolve (u v : Vertex n) |
| (h : ∀ i : Fin 4, (boxGraph n).dist (cornerAnchors n i) u = |
| (boxGraph n).dist (cornerAnchors n i) v) : u = v := by |
| have h0 := h 0 |
| have h1 := h 1 |
| have h2 := h 2 |
| have h3 := h 3 |
| simp only [boxGraph_dist] at h0 h1 h2 h3 |
| simp only [cornerAnchors, Matrix.cons_val_zero, Matrix.cons_val_one, Matrix.cons_val_two, |
| Matrix.cons_val_three, Matrix.head_cons, Matrix.tail_cons, Fin.val_zero, Fin.val_last, |
| Nat.dist_zero_left] at h0 h1 h2 h3 |
| simp only [Nat.dist_eq_sub_of_le_right (Nat.le_of_lt_succ u.1.isLt), |
| Nat.dist_eq_sub_of_le_right (Nat.le_of_lt_succ u.2.1.isLt), |
| Nat.dist_eq_sub_of_le_right (Nat.le_of_lt_succ u.2.2.isLt), |
| Nat.dist_eq_sub_of_le_right (Nat.le_of_lt_succ v.1.isLt), |
| Nat.dist_eq_sub_of_le_right (Nat.le_of_lt_succ v.2.1.isLt), |
| Nat.dist_eq_sub_of_le_right (Nat.le_of_lt_succ v.2.2.isLt)] at h1 h2 h3 |
| apply Prod.ext |
| · apply Fin.ext; omega |
| · apply Prod.ext |
| · apply Fin.ext; omega |
| · apply Fin.ext; omega |
|
|
| end |
|
|
| end WitnessedSeparation.Grid |
|
|
| end OAI |
|
|
