Download data/lean/OAI/Computability/WitnessedChoice/TreeCorrection.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 55.3 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/TreeCorrection.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/WitnessedChoice/TreeCorrection.lean
-
curl -L -o TreeCorrection.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/TreeCorrection.lean
55.3 kB
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
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