| import OAI.Computability.WitnessedChoice.CycleTranslation | |
| namespace OAI | |
| namespace WitnessedSeparation.Grid | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary RelationPools | |
| variable {n : ℕ} {b : Vertex n → Scalar} | |
| def edgeActionRelation (g : BoxGroup n) : Relation (Atom b) := | |
| Finset.univ.image fun r : Σ e : Edge n, LocalGroup e => | |
| ((Sum.inl r : Atom b),actionPerm g (.inl r)) | |
| lemma mem_edgeActionRelation (g : BoxGroup n) (a c : Atom b) : | |
| (a,c) ∈ edgeActionRelation g ↔ | |
| ∃ (e : Edge n) (s : LocalGroup e), a = .inl ⟨e,s⟩ ∧ c = .inl ⟨e,restrictGroup e g*s⟩ := by | |
| simp only [edgeActionRelation,Finset.mem_image,Finset.mem_univ,true_and] | |
| constructor | |
| · rintro ⟨⟨e,s⟩,h⟩ | |
| cases h | |
| exact ⟨e,s,rfl,rfl⟩ | |
| · rintro ⟨e,s,rfl,rfl⟩ | |
| exact ⟨⟨e,s⟩,rfl⟩ | |
| namespace QuotedGrid | |
| open QuotedTerm QuotedFormula SourceSyntax | |
| variable {k : ℕ} {T : RootedTree (Vertex n)} | |
| lemma meaning_cycleY_move (env : Fin k → HF (Atom b)) (F R Γ ot ht st tt : QuotedTerm k) | |
| (P : ParentEdges T) (e : Edge n) (he : e ∉ P.treeEdges) (h : Edge n) (s t : LocalGroup h) | |
| (hF : ∀ z, z ∈ elements (F.meaning (atomInput b) env) ↔ ∃ C : CycleFrame n, frameCode b C = z) | |
| (hR : R.meaning (atomInput b) env = distancesCode b (boxGraph n)) | |
| (hΓ : Γ.meaning (atomInput b) env = traversalCode b P.treeEdges e (tail e) (head e)) | |
| (ho : ot.meaning (atomInput b) env = vertexCode b originVertex) | |
| (hh : ht.meaning (atomInput b) env = edgeCode b h) | |
| (hs : st.meaning (atomInput b) env = atom (.inl ⟨h,s⟩)) | |
| (ht' : tt.meaning (atomInput b) env = atom (.inl ⟨h,t⟩)) (hn : 1 ≤ n) : | |
| (((traversalEdge Γ ht).neg.and (eq st tt)).or | |
| ((traversalEdge Γ ht).and ((baseEq F ht st tt).and (directedZ R Γ ot ht st tt)))).meaning (atomInput b) env ↔ | |
| t = restrictGroup h (⟨0,P.flow e 1⟩ : BoxGroup n)*s := by | |
| rw [meaning_or,meaning_and,meaning_neg,meaning_and,meaning_and, | |
| meaning_traversalEdge env Γ ht P.treeEdges e (tail e) (head e) h hΓ hh, | |
| P.traverses_iff_nonzero e he h, | |
| meaning_baseEq env F ht st tt h s t hF hh hs ht' hn, | |
| meaning_directedZ env R Γ ot ht st tt P.treeEdges e (tail e) (head e) originVertex h s t | |
| hR hΓ ho hh hs ht' hn, | |
| P.directed_flow_iff e he h (s⁻¹*t).flow,meaning_eq,hs,ht'] | |
| have ha : atom (Sum.inl ⟨h,s⟩ : Atom b) = atom (.inl ⟨h,t⟩) ↔ s=t := by | |
| simp only [atom_injective.eq_iff,Sum.inl.injEq,Sigma.mk.inj_iff,heq_eq_eq,true_and] | |
| rw [ha] | |
| change _ ↔ t = (⟨0,(P.flow e 1).val h⟩ : LocalGroup h)*s | |
| rw [local_central_iff] | |
| by_cases hz : (P.flow e 1).val h = 0 | |
| · simp only [hz,not_false_eq_true,true_and,ne_eq,not_true_eq_false,false_and,or_false] | |
| constructor | |
| · rintro rfl | |
| simp | |
| · rintro ⟨hf,htf⟩ | |
| have hh := (local_central_iff h s t 0).mpr ⟨hf,htf⟩ | |
| simpa only [show (⟨0,0⟩ : LocalGroup h)=1 from rfl,one_mul] using hh.symm | |
| · tauto | |
| lemma exists_edgeCode (Q : HF (Atom b) → Prop) : | |
| (∃ z ∈ elements (ofFinset (Finset.univ.image (edgeCode b))), Q z) ↔ | |
| ∃ e : Edge n, Q (edgeCode b e) := by | |
| simp only [elements_ofFinset,Finset.mem_image,Finset.mem_univ,true_and] | |
| constructor | |
| · rintro ⟨z,⟨e,rfl⟩,h⟩ | |
| exact ⟨e,h⟩ | |
| · rintro ⟨e,h⟩ | |
| exact ⟨_,⟨e,rfl⟩,h⟩ | |
| lemma meaning_cycleY (env : Fin k → HF (Atom b)) (E F R Γ ot : QuotedTerm k) | |
| (P : ParentEdges T) (e : Edge n) (he : e ∉ P.treeEdges) | |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) | |
| (hF : ∀ z, z ∈ elements (F.meaning (atomInput b) env) ↔ ∃ C : CycleFrame n, frameCode b C = z) | |
| (hR : R.meaning (atomInput b) env = distancesCode b (boxGraph n)) | |
| (hΓ : Γ.meaning (atomInput b) env = traversalCode b P.treeEdges e (tail e) (head e)) | |
| (ho : ot.meaning (atomInput b) env = vertexCode b originVertex) (hn : 1 ≤ n) : | |
| (cycleY E F R Γ ot).meaning (atomInput b) env = | |
| relationCode (edgeActionRelation (b := b) (⟨0,P.flow e 1⟩ : BoxGroup n)) := by | |
| rw [cycleY,meaning_relation] | |
| apply congrArg relationCode | |
| ext ⟨a,c⟩ | |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and,meaning_existsIn,QuotedTerm.meaning_up, | |
| hE,exists_edgeCode, | |
| meaning_allList,List.mem_cons,List.mem_nil_iff,forall_eq_or_imp,forall_false,implies_true,and_true, | |
| meaning_mem,meaning_var,Fin.cons_zero,Fin.cons_one,fin_cons_two,mem_edgeCode_iff, | |
| mem_edgeActionRelation] | |
| constructor | |
| · rintro ⟨h,⟨s,hs⟩,⟨t,ht⟩,hm⟩ | |
| have hs' := atom_injective hs | |
| have ht' := atom_injective ht | |
| subst a | |
| subst c | |
| have hmove := (meaning_cycleY_move | |
| (Fin.cons (edgeCode b h) (Fin.cons (atom (.inl ⟨h,t⟩)) (Fin.cons (atom (.inl ⟨h,s⟩)) env))) | |
| F.up.up.up R.up.up.up Γ.up.up.up ot.up.up.up (var 0) (var 2) (var 1) | |
| P e he h s t hF hR hΓ ho rfl rfl rfl hn).mp hm | |
| exact ⟨h,s,rfl,congrArg (fun t : LocalGroup h => (Sum.inl ⟨h,t⟩ : Atom b)) hmove⟩ | |
| · rintro ⟨h,s,rfl,rfl⟩ | |
| refine ⟨h,⟨s,rfl⟩,⟨restrictGroup h (⟨0,P.flow e 1⟩ : BoxGroup n)*s,rfl⟩,?_⟩ | |
| exact (meaning_cycleY_move | |
| (Fin.cons (edgeCode b h) (Fin.cons (atom (.inl ⟨h,restrictGroup h (⟨0,P.flow e 1⟩ : BoxGroup n)*s⟩)) | |
| (Fin.cons (atom (.inl ⟨h,s⟩)) env))) | |
| F.up.up.up R.up.up.up Γ.up.up.up ot.up.up.up (var 0) (var 2) (var 1) | |
| P e he h s _ hF hR hΓ ho rfl rfl rfl hn).mpr rfl | |
| end QuotedGrid | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary RelationPools | |
| variable {n : ℕ} {b : Vertex n → Scalar} | |
| def configActionRelation (g : BoxGroup n) : Relation (Atom b) := | |
| Finset.univ.image fun r : Σ v : Vertex n, Configuration b v => | |
| ((Sum.inr r : Atom b),actionPerm g (.inr r)) | |
| lemma mem_configActionRelation (g : BoxGroup n) (a c : Atom b) : | |
| (a,c) ∈ configActionRelation g ↔ | |
| ∃ (v : Vertex n) (s : Configuration b v), a = .inr ⟨v,s⟩ ∧ c = .inr ⟨v,actConfiguration g s⟩ := by | |
| simp only [configActionRelation,Finset.mem_image,Finset.mem_univ,true_and] | |
| constructor | |
| · rintro ⟨⟨v,s⟩,h⟩ | |
| cases h | |
| exact ⟨v,s,rfl,rfl⟩ | |
| · rintro ⟨v,s,rfl,rfl⟩ | |
| exact ⟨⟨v,s⟩,rfl⟩ | |
| lemma edge_config_union (g : BoxGroup n) : | |
| edgeActionRelation (b := b) g ∪ configActionRelation g = graph (actionPerm g) := by | |
| ext ⟨a,c⟩ | |
| simp only [Finset.mem_union,mem_edgeActionRelation,mem_configActionRelation,mem_graph] | |
| cases a with | |
| | inl r => | |
| rcases r with ⟨e,s⟩ | |
| simp only [Sum.inl.injEq,Sum.inl_ne_inr,false_and,exists_false,or_false] | |
| constructor | |
| · rintro ⟨d,t,h,rfl⟩ | |
| cases h | |
| rfl | |
| · intro h | |
| exact ⟨e,s,rfl,h.symm⟩ | |
| | inr r => | |
| rcases r with ⟨v,s⟩ | |
| simp only [Sum.inr.injEq,Sum.inr_ne_inl,false_and,exists_false,false_or] | |
| constructor | |
| · rintro ⟨w,t,h,rfl⟩ | |
| cases h | |
| rfl | |
| · intro h | |
| exact ⟨v,s,rfl,h.symm⟩ | |
| namespace QuotedGrid | |
| open QuotedTerm QuotedFormula SourceSyntax | |
| variable {k : ℕ} | |
| lemma exists_vertexBlockCode (Q : HF (Atom b) → Prop) : | |
| (∃ z ∈ elements (ofFinset (Finset.univ.image (vertexCode b))), Q z) ↔ | |
| ∃ v : Vertex n, Q (vertexCode b v) := by | |
| simp only [elements_ofFinset,Finset.mem_image,Finset.mem_univ,true_and] | |
| constructor | |
| · rintro ⟨z,⟨v,rfl⟩,h⟩ | |
| exact ⟨v,h⟩ | |
| · rintro ⟨v,h⟩ | |
| exact ⟨_,⟨v,rfl⟩,h⟩ | |
| lemma all_edgeBlockCode (Q : HF (Atom b) → Prop) : | |
| (∀ z ∈ elements (ofFinset (Finset.univ.image (edgeCode b))), Q z) ↔ | |
| ∀ e : Edge n, Q (edgeCode b e) := by | |
| simp only [elements_ofFinset,Finset.mem_image,Finset.mem_univ,true_and] | |
| constructor | |
| · intro h e | |
| exact h _ ⟨e,rfl⟩ | |
| · rintro h z ⟨e,rfl⟩ | |
| exact h e | |
| lemma pair_atoms_relationCode (r : Relation (Atom b)) (a c : Atom b) : | |
| Hereditary.pair (atom a) (atom c) ∈ elements (relationCode r) ↔ (a,c) ∈ r := | |
| mem_elements_relationCode r a c | |
| lemma meaning_cycleX (env : Fin k → HF (Atom b)) (V E cY : QuotedTerm k) (g : BoxGroup n) | |
| (hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) | |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) | |
| (hY : cY.meaning (atomInput b) env = relationCode (edgeActionRelation g)) (hn : 1 ≤ n) : | |
| (cycleX V E cY).meaning (atomInput b) env = relationCode (configActionRelation g) := by | |
| rw [cycleX,meaning_relation] | |
| apply congrArg relationCode | |
| ext ⟨a,c⟩ | |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and,meaning_existsIn,QuotedTerm.meaning_up, | |
| hV,exists_vertexBlockCode,meaning_allList,List.mem_cons,List.mem_nil_iff,forall_eq_or_imp, | |
| forall_false,implies_true,and_true,meaning_mem,meaning_var,Fin.cons_zero,Fin.cons_one,fin_cons_two, | |
| mem_vertexCode_iff,mem_configActionRelation] | |
| constructor | |
| · rintro ⟨v,⟨s,hs⟩,⟨t,ht⟩,hm⟩ | |
| have hs' := atom_injective hs | |
| have ht' := atom_injective ht | |
| subst a | |
| subst c | |
| refine ⟨v,s,rfl,?_⟩ | |
| apply congrArg (fun t : Configuration b v => (Sum.inr ⟨v,t⟩ : Atom b)) | |
| apply Configuration.ext | |
| intro e | |
| simp only [meaning_allIn,QuotedTerm.meaning_up,hE,all_edgeBlockCode] at hm | |
| have hh := hm e.val | |
| rw [meaning_imp,meaning_incident _ _ _ v e.val rfl rfl hn] at hh | |
| have he := hh e.property | |
| simp only [meaning_existsIn,meaning_var,Fin.cons_zero,Fin.cons_one, | |
| WitnessedSeparation.Grid.exists_edgeCode,meaning_allList,List.mem_cons,List.mem_nil_iff, | |
| forall_eq_or_imp,forall_false,implies_true,and_true,meaning_input, | |
| fin_cons_two,fin_cons_three,fin_cons_four,fin_cons_five,Fin.cons_zero,QuotedTerm.meaning_up,input_inc_iff, | |
| meaning_link,hY,pair_atoms_relationCode] at he | |
| obtain ⟨r,q,⟨hr,hsr⟩,⟨hq,htq⟩,hrel⟩ := he | |
| rw [mem_edgeActionRelation] at hrel | |
| obtain ⟨d,u,hru,hqu⟩ := hrel | |
| have hru' := Sum.inl.inj hru | |
| cases hru' | |
| have heq := eq_of_heq (Sigma.mk.inj (Sum.inl.inj hqu)).2 | |
| change t.state e = restrictGroup e.val g*s.state e | |
| rw [hsr,htq,heq] | |
| · rintro ⟨v,s,rfl,rfl⟩ | |
| refine ⟨v,⟨s,rfl⟩,⟨actConfiguration g s,rfl⟩,?_⟩ | |
| simp only [meaning_allIn,QuotedTerm.meaning_up,hE,all_edgeBlockCode] | |
| intro e | |
| rw [meaning_imp,meaning_incident _ _ _ v e rfl rfl hn] | |
| intro he | |
| simp only [meaning_existsIn,meaning_var,Fin.cons_zero,Fin.cons_one, | |
| WitnessedSeparation.Grid.exists_edgeCode,meaning_allList,List.mem_cons,List.mem_nil_iff, | |
| forall_eq_or_imp,forall_false,implies_true,and_true,meaning_input, | |
| fin_cons_two,fin_cons_three,fin_cons_four,fin_cons_five,Fin.cons_zero,QuotedTerm.meaning_up,input_inc_iff, | |
| meaning_link,hY,pair_atoms_relationCode] | |
| exact ⟨s.state ⟨e,he⟩,restrictGroup e g*s.state ⟨e,he⟩, | |
| ⟨he,rfl⟩,⟨he,rfl⟩,(mem_edgeActionRelation _ _ _).mpr ⟨e,_,rfl,rfl⟩⟩ | |
| end QuotedGrid | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary | |
| variable {n : ℕ} | |
| def oppositeVertex : Vertex n := (Fin.last n,Fin.last n,Fin.last n) | |
| lemma dist_opposite_tail (h : Edge n) : | |
| (boxGraph n).dist oppositeVertex (tail h) = (boxGraph n).dist oppositeVertex (head h) + 1 := by | |
| rcases h with ⟨i,j,k⟩ | (⟨i,j,k⟩ | ⟨i,j,k⟩) | |
| all_goals | |
| simp only [boxGraph_dist,oppositeVertex,tail,head,Fin.val_last,Fin.val_succ,Fin.val_castSucc] | |
| repeat' rw [Nat.dist_eq_sub_of_le_right (by omega)] | |
| omega | |
| namespace ParentEdges | |
| variable {T : RootedTree (Vertex n)} (P : ParentEdges T) | |
| lemma flow_zero (e : Edge n) : P.flow e 0 = 0 := by | |
| apply Subtype.ext | |
| simp [flow,fundamental] | |
| lemma flow_neg_one (e h : Edge n) : (P.flow e (-1)).val h = -(P.flow e 1).val h := by | |
| simp only [flow,fundamental,Pi.sub_apply,Pi.add_apply,Pi.smul_apply,smul_eq_mul, | |
| neg_mul,one_mul,Pi.single_apply] | |
| split_ifs <;> ring | |
| lemma traverses_iff_neg_nonzero (e : Edge n) (he : e ∉ P.treeEdges) (h : Edge n) : | |
| (∃ a c, Traverses P.treeEdges e (tail e) (head e) h a c) ↔ (P.flow e (-1)).val h ≠ 0 := by | |
| rw [P.flow_neg_one,neg_ne_zero,P.traverses_iff_nonzero e he h] | |
| lemma opposite_directed_flow_iff (e : Edge n) (he : e ∉ P.treeEdges) (h : Edge n) (z : Scalar) : | |
| (∃ a c, Traverses P.treeEdges e (tail e) (head e) h a c ∧ | |
| if (boxGraph n).dist oppositeVertex a < (boxGraph n).dist oppositeVertex c then z=1 else z=2) ↔ | |
| (P.flow e (-1)).val h ≠ 0 ∧ z=(P.flow e (-1)).val h := by | |
| have hlt := dist_opposite_tail h | |
| have hm : (2 : Scalar) = -1 := by decide | |
| constructor | |
| · rintro ⟨a,c,htr,hz⟩ | |
| have hne := (P.traverses_iff_neg_nonzero e he h).mp ⟨a,c,htr⟩ | |
| refine ⟨hne,?_⟩ | |
| rw [P.flow_neg_one] | |
| rcases P.traverses_endpoints htr with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩ | |
| · rw [(P.traverses_forward e he h).mp htr] | |
| simpa only [ite_eq_right (show ¬(boxGraph n).dist oppositeVertex (tail h) < | |
| (boxGraph n).dist oppositeVertex (head h) by omega),hm] using hz | |
| · rw [(P.traverses_reverse e he h).mp htr,neg_neg] | |
| simpa only [ite_eq_left (show (boxGraph n).dist oppositeVertex (head h) < | |
| (boxGraph n).dist oppositeVertex (tail h) by omega)] using hz | |
| · rintro ⟨hne,rfl⟩ | |
| rw [P.flow_neg_one,neg_ne_zero] at hne | |
| rcases scalar_cases ((P.flow e 1).val h) with hz | hp | hm' | |
| · exact False.elim (hne hz) | |
| · refine ⟨tail h,head h,(P.traverses_forward e he h).mpr hp,?_⟩ | |
| rw [ite_eq_right (by omega),P.flow_neg_one,hp,hm] | |
| · refine ⟨head h,tail h,(P.traverses_reverse e he h).mpr hm',?_⟩ | |
| rw [ite_eq_left (by omega),P.flow_neg_one,hm',neg_neg] | |
| end ParentEdges | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary RelationPools | |
| variable {n : ℕ} {b : Vertex n → Scalar} | |
| namespace QuotedGrid | |
| open QuotedTerm QuotedFormula SourceSyntax | |
| variable {k : ℕ} {T : RootedTree (Vertex n)} | |
| lemma meaning_reverseCycleY_move (env : Fin k → HF (Atom b)) (F R Γ ot ht st tt : QuotedTerm k) | |
| (P : ParentEdges T) (e : Edge n) (he : e ∉ P.treeEdges) (h : Edge n) (s t : LocalGroup h) | |
| (hF : ∀ z, z ∈ elements (F.meaning (atomInput b) env) ↔ ∃ C : CycleFrame n, frameCode b C = z) | |
| (hR : R.meaning (atomInput b) env = distancesCode b (boxGraph n)) | |
| (hΓ : Γ.meaning (atomInput b) env = traversalCode b P.treeEdges e (tail e) (head e)) | |
| (ho : ot.meaning (atomInput b) env = vertexCode b oppositeVertex) | |
| (hh : ht.meaning (atomInput b) env = edgeCode b h) | |
| (hs : st.meaning (atomInput b) env = atom (.inl ⟨h,s⟩)) | |
| (ht' : tt.meaning (atomInput b) env = atom (.inl ⟨h,t⟩)) (hn : 1 ≤ n) : | |
| (((traversalEdge Γ ht).neg.and (eq st tt)).or | |
| ((traversalEdge Γ ht).and ((baseEq F ht st tt).and (directedZ R Γ ot ht st tt)))).meaning (atomInput b) env ↔ | |
| t = restrictGroup h (⟨0,P.flow e (-1)⟩ : BoxGroup n)*s := by | |
| rw [meaning_or,meaning_and,meaning_neg,meaning_and,meaning_and, | |
| meaning_traversalEdge env Γ ht P.treeEdges e (tail e) (head e) h hΓ hh, | |
| P.traverses_iff_neg_nonzero e he h, | |
| meaning_baseEq env F ht st tt h s t hF hh hs ht' hn, | |
| meaning_directedZ env R Γ ot ht st tt P.treeEdges e (tail e) (head e) oppositeVertex h s t | |
| hR hΓ ho hh hs ht' hn, | |
| P.opposite_directed_flow_iff e he h (s⁻¹*t).flow,meaning_eq,hs,ht'] | |
| have ha : atom (Sum.inl ⟨h,s⟩ : Atom b) = atom (.inl ⟨h,t⟩) ↔ s=t := by | |
| simp only [atom_injective.eq_iff,Sum.inl.injEq,Sigma.mk.inj_iff,heq_eq_eq,true_and] | |
| rw [ha] | |
| change _ ↔ t = (⟨0,(P.flow e (-1)).val h⟩ : LocalGroup h)*s | |
| rw [local_central_iff] | |
| by_cases hz : (P.flow e (-1)).val h = 0 | |
| · simp only [hz,not_false_eq_true,true_and,ne_eq,not_true_eq_false,false_and,or_false] | |
| constructor | |
| · rintro rfl | |
| simp | |
| · rintro ⟨hf,htf⟩ | |
| have hh := (local_central_iff h s t 0).mpr ⟨hf,htf⟩ | |
| simpa only [show (⟨0,0⟩ : LocalGroup h)=1 from rfl,one_mul] using hh.symm | |
| · tauto | |
| lemma meaning_reverseCycleY (env : Fin k → HF (Atom b)) (E F R Γ ot : QuotedTerm k) | |
| (P : ParentEdges T) (e : Edge n) (he : e ∉ P.treeEdges) | |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) | |
| (hF : ∀ z, z ∈ elements (F.meaning (atomInput b) env) ↔ ∃ C : CycleFrame n, frameCode b C = z) | |
| (hR : R.meaning (atomInput b) env = distancesCode b (boxGraph n)) | |
| (hΓ : Γ.meaning (atomInput b) env = traversalCode b P.treeEdges e (tail e) (head e)) | |
| (ho : ot.meaning (atomInput b) env = vertexCode b oppositeVertex) (hn : 1 ≤ n) : | |
| (cycleY E F R Γ ot).meaning (atomInput b) env = | |
| relationCode (edgeActionRelation (b := b) (⟨0,P.flow e (-1)⟩ : BoxGroup n)) := by | |
| rw [cycleY,meaning_relation] | |
| apply congrArg relationCode | |
| ext ⟨a,c⟩ | |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and,meaning_existsIn,QuotedTerm.meaning_up, | |
| hE,exists_edgeCode, | |
| meaning_allList,List.mem_cons,List.mem_nil_iff,forall_eq_or_imp,forall_false,implies_true,and_true, | |
| meaning_mem,meaning_var,Fin.cons_zero,Fin.cons_one,fin_cons_two,mem_edgeCode_iff, | |
| mem_edgeActionRelation] | |
| constructor | |
| · rintro ⟨h,⟨s,hs⟩,⟨t,ht⟩,hm⟩ | |
| have hs' := atom_injective hs | |
| have ht' := atom_injective ht | |
| subst a | |
| subst c | |
| have hmove := (meaning_reverseCycleY_move | |
| (Fin.cons (edgeCode b h) (Fin.cons (atom (.inl ⟨h,t⟩)) (Fin.cons (atom (.inl ⟨h,s⟩)) env))) | |
| F.up.up.up R.up.up.up Γ.up.up.up ot.up.up.up (var 0) (var 2) (var 1) | |
| P e he h s t hF hR hΓ ho rfl rfl rfl hn).mp hm | |
| exact ⟨h,s,rfl,congrArg (fun t : LocalGroup h => (Sum.inl ⟨h,t⟩ : Atom b)) hmove⟩ | |
| · rintro ⟨h,s,rfl,rfl⟩ | |
| refine ⟨h,⟨s,rfl⟩,⟨restrictGroup h (⟨0,P.flow e (-1)⟩ : BoxGroup n)*s,rfl⟩,?_⟩ | |
| exact (meaning_reverseCycleY_move | |
| (Fin.cons (edgeCode b h) (Fin.cons (atom (.inl ⟨h,restrictGroup h (⟨0,P.flow e (-1)⟩ : BoxGroup n)*s⟩)) | |
| (Fin.cons (atom (.inl ⟨h,s⟩)) env))) | |
| F.up.up.up R.up.up.up Γ.up.up.up ot.up.up.up (var 0) (var 2) (var 1) | |
| P e he h s _ hF hR hΓ ho rfl rfl rfl hn).mpr rfl | |
| end QuotedGrid | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice | |
| variable {n : ℕ} | |
| abbrev VertexKey := Lex (Fin 4 → ℕ) | |
| def vertexKey (α : Fin 4 → Vertex n) := AnchoredTree.key (boxGraph n) α | |
| def lowEnd (α : Fin 4 → Vertex n) (e : Edge n) : Vertex n := | |
| if vertexKey α (tail e) < vertexKey α (head e) then tail e else head e | |
| def highEnd (α : Fin 4 → Vertex n) (e : Edge n) : Vertex n := | |
| if vertexKey α (tail e) < vertexKey α (head e) then head e else tail e | |
| def edgeKey (α : Fin 4 → Vertex n) (e : Edge n) : Lex (VertexKey × VertexKey) := | |
| toLex (vertexKey α (lowEnd α e),vertexKey α (highEnd α e)) | |
| lemma low_high_endpoints (α : Fin 4 → Vertex n) (e : Edge n) : | |
| (lowEnd α e = tail e ∧ highEnd α e = head e) ∨ | |
| (highEnd α e = tail e ∧ lowEnd α e = head e) := by | |
| unfold lowEnd highEnd | |
| split_ifs <;> simp | |
| lemma low_lt_high (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) (e : Edge n) : | |
| vertexKey α (lowEnd α e) < vertexKey α (highEnd α e) := by | |
| have hne : vertexKey α (tail e) ≠ vertexKey α (head e) := | |
| fun h => (head_ne_tail e) (hα h).symm | |
| unfold lowEnd highEnd | |
| split_ifs with h | |
| · exact h | |
| · exact lt_of_le_of_ne (le_of_not_gt h) hne.symm | |
| lemma ordered_endpoints_iff (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) | |
| (e : Edge n) (u v : Vertex n) : | |
| (((u=tail e ∧ v=head e) ∨ (v=tail e ∧ u=head e)) ∧ vertexKey α u < vertexKey α v) ↔ | |
| u=lowEnd α e ∧ v=highEnd α e := by | |
| constructor | |
| · rintro ⟨(⟨rfl,rfl⟩|⟨rfl,rfl⟩),h⟩ | |
| · simp only [lowEnd,highEnd,ite_eq_left h,and_self] | |
| · unfold lowEnd highEnd | |
| split_ifs with hh | |
| · exact False.elim ((not_lt_of_ge (le_of_lt h)) hh) | |
| · exact ⟨rfl,rfl⟩ | |
| · rintro ⟨rfl,rfl⟩ | |
| exact ⟨low_high_endpoints α e,low_lt_high α hα e⟩ | |
| lemma edgeKey_injective (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) : | |
| Function.Injective (edgeKey α) := by | |
| intro e f h | |
| have h₁ := hα (congrArg (fun k : Lex (VertexKey × VertexKey) => (ofLex k).1) h) | |
| have h₂ := hα (congrArg (fun k : Lex (VertexKey × VertexKey) => (ofLex k).2) h) | |
| change lowEnd α e = lowEnd α f at h₁ | |
| change highEnd α e = highEnd α f at h₂ | |
| apply edge_eq_of_endpoints | |
| rcases low_high_endpoints α e with ⟨he,he'⟩ | ⟨he',he⟩ <;> | |
| rcases low_high_endpoints α f with ⟨hf,hf'⟩ | ⟨hf',hf⟩ | |
| · exact Or.inl ⟨he.symm.trans (h₁.trans hf),he'.symm.trans (h₂.trans hf')⟩ | |
| · exact Or.inr ⟨he.symm.trans (h₁.trans hf),he'.symm.trans (h₂.trans hf')⟩ | |
| · exact Or.inr ⟨he'.symm.trans (h₂.trans hf'),he.symm.trans (h₁.trans hf)⟩ | |
| · exact Or.inl ⟨he'.symm.trans (h₂.trans hf'),he.symm.trans (h₁.trans hf)⟩ | |
| def leastEdges (α : Fin 4 → Vertex n) (D : Finset (Edge n)) : Finset (Edge n) := | |
| D.filter (fun e => ∀ f ∈ D, ¬edgeKey α f < edgeKey α e) | |
| lemma leastEdges_empty_iff (α : Fin 4 → Vertex n) (D : Finset (Edge n)) : | |
| leastEdges α D = ∅ ↔ D=∅ := by | |
| constructor | |
| · intro h | |
| by_contra hn | |
| have hD := Finset.nonempty_iff_ne_empty.mpr hn | |
| let K := D.image (edgeKey α) | |
| have hK : K.Nonempty := hD.image _ | |
| obtain ⟨e,he,hek⟩ := Finset.mem_image.mp (Finset.min'_mem K hK) | |
| have hemin : e ∈ leastEdges α D := by | |
| refine Finset.mem_filter.mpr ⟨he,?_⟩ | |
| intro f hf hlt | |
| have hm := Finset.min'_le K (edgeKey α f) (Finset.mem_image.mpr ⟨f,hf,rfl⟩) | |
| rw [←hek] at hm | |
| exact (not_lt_of_ge hm) hlt | |
| rw [h] at hemin | |
| exact Finset.notMem_empty _ hemin | |
| · rintro rfl | |
| simp [leastEdges] | |
| lemma leastEdges_subsingleton (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) | |
| (D : Finset (Edge n)) : (↑(leastEdges α D) : Set (Edge n)).Subsingleton := by | |
| intro e he f hf | |
| obtain ⟨he,hm⟩ := Finset.mem_filter.mp he | |
| obtain ⟨hf,hn⟩ := Finset.mem_filter.mp hf | |
| exact edgeKey_injective α hα (le_antisymm (le_of_not_gt (hm f hf)) (le_of_not_gt (hn e he))) | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.BGS Hereditary | |
| variable {n : ℕ} {b : Vertex n → Scalar} | |
| namespace QuotedGrid | |
| open QuotedTerm QuotedFormula | |
| variable {k : ℕ} | |
| lemma meaning_edgeLt (env : Fin k → HF (Atom b)) (ats VT R et ft : QuotedTerm k) | |
| (α : Fin 4 → Vertex n) (e f : Edge n) (hres : AnchoredTree.Resolving (boxGraph n) α) | |
| (hα : ats.meaning (atomInput b) env = tupleCode (List.ofFn (vertexCode b ∘ α))) | |
| (hV : VT.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) | |
| (hR : R.meaning (atomInput b) env = ofFinset | |
| ((BFS.closure (boxGraph n) (Fintype.card (Atom b))).image (distanceCode (vertexCode b)))) | |
| (he : et.meaning (atomInput b) env = edgeCode b e) | |
| (hf : ft.meaning (atomInput b) env = edgeCode b f) (hn : 1 ≤ n) : | |
| (edgeLt ats VT R et ft).meaning (atomInput b) env ↔ edgeKey α e < edgeKey α f := by | |
| have hlt {l : ℕ} (env' : Fin l → HF (Atom b)) (at' R' ut vt : QuotedTerm l) (u v : Vertex n) | |
| (hat : at'.meaning (atomInput b) env' = tupleCode (List.ofFn (vertexCode b ∘ α))) | |
| (hR' : R'.meaning (atomInput b) env' = R.meaning (atomInput b) env) | |
| (hu : ut.meaning (atomInput b) env' = vertexCode b u) | |
| (hv : vt.meaning (atomInput b) env' = vertexCode b v) : | |
| (vertexLt at' R' ut vt).meaning (atomInput b) env' ↔ vertexKey α u < vertexKey α v := by | |
| exact QuotedFormula.meaning_vertexLt (atomInput b) env' at' R' ut vt (vertexCode b) | |
| (vertexCode_injective hn) (boxGraph n) (boxGraph_connected n) α u v hat (hR'.trans hR) hu hv (vertex_card_le_atoms hn) | |
| have hm (u v w z : Vertex n) := hlt | |
| (Fin.cons (vertexCode b z) (Fin.cons (vertexCode b w) (Fin.cons (vertexCode b v) (Fin.cons (vertexCode b u) env)))) | |
| ats.up.up.up.up R.up.up.up.up | |
| have hp (u v w z : Vertex n) := meaning_hasEndpoints | |
| (Fin.cons (vertexCode b z) (Fin.cons (vertexCode b w) (Fin.cons (vertexCode b v) (Fin.cons (vertexCode b u) env)))) | |
| simp only [edgeLt,meaning_existsIn,QuotedTerm.meaning_up,hV,elements_ofFinset,Finset.mem_image, | |
| Finset.mem_univ,true_and,exists_exists_eq_and,meaning_allList,List.mem_cons, | |
| List.mem_nil_iff,forall_eq_or_imp,forall_false,implies_true,and_true,meaning_and,meaning_or,meaning_eq, | |
| meaning_var,Fin.cons_zero,Fin.cons_one,fin_cons_two,fin_cons_three,(vertexCode_injective hn).eq_iff] | |
| have hh (u v w z : Vertex n) : | |
| (hasEndpoints et.up.up.up.up (var 3) (var 2)).meaning (atomInput b) | |
| (Fin.cons (vertexCode b z) (Fin.cons (vertexCode b w) (Fin.cons (vertexCode b v) (Fin.cons (vertexCode b u) env)))) ↔ | |
| (u=tail e ∧ v=head e) ∨ (v=tail e ∧ u=head e) := hp u v w z _ _ _ e u v he rfl rfl hn | |
| have hh' (u v w z : Vertex n) : | |
| (hasEndpoints ft.up.up.up.up (var 1) (var 0)).meaning (atomInput b) | |
| (Fin.cons (vertexCode b z) (Fin.cons (vertexCode b w) (Fin.cons (vertexCode b v) (Fin.cons (vertexCode b u) env)))) ↔ | |
| (w=tail f ∧ z=head f) ∨ (z=tail f ∧ w=head f) := hp u v w z _ _ _ f w z hf rfl rfl hn | |
| have hm32 (u v w z : Vertex n) : | |
| (vertexLt ats.up.up.up.up R.up.up.up.up (var 3) (var 2)).meaning (atomInput b) | |
| (Fin.cons (vertexCode b z) (Fin.cons (vertexCode b w) (Fin.cons (vertexCode b v) (Fin.cons (vertexCode b u) env)))) ↔ | |
| vertexKey α u < vertexKey α v := hm u v w z _ _ u v hα rfl rfl rfl | |
| have hm10 (u v w z : Vertex n) : | |
| (vertexLt ats.up.up.up.up R.up.up.up.up (var 1) (var 0)).meaning (atomInput b) | |
| (Fin.cons (vertexCode b z) (Fin.cons (vertexCode b w) (Fin.cons (vertexCode b v) (Fin.cons (vertexCode b u) env)))) ↔ | |
| vertexKey α w < vertexKey α z := hm u v w z _ _ w z hα rfl rfl rfl | |
| have hm31 (u v w z : Vertex n) : | |
| (vertexLt ats.up.up.up.up R.up.up.up.up (var 3) (var 1)).meaning (atomInput b) | |
| (Fin.cons (vertexCode b z) (Fin.cons (vertexCode b w) (Fin.cons (vertexCode b v) (Fin.cons (vertexCode b u) env)))) ↔ | |
| vertexKey α u < vertexKey α w := hm u v w z _ _ u w hα rfl rfl rfl | |
| have hm20 (u v w z : Vertex n) : | |
| (vertexLt ats.up.up.up.up R.up.up.up.up (var 2) (var 0)).meaning (atomInput b) | |
| (Fin.cons (vertexCode b z) (Fin.cons (vertexCode b w) (Fin.cons (vertexCode b v) (Fin.cons (vertexCode b u) env)))) ↔ | |
| vertexKey α v < vertexKey α z := hm u v w z _ _ v z hα rfl rfl rfl | |
| simp only [hh,hh',hm32,hm10,hm31,hm20] | |
| constructor | |
| · rintro ⟨u,v,w,z,he,hf,huv,hwz,h⟩ | |
| obtain ⟨rfl,rfl⟩ := (ordered_endpoints_iff α hres e u v).mp ⟨he,huv⟩ | |
| obtain ⟨rfl,rfl⟩ := (ordered_endpoints_iff α hres f w z).mp ⟨hf,hwz⟩ | |
| rw [edgeKey,edgeKey,Prod.Lex.toLex_lt_toLex] | |
| exact h.imp id (fun ⟨he,hl⟩ => ⟨congrArg (vertexKey α) he,hl⟩) | |
| · intro h | |
| rw [edgeKey,edgeKey,Prod.Lex.toLex_lt_toLex] at h | |
| exact ⟨lowEnd α e,highEnd α e,lowEnd α f,highEnd α f, | |
| low_high_endpoints α e,low_high_endpoints α f,low_lt_high α hres e,low_lt_high α hres f, | |
| h.imp id (fun ⟨he,hl⟩ => ⟨hres he,hl⟩)⟩ | |
| end QuotedGrid | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.BGS Hereditary | |
| variable {n : ℕ} {b : Vertex n → Scalar} | |
| def missingEdge (x : Finset (Σ e : Edge n, LocalGroup e)) (e : Edge n) : Prop := | |
| ∀ r ∈ x, r.1 ≠ e | |
| def remainingEdges (T : Finset (Edge n)) (x : Finset (Σ e : Edge n, LocalGroup e)) : Finset (Edge n) := | |
| (Finset.univ \ T).filter (missingEdge x) | |
| lemma selected_inter_empty (x : Finset (Σ e : Edge n, LocalGroup e)) (e : Edge n) : | |
| ofFinset ((elements (stateCode (x.image Sum.inl : Finset (Atom b)))) ∩ elements (edgeCode b e)) = emptyHF ↔ | |
| missingEdge x e := by | |
| rw [show emptyHF = (ofFinset ∅ : HF (Atom b)) from rfl, ofFinset_inj,Finset.eq_empty_iff_forall_notMem] | |
| simp only [Finset.mem_inter,stateCode,elements_ofFinset,Finset.image_image,Finset.mem_image,Function.comp_apply] | |
| constructor | |
| · intro h r hr he | |
| exact h (atom (.inl r)) ⟨⟨r,hr,rfl⟩,(atom_mem_edgeCode _ _ _).mpr he⟩ | |
| · rintro h z ⟨⟨r,hr,rfl⟩,he⟩ | |
| exact h r hr ((atom_mem_edgeCode _ _ _).mp he) | |
| namespace QuotedGrid | |
| open QuotedTerm QuotedFormula | |
| variable {k : ℕ} | |
| lemma meaning_nextEdges (env : Fin k → HF (Atom b)) (ats VT ET R TT xt : QuotedTerm k) | |
| (α : Fin 4 → Vertex n) (T : Finset (Edge n)) (x : Finset (Σ e : Edge n, LocalGroup e)) | |
| (hres : AnchoredTree.Resolving (boxGraph n) α) | |
| (hα : ats.meaning (atomInput b) env = tupleCode (List.ofFn (vertexCode b ∘ α))) | |
| (hV : VT.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) | |
| (hE : ET.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) | |
| (hR : R.meaning (atomInput b) env = ofFinset | |
| ((BFS.closure (boxGraph n) (Fintype.card (Atom b))).image (distanceCode (vertexCode b)))) | |
| (hT : TT.meaning (atomInput b) env = ofFinset (T.image (edgeCode b))) | |
| (hx : xt.meaning (atomInput b) env = stateCode (x.image Sum.inl)) (hn : 1 ≤ n) : | |
| (nextEdges ats VT ET R TT xt).meaning (atomInput b) env = | |
| ofFinset ((leastEdges α (remainingEdges T x)).image (edgeCode b)) := by | |
| have hd : (ET.diff TT).meaning (atomInput b) env = ofFinset ((Finset.univ \ T).image (edgeCode b)) := by | |
| simp only [meaning_diff,hE,hT,elements_ofFinset] | |
| apply ofFinset_inj.mpr | |
| ext z | |
| simp only [Finset.mem_filter,Finset.mem_image,Finset.mem_univ,true_and,Finset.mem_sdiff, | |
| not_exists,not_and] | |
| constructor | |
| · rintro ⟨⟨e,rfl⟩,he⟩ | |
| refine ⟨e,?_,rfl⟩ | |
| exact fun ht => he e ht rfl | |
| · rintro ⟨e,he,rfl⟩ | |
| exact ⟨⟨e,rfl⟩,fun f hf hfe => he ((edgeCode_injective hfe) ▸ hf)⟩ | |
| have hmiss {l : ℕ} (env' : Fin l → HF (Atom b)) (x' e' : QuotedTerm l) (e : Edge n) | |
| (hx' : x'.meaning (atomInput b) env' = stateCode (x.image Sum.inl)) | |
| (he' : e'.meaning (atomInput b) env' = edgeCode b e) : | |
| (eq (x'.inter e') empty).meaning (atomInput b) env' ↔ missingEdge x e := by | |
| simp only [meaning_eq,meaning_inter,hx',he',meaning_empty] | |
| exact selected_inter_empty x e | |
| have hm1 (e : Edge n) := hmiss (Fin.cons (edgeCode b e) env) xt.up (var 0) e hx rfl | |
| have hm2 (e f : Edge n) := hmiss (Fin.cons (edgeCode b f) (Fin.cons (edgeCode b e) env)) xt.up.up (var 0) f hx rfl | |
| have ho (e f : Edge n) := meaning_edgeLt (Fin.cons (edgeCode b f) (Fin.cons (edgeCode b e) env)) | |
| ats.up.up VT.up.up R.up.up (var 0) (var 1) α f e hres hα hV hR rfl rfl hn | |
| simp only [nextEdges,QuotedTerm.meaning_filter,hd,elements_ofFinset] | |
| apply ofFinset_inj.mpr | |
| ext z | |
| simp only [Finset.mem_filter,Finset.mem_image] | |
| constructor | |
| · rintro ⟨⟨⟨e,he,rfl⟩,hm⟩,hmin⟩ | |
| refine ⟨e,Finset.mem_filter.mpr ⟨Finset.mem_filter.mpr ⟨he,(hm1 e).mp hm⟩,?_⟩,rfl⟩ | |
| simp only [meaning_allIn,QuotedTerm.meaning_up,hd,elements_ofFinset,Finset.forall_mem_image,meaning_neg,meaning_and,hm2,ho] at hmin | |
| intro f hf | |
| obtain ⟨hf,hfm⟩ := Finset.mem_filter.mp hf | |
| exact fun hlt => hmin hf ⟨hfm,hlt⟩ | |
| · rintro ⟨e,he,rfl⟩ | |
| obtain ⟨he,hmin⟩ := Finset.mem_filter.mp he | |
| obtain ⟨he,hm⟩ := Finset.mem_filter.mp he | |
| refine ⟨⟨⟨e,he,rfl⟩,(hm1 e).mpr hm⟩,?_⟩ | |
| simp only [meaning_allIn,QuotedTerm.meaning_up,hd,elements_ofFinset,Finset.forall_mem_image,meaning_neg,meaning_and,hm2,ho] | |
| intro f hf ⟨hfm,hlt⟩ | |
| exact hmin f (Finset.mem_filter.mpr ⟨hf,hfm⟩) hlt | |
| end QuotedGrid | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice | |
| variable {n : ℕ} | |
| def gridCandidates (α : Fin 4 → Vertex n) (T : Finset (Edge n)) | |
| (x : Finset (Σ e : Edge n, LocalGroup e)) : Finset (Σ e : Edge n, LocalGroup e) := | |
| Finset.univ.filter fun r => r.1 ∈ leastEdges α (remainingEdges T x) ∧ AcceptsFaces x r.1 r.2 | |
| lemma mem_gridCandidates (α : Fin 4 → Vertex n) (T : Finset (Edge n)) | |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (r : Σ e : Edge n, LocalGroup e) : | |
| r ∈ gridCandidates α T x ↔ r.1 ∈ leastEdges α (remainingEdges T x) ∧ AcceptsFaces x r.1 r.2 := by | |
| simp only [gridCandidates,Finset.mem_filter,Finset.mem_univ,true_and] | |
| lemma candidate_new_edge {α : Fin 4 → Vertex n} {T : Finset (Edge n)} | |
| {x : Finset (Σ e : Edge n, LocalGroup e)} {r : Σ e : Edge n, LocalGroup e} | |
| (hr : r ∈ gridCandidates α T x) : r.1 ∉ T ∧ missingEdge x r.1 := by | |
| obtain ⟨hh,_⟩ := (mem_gridCandidates α T x r).mp hr | |
| have he := (Finset.mem_filter.mp hh).1 | |
| simpa only [remainingEdges,Finset.mem_filter,Finset.mem_sdiff,Finset.mem_univ,true_and] using he | |
| lemma gridCandidates_fresh {α : Fin 4 → Vertex n} {T : Finset (Edge n)} | |
| {x : Finset (Σ e : Edge n, LocalGroup e)} {r : Σ e : Edge n, LocalGroup e} | |
| (hr : r ∈ gridCandidates α T x) : r ∉ x := fun hx => (candidate_new_edge hr).2 r hx rfl | |
| lemma consistent_empty : ConsistentSelection (∅ : Finset (Σ e : Edge n, LocalGroup e)) := by | |
| simp [ConsistentSelection] | |
| lemma consistent_insert {x : Finset (Σ e : Edge n, LocalGroup e)} | |
| (hx : ConsistentSelection x) {e : Edge n} {s : LocalGroup e} | |
| (hnew : missingEdge x e) (hs : AcceptsFaces x e s) : ConsistentSelection (insert ⟨e,s⟩ x) := by | |
| constructor | |
| · intro r hr t ht heq | |
| rcases Finset.mem_insert.mp hr with rfl | hr <;> | |
| rcases Finset.mem_insert.mp ht with rfl | ht | |
| · rfl | |
| · exact False.elim (hnew t ht heq.symm) | |
| · exact False.elim (hnew r hr heq) | |
| · exact hx.1 r hr t ht heq | |
| · intro r hr t ht f hf ht' | |
| rcases Finset.mem_insert.mp hr with rfl | hr <;> | |
| rcases Finset.mem_insert.mp ht with rfl | ht | |
| · rfl | |
| · exact hs t ht f hf ht' | |
| · exact (hs r hr f ht' hf).symm | |
| · exact hx.2 r hr t ht f hf ht' | |
| lemma selectedVectors_accepts {x : Finset (Σ e : Edge n, LocalGroup e)} | |
| (hx : ConsistentSelection x) (e : Edge n) : | |
| AcceptsFaces x e (globalStates (selectedVectors x) 0 e) := by | |
| intro r hr f he hf | |
| exact selectedVectors_preserves hx hr ⟨f,hf⟩ | |
| lemma gridCandidates_empty_iff (α : Fin 4 → Vertex n) (T : Finset (Edge n)) | |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hx : ConsistentSelection x) : | |
| gridCandidates α T x = ∅ ↔ remainingEdges T x = ∅ := by | |
| rw [←leastEdges_empty_iff α (remainingEdges T x)] | |
| constructor | |
| · intro h | |
| apply Finset.eq_empty_iff_forall_notMem.mpr | |
| intro e he | |
| have hm := (mem_gridCandidates α T x ⟨e,globalStates (selectedVectors x) 0 e⟩).mpr | |
| ⟨he,selectedVectors_accepts hx e⟩ | |
| rw [h] at hm | |
| exact Finset.notMem_empty _ hm | |
| · intro h | |
| apply Finset.eq_empty_iff_forall_notMem.mpr | |
| intro r hr | |
| have hm := (mem_gridCandidates α T x r).mp hr |>.1 | |
| rw [h] at hm | |
| exact Finset.notMem_empty _ hm | |
| lemma remaining_empty_iff (T : Finset (Edge n)) (x : Finset (Σ e : Edge n, LocalGroup e)) : | |
| remainingEdges T x = ∅ ↔ ∀ e, e ∉ T → ∃ r ∈ x, r.1 = e := by | |
| simp only [Finset.eq_empty_iff_forall_notMem,remainingEdges,Finset.mem_filter, | |
| Finset.mem_sdiff,Finset.mem_univ,true_and,not_and,missingEdge,not_forall,not_not] | |
| constructor <;> intro H e he | |
| · obtain ⟨r,hr,hre⟩ := H e he | |
| exact ⟨r,hr,hre⟩ | |
| · obtain ⟨r,hr,hre⟩ := H e he | |
| exact ⟨r,hr,hre⟩ | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.TreeTest RelationPools | |
| variable {n : ℕ} {b : Vertex n → Scalar} | |
| lemma actionPerm_edgeBlock (g : BoxGroup n) (e : Edge n) : | |
| (edgeBlockSet b e).image (actionPerm g) = edgeBlockSet b e := by | |
| apply Finset.eq_of_subset_of_card_le | |
| · intro a ha | |
| obtain ⟨d,hd,rfl⟩ := Finset.mem_image.mp ha | |
| obtain ⟨s,rfl⟩ := (mem_edgeBlockSet e d).mp hd | |
| exact (mem_edgeBlockSet e _).mpr ⟨restrictGroup e g*s,rfl⟩ | |
| · rw [Finset.card_image_of_injective _ (actionPerm g).injective] | |
| lemma actionPerm_vertexBlock (g : BoxGroup n) (v : Vertex n) : | |
| (vertexBlockSet b v).image (actionPerm g) = vertexBlockSet b v := by | |
| apply Finset.eq_of_subset_of_card_le | |
| · intro a ha | |
| obtain ⟨d,hd,rfl⟩ := Finset.mem_image.mp ha | |
| obtain ⟨s,rfl⟩ := (mem_vertexBlockSet v d).mp hd | |
| exact (mem_vertexBlockSet v _).mpr ⟨actConfiguration g s,rfl⟩ | |
| · rw [Finset.card_image_of_injective _ (actionPerm g).injective] | |
| lemma actionPerm_blocks (hn : 1 ≤ n) (g : BoxGroup n) : | |
| ∀ u ∈ blocks (atomInput b), u.image (actionPerm g) = u := by | |
| intro u hu | |
| rcases Finset.mem_union.mp hu with hu | hu | |
| · rw [edgeBlocks_grid] at hu | |
| obtain ⟨e,_,rfl⟩ := Finset.mem_image.mp hu | |
| exact actionPerm_edgeBlock g e | |
| · rw [vertexBlocks_grid hn] at hu | |
| obtain ⟨v,_,rfl⟩ := Finset.mem_image.mp hu | |
| exact actionPerm_vertexBlock g v | |
| namespace ParentEdges | |
| variable {T : RootedTree (Vertex n)} (P : ParentEdges T) | |
| def fundamentalPool (N : Finset (Edge n)) : Finset (Relation (Atom b)) := | |
| (N.product Finset.univ).image fun ea => graph (actionPerm (⟨0,P.flow ea.1 ea.2⟩ : BoxGroup n)) | |
| lemma fundamental_mem {N : Finset (Edge n)} {e : Edge n} (he : e ∈ N) (a : Scalar) : | |
| graph (actionPerm (b := b) (⟨0,P.flow e a⟩ : BoxGroup n)) ∈ P.fundamentalPool N := | |
| Finset.mem_image.mpr ⟨(e,a),Finset.mem_product.mpr ⟨he,Finset.mem_univ _⟩,rfl⟩ | |
| lemma grid_transitivity (hn : 1 ≤ n) (α : Fin 4 → Vertex n) | |
| (hα : AnchoredTree.Resolving (boxGraph n) α) | |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hoff : ∀ r ∈ x, r.1 ∉ P.treeEdges) | |
| (r t : Σ e : Edge n, LocalGroup e) | |
| (hr : r ∈ gridCandidates α P.treeEdges x) (ht : t ∈ gridCandidates α P.treeEdges x) : | |
| ∃ g ∈ witnessPool localBound (atomInput b) True | |
| (fun _ => P.fundamentalPool (leastEdges α (remainingEdges P.treeEdges x))) (x.image Sum.inl), | |
| g (.inl r) = .inl t := by | |
| obtain ⟨hrN,hrs⟩ := (mem_gridCandidates α P.treeEdges x r).mp hr | |
| obtain ⟨htN,hts⟩ := (mem_gridCandidates α P.treeEdges x t).mp ht | |
| have ret := leastEdges_subsingleton α hα _ hrN htN | |
| rcases r with ⟨e,s⟩ | |
| rcases t with ⟨e',t⟩ | |
| dsimp at ret | |
| subst e' | |
| have hen := (candidate_new_edge hr).1 | |
| have hnew := (candidate_new_edge hr).2 | |
| let l := actionPerm (b := b) (⟨faceDelta e s t,0⟩ : BoxGroup n) | |
| let a := t.flow - (restrictGroup e (⟨faceDelta e s t,0⟩ : BoxGroup n) * s).flow | |
| let c := actionPerm (b := b) (⟨0,P.flow e a⟩ : BoxGroup n) | |
| have fixl : ∀ r ∈ x, l (.inl r) = .inl r := fun r hr => faceDelta_fix_past hrs hts hr | |
| have fixc : ∀ r ∈ x, c (.inl r) = .inl r := by | |
| intro r hr | |
| apply central_fix_edge | |
| exact P.flow_other e r.1 (hoff r hr) (hnew r hr) a | |
| have hfilter : PoolFilter (atomInput b) (x.image Sum.inl) (c*l) := by | |
| refine ⟨(fullAut (atomInput b)).mul_mem (actionPerm_fullAut _) (actionPerm_fullAut _),?_,?_⟩ | |
| · intro u hu | |
| change u.image (c ∘ l) = u | |
| rw [←Finset.image_image,actionPerm_blocks hn _ u hu,actionPerm_blocks hn _ u hu] | |
| · intro a ha | |
| obtain ⟨r,hr,rfl⟩ := Finset.mem_image.mp ha | |
| change c (l (.inl r)) = _ | |
| rw [fixl r hr,fixc r hr] | |
| refine ⟨c*l,?_,?_⟩ | |
| · rw [witnessPool,ite_eq_left True.intro] | |
| apply Finset.mem_insert_of_mem | |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and] | |
| exact ⟨hfilter,graph l,faceDelta_in_localPool hn e s t, | |
| graph c,P.fundamental_mem hrN a,compose_graph l c⟩ | |
| · exact central_after_local e s t (P.flow e a) (P.flow_self e hen a) | |
| end ParentEdges | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.TreeTest | |
| variable {n : ℕ} {b : Vertex n → Scalar} | |
| def edgeState (x : Finset (Σ e : Edge n, LocalGroup e)) : Finset (Atom b) := x.image Sum.inl | |
| @[simp] lemma edgeState_empty : edgeState (b := b) ∅ = ∅ := Finset.image_empty _ | |
| @[simp] lemma edgeState_insert (r : Σ e : Edge n, LocalGroup e) (x) : | |
| edgeState (b := b) (insert r x) = insert (.inl r) (edgeState x) := Finset.image_insert _ _ _ | |
| lemma edgeState_injective : Function.Injective (edgeState (b := b)) := | |
| fun _ _ h => (Finset.image_inj Sum.inl_injective).mp h | |
| lemma mem_edgeState (x : Finset (Σ e : Edge n, LocalGroup e)) (a : Atom b) : | |
| a ∈ edgeState x ↔ ∃ r ∈ x, Sum.inl r = a := Finset.mem_image | |
| namespace ParentEdges | |
| variable {T : RootedTree (Vertex n)} (P : ParentEdges T) | |
| lemma prefix_invariant (α : Fin 4 → Vertex n) (S : Selection (Atom b)) | |
| (hD : ∀ x, S.candidates (edgeState x) = edgeState (gridCandidates α P.treeEdges x)) | |
| {B : ℕ → Finset (Atom b)} {c : ℕ → Option (Atom b)} {k : ℕ} (hpath : S.Prefix B c k) : | |
| ∀ i ≤ k, ∃ x : Finset (Σ e : Edge n, LocalGroup e), | |
| B i = edgeState x ∧ ConsistentSelection x ∧ ∀ r ∈ x, r.1 ∉ P.treeEdges := by | |
| intro i | |
| induction i with | |
| | zero => | |
| intro _ | |
| exact ⟨∅,hpath.1.trans edgeState_empty.symm,consistent_empty,by simp⟩ | |
| | succ i ih => | |
| intro hi | |
| obtain ⟨x,hx,hcons,hoff⟩ := ih (by omega) | |
| obtain ⟨hc,hstep⟩ := hpath.2 i (by omega) | |
| cases hci : c i with | |
| | none => | |
| rw [hci] at hstep | |
| exact ⟨x,hstep.trans hx,hcons,hoff⟩ | |
| | some a => | |
| rw [hci] at hc hstep | |
| have ha := (Selection.some_mem_choices.mp hc).1 | |
| rw [hx,hD] at ha | |
| obtain ⟨r,hr,rfl⟩ := (mem_edgeState _ a).mp ha | |
| obtain ⟨hne,hnew⟩ := candidate_new_edge hr | |
| have hh : B (i+1) = edgeState (insert r x) := by | |
| rw [hstep,hx,Selection.advance,edgeState_insert] | |
| refine ⟨insert r x,hh,consistent_insert hcons hnew ((mem_gridCandidates _ _ _ _).mp hr).2,?_⟩ | |
| intro s hs | |
| rcases Finset.mem_insert.mp hs with rfl | hs | |
| · exact hne | |
| · exact hoff s hs | |
| lemma terminal_complete (α : Fin 4 → Vertex n) (S : Selection (Atom b)) | |
| (hD : ∀ x, S.candidates (edgeState x) = edgeState (gridCandidates α P.treeEdges x)) | |
| (hTrans : ∀ x, ConsistentSelection x → (∀ r ∈ x, r.1 ∉ P.treeEdges) → | |
| S.TransitiveAt (edgeState x)) | |
| {B : ℕ → Finset (Atom b)} {c : ℕ → Option (Atom b)} {t : ℕ} (hpath : S.FirstStabilization B c t) : | |
| ∃ x : Finset (Σ e : Edge n, LocalGroup e), B t = edgeState x ∧ ConsistentSelection x ∧ | |
| (∀ r ∈ x, r.1 ∉ P.treeEdges) ∧ ∀ e, e ∉ P.treeEdges → ∃ r ∈ x, r.1 = e := by | |
| obtain ⟨x,hx,hcons,hoff⟩ := P.prefix_invariant α S hD hpath.1 t (by omega) | |
| refine ⟨x,hx,hcons,hoff,(remaining_empty_iff P.treeEdges x).mp ?_⟩ | |
| apply (gridCandidates_empty_iff α P.treeEdges x hcons).mp | |
| apply Finset.eq_empty_iff_forall_notMem.mpr | |
| intro r hr | |
| have hne : (S.candidates (B t)).Nonempty := by | |
| rw [hx,hD] | |
| exact ⟨.inl r,(mem_edgeState _ _).mpr ⟨r,hr,rfl⟩⟩ | |
| have ht : S.TransitiveAt (B t) := hx.symm ▸ hTrans x hcons hoff | |
| have hc := (hpath.1.2 t (by omega)).1 | |
| have hs := (hpath.1.2 t (by omega)).2 | |
| cases hci : c t with | |
| | none => | |
| rw [hci] at hc | |
| exact (Selection.none_mem_choices.mp hc) ⟨hne,ht⟩ | |
| | some a => | |
| rw [hci] at hc hs | |
| have ha := (Selection.some_mem_choices.mp hc).1 | |
| rw [hx,hD] at ha | |
| obtain ⟨s,hsc,rfl⟩ := (mem_edgeState _ a).mp ha | |
| simp only [Selection.advance] at hs | |
| have heq : insert s x = x := by | |
| apply edgeState_injective | |
| rw [edgeState_insert,←hx,←hs,←hpath.2.2] | |
| have hmem : s ∈ x := by rw [←heq]; exact Finset.mem_insert_self _ _ | |
| exact gridCandidates_fresh hsc hmem | |
| end ParentEdges | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary RelationPools | |
| variable {n : ℕ} {b : Vertex n → Scalar} | |
| namespace QuotedGrid | |
| open QuotedTerm QuotedFormula SourceSyntax | |
| variable {k : ℕ} | |
| lemma meaning_cycleRelation_of_Y (env : Fin k → HF (Atom b)) (V E F R Γ ot : QuotedTerm k) | |
| (g : BoxGroup n) | |
| (hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) | |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) | |
| (hY : (cycleY E F R Γ ot).meaning (atomInput b) env = relationCode (edgeActionRelation g)) | |
| (hn : 1 ≤ n) : | |
| (cycleRelation V E F R Γ ot).meaning (atomInput b) env = relationCode (graph (actionPerm g)) := by | |
| rw [cycleRelation,meaning_cup,hY,meaning_cycleX env V E _ g hV hE hY hn] | |
| simpa only [relationCode,elements_ofFinset,←Finset.image_union] using | |
| congrArg relationCode (edge_config_union (b := b) g) | |
| lemma cycleRelations_mem (env : Fin k → HF (Atom b)) (V E F R T H N : QuotedTerm k) | |
| (Ts : Finset (Edge n)) (Ns : Finset (Edge n)) (e : Edge n) (o : Vertex n) (g : BoxGroup n) | |
| (hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) | |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) | |
| (hT : T.meaning (atomInput b) env = ofFinset (Ts.image (edgeCode b))) | |
| (hH : H.meaning (atomInput b) env = connTableCode b Ts) | |
| (hN : N.meaning (atomInput b) env = ofFinset (Ns.image (edgeCode b))) | |
| (he : e ∈ Ns) | |
| (hY : ∀ (env' : Fin (k+4) → HF (Atom b)) (Γ : QuotedTerm (k+4)), | |
| F.up.up.up.up.meaning (atomInput b) env' = F.meaning (atomInput b) env → | |
| R.up.up.up.up.meaning (atomInput b) env' = R.meaning (atomInput b) env → | |
| E.up.up.up.up.meaning (atomInput b) env' = E.meaning (atomInput b) env → | |
| Γ.meaning (atomInput b) env' = traversalCode b Ts e (tail e) (head e) → | |
| (var 0 : QuotedTerm (k+4)).meaning (atomInput b) env' = vertexCode b o → | |
| (cycleY E.up.up.up.up F.up.up.up.up R.up.up.up.up Γ (var 0)).meaning (atomInput b) env' = | |
| relationCode (edgeActionRelation g)) (hn : 1 ≤ n) : | |
| relationCode (graph (actionPerm g)) ∈ elements ((cycleRelations V E F R T H N).meaning (atomInput b) env) := by | |
| simp only [cycleRelations,meaning_cup,elements_ofFinset,Finset.mem_union,meaning_bind, | |
| QuotedTerm.meaning_up,hN,hV,Finset.mem_biUnion,Finset.mem_image,Finset.mem_univ,true_and, | |
| meaning_map,QuotedTerm.meaning_filter,Finset.mem_filter] | |
| apply Or.inr | |
| refine ⟨edgeCode b e,⟨e,he,rfl⟩,vertexCode b (tail e),⟨tail e,rfl⟩, | |
| vertexCode b (head e),⟨head e,rfl⟩,vertexCode b o,⟨⟨o,rfl⟩,?_⟩,?_⟩ | |
| · exact (meaning_hasEndpoints _ _ _ _ e (tail e) (head e) rfl rfl rfl hn).mpr (Or.inl ⟨rfl,rfl⟩) | |
| · have htr := meaning_traversal | |
| (Fin.cons (vertexCode b o) (Fin.cons (vertexCode b (head e)) | |
| (Fin.cons (vertexCode b (tail e)) (Fin.cons (edgeCode b e) env)))) | |
| V.up.up.up.up T.up.up.up.up H.up.up.up.up (var 3) (var 2) (var 1) | |
| Ts e (tail e) (head e) hV hT hH rfl rfl rfl hn | |
| exact meaning_cycleRelation_of_Y _ _ _ _ _ _ _ g hV hE (hY _ _ rfl rfl rfl htr rfl) hn | |
| end QuotedGrid | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary RelationPools | |
| variable {n : ℕ} {b : Vertex n → Scalar} | |
| namespace QuotedGrid | |
| open QuotedTerm QuotedFormula SourceSyntax | |
| variable {k : ℕ} {T₀ : RootedTree (Vertex n)} | |
| attribute [local irreducible] SourceSyntax.cycleRelations SourceSyntax.cycleY | |
| lemma cycleRelations_identity (env : Fin k → HF (Atom b)) (V E F R T H N : QuotedTerm k) : | |
| relationCode (graph 1) ∈ elements ((cycleRelations V E F R T H N).meaning (atomInput b) env) := by | |
| rw [cycleRelations,meaning_cup,elements_ofFinset] | |
| apply Finset.mem_union_left | |
| rw [meaning_singleton,Hereditary.singleton,elements_ofFinset] | |
| exact Finset.mem_singleton_self _ | |
| lemma cycleRelations_positive (env : Fin k → HF (Atom b)) (V E F R T H N : QuotedTerm k) | |
| (P : ParentEdges T₀) (Ns : Finset (Edge n)) | |
| (hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) | |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) | |
| (hF : ∀ z, z ∈ elements (F.meaning (atomInput b) env) ↔ ∃ C : CycleFrame n, frameCode b C = z) | |
| (hR : R.meaning (atomInput b) env = distancesCode b (boxGraph n)) | |
| (hT : T.meaning (atomInput b) env = ofFinset (P.treeEdges.image (edgeCode b))) | |
| (hH : H.meaning (atomInput b) env = connTableCode b P.treeEdges) | |
| (hN : N.meaning (atomInput b) env = ofFinset (Ns.image (edgeCode b))) | |
| (e : Edge n) (he : e ∈ Ns) (hne : e ∉ P.treeEdges) (hn : 1 ≤ n) : | |
| relationCode (graph (actionPerm (b := b) (⟨0,P.flow e 1⟩ : BoxGroup n))) ∈ | |
| elements ((cycleRelations V E F R T H N).meaning (atomInput b) env) := by | |
| refine cycleRelations_mem env V E F R T H N P.treeEdges Ns e originVertex | |
| (⟨0,P.flow e 1⟩ : BoxGroup n) hV hE hT hH hN he ?_ hn | |
| intro env' Γ hF' hR' hE' hΓ ho | |
| have hfe : ∀ z, z ∈ elements (F.up.up.up.up.meaning (atomInput b) env') ↔ | |
| ∃ C : CycleFrame n, frameCode b C = z := fun z => by rw [hF']; exact hF z | |
| exact meaning_cycleY env' E.up.up.up.up F.up.up.up.up R.up.up.up.up Γ (var 0) P e hne (hE'.trans hE) hfe (hR'.trans hR) hΓ ho hn | |
| lemma cycleRelations_negative (env : Fin k → HF (Atom b)) (V E F R T H N : QuotedTerm k) | |
| (P : ParentEdges T₀) (Ns : Finset (Edge n)) | |
| (hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) | |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) | |
| (hF : ∀ z, z ∈ elements (F.meaning (atomInput b) env) ↔ ∃ C : CycleFrame n, frameCode b C = z) | |
| (hR : R.meaning (atomInput b) env = distancesCode b (boxGraph n)) | |
| (hT : T.meaning (atomInput b) env = ofFinset (P.treeEdges.image (edgeCode b))) | |
| (hH : H.meaning (atomInput b) env = connTableCode b P.treeEdges) | |
| (hN : N.meaning (atomInput b) env = ofFinset (Ns.image (edgeCode b))) | |
| (e : Edge n) (he : e ∈ Ns) (hne : e ∉ P.treeEdges) (hn : 1 ≤ n) : | |
| relationCode (graph (actionPerm (b := b) (⟨0,P.flow e (-1)⟩ : BoxGroup n))) ∈ | |
| elements ((cycleRelations V E F R T H N).meaning (atomInput b) env) := by | |
| refine cycleRelations_mem env V E F R T H N P.treeEdges Ns e oppositeVertex | |
| (⟨0,P.flow e (-1)⟩ : BoxGroup n) hV hE hT hH hN he ?_ hn | |
| intro env' Γ hF' hR' hE' hΓ ho | |
| have hfe : ∀ z, z ∈ elements (F.up.up.up.up.meaning (atomInput b) env') ↔ | |
| ∃ C : CycleFrame n, frameCode b C = z := fun z => by rw [hF']; exact hF z | |
| exact meaning_reverseCycleY env' E.up.up.up.up F.up.up.up.up R.up.up.up.up Γ (var 0) P e hne (hE'.trans hE) hfe (hR'.trans hR) hΓ ho hn | |
| lemma fundamentalPool_in_cycles (env : Fin k → HF (Atom b)) (V E F R T H N : QuotedTerm k) | |
| (P : ParentEdges T₀) (Ns : Finset (Edge n)) | |
| (hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) | |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) | |
| (hF : ∀ z, z ∈ elements (F.meaning (atomInput b) env) ↔ ∃ C : CycleFrame n, frameCode b C = z) | |
| (hR : R.meaning (atomInput b) env = distancesCode b (boxGraph n)) | |
| (hT : T.meaning (atomInput b) env = ofFinset (P.treeEdges.image (edgeCode b))) | |
| (hH : H.meaning (atomInput b) env = connTableCode b P.treeEdges) | |
| (hN : N.meaning (atomInput b) env = ofFinset (Ns.image (edgeCode b))) | |
| (hoff : ∀ e ∈ Ns, e ∉ P.treeEdges) (hn : 1 ≤ n) : | |
| ∀ r ∈ P.fundamentalPool Ns, | |
| relationCode r ∈ elements ((cycleRelations V E F R T H N).meaning (atomInput b) env) := by | |
| intro r hr | |
| obtain ⟨⟨e,a⟩,hmem,rfl⟩ := Finset.mem_image.mp hr | |
| obtain ⟨he,_⟩ := Finset.mem_product.mp hmem | |
| rcases scalar_cases a with rfl | rfl | rfl | |
| · have hg : (⟨0,P.flow e 0⟩ : BoxGroup n) = 1 := by rw [P.flow_zero]; rfl | |
| have ha : actionPerm (b := b) (1 : BoxGroup n) = 1 := map_one (MulAction.toPermHom _ _) | |
| rw [hg,ha] | |
| exact cycleRelations_identity env V E F R T H N | |
| · exact cycleRelations_positive env V E F R T H N P Ns hV hE hF hR hT hH hN e he (hoff e he) hn | |
| · exact cycleRelations_negative env V E F R T H N P Ns hV hE hF hR hT hH hN e he (hoff e he) hn | |
| end QuotedGrid | |
| end | |
| noncomputable section | |
| open Classical WitnessedChoice WitnessedChoice.BGS Hereditary | |
| variable {n : ℕ} {b : Vertex n → Scalar} | |
| lemma edgeAtoms_grid : WitnessedChoice.edgeAtoms (atomInput b) = | |
| (Finset.univ : Finset (Σ e : Edge n, LocalGroup e)).image Sum.inl := by | |
| ext a | |
| simp only [WitnessedChoice.edgeAtoms,Finset.mem_filter,Finset.mem_univ,true_and, | |
| atomInput,decide_eq_true_eq,Finset.mem_image] | |
| constructor | |
| · intro h | |
| cases h with | ed e c => exact ⟨⟨e,c⟩,rfl⟩ | |
| · rintro ⟨⟨e,c⟩,rfl⟩ | |
| exact .ed e c | |
| namespace QuotedGrid | |
| open QuotedTerm QuotedFormula SourceSyntax SourceProgram | |
| attribute [local irreducible] QuotedTerm.nextEdges QuotedTerm.tree SourceSyntax.candidates | |
| lemma mem_value_candidates (p : Polynomial ℝ) (hp : GridResources p b) | |
| (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) | |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hn : 1 ≤ n) (z : HF (Atom b)) : | |
| z ∈ elements (SourceProgram.candidates.value (atomInput b) p | |
| (Fin.cons (stateCode (edgeState x)) (Fin.cons (tupleCode (List.ofFn (vertexCode b ∘ α))) Fin.elim0))) ↔ | |
| ∃ r ∈ gridCandidates α (anchoredParents α).treeEdges x, atom (.inl r) = z := by | |
| let env : Fin 3 → HF (Atom b) := Fin.cons (distancesCode b (boxGraph n)) | |
| (Fin.cons (stateCode (edgeState x)) (Fin.cons (tupleCode (List.ofFn (vertexCode b ∘ α))) Fin.elim0)) | |
| have hV := quoted_vertexBlocks (b := b) hn env | |
| have hE := quoted_edgeBlocks (b := b) env | |
| have hT := meaning_tree env (var 2) QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 0) | |
| α hα rfl hV hE rfl hn | |
| have hN := meaning_nextEdges env (var 2) QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 0) | |
| (tree (var 2) QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 0)) (var 1) | |
| α (anchoredParents α).treeEdges x hα rfl hV hE rfl hT rfl hn | |
| rw [SourceProgram.candidates,CPTTerm.value_letIn,value_distances _ p hp hn,CPTTerm.value_quoted] | |
| rw [mem_candidates env _ _ _ _ x (mem_faces env _ _ hV hE hn) hN rfl hn z] | |
| constructor | |
| · rintro ⟨e,he,s,hz,hs⟩ | |
| exact ⟨⟨e,s⟩,(mem_gridCandidates _ _ _ _).mpr ⟨he,hs⟩,hz.symm⟩ | |
| · rintro ⟨⟨e,s⟩,hr,hz⟩ | |
| obtain ⟨he,hs⟩ := (mem_gridCandidates _ _ _ _).mp hr | |
| exact ⟨e,he,s,hz.symm,hs⟩ | |
| lemma selection_candidates (p : Polynomial ℝ) (hp : GridResources p b) | |
| (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) | |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hn : 1 ≤ n) : | |
| (SourceProgram.program.body.selection (atomInput b) p | |
| (tupleCode (List.ofFn (vertexCode b ∘ α)))).candidates (edgeState x) = | |
| edgeState (gridCandidates α (anchoredParents α).treeEdges x) := by | |
| rw [GuardedProgram.candidates_eq] | |
| unfold GuardedProgram.candidateSet | |
| change decodeState (SourceProgram.candidates.value (atomInput b) p _) ∩ | |
| WitnessedChoice.edgeAtoms (atomInput b) = _ | |
| ext a | |
| simp only [Finset.mem_inter,decodeState,Finset.mem_filter,Finset.mem_univ,true_and, | |
| mem_value_candidates p hp α hα x hn,atom_injective.eq_iff,mem_edgeState] | |
| constructor | |
| · exact fun h => h.1 | |
| · rintro ⟨r,hr,rfl⟩ | |
| refine ⟨⟨r,hr,rfl⟩,?_⟩ | |
| rw [edgeAtoms_grid] | |
| exact Finset.mem_image.mpr ⟨r,Finset.mem_univ _,rfl⟩ | |
| end QuotedGrid | |
| end | |
| end WitnessedSeparation.Grid | |
| end OAI | |