Download data/lean/OAI/Computability/WitnessedChoice/CycleTranslation.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 53.5 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/CycleTranslation.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/WitnessedChoice/CycleTranslation.lean
-
curl -L -o CycleTranslation.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/CycleTranslation.lean
53.5 kB
import OAI.Computability.WitnessedChoice.AnchoredTree
namespace OAI
section
namespace WitnessedChoice.BGS.QuotedTerm
noncomputable section
open Classical WitnessedSeparation WitnessedSeparation.Hereditary
variable {A B : Type} [Fintype A] [Fintype B] {k : ℕ}
lemma mem_tupleProduct_image (m : ℕ) (r : QuotedTerm k) (S : Input A) (env : Fin k → HF A)
(code : B → HF A) (hr : r.meaning S env = ofFinset (Finset.univ.image code)) (z : HF A) :
z ∈ elements ((tupleProduct m r).meaning S env) ↔
∃ f : Fin m → B, tupleCode (List.ofFn (code ∘ f)) = z := by
rw [mem_tupleProduct]
simp only [hr,elements_ofFinset,Finset.mem_image,Finset.mem_univ,true_and]
constructor
· rintro ⟨g,hg,hz⟩
choose f hf using hg
exact ⟨f,by simpa only [show code ∘ f = g from funext hf] using hz⟩
· rintro ⟨f,hf⟩
exact ⟨code ∘ f,fun i => ⟨f i,rfl⟩,hf⟩
end
end WitnessedChoice.BGS.QuotedTerm
namespace WitnessedSeparation.Grid
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
lemma endpoints_incident_iff (e : Edge n) (u v : Vertex n) :
((u = tail e ∧ v = head e) ∨ (v = tail e ∧ u = head e)) ↔
u ≠ v ∧ incident u e ∧ incident v e := by
constructor
· rintro (⟨rfl,rfl⟩ | ⟨rfl,rfl⟩)
· exact ⟨(head_ne_tail e).symm,Or.inr rfl,Or.inl rfl⟩
· exact ⟨head_ne_tail e,Or.inl rfl,Or.inr rfl⟩
· rintro ⟨hne,(hu|hu),(hv|hv)⟩
· exact (hne (hu.symm.trans hv)).elim
· exact Or.inr ⟨hv.symm,hu.symm⟩
· exact Or.inl ⟨hu.symm,hv.symm⟩
· exact (hne (hu.symm.trans hv)).elim
def frameCode (b : Vertex n → Scalar) (C : CycleFrame n) : HF (Atom b) :=
Hereditary.pair (tupleCode (List.ofFn (vertexCode b ∘ C.vertex)))
(tupleCode (List.ofFn (edgeCode b ∘ C.edge)))
namespace QuotedGrid
open QuotedTerm QuotedFormula SourceSyntax
variable {k : ℕ}
@[simp] lemma next4_eq_add (i : Fin 4) : next4 i = i+1 := rfl
@[simp] lemma prev4_eq_add (i : Fin 4) : prev4 i = i+3 := rfl
lemma adjacent_index_iff (i j : Fin 4) : (j=next4 i ∨ j=prev4 i) ↔ AdjacentIndex i j := by
rw [next4_eq_add,prev4_eq_add]
revert i j
unfold AdjacentIndex
decide
lemma meaning_fv_pair (env : Fin k → HF (Atom b)) (ft : QuotedTerm k)
(v : Fin 4 → Vertex n) (e : Fin 4 → Edge n)
(hf : ft.meaning (atomInput b) env = Hereditary.pair (tupleCode (List.ofFn (vertexCode b ∘ v)))
(tupleCode (List.ofFn (edgeCode b ∘ e)))) (i : Fin 4) :
(fv ft i).meaning (atomInput b) env = vertexCode b (v i) := by
exact meaning_component_ofFn _ _ _ _ (meaning_fst_of_eq _ _ _ _ _ hf) i
lemma meaning_fe_pair (env : Fin k → HF (Atom b)) (ft : QuotedTerm k)
(v : Fin 4 → Vertex n) (e : Fin 4 → Edge n)
(hf : ft.meaning (atomInput b) env = Hereditary.pair (tupleCode (List.ofFn (vertexCode b ∘ v)))
(tupleCode (List.ofFn (edgeCode b ∘ e)))) (i : Fin 4) :
(fe ft i).meaning (atomInput b) env = edgeCode b (e i) := by
exact meaning_component_ofFn _ _ _ _ (meaning_snd_of_eq _ _ _ _ _ hf) i
lemma meaning_faceDescription (env : Fin k → HF (Atom b)) (ft : QuotedTerm k)
(v : Fin 4 → Vertex n) (e : Fin 4 → Edge n)
(hf : ft.meaning (atomInput b) env = Hereditary.pair (tupleCode (List.ofFn (vertexCode b ∘ v)))
(tupleCode (List.ofFn (edgeCode b ∘ e)))) (hn : 1 ≤ n) :
(faceDescription ft).meaning (atomInput b) env ↔
Function.Injective v ∧ Function.Injective e ∧
∀ i, (v i = tail (e i) ∧ v (i+1) = head (e i)) ∨
(v (i+1) = tail (e i) ∧ v i = head (e i)) := by
have hv := meaning_fv_pair env ft v e hf
have he := meaning_fe_pair env ft v e hf
have ha (i : Fin 4) : (hasEndpoints (fe ft i) (fv ft i) (fv ft (next4 i))).meaning (atomInput b) env ↔
((v i = tail (e i) ∧ v (i+1) = head (e i)) ∨
(v (i+1) = tail (e i) ∧ v i = head (e i))) := by
simp only [next4_eq_add,hasEndpoints,meaning_and,meaning_neg,meaning_eq,hv,(vertexCode_injective hn).eq_iff,
meaning_incident env _ _ _ _ (hv i) (he i) hn,
meaning_incident env _ _ _ _ (hv (i+1)) (he i) hn]
exact (endpoints_incident_iff (e i) (v i) (v (i+1))).symm
have hne (i j : Fin 4) : (if i=j then truth else
(eq (fv ft i) (fv ft j)).neg.and (eq (fe ft i) (fe ft j)).neg).meaning (atomInput b) env ↔
(i ≠ j → v i ≠ v j ∧ e i ≠ e j) := by
split_ifs with hij
· simp [truth,hij]
· simp only [meaning_and,meaning_neg,meaning_eq,hv,he,(vertexCode_injective hn).eq_iff,
edgeCode_injective.eq_iff,Ne,hij,not_false_eq_true,true_implies]
simp only [faceDescription,meaning_allFin,meaning_and,hne,ha]
constructor
· intro hh
refine ⟨?_,?_,fun i => (hh i).2⟩
· intro i j hij
by_contra hn
exact ((hh i).1 j hn).1 hij
· intro i j hij
by_contra hn
exact ((hh i).1 j hn).2 hij
· rintro ⟨hv,he,hh⟩ i
exact ⟨fun j hij => ⟨fun h => hij (hv h),fun h => hij (he h)⟩,hh i⟩
lemma mem_faces (env : Fin k → HF (Atom b)) (VT Et : QuotedTerm k)
(hV : VT.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b)))
(hE : Et.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b)))
(hn : 1 ≤ n) (z : HF (Atom b)) :
z ∈ elements ((faces VT Et).meaning (atomInput b) env) ↔
∃ C : CycleFrame n, frameCode b C = z := by
have hTV (t : HF (Atom b)) := mem_tupleProduct_image 4 VT (atomInput b) env (vertexCode b) hV t
have hTE (t u : HF (Atom b)) := mem_tupleProduct_image 4 Et.up (atomInput b) (Fin.cons t env)
(edgeCode b) (by exact hE) u
simp only [faces,QuotedTerm.meaning_filter,meaning_bind,meaning_map,meaning_pair,meaning_var,
Fin.cons_zero,Fin.cons_one,elements_ofFinset,Finset.mem_filter,Finset.mem_biUnion,
Finset.mem_image,hTV,hTE,exists_exists_eq_and]
constructor
· rintro ⟨⟨v,e,rfl⟩,hd⟩
have hh := (meaning_faceDescription (Fin.cons _ env) (var 0) v e rfl hn).mp hd
exact ⟨⟨v,e,hh.1,hh.2.1,hh.2.2⟩,rfl⟩
· rintro ⟨C,rfl⟩
refine ⟨⟨C.vertex,C.edge,rfl⟩,?_⟩
exact (meaning_faceDescription (Fin.cons _ env) (var 0) C.vertex C.edge rfl hn).mpr
⟨C.vertex_injective,C.edge_injective,C.endpoints⟩
end QuotedGrid
end
end WitnessedSeparation.Grid
end
namespace WitnessedSeparation.Grid
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
namespace QuotedGrid
open QuotedTerm QuotedFormula SourceSyntax
variable {k : ℕ}
lemma meaning_hasEndpoints (env : Fin k → HF (Atom b)) (et ut vt : QuotedTerm k)
(e : Edge n) (u v : Vertex n)
(he : et.meaning (atomInput b) env = edgeCode b e)
(hu : ut.meaning (atomInput b) env = vertexCode b u)
(hv : vt.meaning (atomInput b) env = vertexCode b v) (hn : 1 ≤ n) :
(hasEndpoints et ut vt).meaning (atomInput b) env ↔
((u=tail e ∧ v=head e) ∨ (v=tail e ∧ u=head e)) := by
simp only [hasEndpoints,meaning_and,meaning_neg,meaning_eq,hu,hv,
(vertexCode_injective hn).eq_iff,meaning_incident env ut et u e hu he hn,
meaning_incident env vt et v e hv he hn]
exact (endpoints_incident_iff e u v).symm
lemma meaning_tree (env : Fin k → HF (Atom b)) (ats VT Et R : QuotedTerm k)
(α : Fin 4 → Vertex 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)))
(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))))
(hn : 1 ≤ n) :
(tree ats VT Et R).meaning (atomInput b) env =
ofFinset ((anchoredParents α).treeEdges.image (edgeCode b)) := by
have hr := QuotedTerm.meaning_root (atomInput b) env ats VT R (vertexCode b)
(vertexCode_injective hn) (boxGraph n) (boxGraph_connected n) α hα hV hR (vertex_card_le_atoms hn)
have hpred (e : Edge n) :
(existsIn VT.up (existsIn VT.up.up
((QuotedFormula.parent ats.up.up.up VT.up.up.up Et.up.up.up R.up.up.up
(root ats VT R).up.up.up (var 1) (var 0)).and
(hasEndpoints (var 2) (var 1) (var 0))))).meaning (atomInput b)
(Fin.cons (edgeCode b e) env) ↔ e ∈ (anchoredParents α).treeEdges := by
have hp (v w : Vertex n) := meaning_parent
(Fin.cons (vertexCode b w) (Fin.cons (vertexCode b v) (Fin.cons (edgeCode b e) env)))
ats.up.up.up VT.up.up.up Et.up.up.up R.up.up.up (root ats VT R).up.up.up (var 1) (var 0)
α v w hres hα hV hE hR hr rfl rfl hn
have hep (v w : Vertex n) := meaning_hasEndpoints
(Fin.cons (vertexCode b w) (Fin.cons (vertexCode b v) (Fin.cons (edgeCode b e) env)))
(var 2) (var 1) (var 0) e v w rfl rfl rfl hn
simp only [meaning_existsIn,QuotedTerm.meaning_up,hV,elements_ofFinset,Finset.mem_image,
Finset.mem_univ,true_and,exists_exists_eq_and,meaning_and,hp,hep]
constructor
· rintro ⟨v,w,⟨hv,rfl⟩,he⟩
have hpe := (anchoredParents α).endpoints v hv
have heq : e = (anchoredParents α).edge v hv := by
apply edge_eq_of_endpoints
rcases he with ⟨ht,hh⟩ | ⟨ht,hh⟩ <;> rcases hpe with ⟨hp,hp'⟩ | ⟨hp',hp⟩
· exact Or.inr ⟨ht.symm.trans hp.symm,hh.symm.trans hp'.symm⟩
· exact Or.inl ⟨ht.symm.trans hp'.symm,hh.symm.trans hp.symm⟩
· exact Or.inl ⟨ht.symm.trans hp'.symm,hh.symm.trans hp.symm⟩
· exact Or.inr ⟨ht.symm.trans hp.symm,hh.symm.trans hp'.symm⟩
rw [heq]
exact (anchoredParents α).edge_mem v hv
· intro he
obtain ⟨v,_,rfl⟩ := Finset.mem_image.mp he
refine ⟨v.val,(anchoredTree α).parent v.val,⟨v.property,rfl⟩,?_⟩
rcases (anchoredParents α).endpoints v.val v.property with ⟨hh,ht⟩ | ⟨ht,hh⟩
· exact Or.inr ⟨ht.symm,hh.symm⟩
· exact Or.inl ⟨ht.symm,hh.symm⟩
simp only [tree,QuotedTerm.meaning_filter,hE,elements_ofFinset]
congr 1
ext z
simp only [Finset.mem_filter,Finset.mem_image,Finset.mem_univ,true_and]
constructor
· rintro ⟨⟨e,rfl⟩,h⟩
exact ⟨e,(hpred e).mp h,rfl⟩
· rintro ⟨e,he,rfl⟩
exact ⟨⟨e,rfl⟩,(hpred e).mpr he⟩
end QuotedGrid
end
end WitnessedSeparation.Grid
section
namespace WitnessedChoice.BGS
noncomputable section
open Classical WitnessedSeparation WitnessedSeparation.Hereditary
namespace QuotedTerm
variable {k : ℕ} {A V : Type} [Fintype A] [Fintype V]
lemma meaning_tripleDomain (S : Input A) (env : Fin k → HF A) (VT : QuotedTerm k)
(code : V → HF A) (hV : VT.meaning S env = ofFinset (Finset.univ.image code)) :
(tripleDomain VT).meaning S env =
ofFinset (Finset.univ.image (distanceCode code)) := by
simp only [tripleDomain,meaning_bind,meaning_up,hV,elements_ofFinset,meaning_map,
meaning_indices,meaning_triple,meaning_var,Fin.cons_zero,Fin.cons_one,fin_cons_two]
apply ofFinset_inj.mpr
ext z
simp only [Finset.mem_biUnion,Finset.mem_image,Finset.mem_univ,true_and]
constructor
· rintro ⟨_,⟨v,rfl⟩,_,⟨w,rfl⟩,i,hi,rfl⟩
obtain ⟨k,hk,rfl⟩ := (mem_ordinal i (Fintype.card A+1)).mp hi
exact ⟨(v,w,⟨k,hk⟩),rfl⟩
· rintro ⟨⟨v,w,i⟩,rfl⟩
exact ⟨code v,⟨v,rfl⟩,code w,⟨w,rfl⟩,ordinal i.val,
(ordinal_mem_elements _ _).mpr i.isLt,rfl⟩
end QuotedTerm
namespace SourceProgram
def cost : Polynomial ℕ :=
Polynomial.X^2*(Polynomial.X+1) +
(QuotedTerm.tripleDomain (QuotedTerm.vertexBlocks : QuotedTerm 0)).code.traceBound.comp
(Polynomial.X+1) + Polynomial.X+2
def polynomial : Polynomial ℝ := cost.map (Nat.castRingHom ℝ)
lemma resource_polynomial (m : ℕ) : resource polynomial m = cost.eval m := by
unfold resource polynomial
rw [Polynomial.eval_map]
have h : Polynomial.eval₂ (Nat.castRingHom ℝ) (m : ℝ) cost = ((cost.eval m : ℕ) : ℝ) := by
exact Polynomial.eval₂_at_apply (Nat.castRingHom ℝ) m
rw [h,Nat.floor_natCast]
lemma resource_basic (m : ℕ) : m+2 ≤ resource polynomial m := by
rw [resource_polynomial]
simp only [cost,Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_pow,
Polynomial.eval_X,Polynomial.eval_one,Polynomial.eval_ofNat]
omega
end SourceProgram
end
end WitnessedChoice.BGS
namespace WitnessedSeparation.Grid
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
structure GridResources (p : Polynomial ℝ) (b : Vertex n → Scalar) : Prop where
basic : Fintype.card (Atom b)+2 ≤ resource p (Fintype.card (Atom b))
time : Fintype.card (BFS.Item (Vertex n) (Fintype.card (Atom b))) ≤ resource p (Fintype.card (Atom b))
space : (TC (ofFinset (Finset.univ.image (distanceCode (vertexCode b))))).card ≤
resource p (Fintype.card (Atom b))
lemma gridResources (hn : 1 ≤ n) : GridResources SourceProgram.polynomial b := by
refine ⟨SourceProgram.resource_basic _,?_,?_⟩
· rw [SourceProgram.resource_polynomial]
simp only [SourceProgram.cost,Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_pow,
Polynomial.eval_X,Polynomial.eval_one,Polynomial.eval_ofNat]
have h := vertex_card_le_atoms (b := b) hn
have hc : Fintype.card (BFS.Item (Vertex n) (Fintype.card (Atom b))) ≤
Fintype.card (Atom b)^2*(Fintype.card (Atom b)+1) := by
have h₂ := Nat.mul_le_mul_right (Fintype.card (Atom b)+1) (Nat.mul_self_le_mul_self h)
simpa only [BFS.Item,Fintype.card_prod,Fintype.card_fin,pow_two,Nat.mul_assoc] using h₂
omega
· have h := QuotedTerm.TC_bound
(QuotedTerm.tripleDomain (QuotedTerm.vertexBlocks : QuotedTerm 0))
(atomInput b) Fin.elim0 (Fintype.card (Atom b)+1) (by simp [tracePotential])
rw [QuotedTerm.meaning_tripleDomain _ _ _ (vertexCode b) (quoted_vertexBlocks hn _)] at h
apply h.trans
rw [SourceProgram.resource_polynomial]
simp only [SourceProgram.cost,Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_pow,
Polynomial.eval_X,Polynomial.eval_one,Polynomial.eval_ofNat,Polynomial.eval_comp]
omega
end
end WitnessedSeparation.Grid
end
namespace WitnessedSeparation.Grid
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
lemma mem_edgeCode_iff (e : Edge n) (z : HF (Atom b)) :
z ∈ elements (edgeCode b e) ↔ ∃ s : LocalGroup e, z = atom (.inl ⟨e,s⟩) := by
simp only [edgeCode,stateCode,elements_ofFinset,Finset.mem_image,mem_edgeBlockSet]
constructor
· rintro ⟨a,⟨s,rfl⟩,rfl⟩
exact ⟨s,rfl⟩
· rintro ⟨s,rfl⟩
exact ⟨_,⟨s,rfl⟩,rfl⟩
lemma mem_vertexCode_iff (v : Vertex n) (z : HF (Atom b)) :
z ∈ elements (vertexCode b v) ↔ ∃ s : Configuration b v, z = atom (.inr ⟨v,s⟩) := by
simp only [vertexCode,stateCode,elements_ofFinset,Finset.mem_image,mem_vertexBlockSet]
constructor
· rintro ⟨a,⟨s,rfl⟩,rfl⟩
exact ⟨s,rfl⟩
· rintro ⟨s,rfl⟩
exact ⟨_,⟨s,rfl⟩,rfl⟩
lemma exists_edgeCode (e : Edge n) (P : HF (Atom b) → Prop) :
(∃ z ∈ elements (edgeCode b e), P z) ↔ ∃ s : LocalGroup e, P (atom (.inl ⟨e,s⟩)) := by
simp only [mem_edgeCode_iff]
constructor
· rintro ⟨_,⟨s,rfl⟩,h⟩
exact ⟨s,h⟩
· rintro ⟨s,h⟩
exact ⟨_,⟨s,rfl⟩,h⟩
lemma exists_vertexCode (v : Vertex n) (P : HF (Atom b) → Prop) :
(∃ z ∈ elements (vertexCode b v), P z) ↔ ∃ s : Configuration b v, P (atom (.inr ⟨v,s⟩)) := by
simp only [mem_vertexCode_iff]
constructor
· rintro ⟨_,⟨s,rfl⟩,h⟩
exact ⟨s,h⟩
· rintro ⟨s,h⟩
exact ⟨_,⟨s,rfl⟩,h⟩
@[simp] lemma atom_mem_edgeCode (e d : Edge n) (s : LocalGroup e) :
atom (.inl ⟨e,s⟩) ∈ elements (edgeCode b d) ↔ e=d := by
rw [mem_edgeCode_iff]
constructor
· rintro ⟨t,ht⟩
exact congrArg Sigma.fst (Sum.inl.inj (atom_injective ht))
· rintro rfl
exact ⟨s,rfl⟩
lemma input_inc_iff (v : Vertex n) (c : Configuration b v) (e : Edge n) (s : LocalGroup e) :
inputHF (atomInput b) .I (atom (.inr ⟨v,c⟩)) (atom (.inl ⟨e,s⟩)) = true ↔
∃ h : incident v e, c.state ⟨e,h⟩ = s := by
rw [inputHF_atoms]
change decide (AtomRelation b .I (.inr ⟨v,c⟩) (.inl ⟨e,s⟩)) = true ↔ _
rw [decide_eq_true_eq]
constructor
· intro h
cases h with | inc v c e => exact ⟨e.property,rfl⟩
· rintro ⟨h,rfl⟩
exact .inc v c ⟨e,h⟩
namespace QuotedGrid
open QuotedTerm QuotedFormula SourceSyntax
variable {k : ℕ}
lemma meaning_adjacentMatch (env : Fin k → HF (Atom b)) (ft st tt : QuotedTerm k)
(C : CycleFrame n) (i j : Fin 4) (s : LocalGroup (C.edge i)) (t : LocalGroup (C.edge j))
(hf : ft.meaning (atomInput b) env = frameCode b C)
(hs : st.meaning (atomInput b) env = atom (.inl ⟨C.edge i,s⟩))
(ht : tt.meaning (atomInput b) env = atom (.inl ⟨C.edge j,t⟩)) :
(adjacentMatch ft st tt i j).meaning (atomInput b) env ↔ C.Across (b := b) i j s t := by
have hv := meaning_fv_pair env ft C.vertex C.edge hf
have he := meaning_fe_pair env ft C.vertex C.edge hf
have hj : C.vertex (if j=next4 i then j else i) = C.joint i j := by
by_cases h : j=i+1 <;> simp [next4_eq_add,CycleFrame.joint,h]
simp only [adjacentMatch,meaning_allList,List.mem_cons,List.mem_nil_iff,forall_eq_or_imp,
forall_false,implies_true,and_true,meaning_mem,hs,ht,he,atom_mem_edgeCode,meaning_existsIn,hv,hj,
exists_vertexCode,meaning_and,meaning_input,meaning_var,
Fin.cons_zero,QuotedTerm.meaning_up,input_inc_iff,true_and]
constructor
· rintro ⟨c,⟨hi,hs⟩,⟨hj,ht⟩⟩
exact ⟨hi,hj,c,hs,ht⟩
· rintro ⟨hi,hj,c,hs,ht⟩
exact ⟨c,⟨hi,hs⟩,⟨hj,ht⟩⟩
lemma meaning_matchFace (env : Fin k → HF (Atom b)) (ft st tt : QuotedTerm k)
(C : CycleFrame n) (i j : Fin 4) (s : LocalGroup (C.edge i)) (t : LocalGroup (C.edge j))
(hf : ft.meaning (atomInput b) env = frameCode b C)
(hs : st.meaning (atomInput b) env = atom (.inl ⟨C.edge i,s⟩))
(ht : tt.meaning (atomInput b) env = atom (.inl ⟨C.edge j,t⟩)) :
(matchFace ft st tt).meaning (atomInput b) env ↔ C.Match (b := b) i j s t := by
have he := meaning_fe_pair env ft C.vertex C.edge hf
simp only [matchFace,meaning_anyFin,meaning_and,meaning_mem,hs,ht,he,
atom_mem_edgeCode,C.edge_injective.eq_iff,exists_and_left,exists_eq_left']
simp only [adjacent_index_iff]
unfold CycleFrame.Match
split_ifs with h
· exact meaning_adjacentMatch env ft st tt C i j s t hf hs ht
· simp only [meaning_existsIn,he,next4_eq_add,exists_edgeCode,
meaning_and]
apply exists_congr
intro q
exact and_congr (meaning_adjacentMatch (Fin.cons _ env) ft.up st.up (var 0) C i (i+1) s q hf hs rfl)
(meaning_adjacentMatch (Fin.cons _ env) ft.up tt.up (var 0) C j (i+1) t q hf ht rfl)
end QuotedGrid
end
noncomputable section
open Classical WitnessedChoice WitnessedChoice.TreeTest
variable {n : ℕ}
lemma edgeGraph_erase (T : Finset (Edge n)) (h : Edge n) :
edgeGraph (T.erase h) = (edgeGraph T).deleteEdges {symEdge h} := by
apply SimpleGraph.edgeSet_injective
rw [SimpleGraph.edgeSet_deleteEdges]
apply Set.ext
intro q
rw [← SimpleGraph.mem_edgeFinset,edgeGraph_edgeFinset]
simp only [Set.mem_sdiff, Set.mem_singleton_iff]
rw [← SimpleGraph.mem_edgeFinset,edgeGraph_edgeFinset]
simp only [Finset.mem_image,Finset.mem_erase]
constructor
· rintro ⟨e,⟨he,heT⟩,rfl⟩
exact ⟨⟨e,heT,rfl⟩,fun hh => he (symEdge_injective hh)⟩
· rintro ⟨⟨e,heT,rfl⟩,he⟩
exact ⟨e,⟨fun hh => he (congrArg symEdge hh),heT⟩,rfl⟩
lemma cut_cover (T : Finset (Edge n)) (hT : (edgeGraph T).Connected) (h : Edge n) (v : Vertex n) :
(edgeGraph (T.erase h)).Reachable (head h) v ∨
(edgeGraph (T.erase h)).Reachable (tail h) v := by
have transport {u v : Vertex n} (p : (edgeGraph T).Walk u v) :
((edgeGraph (T.erase h)).Reachable (head h) u ∨
(edgeGraph (T.erase h)).Reachable (tail h) u) →
((edgeGraph (T.erase h)).Reachable (head h) v ∨
(edgeGraph (T.erase h)).Reachable (tail h) v) := by
induction p with
| nil => exact id
| @cons u w v hadj p ih =>
intro hu
apply ih
obtain ⟨e,he,hh⟩ := hadj
by_cases heh : e = h
· subst e
rcases hh with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
· exact Or.inl .rfl
· exact Or.inr .rfl
· have hw : (edgeGraph (T.erase h)).Adj u w := ⟨e,Finset.mem_erase.mpr ⟨heh,he⟩,hh⟩
exact hu.imp (fun x => x.trans hw.reachable) (fun x => x.trans hw.reachable)
exact transport (hT (head h) v).some (Or.inl .rfl)
namespace ParentEdges
variable {T : RootedTree (Vertex n)} (P : ParentEdges T)
def cut (h : Edge n) : SimpleGraph (Vertex n) := edgeGraph (P.treeEdges.erase h)
lemma cut_separated (h : Edge n) (hh : h ∈ P.treeEdges) :
¬(P.cut h).Reachable (tail h) (head h) := by
have ha : (edgeGraph P.treeEdges).Adj (tail h) (head h) := ⟨h,hh,Or.inl ⟨rfl,rfl⟩⟩
have hb := (SimpleGraph.isAcyclic_iff_forall_adj_isBridge.mp P.graph_isTree.isAcyclic) ha
simpa only [SimpleGraph.isBridge_iff,cut,edgeGraph_erase,symEdge] using hb
lemma cut_reachable_iff (h : Edge n) (_hh : h ∈ P.treeEdges) (u v : Vertex n) :
(P.cut h).Reachable u v ↔
((P.cut h).Reachable (head h) u ↔ (P.cut h).Reachable (head h) v) := by
constructor
· intro huv
exact ⟨fun hu => hu.trans huv,fun hv => hv.trans huv.symm⟩
· intro huv
rcases cut_cover P.treeEdges P.graph_connected h u with hu | hu
· exact hu.symm.trans (huv.mp hu)
· rcases cut_cover P.treeEdges P.graph_connected h v with hv | hv
· exact (huv.mpr hv).symm.trans hv
· exact hu.symm.trans hv
def cutIndicator (h : Edge n) (v : Vertex n) : Scalar :=
if (P.cut h).Reachable (head h) v then 1 else 0
lemma cutIndicator_head (h : Edge n) : P.cutIndicator h (head h) = 1 := by
simp [cutIndicator,SimpleGraph.Reachable.rfl]
lemma cutIndicator_tail (h : Edge n) (hh : h ∈ P.treeEdges) : P.cutIndicator h (tail h) = 0 := by
rw [cutIndicator,ite_eq_right (fun hth => P.cut_separated h hh hth.symm)]
lemma cutIndicator_eq (h : Edge n) {u v : Vertex n} (huv : (P.cut h).Reachable u v) :
P.cutIndicator h u = P.cutIndicator h v := by
have he : (P.cut h).Reachable (head h) u ↔ (P.cut h).Reachable (head h) v :=
⟨fun hu => hu.trans huv, fun hv => hv.trans huv.symm⟩
simp only [cutIndicator,he]
lemma cut_gradient_self (h : Edge n) (hh : h ∈ P.treeEdges) :
gradient (P.cutIndicator h) h = 1 := by
rw [gradient,P.cutIndicator_head,P.cutIndicator_tail h hh,sub_zero]
lemma cut_gradient_other (h f : Edge n) (hf : f ∈ P.treeEdges) (hne : f ≠ h) :
gradient (P.cutIndicator h) f = 0 := by
have ha : (P.cut h).Adj (tail f) (head f) := ⟨f,Finset.mem_erase.mpr ⟨hne,hf⟩,Or.inl ⟨rfl,rfl⟩⟩
rw [gradient,P.cutIndicator_eq h ha.reachable,sub_self]
lemma flow_cut (e : Edge n) (he : e ∉ P.treeEdges) (a : Scalar)
(h : Edge n) (hh : h ∈ P.treeEdges) :
(P.flow e a).val h =
(P.cutIndicator h (tail e) - P.cutIndicator h (head e)) * a := by
have hhe : h ≠ e := by intro hhe; subst h; exact he hh
have hp := pairing_gradient_flow (P.cutIndicator h) (P.flow e a)
change (∑ f, gradient (P.cutIndicator h) f * (P.flow e a).val f) = 0 at hp
have hs : (∑ f, gradient (P.cutIndicator h) f * (P.flow e a).val f) =
gradient (P.cutIndicator h) h * (P.flow e a).val h +
gradient (P.cutIndicator h) e * (P.flow e a).val e := by
apply Fintype.sum_eq_add _ _ hhe
rintro f ⟨hfh,hfe⟩
by_cases hf : f ∈ P.treeEdges
· rw [P.cut_gradient_other h f hf hfh,zero_mul]
· rw [P.flow_other e f hf hfe a,mul_zero]
rw [hs,P.cut_gradient_self h hh,one_mul,P.flow_self e he a,gradient] at hp
linear_combination hp
end ParentEdges
end
end WitnessedSeparation.Grid
section
namespace WitnessedChoice.BGS
noncomputable section
open Classical WitnessedSeparation WitnessedSeparation.Hereditary QuotedTerm
namespace QuotedFormula
variable {k : ℕ} {A V : Type} [Fintype A] [Fintype V]
lemma meaning_connected (S : Input A) (env : Fin k → HF A)
(RT ut vt : QuotedTerm k) (code : V → HF A) (hc : Function.Injective code)
(G : SimpleGraph V) (u v : V)
(hR : RT.meaning S env = ofFinset ((BFS.closure G (Fintype.card A)).image (distanceCode code)))
(hu : ut.meaning S env = code u) (hv : vt.meaning S env = code v)
(hcard : Fintype.card V ≤ Fintype.card A) :
(connected RT ut vt).meaning S env ↔ G.Reachable u v := by
simp only [connected,meaning_mem,meaning_triple,hu,hv,meaning_card,meaning_atoms,hR]
rw [show cardHF (stateCode (Finset.univ : Finset A)) = ordinal (Fintype.card A) by
simp [cardHF,stateCode,Finset.card_image_of_injective _ atom_injective]]
change HFTriple (code u) (code v) (ordinal (Fintype.card A)) ∈
elements (ofFinset ((BFS.closure G (Fintype.card A)).image (distanceCode code))) ↔ _
rw [coded_closure_mem code hc G u v _ le_rfl]
constructor
· rintro ⟨w,_⟩
exact ⟨w⟩
· intro h
obtain ⟨w,hw⟩ := h.exists_isPath
exact ⟨w,(Nat.le_of_lt hw.length_lt).trans hcard⟩
end QuotedFormula
end
end WitnessedChoice.BGS
namespace WitnessedSeparation.Grid
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
def distancesCode (b : Vertex n → Scalar) (G : SimpleGraph (Vertex n)) : HF (Atom b) :=
ofFinset ((BFS.closure G (Fintype.card (Atom b))).image (distanceCode (vertexCode b)))
def connTableCode (b : Vertex n → Scalar) (T : Finset (Edge n)) : HF (Atom b) :=
ofFinset (T.image (fun h => Hereditary.pair (edgeCode b h) (distancesCode b (edgeGraph (T.erase h)))))
namespace QuotedGrid
open QuotedTerm QuotedFormula SourceSyntax
variable {k : ℕ}
lemma meaning_connWithout (env : Fin k → HF (Atom b)) (HT ht ut vt : QuotedTerm k)
(T : Finset (Edge n)) (h : Edge n) (u v : Vertex n)
(hH : HT.meaning (atomInput b) env = connTableCode b T)
(hh : ht.meaning (atomInput b) env = edgeCode b h)
(hu : ut.meaning (atomInput b) env = vertexCode b u)
(hv : vt.meaning (atomInput b) env = vertexCode b v) (hn : 1 ≤ n) :
(connWithout HT ht ut vt).meaning (atomInput b) env ↔
h ∈ T ∧ (edgeGraph (T.erase h)).Reachable u v := by
have hm (e : Edge n) := QuotedFormula.meaning_connected (atomInput b)
(Fin.cons (Hereditary.pair (edgeCode b e) (distancesCode b (edgeGraph (T.erase e)))) env)
(var 0).snd ut.up vt.up (vertexCode b) (vertexCode_injective hn) (edgeGraph (T.erase e)) u v
(meaning_snd_of_eq _ _ _ _ _ rfl) hu hv (vertex_card_le_atoms hn)
simp only [connWithout,meaning_existsIn,hH,connTableCode,elements_ofFinset,Finset.mem_image,
exists_exists_and_eq_and,meaning_and,meaning_eq,meaning_fst,meaning_var,Fin.cons_zero,
firstHF_pair (atomInput b),QuotedTerm.meaning_up,hh,edgeCode_injective.eq_iff,hm]
constructor
· rintro ⟨a,ha,rfl,hr⟩
exact ⟨ha,hr⟩
· rintro ⟨hh,hr⟩
exact ⟨h,hh,rfl,hr⟩
end QuotedGrid
end
end WitnessedSeparation.Grid
end
namespace WitnessedSeparation.Grid
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
namespace QuotedGrid
open QuotedTerm QuotedFormula SourceSyntax SourceProgram
variable {k : ℕ}
lemma value_distance_edges (env : Fin k → HF (Atom b)) (V E : QuotedTerm k)
(D : Finset (Edge n)) (p : Polynomial ℝ) (hp : GridResources p b)
(hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b)))
(hE : E.meaning (atomInput b) env = ofFinset (D.image (edgeCode b))) (hn : 1 ≤ n) :
(CPTTerm.distance (.quoted V) (.quoted E)).value (atomInput b) p env = distancesCode b (edgeGraph D) := by
apply CPTTerm.distance_value (.quoted V) (.quoted E) (atomInput b) p env
(vertexCode b) (vertexCode_injective hn) (edgeGraph D) (by simpa only [CPTTerm.value_quoted] using hV) _ hp.time hp.space
intro u v
simpa only [CPTTerm.value_quoted,hE] using blockAdjacent_edges (b := b) hn D u v
lemma value_distances (env : Fin k → HF (Atom b)) (p : Polynomial ℝ)
(hp : GridResources p b) (hn : 1 ≤ n) :
(SourceProgram.distances : CPTTerm k).value (atomInput b) p env = distancesCode b (boxGraph n) := by
unfold SourceProgram.distances
rw [value_distance_edges env _ _ Finset.univ p hp (quoted_vertexBlocks hn env) (quoted_edgeBlocks env) hn,
edgeGraph_univ]
lemma value_connTable (env : Fin k → HF (Atom b)) (V T : QuotedTerm k)
(D : Finset (Edge n)) (p : Polynomial ℝ) (hp : GridResources p b)
(hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b)))
(hT : T.meaning (atomInput b) env = ofFinset (D.image (edgeCode b))) (hn : 1 ≤ n) :
(SourceProgram.connTable V T).value (atomInput b) p env = connTableCode b D := by
have hd (e : Edge n) :
(T.up.diff (var 0).singleton).meaning (atomInput b) (Fin.cons (edgeCode b e) env) =
ofFinset ((D.erase e).image (edgeCode b)) := by
simp only [meaning_diff,QuotedTerm.meaning_up,hT,meaning_singleton,meaning_var,
Fin.cons_zero,elements_ofFinset,Hereditary.singleton]
congr 1
ext z
simp only [Finset.mem_filter,Finset.mem_image,Finset.mem_erase,Finset.mem_singleton]
constructor
· rintro ⟨⟨f,hf,rfl⟩,hne⟩
exact ⟨f,⟨fun h => hne (by rw [h]),hf⟩,rfl⟩
· rintro ⟨f,⟨hne,hf⟩,rfl⟩
exact ⟨⟨f,hf,rfl⟩,fun h => hne (edgeCode_injective h)⟩
simp only [SourceProgram.connTable,CPTTerm.value_map,CPTTerm.value_quoted,hT,elements_ofFinset,
connTableCode,Finset.image_image]
apply congrArg ofFinset
apply Finset.image_congr
intro e he
simp only [Function.comp_apply]
rw [CPTTerm.value_letIn,value_distance_edges (Fin.cons (edgeCode b e) env) V.up (T.up.diff (var 0).singleton)
(D.erase e) p hp hV (hd e) hn]
simp only [CPTTerm.value_quoted,meaning_pair,meaning_var,Fin.cons_zero,Fin.cons_one]
end QuotedGrid
end
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary QuotedTerm
variable {n : ℕ} {b : Vertex n → Scalar}
def Traverses (T : Finset (Edge n)) (e : Edge n) (u v : Vertex n)
(h : Edge n) (a c : Vertex n) : Prop :=
(h=e ∧ a=u ∧ c=v) ∨ h ∈ T ∧
((a=tail h ∧ c=head h) ∨ (c=tail h ∧ a=head h)) ∧
¬(edgeGraph (T.erase h)).Reachable v u ∧
(edgeGraph (T.erase h)).Reachable v a ∧
(edgeGraph (T.erase h)).Reachable u c
def traversalCode (b : Vertex n → Scalar) (T : Finset (Edge n)) (e : Edge n) (u v : Vertex n) : HF (Atom b) :=
ofFinset ((Finset.univ.filter fun hac : Edge n × Vertex n × Vertex n =>
Traverses T e u v hac.1 hac.2.1 hac.2.2).image fun hac =>
HFTriple (edgeCode b hac.1) (vertexCode b hac.2.1) (vertexCode b hac.2.2))
lemma mem_traversalCode (T : Finset (Edge n)) (e : Edge n) (u v : Vertex n) (z : HF (Atom b)) :
z ∈ elements (traversalCode b T e u v) ↔ ∃ h a c,
Traverses T e u v h a c ∧ HFTriple (edgeCode b h) (vertexCode b a) (vertexCode b c) = z := by
simp only [traversalCode,elements_ofFinset,Finset.mem_image,Finset.mem_filter,
Finset.mem_univ,true_and,Prod.exists]
namespace QuotedGrid
open QuotedTerm QuotedFormula SourceSyntax
variable {k : ℕ}
lemma meaning_traversal (env : Fin k → HF (Atom b)) (VT TT HT et ut vt : QuotedTerm k)
(T : Finset (Edge n)) (e : Edge n) (u v : Vertex n)
(hV : VT.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b)))
(hT : TT.meaning (atomInput b) env = ofFinset (T.image (edgeCode b)))
(hH : HT.meaning (atomInput b) env = connTableCode b T)
(he : et.meaning (atomInput b) env = edgeCode b e)
(hu : ut.meaning (atomInput b) env = vertexCode b u)
(hv : vt.meaning (atomInput b) env = vertexCode b v) (hn : 1 ≤ n) :
(traversal VT TT HT et ut vt).meaning (atomInput b) env = traversalCode b T e u v := by
have hend (h : Edge n) (a c : Vertex n) := meaning_hasEndpoints
(Fin.cons (vertexCode b c) (Fin.cons (vertexCode b a) (Fin.cons (edgeCode b h) env)))
(var 2) (var 1) (var 0) h a c rfl rfl rfl hn
have h0 (h : Edge n) (a c : Vertex n) := meaning_connWithout
(Fin.cons (vertexCode b c) (Fin.cons (vertexCode b a) (Fin.cons (edgeCode b h) env)))
HT.up.up.up (var 2) vt.up.up.up ut.up.up.up T h v u hH rfl hv hu hn
have h1 (h : Edge n) (a c : Vertex n) := meaning_connWithout
(Fin.cons (vertexCode b c) (Fin.cons (vertexCode b a) (Fin.cons (edgeCode b h) env)))
HT.up.up.up (var 2) vt.up.up.up (var 1) T h v a hH rfl hv rfl hn
have h2 (h : Edge n) (a c : Vertex n) := meaning_connWithout
(Fin.cons (vertexCode b c) (Fin.cons (vertexCode b a) (Fin.cons (edgeCode b h) env)))
HT.up.up.up (var 2) ut.up.up.up (var 0) T h u c hH rfl hu rfl hn
rw [traversal,meaning_cup]
apply ofFinset_inj.mpr
ext z
simp only [meaning_singleton,Hereditary.singleton,meaning_triple,he,hu,hv,
elements_ofFinset,Finset.mem_union,Finset.mem_singleton,meaning_bind,
QuotedTerm.meaning_up,hT,hV,Finset.mem_biUnion,Finset.mem_image,Finset.mem_univ,true_and,
meaning_map,QuotedTerm.meaning_filter,Finset.mem_filter,
meaning_var,Fin.cons_zero,Fin.cons_one,fin_cons_two]
constructor
· rintro (hz | ⟨_,⟨h,hh,rfl⟩,_,⟨a,rfl⟩,_,⟨⟨c,rfl⟩,hq⟩,hz⟩)
· exact ⟨(e,u,v),Or.inl ⟨rfl,rfl,rfl⟩,hz.symm⟩
· simp only [meaning_allList,List.mem_cons,List.not_mem_nil,forall_eq_or_imp,
forall_false,implies_true,and_true,meaning_neg,hend,h0,h1,h2] at hq
exact ⟨(h,a,c),Or.inr ⟨hh,hq.1,fun hr => hq.2.1 ⟨hh,hr⟩,hq.2.2.1.2,hq.2.2.2.2⟩,hz⟩
· rintro ⟨⟨h,a,c⟩,htr,hz⟩
rcases htr with ⟨rfl,rfl,rfl⟩ | ⟨hh,hends,hvu,hva,huc⟩
· exact Or.inl hz.symm
· refine Or.inr ⟨edgeCode b h,⟨h,hh,rfl⟩,vertexCode b a,⟨a,rfl⟩,
vertexCode b c,⟨⟨c,rfl⟩,?_⟩,hz⟩
simpa only [meaning_allList,List.mem_cons,List.not_mem_nil,forall_eq_or_imp,
forall_false,implies_true,and_true,meaning_neg,hend,h0,h1,h2] using
(show ((a=tail h ∧ c=head h) ∨ (c=tail h ∧ a=head h)) ∧
¬(h ∈ T ∧ (edgeGraph (T.erase h)).Reachable v u) ∧
(h ∈ T ∧ (edgeGraph (T.erase h)).Reachable v a) ∧
(h ∈ T ∧ (edgeGraph (T.erase h)).Reachable u c) from
⟨hends,fun hr => hvu hr.2,⟨hh,hva⟩,⟨hh,huc⟩⟩)
end QuotedGrid
end
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
namespace QuotedGrid
open QuotedTerm QuotedFormula SourceSyntax
variable {k : ℕ}
lemma meaning_side (env : Fin k → HF (Atom b)) (ft et : QuotedTerm k)
(C : CycleFrame n) (e : Edge n)
(hf : ft.meaning (atomInput b) env = frameCode b C)
(he : et.meaning (atomInput b) env = edgeCode b e) :
(side ft et).meaning (atomInput b) env ↔ cycle C.face e ≠ 0 := by
simp only [side,meaning_anyFin,meaning_eq,he,meaning_fe_pair env ft C.vertex C.edge hf,
edgeCode_injective.eq_iff]
exact (C.support_iff e).symm
lemma meaning_onSide (env : Fin k → HF (Atom b)) (ft st : QuotedTerm k)
(C : CycleFrame n) (e : Edge n) (s : LocalGroup e)
(hf : ft.meaning (atomInput b) env = frameCode b C)
(hs : st.meaning (atomInput b) env = atom (.inl ⟨e,s⟩)) :
(onSide ft st).meaning (atomInput b) env ↔ cycle C.face e ≠ 0 := by
simp only [onSide,meaning_anyFin,meaning_mem,hs,meaning_fe_pair env ft C.vertex C.edge hf,
atom_mem_edgeCode]
exact (C.support_iff e).symm
lemma meaning_matchFace_atoms (env : Fin k → HF (Atom b)) (ft st tt : QuotedTerm k)
(C : CycleFrame n) (e d : Edge n) (s : LocalGroup e) (t : LocalGroup d)
(hf : ft.meaning (atomInput b) env = frameCode b C)
(hs : st.meaning (atomInput b) env = atom (.inl ⟨e,s⟩))
(ht : tt.meaning (atomInput b) env = atom (.inl ⟨d,t⟩))
(he : cycle C.face e ≠ 0) (hd : cycle C.face d ≠ 0) (hn : 1 ≤ n) :
(matchFace ft st tt).meaning (atomInput b) env ↔ s.face ⟨C.face,he⟩ = t.face ⟨C.face,hd⟩ := by
obtain ⟨i,rfl⟩ := (C.support_iff e).mp he
obtain ⟨j,rfl⟩ := (C.support_iff d).mp hd
exact (meaning_matchFace env ft st tt C i j s t hf hs ht).trans (C.match_iff hn i j s t)
lemma meaning_baseEq (env : Fin k → HF (Atom b)) (F et st tt : QuotedTerm k)
(e : Edge n) (s t : LocalGroup e)
(hF : ∀ z, z ∈ elements (F.meaning (atomInput b) env) ↔ ∃ C : CycleFrame n, frameCode b C = z)
(he : et.meaning (atomInput b) env = edgeCode b e)
(hs : st.meaning (atomInput b) env = atom (.inl ⟨e,s⟩))
(ht : tt.meaning (atomInput b) env = atom (.inl ⟨e,t⟩)) (hn : 1 ≤ n) :
(baseEq F et st tt).meaning (atomInput b) env ↔ s.face = t.face := by
have hside (C : CycleFrame n) := meaning_side (Fin.cons (frameCode b C) env) (var 0) et.up C e rfl he
simp only [baseEq,meaning_allIn,hF,forall_exists_index,forall_apply_eq_imp_iff,meaning_imp,hside]
constructor
· intro h
funext f
have hf : cycle (standardFrame f.val).face e ≠ 0 := by simpa using f.property
simpa only [standardFrame_face] using (meaning_matchFace_atoms (Fin.cons (frameCode b (standardFrame f.val)) env)
(var 0) st.up tt.up _ e e s t rfl hs ht hf hf hn).mp (h _ hf)
· intro h C hC
apply (meaning_matchFace_atoms (Fin.cons (frameCode b C) env) (var 0) st.up tt.up C e e s t rfl hs ht hC hC hn).mpr
exact congrFun h ⟨C.face,hC⟩
lemma meaning_acceptsFaces (env : Fin k → HF (Atom b)) (F xt et st : QuotedTerm k)
(x : Finset (Σ e : Edge n, LocalGroup e)) (e : Edge n) (s : LocalGroup e)
(hF : ∀ z, z ∈ elements (F.meaning (atomInput b) env) ↔ ∃ C : CycleFrame n, frameCode b C = z)
(hx : xt.meaning (atomInput b) env = stateCode (x.image Sum.inl))
(he : et.meaning (atomInput b) env = edgeCode b e)
(hs : st.meaning (atomInput b) env = atom (.inl ⟨e,s⟩)) (hn : 1 ≤ n) :
(allIn F ((side (var 0) et.up).imp
(allIn xt.up ((onSide (var 1) (var 0)).imp
(matchFace (var 1) st.up.up (var 0)))))).meaning (atomInput b) env ↔ AcceptsFaces x e s := by
have hside (C : CycleFrame n) := meaning_side (Fin.cons (frameCode b C) env) (var 0) et.up C e rfl he
have hon (C : CycleFrame n) (a : Σ e : Edge n, LocalGroup e) :=
meaning_onSide (Fin.cons (atom (.inl a)) (Fin.cons (frameCode b C) env))
(var 1) (var 0) C a.1 a.2 rfl rfl
simp only [meaning_allIn,hF,forall_exists_index,forall_apply_eq_imp_iff,meaning_imp,hside,
QuotedTerm.meaning_up,hx,all_stateCode,Finset.forall_mem_image,hon]
constructor
· intro h a ha f he hf
have he' : cycle (standardFrame f).face e ≠ 0 := by simpa using he
have hf' : cycle (standardFrame f).face a.1 ≠ 0 := by simpa using hf
simpa only [standardFrame_face] using (meaning_matchFace_atoms (Fin.cons (atom (.inl a)) (Fin.cons (frameCode b (standardFrame f)) env))
(var 1) st.up.up (var 0) _ e a.1 s a.2 rfl hs rfl he' hf' hn).mp (h _ he' ha hf')
· intro h C hC a ha hCa
exact (meaning_matchFace_atoms (Fin.cons (atom (.inl a)) (Fin.cons (frameCode b C) env))
(var 1) st.up.up (var 0) C e a.1 s a.2 rfl hs rfl hC hCa hn).mpr (h a ha C.face hC hCa)
lemma mem_candidates (env : Fin k → HF (Atom b)) (F N xt : QuotedTerm k)
(D : Finset (Edge n)) (x : Finset (Σ e : Edge n, LocalGroup e))
(hF : ∀ z, z ∈ elements (F.meaning (atomInput b) env) ↔ ∃ C : CycleFrame n, frameCode b C = z)
(hN : N.meaning (atomInput b) env = ofFinset (D.image (edgeCode b)))
(hx : xt.meaning (atomInput b) env = stateCode (x.image Sum.inl)) (hn : 1 ≤ n) (z : HF (Atom b)) :
z ∈ elements ((candidates F N xt).meaning (atomInput b) env) ↔
∃ e ∈ D, ∃ s : LocalGroup e, z = atom (.inl ⟨e,s⟩) ∧ AcceptsFaces x e s := by
have hac (e : Edge n) (s : LocalGroup e) :=
meaning_acceptsFaces (Fin.cons (atom (.inl ⟨e,s⟩)) (Fin.cons (edgeCode b e) env))
F.up.up xt.up.up (var 1) (var 0) x e s hF hx rfl rfl hn
simp only [candidates,meaning_bind,hN,elements_ofFinset,Finset.mem_biUnion,Finset.mem_image,
QuotedTerm.meaning_filter,meaning_var,Fin.cons_zero,elements_ofFinset,Finset.mem_filter]
constructor
· rintro ⟨_,⟨e,he,rfl⟩,hz,hs⟩
obtain ⟨s,rfl⟩ := (mem_edgeCode_iff e z).mp hz
exact ⟨e,he,s,rfl,(hac e s).mp hs⟩
· rintro ⟨e,he,s,rfl,hs⟩
exact ⟨edgeCode b e,⟨e,he,rfl⟩,(mem_edgeCode_iff e _).mpr ⟨s,rfl⟩,(hac e s).mpr hs⟩
end QuotedGrid
end
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary QuotedTerm
variable {n : ℕ} {b : Vertex n → Scalar}
def originVertex : Vertex n := (0,0,0)
lemma dist_origin_head (h : Edge n) :
(boxGraph n).dist originVertex (head h) = (boxGraph n).dist originVertex (tail h) + 1 := by
rcases h with ⟨i,j,k⟩ | (⟨i,j,k⟩ | ⟨i,j,k⟩)
all_goals simp [boxGraph_dist,originVertex,head,tail,Nat.dist] ; omega
lemma exists_traversalCode (T : Finset (Edge n)) (e : Edge n) (u v : Vertex n)
(Q : HF (Atom b) → Prop) :
(∃ z ∈ elements (traversalCode b T e u v), Q z) ↔
∃ h a c, Traverses T e u v h a c ∧ Q (HFTriple (edgeCode b h) (vertexCode b a) (vertexCode b c)) := by
constructor
· rintro ⟨z,hz,hQ⟩
obtain ⟨h,a,c,htr,rfl⟩ := (mem_traversalCode T e u v z).mp hz
exact ⟨h,a,c,htr,hQ⟩
· rintro ⟨h,a,c,htr,hQ⟩
exact ⟨_,(mem_traversalCode T e u v _).mpr ⟨h,a,c,htr,rfl⟩,hQ⟩
lemma input_z_iff (e : Edge n) (s t : LocalGroup e) (δ : Scalar) :
inputHF (atomInput b) (.Z δ) (atom (.inl ⟨e,s⟩)) (atom (.inl ⟨e,t⟩)) = true ↔
(s⁻¹*t).flow = δ := by
rw [inputHF_atoms]
change decide (AtomRelation b (.Z δ) (.inl ⟨e,s⟩) (.inl ⟨e,t⟩)) = true ↔ _
rw [decide_eq_true_eq]
constructor
· intro h; cases h with | z e s t δ h => exact h
· intro h; exact .z e s t δ h
namespace QuotedGrid
open QuotedFormula SourceSyntax
variable {k : ℕ}
lemma meaning_traversalEdge (env : Fin k → HF (Atom b)) (Γ ht : QuotedTerm k)
(T : Finset (Edge n)) (e : Edge n) (u v : Vertex n) (h : Edge n)
(hΓ : Γ.meaning (atomInput b) env = traversalCode b T e u v)
(hh : ht.meaning (atomInput b) env = edgeCode b h) :
(traversalEdge Γ ht).meaning (atomInput b) env ↔ ∃ a c, Traverses T e u v h a c := by
simp only [traversalEdge,meaning_existsIn,hΓ,exists_traversalCode,
meaning_eq,meaning_fst,meaning_var,Fin.cons_zero,HFTriple,firstHF_pair (atomInput b),
QuotedTerm.meaning_up,hh,edgeCode_injective.eq_iff]
constructor
· rintro ⟨d,a,c,htr,rfl⟩
exact ⟨a,c,htr⟩
· rintro ⟨a,c,htr⟩
exact ⟨h,a,c,htr,rfl⟩
lemma meaning_directedZ (env : Fin k → HF (Atom b)) (R Γ ot ht st tt : QuotedTerm k)
(T : Finset (Edge n)) (e : Edge n) (u v : Vertex n) (o : Vertex n)
(h : Edge n) (s t : LocalGroup h)
(hR : R.meaning (atomInput b) env = distancesCode b (boxGraph n))
(hΓ : Γ.meaning (atomInput b) env = traversalCode b T e u v)
(ho : ot.meaning (atomInput b) env = vertexCode b o)
(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) :
(directedZ R Γ ot ht st tt).meaning (atomInput b) env ↔ ∃ a c,
Traverses T e u v h a c ∧
if (boxGraph n).dist o a < (boxGraph n).dist o c then
(s⁻¹*t).flow = 1 else (s⁻¹*t).flow = 2 := by
have hd1 (d : Edge n) (a c : Vertex n) :
(distanceAt R.up ot.up (var 0).snd.fst).meaning (atomInput b)
(Fin.cons (HFTriple (edgeCode b d) (vertexCode b a) (vertexCode b c)) env) =
ordinal ((boxGraph n).dist o a) := by
have hRu : R.up.meaning (atomInput b)
(Fin.cons (HFTriple (edgeCode b d) (vertexCode b a) (vertexCode b c)) env) =
distancesCode b (boxGraph n) := hR
have hov : ot.up.meaning (atomInput b)
(Fin.cons (HFTriple (edgeCode b d) (vertexCode b a) (vertexCode b c)) env) = vertexCode b o := ho
have hav : ((var 0).snd.fst : QuotedTerm (k+1)).meaning (atomInput b)
(Fin.cons (HFTriple (edgeCode b d) (vertexCode b a) (vertexCode b c)) env) = vertexCode b a := by
simp only [meaning_fst,meaning_snd,meaning_var,Fin.cons_zero,HFTriple,
secondHF_pair (atomInput b),firstHF_pair (atomInput b)]
exact meaning_distanceAt (atomInput b) _ R.up ot.up (var 0).snd.fst
(vertexCode b) (vertexCode_injective hn) (boxGraph n) (boxGraph_connected n) o a
hRu hov hav (vertex_card_le_atoms hn)
have hd2 (d : Edge n) (a c : Vertex n) :
(distanceAt R.up ot.up (var 0).snd.snd).meaning (atomInput b)
(Fin.cons (HFTriple (edgeCode b d) (vertexCode b a) (vertexCode b c)) env) =
ordinal ((boxGraph n).dist o c) := by
have hRu : R.up.meaning (atomInput b)
(Fin.cons (HFTriple (edgeCode b d) (vertexCode b a) (vertexCode b c)) env) =
distancesCode b (boxGraph n) := hR
have hov : ot.up.meaning (atomInput b)
(Fin.cons (HFTriple (edgeCode b d) (vertexCode b a) (vertexCode b c)) env) = vertexCode b o := ho
have hcv : ((var 0).snd.snd : QuotedTerm (k+1)).meaning (atomInput b)
(Fin.cons (HFTriple (edgeCode b d) (vertexCode b a) (vertexCode b c)) env) = vertexCode b c := by
simp only [meaning_snd,meaning_var,Fin.cons_zero,HFTriple,secondHF_pair (atomInput b)]
exact meaning_distanceAt (atomInput b) _ R.up ot.up (var 0).snd.snd
(vertexCode b) (vertexCode_injective hn) (boxGraph n) (boxGraph_connected n) o c
hRu hov hcv (vertex_card_le_atoms hn)
simp only [HFTriple] at hd1 hd2
simp only [directedZ,meaning_existsIn,hΓ,exists_traversalCode,
meaning_and,meaning_eq,meaning_fst,meaning_var,Fin.cons_zero,HFTriple,firstHF_pair (atomInput b),
QuotedTerm.meaning_up,hh,edgeCode_injective.eq_iff,meaning_or,meaning_mem,meaning_neg,
meaning_input,hs,ht',input_z_iff]
constructor
· rintro ⟨d,a,c,htr,hd,hZ⟩
subst d
refine ⟨a,c,htr,?_⟩
change (_ ∧ _) ∨ (¬_ ∧ _) at hZ
rw [hd1,hd2,ordinal_mem_elements] at hZ
split_ifs with hl
· exact hZ.elim And.right (fun hz => False.elim (hz.1 hl))
· exact hZ.elim (fun hz => False.elim (hl hz.1)) And.right
· rintro ⟨a,c,htr,hZ⟩
refine ⟨h,a,c,htr,rfl,?_⟩
rw [hd1,hd2,ordinal_mem_elements]
split_ifs at hZ with hl
· exact Or.inl ⟨hl,hZ⟩
· exact Or.inr ⟨hl,hZ⟩
end QuotedGrid
end
noncomputable section
open Classical WitnessedChoice WitnessedChoice.TreeTest
variable {n : ℕ}
namespace ParentEdges
variable {T : RootedTree (Vertex n)} (P : ParentEdges T)
lemma cut_reachable_tail_iff (h : Edge n) (hh : h ∈ P.treeEdges) (v : Vertex n) :
(P.cut h).Reachable v (tail h) ↔ ¬(P.cut h).Reachable (head h) v := by
constructor
· intro hv hh'
exact P.cut_separated h hh (hh'.trans hv).symm
· intro hv
rcases cut_cover P.treeEdges P.graph_connected h v with h' | h'
· exact False.elim (hv h')
· exact h'.symm
lemma cut_reachable_head_iff (h : Edge n) (v : Vertex n) :
(P.cut h).Reachable v (head h) ↔ (P.cut h).Reachable (head h) v :=
⟨SimpleGraph.Reachable.symm,SimpleGraph.Reachable.symm⟩
lemma traverses_forward (e : Edge n) (he : e ∉ P.treeEdges) (h : Edge n) :
Traverses P.treeEdges e (tail e) (head e) h (tail h) (head h) ↔
(P.flow e 1).val h = 1 := by
by_cases hhe : h=e
· subst h
simp [Traverses,he,P.flow_self e he]
by_cases hh : h ∈ P.treeEdges
· have hf := P.flow_cut e he 1 h hh
have hr := P.cut_reachable_iff h hh (head e) (tail e)
have ht := P.cut_reachable_tail_iff h hh (head e)
have hu := P.cut_reachable_head_iff h (tail e)
change _ ↔ _ at hr ht hu
simp only [Traverses,hhe,false_and,false_or,hh,true_and,
and_self,true_or,head_ne_tail h,Ne.symm (head_ne_tail h)]
change (¬(P.cut h).Reachable (head e) (tail e) ∧
(P.cut h).Reachable (head e) (tail h) ∧ (P.cut h).Reachable (tail e) (head h)) ↔ _
rw [hr,ht,hu,hf,mul_one]
unfold cutIndicator
by_cases ha : (P.cut h).Reachable (head h) (tail e) <;>
by_cases hb : (P.cut h).Reachable (head h) (head e) <;> simp [ha,hb] ; decide
· rw [P.flow_other e h hh hhe 1]
simp [Traverses,hhe,hh]
lemma traverses_reverse (e : Edge n) (he : e ∉ P.treeEdges) (h : Edge n) :
Traverses P.treeEdges e (tail e) (head e) h (head h) (tail h) ↔
(P.flow e 1).val h = -1 := by
by_cases hhe : h=e
· subst h
simp [Traverses,he,P.flow_self e he,head_ne_tail] ; decide
by_cases hh : h ∈ P.treeEdges
· have hf := P.flow_cut e he 1 h hh
have hr := P.cut_reachable_iff h hh (head e) (tail e)
have ht := P.cut_reachable_tail_iff h hh (tail e)
have hu := P.cut_reachable_head_iff h (head e)
simp only [Traverses,hhe,false_and,false_or,hh,true_and,and_self,
or_true,head_ne_tail h,Ne.symm (head_ne_tail h)]
change (¬(P.cut h).Reachable (head e) (tail e) ∧
(P.cut h).Reachable (head e) (head h) ∧ (P.cut h).Reachable (tail e) (tail h)) ↔ _
rw [hr,ht,hu,hf,mul_one]
unfold cutIndicator
by_cases ha : (P.cut h).Reachable (head h) (tail e) <;>
by_cases hb : (P.cut h).Reachable (head h) (head e) <;> simp [ha,hb] ; decide
· rw [P.flow_other e h hh hhe 1]
simp [Traverses,hhe,hh]
lemma traverses_endpoints {e h : Edge n} {u v : Vertex n}
(htr : Traverses P.treeEdges e (tail e) (head e) h u v) :
(u=tail h ∧ v=head h) ∨ (v=tail h ∧ u=head h) := by
rcases htr with ⟨rfl,rfl,rfl⟩ | ⟨_,hh,_⟩
· exact Or.inl ⟨rfl,rfl⟩
· exact hh
end ParentEdges
end
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
lemma scalar_cases (a : Scalar) : a=0 ∨ a=1 ∨ a= -1 := by
fin_cases a
· exact Or.inl rfl
· exact Or.inr (Or.inl rfl)
· exact Or.inr (Or.inr rfl)
namespace ParentEdges
variable {T : RootedTree (Vertex n)} (P : ParentEdges T)
lemma traverses_iff_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
constructor
· rintro ⟨a,c,htr⟩
rcases P.traverses_endpoints htr with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
· rw [(P.traverses_forward e he h).mp htr]; decide
· rw [(P.traverses_reverse e he h).mp htr]; decide
· intro hne
rcases scalar_cases ((P.flow e 1).val h) with hz | hp | hm
· exact False.elim (hne hz)
· exact ⟨tail h,head h,(P.traverses_forward e he h).mpr hp⟩
· exact ⟨head h,tail h,(P.traverses_reverse e he h).mpr hm⟩
lemma 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 originVertex a < (boxGraph n).dist originVertex 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_origin_head h
have hm : (2 : Scalar) = -1 := by decide
constructor
· rintro ⟨a,c,htr,hz⟩
have hne := (P.traverses_iff_nonzero e he h).mp ⟨a,c,htr⟩
refine ⟨hne,?_⟩
rcases P.traverses_endpoints htr with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
· rw [(P.traverses_forward e he h).mp htr]
simpa only [ite_eq_left (show (boxGraph n).dist originVertex (tail h) <
(boxGraph n).dist originVertex (head h) by omega)] using hz
· rw [(P.traverses_reverse e he h).mp htr]
simpa only [ite_eq_right (show ¬(boxGraph n).dist originVertex (head h) <
(boxGraph n).dist originVertex (tail h) by omega),hm] using hz
· rintro ⟨hne,rfl⟩
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_left (by omega),hp]
· refine ⟨head h,tail h,(P.traverses_reverse e he h).mpr hm',?_⟩
rw [ite_eq_right (by omega),hm',hm]
end ParentEdges
lemma local_central_iff (h : Edge n) (s t : LocalGroup h) (z : Scalar) :
t = (⟨0,z⟩ : LocalGroup h) * s ↔ s.face = t.face ∧ (s⁻¹*t).flow = z := by
constructor
· rintro rfl
simp only [Support.H.mul_face,zero_add,true_and,Support.H.mul_flow,Support.H.inv_flow,
Support.H.inv_face,Support.correction_zero_left,add_zero,Support.correction_neg_left,
Support.correction_self,neg_zero]
abel
· rintro ⟨hf,hz⟩
apply Support.H.ext
· simpa only [Support.H.mul_face,zero_add] using hf.symm
· simp only [Support.H.mul_flow,Support.H.inv_flow,Support.H.inv_face,←hf,
Support.correction_neg_left,Support.correction_self,neg_zero,add_zero] at hz
simp only [Support.H.mul_flow,Support.correction_zero_left,add_zero]
rw [←hz]
abel
end
end WitnessedSeparation.Grid
end OAI
import OAI.Computability.WitnessedChoice.AnchoredTree
namespace OAI
section
namespace WitnessedChoice.BGS.QuotedTerm
noncomputable section
open Classical WitnessedSeparation WitnessedSeparation.Hereditary
variable {A B : Type} [Fintype A] [Fintype B] {k : ℕ}
lemma mem_tupleProduct_image (m : ℕ) (r : QuotedTerm k) (S : Input A) (env : Fin k → HF A)
(code : B → HF A) (hr : r.meaning S env = ofFinset (Finset.univ.image code)) (z : HF A) :
z ∈ elements ((tupleProduct m r).meaning S env) ↔
∃ f : Fin m → B, tupleCode (List.ofFn (code ∘ f)) = z := by
rw [mem_tupleProduct]
simp only [hr,elements_ofFinset,Finset.mem_image,Finset.mem_univ,true_and]
constructor
· rintro ⟨g,hg,hz⟩
choose f hf using hg
exact ⟨f,by simpa only [show code ∘ f = g from funext hf] using hz⟩
· rintro ⟨f,hf⟩
exact ⟨code ∘ f,fun i => ⟨f i,rfl⟩,hf⟩
end
end WitnessedChoice.BGS.QuotedTerm
namespace WitnessedSeparation.Grid
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
lemma endpoints_incident_iff (e : Edge n) (u v : Vertex n) :
((u = tail e ∧ v = head e) ∨ (v = tail e ∧ u = head e)) ↔
u ≠ v ∧ incident u e ∧ incident v e := by
constructor
· rintro (⟨rfl,rfl⟩ | ⟨rfl,rfl⟩)
· exact ⟨(head_ne_tail e).symm,Or.inr rfl,Or.inl rfl⟩
· exact ⟨head_ne_tail e,Or.inl rfl,Or.inr rfl⟩
· rintro ⟨hne,(hu|hu),(hv|hv)⟩
· exact (hne (hu.symm.trans hv)).elim
· exact Or.inr ⟨hv.symm,hu.symm⟩
· exact Or.inl ⟨hu.symm,hv.symm⟩
· exact (hne (hu.symm.trans hv)).elim
def frameCode (b : Vertex n → Scalar) (C : CycleFrame n) : HF (Atom b) :=
Hereditary.pair (tupleCode (List.ofFn (vertexCode b ∘ C.vertex)))
(tupleCode (List.ofFn (edgeCode b ∘ C.edge)))
namespace QuotedGrid
open QuotedTerm QuotedFormula SourceSyntax
variable {k : ℕ}
@[simp] lemma next4_eq_add (i : Fin 4) : next4 i = i+1 := rfl
@[simp] lemma prev4_eq_add (i : Fin 4) : prev4 i = i+3 := rfl
lemma adjacent_index_iff (i j : Fin 4) : (j=next4 i ∨ j=prev4 i) ↔ AdjacentIndex i j := by
rw [next4_eq_add,prev4_eq_add]
revert i j
unfold AdjacentIndex
decide
lemma meaning_fv_pair (env : Fin k → HF (Atom b)) (ft : QuotedTerm k)
(v : Fin 4 → Vertex n) (e : Fin 4 → Edge n)
(hf : ft.meaning (atomInput b) env = Hereditary.pair (tupleCode (List.ofFn (vertexCode b ∘ v)))
(tupleCode (List.ofFn (edgeCode b ∘ e)))) (i : Fin 4) :
(fv ft i).meaning (atomInput b) env = vertexCode b (v i) := by
exact meaning_component_ofFn _ _ _ _ (meaning_fst_of_eq _ _ _ _ _ hf) i
lemma meaning_fe_pair (env : Fin k → HF (Atom b)) (ft : QuotedTerm k)
(v : Fin 4 → Vertex n) (e : Fin 4 → Edge n)
(hf : ft.meaning (atomInput b) env = Hereditary.pair (tupleCode (List.ofFn (vertexCode b ∘ v)))
(tupleCode (List.ofFn (edgeCode b ∘ e)))) (i : Fin 4) :
(fe ft i).meaning (atomInput b) env = edgeCode b (e i) := by
exact meaning_component_ofFn _ _ _ _ (meaning_snd_of_eq _ _ _ _ _ hf) i
lemma meaning_faceDescription (env : Fin k → HF (Atom b)) (ft : QuotedTerm k)
(v : Fin 4 → Vertex n) (e : Fin 4 → Edge n)
(hf : ft.meaning (atomInput b) env = Hereditary.pair (tupleCode (List.ofFn (vertexCode b ∘ v)))
(tupleCode (List.ofFn (edgeCode b ∘ e)))) (hn : 1 ≤ n) :
(faceDescription ft).meaning (atomInput b) env ↔
Function.Injective v ∧ Function.Injective e ∧
∀ i, (v i = tail (e i) ∧ v (i+1) = head (e i)) ∨
(v (i+1) = tail (e i) ∧ v i = head (e i)) := by
have hv := meaning_fv_pair env ft v e hf
have he := meaning_fe_pair env ft v e hf
have ha (i : Fin 4) : (hasEndpoints (fe ft i) (fv ft i) (fv ft (next4 i))).meaning (atomInput b) env ↔
((v i = tail (e i) ∧ v (i+1) = head (e i)) ∨
(v (i+1) = tail (e i) ∧ v i = head (e i))) := by
simp only [next4_eq_add,hasEndpoints,meaning_and,meaning_neg,meaning_eq,hv,(vertexCode_injective hn).eq_iff,