Download data/lean/OAI/Computability/WitnessedChoice/AnchoredTree.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 49.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/AnchoredTree.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/WitnessedChoice/AnchoredTree.lean
-
curl -L -o AnchoredTree.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/AnchoredTree.lean
49.1 kB
import OAI.Computability.WitnessedChoice.GridGeometry
namespace OAI
namespace WitnessedChoice
noncomputable section
open Classical
namespace AnchoredTree
variable {V : Type} [Fintype V]
def key (G : SimpleGraph V) (α : Fin 4 → V) (v : V) : Lex (Fin 4 → ℕ) :=
toLex (fun i => G.dist (α i) v)
def Resolving (G : SimpleGraph V) (α : Fin 4 → V) : Prop := Function.Injective (key G α)
def Eligible (G : SimpleGraph V) (r v w : V) : Prop := G.Adj v w ∧ G.dist r w + 1 = G.dist r v
omit [Fintype V] in
lemma root_lt (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V)
(v : V) (hv : v ≠ α 0) : key G α (α 0) < key G α v := by
refine ⟨0,?_,?_⟩
· intro j hj; exact (Fin.not_lt_zero j hj).elim
· change G.dist (α 0) (α 0) < G.dist (α 0) v
rw [G.dist_self]
exact Nat.pos_of_ne_zero (fun h => hv ((hG (α 0) v).dist_eq_zero_iff.mp h).symm)
omit [Fintype V] in
lemma least_iff_root (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V) (v : V) :
(∀ w, ¬key G α w < key G α v) ↔ v = α 0 := by
constructor
· intro h; by_contra hn; exact h _ (root_lt G hG α v hn)
· rintro rfl w hw
by_cases h : w = α 0
· subst w; exact lt_irrefl _ hw
· exact (lt_asymm hw (root_lt G hG α w h))
omit [Fintype V] in
lemma exists_eligible (G : SimpleGraph V) (hG : G.Connected) (r v : V) (hv : v ≠ r) :
∃ w, Eligible G r v w := by
obtain ⟨p,hp⟩ := hG.exists_walk_length_eq_dist v r
cases p with
| nil => exact (hv rfl).elim
| @cons _ w _ hadj q =>
refine ⟨w,hadj,?_⟩
have hle := G.dist_le q
have hd := hadj.diff_dist_adj (u := r)
simp only [SimpleGraph.Walk.length_cons] at hp
rw [G.dist_comm (u := v) (v := r)] at hp
rw [G.dist_comm (u := w) (v := r)] at hle
omega
omit [Fintype V] in
lemma exists_min_key (G : SimpleGraph V) (α : Fin 4 → V) (D : Finset V) (hD : D.Nonempty) :
∃ v ∈ D, ∀ w ∈ D, ¬key G α w < key G α v := by
let K := D.image (key G α)
have hK : K.Nonempty := hD.image _
obtain ⟨v,hv,he⟩ := Finset.mem_image.mp (Finset.min'_mem K hK)
refine ⟨v,hv,?_⟩
intro w hw hlt
have hm := Finset.min'_le K (key G α w) (Finset.mem_image.mpr ⟨w,hw,rfl⟩)
rw [←he] at hm
exact (not_lt_of_ge hm) hlt
lemma exists_parent (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V)
(v : V) (hv : v ≠ α 0) :
∃ w, Eligible G (α 0) v w ∧ ∀ z, Eligible G (α 0) v z → ¬key G α z < key G α w := by
obtain ⟨w,hw⟩ := exists_eligible G hG (α 0) v hv
obtain ⟨z,hz,hm⟩ := exists_min_key G α (Finset.univ.filter (Eligible G (α 0) v))
⟨w,Finset.mem_filter.mpr ⟨Finset.mem_univ _,hw⟩⟩
exact ⟨z,(Finset.mem_filter.mp hz).2,fun y hy => hm y (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hy⟩)⟩
def parent (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V) (v : V) : V :=
if hv : v = α 0 then α 0 else (exists_parent G hG α v hv).choose
lemma parent_property (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V)
(v : V) (hv : v ≠ α 0) :
Eligible G (α 0) v (parent G hG α v) ∧
∀ z, Eligible G (α 0) v z → ¬key G α z < key G α (parent G hG α v) := by
rw [parent,dite_eq_right hv]
exact (exists_parent G hG α v hv).choose_spec
def rooted (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V) : TreeTest.RootedTree V where
root := α 0
parent := parent G hG α
level := G.dist (α 0)
parent_lower v hv := by have h := (parent_property G hG α v hv).1.2; omega
lemma parent_iff (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V)
(hα : Resolving G α) (v w : V) :
(Eligible G (α 0) v w ∧ ∀ z, Eligible G (α 0) v z → ¬key G α z < key G α w) ↔
v ≠ α 0 ∧ (rooted G hG α).parent v = w := by
constructor
· rintro ⟨hw,hm⟩
have hv : v ≠ α 0 := by intro hh; have hd := hw.2; rw [hh,G.dist_self] at hd; omega
refine ⟨hv,?_⟩
have hp := parent_property G hG α v hv
apply hα
exact le_antisymm (le_of_not_gt (hp.2 w hw)) (le_of_not_gt (hm _ hp.1))
· rintro ⟨hv,rfl⟩
exact parent_property G hG α v hv
end AnchoredTree
end
end WitnessedChoice
namespace WitnessedChoice.BGS
noncomputable section
open Classical WitnessedSeparation WitnessedSeparation.Hereditary QuotedTerm
namespace QuotedFormula
variable {A V : Type} [Fintype A] [Fintype V] {k : ℕ}
lemma meaning_vertexLt (S : Input A) (env : Fin k → HF A)
(ats R ut vt : QuotedTerm k) (code : V → HF A) (hc : Function.Injective code)
(G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V) (u v : V)
(hα : ats.meaning S env = tupleCode (List.ofFn (code ∘ α)))
(hR : R.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) :
(vertexLt ats R ut vt).meaning S env ↔ AnchoredTree.key G α u < AnchoredTree.key G α v := by
have hdU (i : Fin 4) : (distanceAt R (ats.component i.val) ut).meaning S env = ordinal (G.dist (α i) u) :=
meaning_distanceAt S env R _ _ code hc G hG _ _ hR
(meaning_component_ofFn S env ats (code ∘ α) hα i) hu hcard
have hdV (i : Fin 4) : (distanceAt R (ats.component i.val) vt).meaning S env = ordinal (G.dist (α i) v) :=
meaning_distanceAt S env R _ _ code hc G hG _ _ hR
(meaning_component_ofFn S env ats (code ∘ α) hα i) hv hcard
simp only [vertexLt,meaning_anyFin,meaning_and,meaning_allFin,meaning_mem,hdU,hdV,
ordinal_mem_elements]
change (∃ i : Fin 4, (∀ j : Fin 4, _) ∧ _) ↔ _
have hm (i j : Fin 4) :
(if j.val < i.val then eq (distanceAt R (ats.component j.val) ut)
(distanceAt R (ats.component j.val) vt) else truth).meaning S env ↔
(j < i → G.dist (α j) u = G.dist (α j) v) := by
split_ifs with h
· simp only [meaning_eq,hdU,hdV,ordinal_injective.eq_iff]
simp only [Fin.lt_def,h,true_implies]
· simp [truth, Fin.lt_def, h]
simp only [hm]
rfl
lemma meaning_resolving (S : Input A) (env : Fin k → HF A)
(ats VT R : QuotedTerm k) (code : V → HF A) (hc : Function.Injective code)
(G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V)
(hα : ats.meaning S env = tupleCode (List.ofFn (code ∘ α)))
(hV : VT.meaning S env = ofFinset (Finset.univ.image code))
(hR : R.meaning S env = ofFinset ((BFS.closure G (Fintype.card A)).image (distanceCode code)))
(hcard : Fintype.card V ≤ Fintype.card A) :
(resolving ats VT R).meaning S env ↔ AnchoredTree.Resolving G α := by
simp only [resolving,meaning_allIn,meaning_imp,meaning_allFin,meaning_eq,meaning_var,
QuotedTerm.meaning_up,hV,elements_ofFinset,Finset.mem_image,Finset.mem_univ,true_and,
forall_exists_index,forall_apply_eq_imp_iff,Fin.cons_zero,Fin.cons_one]
have hd (u v : V) (i : Fin 4) (w : V) (wt : QuotedTerm (k+2))
(hw : wt.meaning S (Fin.cons (code v) (Fin.cons (code u) env)) = code w) :
(distanceAt R.up.up (ats.up.up.component i.val) wt).meaning S
(Fin.cons (code v) (Fin.cons (code u) env)) = ordinal (G.dist (α i) w) := by
apply meaning_distanceAt S _ _ _ _ code hc G hG _ _ _ _ hw hcard
· simpa only [QuotedTerm.meaning_up] using hR
· apply meaning_component_ofFn S _ _ (code ∘ α) _ i
simpa only [QuotedTerm.meaning_up] using hα
have hd₁ (u v : V) (i : Fin 4) := hd u v i u (var 1) (by simp)
have hd₀ (u v : V) (i : Fin 4) := hd u v i v (var 0) (by simp)
simp only [hd₁,hd₀,ordinal_injective.eq_iff,hc.eq_iff]
constructor
· intro h u v huv
exact h u v (fun i => congrFun huv i)
· intro h u v huv
apply h
exact funext huv
end QuotedFormula
end
end WitnessedChoice.BGS
namespace WitnessedSeparation.Grid
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
lemma configuration_exists (hn : 1 ≤ n) (v : Vertex n) : Nonempty (Configuration b v) := by
obtain ⟨e0,_⟩ := incident_on_axis hn v 0
exact ⟨{ state := fun e => ⟨0,extendVertexScalars b v e0 0 e⟩
compatible := by intro e e' f hf hf'; rfl
charge := extendVertexScalars_charge e0 0 }⟩
@[simp] lemma mem_edgeBlockSet (e : Edge n) (a : Atom b) :
a ∈ edgeBlockSet b e ↔ ∃ s : LocalGroup e, a = .inl ⟨e,s⟩ := by
simp only [edgeBlockSet,Finset.mem_image,Finset.mem_univ,true_and]
aesop
@[simp] lemma mem_vertexBlockSet (v : Vertex n) (a : Atom b) :
a ∈ vertexBlockSet b v ↔ ∃ s : Configuration b v, a = .inr ⟨v,s⟩ := by
simp only [vertexBlockSet,Finset.mem_image,Finset.mem_univ,true_and]
aesop
lemma edgeBlockSet_injective : Function.Injective (edgeBlockSet b) := by
intro e f h
have hm : (Sum.inl ⟨e,1⟩ : Atom b) ∈ edgeBlockSet b e := by simp
rw [h,mem_edgeBlockSet] at hm
obtain ⟨t,ht⟩ := hm
exact congrArg Sigma.fst (Sum.inl.inj ht)
lemma vertexBlockSet_injective (hn : 1 ≤ n) : Function.Injective (vertexBlockSet b) := by
intro v w h
obtain ⟨s⟩ := configuration_exists (b := b) hn v
have hm : (Sum.inr ⟨v,s⟩ : Atom b) ∈ vertexBlockSet b v := by simp
rw [h,mem_vertexBlockSet] at hm
obtain ⟨t,ht⟩ := hm
exact congrArg Sigma.fst (Sum.inr.inj ht)
lemma edgeRow_grid (e : Edge n) (s : LocalGroup e) :
WitnessedChoice.edgeRow (atomInput b) (.inl ⟨e,s⟩) = edgeBlockSet b e := by
ext a
simp only [WitnessedChoice.edgeRow,WitnessedChoice.edgeAtoms,Finset.mem_filter,
Finset.mem_univ,true_and,atomInput,decide_eq_true_eq,mem_edgeBlockSet]
constructor
· rintro ⟨_,h⟩
cases h with | eb e s t => exact ⟨t,rfl⟩
· rintro ⟨t,rfl⟩
exact ⟨.ed e t,.eb e s t⟩
lemma vertexRow_grid (v : Vertex n) (s : Configuration b v) :
WitnessedChoice.vertexRow (atomInput b) (.inr ⟨v,s⟩) = vertexBlockSet b v := by
ext a
simp only [WitnessedChoice.vertexRow,WitnessedChoice.configAtoms,Finset.mem_filter,
Finset.mem_univ,true_and,atomInput,decide_eq_true_eq,mem_vertexBlockSet]
constructor
· rintro ⟨_,h⟩
cases h with | vb v s t => exact ⟨t,rfl⟩
· rintro ⟨t,rfl⟩
exact ⟨.cf v t,.vb v s t⟩
lemma edgeBlocks_grid : WitnessedChoice.edgeBlocks (atomInput b) =
Finset.univ.image (edgeBlockSet b) := by
ext d
simp only [WitnessedChoice.edgeBlocks,Finset.mem_image,WitnessedChoice.edgeAtoms,
Finset.mem_filter,Finset.mem_univ,true_and,atomInput,decide_eq_true_eq]
constructor
· rintro ⟨a,h,rfl⟩
cases h with | ed e s => exact ⟨e,(edgeRow_grid e s).symm⟩
· rintro ⟨e,rfl⟩
exact ⟨.inl ⟨e,1⟩,.ed e 1,edgeRow_grid e 1⟩
lemma vertexBlocks_grid (hn : 1 ≤ n) : WitnessedChoice.vertexBlocks (atomInput b) =
Finset.univ.image (vertexBlockSet b) := by
ext d
simp only [WitnessedChoice.vertexBlocks,Finset.mem_image,WitnessedChoice.configAtoms,
Finset.mem_filter,Finset.mem_univ,true_and,atomInput,decide_eq_true_eq]
constructor
· rintro ⟨a,h,rfl⟩
cases h with | cf v s => exact ⟨v,(vertexRow_grid v s).symm⟩
· rintro ⟨v,rfl⟩
obtain ⟨s⟩ := configuration_exists (b := b) hn v
exact ⟨.inr ⟨v,s⟩,.cf v s,vertexRow_grid v s⟩
def vertexCode (b : Vertex n → Scalar) (v : Vertex n) : HF (Atom b) := stateCode (vertexBlockSet b v)
def edgeCode (b : Vertex n → Scalar) (e : Edge n) : HF (Atom b) := stateCode (edgeBlockSet b e)
lemma vertexCode_injective (hn : 1 ≤ n) : Function.Injective (vertexCode b) :=
fun _ _ h => vertexBlockSet_injective hn (stateCode_inj.mp h)
lemma edgeCode_injective : Function.Injective (edgeCode b) :=
fun _ _ h => edgeBlockSet_injective (stateCode_inj.mp h)
lemma blockIncident_grid (hn : 1 ≤ n) (v : Vertex n) (e : Edge n) :
blockIncident (atomInput b) (vertexCode b v) (edgeCode b e) ↔ incident v e := by
simp only [blockIncident,vertexCode,edgeCode,exists_stateCode,mem_vertexBlockSet,
mem_edgeBlockSet]
constructor
· rintro ⟨_,⟨s,rfl⟩,_,⟨t,rfl⟩,h⟩
rw [inputHF_atoms] at h
change decide (AtomRelation b .I (.inr ⟨v,s⟩) (.inl ⟨e,t⟩)) = true at h
have h := of_decide_eq_true h
cases h with | inc v s e => exact e.property
· intro h
obtain ⟨s⟩ := configuration_exists (b := b) hn v
exact ⟨.inr ⟨v,s⟩,⟨s,rfl⟩,.inl ⟨e,s.state ⟨e,h⟩⟩,⟨_,rfl⟩,
by rw [inputHF_atoms]; exact decide_eq_true (.inc v s ⟨e,h⟩)⟩
end
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
def edgeGraph (T : Finset (Edge n)) : SimpleGraph (Vertex n) where
Adj u v := ∃ e ∈ T, (u = tail e ∧ v = head e) ∨ (v = tail e ∧ u = head e)
symm := ⟨by intro u v; rintro ⟨e,he,h⟩; exact ⟨e,he,h.symm⟩⟩
loopless := ⟨by
intro v
rintro ⟨e,he,h|h⟩
all_goals exact head_ne_tail e (h.2.symm.trans h.1)⟩
lemma edgeGraph_univ : edgeGraph (Finset.univ : Finset (Edge n)) = boxGraph n := by
ext u v
simp only [edgeGraph,Finset.mem_univ,true_and,boxGraph_adj_iff]
lemma blockAdjacent_edges (hn : 1 ≤ n) (T : Finset (Edge n)) (u v : Vertex n) :
blockAdjacent (atomInput b) (ofFinset (T.image (edgeCode b))) (vertexCode b u) (vertexCode b v) ↔
(edgeGraph T).Adj u v := by
simp only [blockAdjacent,(vertexCode_injective hn).ne_iff,elements_ofFinset,
Finset.mem_image,exists_exists_and_eq_and,blockIncident_grid hn,edgeGraph]
constructor
· rintro ⟨hne,e,he,hu,hv⟩
refine ⟨e,he,?_⟩
rcases hu with hu | hu <;> rcases hv with 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
· rintro ⟨e,he,(⟨rfl,rfl⟩ | ⟨rfl,rfl⟩)⟩
· exact ⟨(head_ne_tail e).symm,e,he,Or.inr rfl,Or.inl rfl⟩
· exact ⟨head_ne_tail e,e,he,Or.inl rfl,Or.inr rfl⟩
lemma vertex_card_le_atoms (hn : 1 ≤ n) : Fintype.card (Vertex n) ≤ Fintype.card (Atom b) := by
let f (v : Vertex n) : Atom b := .inr ⟨v,(configuration_exists (b := b) hn v).some⟩
apply Fintype.card_le_of_injective f
intro v w h
exact congrArg Sigma.fst (Sum.inr.inj h)
lemma quoted_vertexBlocks {k : ℕ} (hn : 1 ≤ n) (env : Fin k → HF (Atom b)) :
(QuotedTerm.vertexBlocks : QuotedTerm k).meaning (atomInput b) env =
ofFinset (Finset.univ.image (vertexCode b)) := by
rw [QuotedTerm.meaning_vertexBlocks,vertexBlocks_grid hn,Finset.image_image]
rfl
lemma quoted_edgeBlocks {k : ℕ} (env : Fin k → HF (Atom b)) :
(QuotedTerm.edgeBlocks : QuotedTerm k).meaning (atomInput b) env =
ofFinset (Finset.univ.image (edgeCode b)) := by
rw [QuotedTerm.meaning_edgeBlocks,edgeBlocks_grid,Finset.image_image]
rfl
end
noncomputable section
open Classical
variable {n : ℕ}
lemma xy_incident_face (i : Fin n) (j k : Fin (n+1)) (i' k' : Fin (n+1)) (j' : Fin n) (v : Vertex n)
(hv : incident v (ex i j k)) (hw : incident v (ey i' j' k')) :
∃ f : Face n, cycle f (ex i j k) ≠ 0 ∧ cycle f (ey i' j' k') ≠ 0 := by
rcases hv with hv|hv
all_goals subst v
all_goals rcases hw with hw|hw
all_goals simp only [head,tail] at hw
all_goals rcases hw with ⟨hi,hj,hk⟩
all_goals refine ⟨.inl (i,j',k),?_,?_⟩
all_goals solve
| (convert cycle_faceSide (n := n) (.inl (i,j',k)) 0 using 1 ; simp_all [faceSide])
| (convert cycle_faceSide (n := n) (.inl (i,j',k)) 1 using 1 ; simp_all [faceSide])
| (convert cycle_faceSide (n := n) (.inl (i,j',k)) 2 using 1 ; simp_all [faceSide])
| (convert cycle_faceSide (n := n) (.inl (i,j',k)) 3 using 1 ; simp_all [faceSide])
lemma xz_incident_face (i : Fin n) (j k : Fin (n+1)) (i' j' : Fin (n+1)) (k' : Fin n) (v : Vertex n)
(hv : incident v (ex i j k)) (hw : incident v (ez i' j' k')) :
∃ f : Face n, cycle f (ex i j k) ≠ 0 ∧ cycle f (ez i' j' k') ≠ 0 := by
rcases hv with hv|hv
all_goals subst v
all_goals rcases hw with hw|hw
all_goals simp only [head,tail] at hw
all_goals rcases hw with ⟨hi,hj,hk⟩
all_goals refine ⟨.inr (.inl (i,j,k')),?_,?_⟩
all_goals solve
| (convert cycle_faceSide (n := n) (.inr (.inl (i,j,k'))) 0 using 1 ; simp_all [faceSide])
| (convert cycle_faceSide (n := n) (.inr (.inl (i,j,k'))) 1 using 1 ; simp_all [faceSide])
| (convert cycle_faceSide (n := n) (.inr (.inl (i,j,k'))) 2 using 1 ; simp_all [faceSide])
| (convert cycle_faceSide (n := n) (.inr (.inl (i,j,k'))) 3 using 1 ; simp_all [faceSide])
lemma yz_incident_face (j : Fin n) (i k : Fin (n+1)) (i' j' : Fin (n+1)) (k' : Fin n) (v : Vertex n)
(hv : incident v (ey i j k)) (hw : incident v (ez i' j' k')) :
∃ f : Face n, cycle f (ey i j k) ≠ 0 ∧ cycle f (ez i' j' k') ≠ 0 := by
rcases hv with hv|hv
all_goals subst v
all_goals rcases hw with hw|hw
all_goals simp only [head,tail] at hw
all_goals rcases hw with ⟨hi,hj,hk⟩
all_goals refine ⟨.inr (.inr (i,j,k')),?_,?_⟩
all_goals solve
| (convert cycle_faceSide (n := n) (.inr (.inr (i,j,k'))) 0 using 1 ; simp_all [faceSide])
| (convert cycle_faceSide (n := n) (.inr (.inr (i,j,k'))) 1 using 1 ; simp_all [faceSide])
| (convert cycle_faceSide (n := n) (.inr (.inr (i,j,k'))) 2 using 1 ; simp_all [faceSide])
| (convert cycle_faceSide (n := n) (.inr (.inr (i,j,k'))) 3 using 1 ; simp_all [faceSide])
lemma incident_perpendicular_face (v : Vertex n) (e e' : Edge n)
(hv : incident v e) (hw : incident v e') (ha : edgeAxis e ≠ edgeAxis e') :
∃ f : Face n, cycle f e ≠ 0 ∧ cycle f e' ≠ 0 := by
have swap : (∃ f : Face n, cycle f e' ≠ 0 ∧ cycle f e ≠ 0) →
∃ f : Face n, cycle f e ≠ 0 ∧ cycle f e' ≠ 0 := by
rintro ⟨f,hf,hf'⟩; exact ⟨f,hf',hf⟩
rcases e with ⟨i,j,k⟩ | (⟨i,j,k⟩ | ⟨i,j,k⟩)
all_goals rcases e' with ⟨i',j',k'⟩ | (⟨i',j',k'⟩ | ⟨i',j',k'⟩)
all_goals first
| exact (ha rfl).elim
| exact xy_incident_face _ _ _ _ _ _ v hv hw
| exact xz_incident_face _ _ _ _ _ _ v hv hw
| exact yz_incident_face _ _ _ _ _ _ v hv hw
| exact swap (xy_incident_face _ _ _ _ _ _ v hw hv)
| exact swap (xz_incident_face _ _ _ _ _ _ v hw hv)
| exact swap (yz_incident_face _ _ _ _ _ _ v hw hv)
end
noncomputable section
open Classical SimpleGraph
variable {n : ℕ}
lemma square_common_neighbors (f : Face n) (i : Fin 4) (v : Vertex n)
(h₀ : (boxGraph n).Adj (faceCorner f i) v)
(h₂ : (boxGraph n).Adj (faceCorner f (i+2)) v) :
v = faceCorner f (i+1) ∨ v = faceCorner f (i+3) := by
rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> fin_cases i
all_goals
simp [boxGraph,boxProd_adj,pathGraph_adj,faceCorner,Prod.ext_iff,Fin.ext_iff] at h₀ h₂ ⊢
omega
end
noncomputable section
open Classical
abbrev Direction := Fin 3 × Bool
def directionVector (d : Direction) : Fin 3 → ℤ :=
fun a => if a = d.1 then (if d.2 then 1 else -1) else 0
def oppositeDirection (d : Direction) : Direction := (d.1,!d.2)
lemma direction_neg (d : Direction) : directionVector (oppositeDirection d) = -directionVector d := by
rcases d with ⟨a,b⟩
funext i
cases b <;> by_cases h : i = a <;> simp [directionVector,oppositeDirection,h]
lemma four_direction_pattern : ∀ d₀ d₁ d₂ d₃ : Direction,
directionVector d₀ + directionVector d₁ + directionVector d₂ + directionVector d₃ = 0 →
directionVector d₀ + directionVector d₁ ≠ 0 →
directionVector d₁ + directionVector d₂ ≠ 0 →
d₂ = oppositeDirection d₀ ∧ d₃ = oppositeDirection d₁ ∧ d₀.1 ≠ d₁.1 := by
decide
end
noncomputable section
open Classical SimpleGraph
variable {n : ℕ}
def vertexInt (v : Vertex n) : Fin 3 → ℤ := fun a => (vertexCoord v a).val
lemma vertexInt_injective : Function.Injective (vertexInt (n := n)) := by
intro v w h
apply vertexCoord_injective
funext a
apply Fin.ext
exact Int.ofNat_inj.mp (congrFun h a)
lemma head_vertexInt (e : Edge n) :
vertexInt (head e) = vertexInt (tail e) + directionVector (edgeAxis e,true) := by
rcases e with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩)
all_goals
funext a
fin_cases a <;> simp [vertexInt,vertexCoord,head,tail,directionVector,edgeAxis]
lemma endpoints_direction (u v : Vertex n) (e : Edge n)
(h : (u = tail e ∧ v = head e) ∨ (v = tail e ∧ u = head e)) :
∃ d : Direction, d.1 = edgeAxis e ∧ vertexInt v - vertexInt u = directionVector d := by
rcases h with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
· exact ⟨(edgeAxis e,true),rfl,by rw [head_vertexInt]; abel⟩
· refine ⟨(edgeAxis e,false),rfl,?_⟩
have ht : directionVector (edgeAxis e,false) = -directionVector (edgeAxis e,true) :=
direction_neg (edgeAxis e,true)
rw [head_vertexInt,ht]
abel
lemma square_consecutive_perpendicular (v : Fin 4 → Vertex n) (e : Fin 4 → Edge n)
(hv : Function.Injective v)
(he : ∀ i, (v i = tail (e i) ∧ v (i+1) = head (e i)) ∨
(v (i+1) = tail (e i) ∧ v i = head (e i))) :
edgeAxis (e 0) ≠ edgeAxis (e 1) := by
choose d hd hvec using fun i => endpoints_direction (v i) (v (i+1)) (e i) (he i)
have hzero : directionVector (d 0) + directionVector (d 1) +
directionVector (d 2) + directionVector (d 3) = 0 := by
rw [← hvec 0,← hvec 1,← hvec 2,← hvec 3]
change (vertexInt (v 1) - vertexInt (v 0)) + (vertexInt (v 2) - vertexInt (v 1)) +
(vertexInt (v 3) - vertexInt (v 2)) + (vertexInt (v 0) - vertexInt (v 3)) = 0
abel
have hz₁ : directionVector (d 0) + directionVector (d 1) ≠ 0 := by
intro h
have hh : vertexInt (v 2) = vertexInt (v 0) := by
have h' : vertexInt (v 2) - vertexInt (v 0) = 0 := by
calc
_ = directionVector (d 0) + directionVector (d 1) := by
rw [← hvec 0,← hvec 1]
change vertexInt (v 2) - vertexInt (v 0) =
(vertexInt (v 1) - vertexInt (v 0)) + (vertexInt (v 2) - vertexInt (v 1))
abel
_ = 0 := h
exact sub_eq_zero.mp h'
exact (by decide : (2 : Fin 4) ≠ 0) (hv (vertexInt_injective hh))
have hz₂ : directionVector (d 1) + directionVector (d 2) ≠ 0 := by
intro h
have hh : vertexInt (v 3) = vertexInt (v 1) := by
have h' : vertexInt (v 3) - vertexInt (v 1) = 0 := by
calc
_ = directionVector (d 1) + directionVector (d 2) := by
rw [← hvec 1,← hvec 2]
change vertexInt (v 3) - vertexInt (v 1) =
(vertexInt (v 2) - vertexInt (v 1)) + (vertexInt (v 3) - vertexInt (v 2))
abel
_ = 0 := h
exact sub_eq_zero.mp h'
exact (by decide : (3 : Fin 4) ≠ 1) (hv (vertexInt_injective hh))
simpa only [hd] using (four_direction_pattern _ _ _ _ hzero hz₁ hz₂).2.2
lemma faceCorner_index_injective (f : Face n) : Function.Injective (faceCorner f) := by
intro i j
rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> fin_cases i <;> fin_cases j
all_goals simp [faceCorner,castSucc_ne_succ_self,succ_ne_castSucc_self]
lemma incident_faceSide (f : Face n) (i : Fin 4) (v : Vertex n) :
incident v (faceSide f i) ↔ v = faceCorner f i ∨ v = faceCorner f (i+1) := by
rcases f with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩) <;> fin_cases i
all_goals simp [incident,faceSide,faceCorner,tail,head,ex,ey,ez,or_comm,eq_comm]
lemma square_index_calculation : ∀ i j a b c : Fin 4, i ≠ j →
(a=i ∨ a=i+1) → (b=i ∨ b=i+1) → (b=j ∨ b=j+1) → (c=j ∨ c=j+1) →
a ≠ b → b ≠ c → c = a+2 := by decide
lemma face_chain_opposite (f : Face n) (i j : Fin 4) (v₀ v₁ v₂ : Vertex n)
(hij : i ≠ j) (h01 : v₀ ≠ v₁) (h12 : v₁ ≠ v₂)
(hi₀ : incident v₀ (faceSide f i)) (hi₁ : incident v₁ (faceSide f i))
(hj₁ : incident v₁ (faceSide f j)) (hj₂ : incident v₂ (faceSide f j)) :
∃ k : Fin 4, v₀ = faceCorner f k ∧ v₂ = faceCorner f (k+2) := by
have h0 : ∃ a, v₀ = faceCorner f a := by
rcases (incident_faceSide f i v₀).mp hi₀ with h|h <;> exact ⟨_,h⟩
have h1 : ∃ a, v₁ = faceCorner f a := by
rcases (incident_faceSide f i v₁).mp hi₁ with h|h <;> exact ⟨_,h⟩
have h2 : ∃ a, v₂ = faceCorner f a := by
rcases (incident_faceSide f j v₂).mp hj₂ with h|h <;> exact ⟨_,h⟩
obtain ⟨a,rfl⟩ := h0
obtain ⟨b,rfl⟩ := h1
obtain ⟨c,rfl⟩ := h2
have hc : c = a+2 := square_index_calculation i j a b c hij
(by simpa only [incident_faceSide,(faceCorner_index_injective f).eq_iff] using hi₀)
(by simpa only [incident_faceSide,(faceCorner_index_injective f).eq_iff] using hi₁)
(by simpa only [incident_faceSide,(faceCorner_index_injective f).eq_iff] using hj₁)
(by simpa only [incident_faceSide,(faceCorner_index_injective f).eq_iff] using hj₂)
(fun h => h01 (congrArg _ h)) (fun h => h12 (congrArg _ h))
exact ⟨a,rfl,congrArg _ hc⟩
lemma edge_eq_of_endpoints (e f : Edge n)
(h : (tail e=tail f ∧ head e=head f) ∨ (tail e=head f ∧ head e=tail f)) : e=f := by
rcases e with ⟨x,y,z⟩ | (⟨x,y,z⟩ | ⟨x,y,z⟩)
all_goals rcases f with ⟨x',y',z'⟩ | (⟨x',y',z'⟩ | ⟨x',y',z'⟩)
all_goals simp [tail,head,Prod.ext_iff,Fin.ext_iff] at h ⊢
all_goals omega
end
noncomputable section
open Classical WitnessedChoice WitnessedChoice.TreeTest
variable {n : ℕ}
def symEdge (e : Edge n) : Sym2 (Vertex n) := s(tail e, head e)
lemma symEdge_injective : Function.Injective (symEdge (n := n)) := by
intro e f h
apply edge_eq_of_endpoints e f
exact Sym2.eq_iff.mp h
lemma edgeGraph_edgeFinset (T : Finset (Edge n)) :
(edgeGraph T).edgeFinset = T.image symEdge := by
apply Finset.ext
intro q
induction q using Sym2.inductionOn with
| _ u v =>
rw [SimpleGraph.mem_edgeFinset,SimpleGraph.mem_edgeSet]
change (∃ e ∈ T, u = tail e ∧ v = head e ∨ v = tail e ∧ u = head e) ↔ _
simp only [Finset.mem_image,symEdge,Sym2.eq_iff]
constructor
· rintro ⟨e,he, (⟨hu,hv⟩ | ⟨hv,hu⟩)⟩
· exact ⟨e,he,Or.inl ⟨hu.symm,hv.symm⟩⟩
· exact ⟨e,he,Or.inr ⟨hv.symm,hu.symm⟩⟩
· rintro ⟨e,he, (⟨hu,hv⟩ | ⟨hv,hu⟩)⟩
· exact ⟨e,he,Or.inl ⟨hu.symm,hv.symm⟩⟩
· exact ⟨e,he,Or.inr ⟨hv.symm,hu.symm⟩⟩
lemma edgeGraph_card (T : Finset (Edge n)) :
Nat.card (edgeGraph T).edgeSet = T.card := by
rw [Nat.card_eq_fintype_card,←SimpleGraph.edgeFinset_card,edgeGraph_edgeFinset,
Finset.card_image_of_injective _ symEdge_injective]
namespace ParentEdges
variable {T : RootedTree (Vertex n)} (P : ParentEdges T)
lemma edge_injective : Function.Injective (fun v : {v : Vertex n // v ≠ T.root} => P.edge v.val v.property) := by
intro v w h
apply Subtype.ext
have hv := P.endpoints v.val v.property
have hw := P.endpoints w.val w.property
change P.edge v.val v.property = P.edge w.val w.property at h
rw [h] at hv
rcases hv with ⟨hv₁,hv₂⟩ | ⟨hv₁,hv₂⟩ <;>
rcases hw with ⟨hw₁,hw₂⟩ | ⟨hw₁,hw₂⟩
· exact hv₁.symm.trans hw₁
· have he₁ := hv₁.symm.trans hw₂
have he₂ := hw₁.symm.trans hv₂
have hlv := T.parent_lower v.val v.property
have hlw := T.parent_lower w.val w.property
rw [←he₁] at hlw
rw [←he₂] at hlv
omega
· have he₁ := hv₁.symm.trans hw₂
have he₂ := hw₁.symm.trans hv₂
have hlv := T.parent_lower v.val v.property
have hlw := T.parent_lower w.val w.property
rw [←he₁] at hlw
rw [←he₂] at hlv
omega
· exact hv₁.symm.trans hw₁
lemma graph_adj (u v : Vertex n) : (edgeGraph P.treeEdges).Adj u v ↔ T.Adj u v := by
simp only [edgeGraph,treeEdges,Finset.mem_image,Finset.mem_univ,true_and,exists_exists_eq_and]
constructor
· rintro ⟨w,h⟩
rcases P.endpoints w.val w.property with ⟨hh,ht⟩ | ⟨ht,hh⟩
· rw [hh,ht] at h
rcases h with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
· exact Or.inr ⟨w.property,rfl⟩
· exact Or.inl ⟨w.property,rfl⟩
· rw [hh,ht] at h
rcases h with ⟨rfl,rfl⟩ | ⟨rfl,rfl⟩
· exact Or.inl ⟨w.property,rfl⟩
· exact Or.inr ⟨w.property,rfl⟩
· rintro (⟨hu,rfl⟩ | ⟨hv,rfl⟩)
· refine ⟨⟨u,hu⟩,?_⟩
rcases P.endpoints u hu with ⟨hh,ht⟩ | ⟨ht,hh⟩
· exact Or.inr ⟨ht.symm,hh.symm⟩
· exact Or.inl ⟨ht.symm,hh.symm⟩
· refine ⟨⟨v,hv⟩,?_⟩
rcases P.endpoints v hv with ⟨hh,ht⟩ | ⟨ht,hh⟩
· exact Or.inl ⟨ht.symm,hh.symm⟩
· exact Or.inr ⟨ht.symm,hh.symm⟩
lemma graph_reachable_root (v : Vertex n) : (edgeGraph P.treeEdges).Reachable v T.root := by
induction v using (measure T.level).wf.induction with
| h v ih =>
by_cases hv : v = T.root
· subst v; exact .rfl
· exact ((P.graph_adj v (T.parent v)).mpr (T.parent_adj v hv)).reachable.trans
(ih (T.parent v) (T.parent_lower v hv))
lemma graph_connected : (edgeGraph P.treeEdges).Connected where
preconnected u v := (P.graph_reachable_root u).trans (P.graph_reachable_root v).symm
nonempty := ⟨T.root⟩
lemma card_treeEdges : P.treeEdges.card + 1 = Fintype.card (Vertex n) := by
simp only [treeEdges,Finset.card_image_of_injective _ P.edge_injective,Finset.card_univ]
have h := Fintype.card_subtype_compl (fun v : Vertex n => v = T.root)
have hc : Fintype.card {v : Vertex n // v = T.root} = 1 := by simp
rw [hc] at h
change Fintype.card {v : Vertex n // v ≠ T.root} = _ at h
have hp : 0 < Fintype.card (Vertex n) := Fintype.card_pos_iff.mpr ⟨T.root⟩
omega
lemma graph_isTree : (edgeGraph P.treeEdges).IsTree := by
rw [SimpleGraph.isTree_iff_connected_and_card]
exact ⟨P.graph_connected,by rw [edgeGraph_card,Nat.card_eq_fintype_card]; exact P.card_treeEdges⟩
end ParentEdges
end
end WitnessedSeparation.Grid
section
namespace WitnessedChoice.BGS
noncomputable section
open Classical WitnessedSeparation WitnessedSeparation.Hereditary QuotedTerm
namespace QuotedFormula
variable {A V : Type} [Fintype A] [Fintype V] {k : ℕ}
lemma meaning_leastVertex (S : Input A) (env : Fin k → HF A)
(ats VT R vt : QuotedTerm k) (code : V → HF A) (hc : Function.Injective code)
(G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V) (v : V)
(hα : ats.meaning S env = tupleCode (List.ofFn (code ∘ α)))
(hV : VT.meaning S env = ofFinset (Finset.univ.image code))
(hR : R.meaning S env = ofFinset ((BFS.closure G (Fintype.card A)).image (distanceCode code)))
(hv : vt.meaning S env = code v) (hcard : Fintype.card V ≤ Fintype.card A) :
(leastVertex ats VT R vt).meaning S env ↔ v = α 0 := by
simp only [leastVertex,meaning_and,meaning_mem,hv,hV,elements_ofFinset,
Finset.mem_image,Finset.mem_univ,true_and,hc.eq_iff,exists_eq,true_and,
meaning_allIn,forall_exists_index,forall_apply_eq_imp_iff,meaning_neg]
have hm (w : V) : (vertexLt ats.up R.up (var 0) vt.up).meaning S (Fin.cons (code w) env) ↔
AnchoredTree.key G α w < AnchoredTree.key G α v := by
apply meaning_vertexLt S _ _ _ _ _ code hc G hG α w v
all_goals first | assumption | rfl
simpa only [hm] using AnchoredTree.least_iff_root G hG α v
end QuotedFormula
namespace QuotedTerm
variable {A V : Type} [Fintype A] [Fintype V] {k : ℕ}
lemma meaning_root (S : Input A) (env : Fin k → HF A)
(ats VT R : QuotedTerm k) (code : V → HF A) (hc : Function.Injective code)
(G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V)
(hα : ats.meaning S env = tupleCode (List.ofFn (code ∘ α)))
(hV : VT.meaning S env = ofFinset (Finset.univ.image code))
(hR : R.meaning S env = ofFinset ((BFS.closure G (Fintype.card A)).image (distanceCode code)))
(hcard : Fintype.card V ≤ Fintype.card A) :
(root ats VT R).meaning S env = code (α 0) := by
have hm (v : V) : (QuotedFormula.leastVertex ats.up VT.up R.up (var 0)).meaning S
(Fin.cons (code v) env) ↔ v = α 0 := by
apply QuotedFormula.meaning_leastVertex S _ _ _ _ _ code hc G hG α v
all_goals first | assumption | rfl
simp only [root,meaning_unique,meaning_filter,hV,elements_ofFinset]
have hf : (Finset.univ.image code).filter (fun z =>
(QuotedFormula.leastVertex ats.up VT.up R.up (var 0)).meaning S (Fin.cons z env)) =
{code (α 0)} := by
ext z
simp only [Finset.mem_filter,Finset.mem_image,Finset.mem_univ,true_and,Finset.mem_singleton]
constructor
· rintro ⟨⟨v,rfl⟩,hv⟩
rw [hm] at hv
rw [hv]
· rintro rfl
exact ⟨⟨α 0,rfl⟩,(hm _).mpr rfl⟩
rw [hf]
exact uniqueHF_singleton _
end QuotedTerm
end
end WitnessedChoice.BGS
namespace WitnessedSeparation.Grid
noncomputable section
open Classical WitnessedChoice WitnessedChoice.BGS Hereditary
variable {n : ℕ} {b : Vertex n → Scalar}
def anchoredTree (α : Fin 4 → Vertex n) : TreeTest.RootedTree (Vertex n) :=
AnchoredTree.rooted (boxGraph n) (boxGraph_connected n) α
def anchoredParents (α : Fin 4 → Vertex n) : ParentEdges (anchoredTree α) where
edge v hv := ((boxGraph_adj_iff v ((anchoredTree α).parent v)).mp
(AnchoredTree.parent_property (boxGraph n) (boxGraph_connected n) α v hv).1.1).choose
endpoints v hv := by
have h := ((boxGraph_adj_iff v ((anchoredTree α).parent v)).mp
(AnchoredTree.parent_property (boxGraph n) (boxGraph_connected n) α v hv).1.1).choose_spec
rcases h with ⟨h,h'⟩ | ⟨h',h⟩
· exact Or.inr ⟨h.symm,h'.symm⟩
· exact Or.inl ⟨h.symm,h'.symm⟩
namespace QuotedGrid
open QuotedTerm QuotedFormula
variable {k : ℕ}
lemma meaning_incident (env : Fin k → HF (Atom b)) (vt et : QuotedTerm k)
(u : Vertex n) (e : Edge n) (hu : vt.meaning (atomInput b) env = vertexCode b u)
(he : et.meaning (atomInput b) env = edgeCode b e) (hn : 1 ≤ n) :
(QuotedFormula.incident vt et).meaning (atomInput b) env ↔ incident u e := by
rw [QuotedFormula.meaning_incident,hu,he]
exact blockIncident_grid hn u e
lemma meaning_adjacent (env : Fin k → HF (Atom b)) (Et ut vt : QuotedTerm k)
(D : Finset (Edge n)) (u v : Vertex n)
(hE : Et.meaning (atomInput b) env = ofFinset (D.image (edgeCode b)))
(hu : ut.meaning (atomInput b) env = vertexCode b u)
(hv : vt.meaning (atomInput b) env = vertexCode b v) (hn : 1 ≤ n) :
(adjacent Et ut vt).meaning (atomInput b) env ↔ (edgeGraph D).Adj u v := by
rw [QuotedFormula.meaning_adjacent,hE,hu,hv]
exact blockAdjacent_edges hn D u v
lemma meaning_parentEligible (env : Fin k → HF (Atom b)) (Et R rt vt wt : QuotedTerm k)
(r v w : Vertex n)
(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))))
(hr : rt.meaning (atomInput b) env = vertexCode b r)
(hv : vt.meaning (atomInput b) env = vertexCode b v)
(hw : wt.meaning (atomInput b) env = vertexCode b w) (hn : 1 ≤ n) :
(parentEligible Et R rt vt wt).meaning (atomInput b) env ↔ AnchoredTree.Eligible (boxGraph n) r v w := by
have hd (u : Vertex n) (ut : QuotedTerm k) (hu : ut.meaning (atomInput b) env = vertexCode b u) :=
QuotedTerm.meaning_distanceAt (atomInput b) env R rt ut (vertexCode b) (vertexCode_injective hn)
(boxGraph n) (boxGraph_connected n) r u hR hr hu (vertex_card_le_atoms hn)
rw [parentEligible,meaning_and,meaning_adjacent env Et vt wt _ v w hE hv hw hn,edgeGraph_univ]
simp only [meaning_eq,meaning_successor,hd w wt hw,hd v vt hv]
change ((boxGraph n).Adj v w ∧ ordinal ((boxGraph n).dist r w + 1) = ordinal ((boxGraph n).dist r v)) ↔ _
rw [ordinal_injective.eq_iff]
rfl
lemma meaning_parent (env : Fin k → HF (Atom b)) (ats VT Et R rt vt wt : QuotedTerm k)
(α : Fin 4 → Vertex n) (v w : 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))))
(hr : rt.meaning (atomInput b) env = vertexCode b (α 0))
(hv : vt.meaning (atomInput b) env = vertexCode b v)
(hw : wt.meaning (atomInput b) env = vertexCode b w) (hn : 1 ≤ n) :
(QuotedFormula.parent ats VT Et R rt vt wt).meaning (atomInput b) env ↔
v ≠ α 0 ∧ (anchoredTree α).parent v = w := by
have hel (z : Vertex n) : (parentEligible Et.up R.up rt.up vt.up (var 0)).meaning
(atomInput b) (Fin.cons (vertexCode b z) env) ↔ AnchoredTree.Eligible (boxGraph n) (α 0) v z := by
apply meaning_parentEligible _ _ _ _ _ _ _ _ _ _ _ _ _ _ hn
all_goals first | assumption | exact vertex_card_le_atoms hn | rfl
have hlt (z : Vertex n) : (vertexLt ats.up R.up (var 0) wt.up).meaning
(atomInput b) (Fin.cons (vertexCode b z) env) ↔
AnchoredTree.key (boxGraph n) α z < AnchoredTree.key (boxGraph n) α w := by
apply QuotedFormula.meaning_vertexLt _ _ _ _ _ _ (vertexCode b) (vertexCode_injective hn)
(boxGraph n) (boxGraph_connected n) α z w
all_goals first | assumption | exact vertex_card_le_atoms hn | rfl
simp only [QuotedFormula.parent,meaning_and,meaning_parentEligible env Et R rt vt wt _ _ _ hE hR hr hv hw hn,
meaning_allIn,hV,elements_ofFinset,Finset.mem_image,Finset.mem_univ,true_and,
forall_exists_index,forall_apply_eq_imp_iff,meaning_imp,meaning_neg,hel,hlt]
exact AnchoredTree.parent_iff (boxGraph n) (boxGraph_connected n) α hres v w
end QuotedGrid
end
end WitnessedSeparation.Grid
end
namespace WitnessedSeparation.Grid
noncomputable section
open Classical SimpleGraph
variable {n : ℕ}
lemma endpoints_iff_incident (u v : Vertex n) (e : Edge n) (hne : u ≠ v) :
((u = tail e ∧ v = head e) ∨ (v = tail e ∧ u = head e)) ↔
incident u e ∧ incident v e := by
simp only [incident]
constructor
· rintro (⟨hu,hv⟩|⟨hv,hu⟩)
· exact ⟨Or.inr hu.symm,Or.inl hv.symm⟩
· exact ⟨Or.inl hu.symm,Or.inr hv.symm⟩
· rintro ⟨(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
lemma edge_eq_of_common_incidents (u v : Vertex n) (e f : Edge n) (hne : u ≠ v)
(heu : incident u e) (hev : incident v e) (hfu : incident u f) (hfv : incident v f) : e=f := by
have he := (endpoints_iff_incident u v e hne).mpr ⟨heu,hev⟩
have hf := (endpoints_iff_incident u v f hne).mpr ⟨hfu,hfv⟩
apply edge_eq_of_endpoints
rcases he with ⟨he₁,he₂⟩|⟨he₂,he₁⟩
all_goals rcases hf with ⟨hf₁,hf₂⟩|⟨hf₂,hf₁⟩
· exact Or.inl ⟨he₁.symm.trans hf₁,he₂.symm.trans hf₂⟩
· exact Or.inr ⟨he₁.symm.trans hf₁,he₂.symm.trans hf₂⟩
· exact Or.inr ⟨he₂.symm.trans hf₂,he₁.symm.trans hf₁⟩
· exact Or.inl ⟨he₂.symm.trans hf₂,he₁.symm.trans hf₁⟩
lemma edge_on_face (f : Face n) (i j : Fin 4) (e : Edge n) (hij : AdjacentIndex i j)
(hi : incident (faceCorner f i) e) (hj : incident (faceCorner f j) e) : cycle f e ≠ 0 := by
rcases hij with rfl|rfl
· have hn : faceCorner f i ≠ faceCorner f (i+1) := by
intro h
have hh := faceCorner_index_injective f h
have hbad : ∀ i : Fin 4, i ≠ i+1 := by decide
exact hbad i hh
have he := edge_eq_of_common_incidents _ _ e (faceSide f i) hn hi hj
((incident_faceSide f i _).mpr (Or.inl rfl))
((incident_faceSide f i _).mpr (Or.inr rfl))
rw [he]
exact cycle_faceSide f i
· have hn : faceCorner f j ≠ faceCorner f (j+1) := by
intro h
have hh := faceCorner_index_injective f h
have hbad : ∀ i : Fin 4, i ≠ i+1 := by decide
exact hbad j hh
have he := edge_eq_of_common_incidents _ _ e (faceSide f j) hn hj hi
((incident_faceSide f j _).mpr (Or.inl rfl))
((incident_faceSide f j _).mpr (Or.inr rfl))
rw [he]
exact cycle_faceSide f j
lemma indexed_cycle_incident (v : Fin 4 → Vertex n) (e : Fin 4 → Edge n)
(he : ∀ i, (v i = tail (e i) ∧ v (i+1) = head (e i)) ∨
(v (i+1) = tail (e i) ∧ v i = head (e i))) (i : Fin 4) :
incident (v i) (e i) ∧ incident (v (i+1)) (e i) := by
rcases he i with ⟨h,h'⟩|⟨h',h⟩
· exact ⟨Or.inr h.symm,Or.inl h'.symm⟩
· exact ⟨Or.inl h.symm,Or.inr h'.symm⟩
theorem indexed_fourcycle_is_face (v : Fin 4 → Vertex n) (e : Fin 4 → Edge n)
(hv : Function.Injective v) (heinj : Function.Injective e)
(he : ∀ i, (v i = tail (e i) ∧ v (i+1) = head (e i)) ∨
(v (i+1) = tail (e i) ∧ v i = head (e i))) :
∃ f : Face n, ∀ i, cycle f (e i) ≠ 0 := by
have hi := indexed_cycle_incident v e he
obtain ⟨f,hf₀,hf₁⟩ := incident_perpendicular_face (v 1) (e 0) (e 1)
(hi 0).2 (hi 1).1 (square_consecutive_perpendicular v e hv he)
obtain ⟨i,hi₀⟩ := support_cycle f (e 0) hf₀
obtain ⟨j,hj₁⟩ := support_cycle f (e 1) hf₁
have hij : i ≠ j := by
intro h
have hh : e 0=e 1 := hi₀.symm.trans (h ▸ hj₁)
exact (by decide : (0 : Fin 4) ≠ 1) (heinj hh)
obtain ⟨k,h₀,h₂⟩ := face_chain_opposite f i j (v 0) (v 1) (v 2) hij
(fun h => (by decide : (0 : Fin 4) ≠ 1) (hv h))
(fun h => (by decide : (1 : Fin 4) ≠ 2) (hv h))
(hi₀ ▸ (hi 0).1) (hi₀ ▸ (hi 0).2) (hj₁ ▸ (hi 1).1) (hj₁ ▸ (hi 1).2)
have hadj (i : Fin 4) : (boxGraph n).Adj (v i) (v (i+1)) :=
(boxGraph_adj_iff _ _).mpr ⟨e i,he i⟩
have h₁ : v 1=faceCorner f (k+1) ∨ v 1=faceCorner f (k+3) :=
square_common_neighbors f k (v 1) (h₀ ▸ hadj 0) (h₂ ▸ (hadj 1).symm)
have h₃ : v 3=faceCorner f (k+1) ∨ v 3=faceCorner f (k+3) :=
square_common_neighbors f k (v 3) (h₀ ▸ (hadj 3).symm) (h₂ ▸ hadj 2)
have hv₁₃ : v 1 ≠ v 3 := fun h => (by decide : (1 : Fin 4) ≠ 3) (hv h)
have sufficient (J : Fin 4 → Fin 4) (hJ : ∀ i, v i = faceCorner f (J i))
(hA : ∀ i, AdjacentIndex (J i) (J (i+1))) : ∀ i, cycle f (e i) ≠ 0 := by
intro i
exact edge_on_face f _ _ (e i) (hA i) (hJ i ▸ (hi i).1) (hJ (i+1) ▸ (hi i).2)
refine ⟨f,?_⟩
rcases h₁ with h₁|h₁
all_goals rcases h₃ with h₃|h₃
· exact (hv₁₃ (h₁.trans h₃.symm)).elim
· refine sufficient ![k,k+1,k+2,k+3] ?_ ?_
· intro i; fin_cases i <;> assumption
· have h : ∀ k i : Fin 4, AdjacentIndex (![k,k+1,k+2,k+3] i)
(![k,k+1,k+2,k+3] (i+1)) := by unfold AdjacentIndex; decide
exact h k
· refine sufficient ![k,k+3,k+2,k+1] ?_ ?_
· intro i; fin_cases i <;> assumption
· have h : ∀ k i : Fin 4, AdjacentIndex (![k,k+3,k+2,k+1] i)
(![k,k+3,k+2,k+1] (i+1)) := by unfold AdjacentIndex; decide
exact h k
· exact (hv₁₃ (h₁.trans h₃.symm)).elim
end
noncomputable section
open Classical Support
variable {n : ℕ} {b : Vertex n → Scalar}
structure CycleFrame (n : ℕ) where
vertex : Fin 4 → Vertex n
edge : Fin 4 → Edge n
vertex_injective : Function.Injective vertex
edge_injective : Function.Injective edge
endpoints : ∀ i, (vertex i = tail (edge i) ∧ vertex (i+1) = head (edge i)) ∨
(vertex (i+1) = tail (edge i) ∧ vertex i = head (edge i))
namespace CycleFrame
variable (C : CycleFrame n)
def face : Face n := (indexed_fourcycle_is_face C.vertex C.edge C.vertex_injective C.edge_injective C.endpoints).choose
lemma on_face (i : Fin 4) : cycle C.face (C.edge i) ≠ 0 :=
(indexed_fourcycle_is_face C.vertex C.edge C.vertex_injective C.edge_injective C.endpoints).choose_spec i
lemma incident_ends (i : Fin 4) : incident (C.vertex i) (C.edge i) ∧ incident (C.vertex (i+1)) (C.edge i) :=
indexed_cycle_incident C.vertex C.edge C.endpoints i
lemma consecutive_axis_ne (i : Fin 4) : edgeAxis (C.edge i) ≠ edgeAxis (C.edge (i+1)) := by
have hadd : Function.Injective (fun j : Fin 4 => i+j) := by
have h : ∀ i j k : Fin 4, i+j=i+k → j=k := by decide
exact h i
have hh := square_consecutive_perpendicular (fun j => C.vertex (i+j)) (fun j => C.edge (i+j))
(C.vertex_injective.comp hadd) (fun j => by simpa only [add_assoc] using C.endpoints (i+j))
simpa only [add_zero] using hh
lemma adjacent_axis_ne (i j : Fin 4) (h : AdjacentIndex i j) : edgeAxis (C.edge i) ≠ edgeAxis (C.edge j) := by
rcases h with rfl | rfl
· exact C.consecutive_axis_ne i
· exact (C.consecutive_axis_ne j).symm
lemma support_iff (e : Edge n) : cycle C.face e ≠ 0 ↔ ∃ i, e = C.edge i := by
choose J hJ using fun i => support_cycle C.face (C.edge i) (C.on_face i)
have hJi : Function.Injective J := by
intro i j hh
apply C.edge_injective
exact (hJ i).symm.trans (hh ▸ hJ j)
constructor
· intro he
obtain ⟨k,hk⟩ := support_cycle C.face e he
obtain ⟨i,rfl⟩ := Finite.surjective_of_injective hJi k
exact ⟨i,hk.symm.trans (hJ i)⟩
· rintro ⟨i,rfl⟩
exact C.on_face i
lemma face_unique (f : Face n) (hf : ∀ i, cycle f (C.edge i) ≠ 0) : C.face = f :=
common_face_unique (C.edge 0) (C.edge 1) (C.consecutive_axis_ne 0)
(C.on_face 0) (C.on_face 1) (hf 0) (hf 1)
def joint (i j : Fin 4) : Vertex n := if j=i+1 then C.vertex j else C.vertex i
lemma joint_incident (i j : Fin 4) (h : AdjacentIndex i j) :
incident (C.joint i j) (C.edge i) ∧ incident (C.joint i j) (C.edge j) := by
unfold joint
split_ifs with he
· subst j
exact ⟨(C.incident_ends i).2,(C.incident_ends (i+1)).1⟩
· have hi : i=j+1 := h.resolve_left he
subst i
exact ⟨(C.incident_ends (j+1)).1,(C.incident_ends j).2⟩
def Across (i j : Fin 4) (s : LocalGroup (C.edge i)) (t : LocalGroup (C.edge j)) : Prop :=
∃ hi : incident (C.joint i j) (C.edge i), ∃ hj : incident (C.joint i j) (C.edge j),
∃ c : Configuration b (C.joint i j), c.state ⟨C.edge i,hi⟩ = s ∧ c.state ⟨C.edge j,hj⟩ = t
lemma across_iff (hn : 1 ≤ n) (i j : Fin 4) (h : AdjacentIndex i j)
(s : LocalGroup (C.edge i)) (t : LocalGroup (C.edge j)) :
C.Across (b := b) i j s t ↔ s.face ⟨C.face,C.on_face i⟩ = t.face ⟨C.face,C.on_face j⟩ := by
constructor
· rintro ⟨hi,hj,c,hs,ht⟩
simpa only [hs,ht] using c.compatible ⟨_,hi⟩ ⟨_,hj⟩ C.face (C.on_face i) (C.on_face j)
· intro hs
obtain ⟨hi,hj⟩ := C.joint_incident i j h
have he : (⟨C.edge i,hi⟩ : IncidentEdges (C.joint i j)) ≠ ⟨C.edge j,hj⟩ := by
intro hh
exact C.adjacent_axis_ne i j h (congrArg (edgeAxis ∘ Subtype.val) hh)
obtain ⟨c,hc,hc'⟩ := exists_configuration_two (b := b) hn ⟨_,hi⟩ ⟨_,hj⟩ he s t (by
intro f hfi hfj
have hf := common_face_unique _ _ (C.adjacent_axis_ne i j h) (C.on_face i) (C.on_face j) hfi hfj
subst f
exact hs)
exact ⟨hi,hj,c,hc,hc'⟩
def Match (i j : Fin 4) (s : LocalGroup (C.edge i)) (t : LocalGroup (C.edge j)) : Prop :=
if AdjacentIndex i j then C.Across (b := b) i j s t else
∃ q : LocalGroup (C.edge (i+1)), C.Across (b := b) i (i+1) s q ∧ C.Across (b := b) j (i+1) t q
lemma match_iff (hn : 1 ≤ n) (i j : Fin 4) (s : LocalGroup (C.edge i)) (t : LocalGroup (C.edge j)) :
C.Match (b := b) i j s t ↔ s.face ⟨C.face,C.on_face i⟩ = t.face ⟨C.face,C.on_face j⟩ := by
unfold Match
split_ifs with h
· exact C.across_iff hn i j h s t
· simp only [C.across_iff hn i (i+1) (index_next_adjacent i),
C.across_iff hn j (i+1) (nonadjacent_next i j h)]
constructor
· rintro ⟨q,hs,ht⟩
exact hs.trans ht.symm
· intro he
exact ⟨⟨fun _ => s.face ⟨C.face,C.on_face i⟩,0⟩,rfl,he.symm⟩
end CycleFrame
def standardFrame (f : Face n) : CycleFrame n where
vertex := faceCorner f
edge := faceSide f
vertex_injective := faceCorner_index_injective f
edge_injective := faceSide_injective_index f
endpoints i := by
have hi := (incident_faceSide f i (faceCorner f i)).mpr (Or.inl rfl)
have hj := (incident_faceSide f i (faceCorner f (i+1))).mpr (Or.inr rfl)
have hne : faceCorner f i ≠ faceCorner f (i+1) := by
intro hh
have he := faceCorner_index_injective f hh
have hbad : ∀ i : Fin 4, i ≠ i+1 := by decide
exact hbad i he
rcases hi with hi | hi <;> rcases hj with hj | hj
· exact (hne (hi.symm.trans hj)).elim
· exact Or.inr ⟨hj.symm,hi.symm⟩
· exact Or.inl ⟨hi.symm,hj.symm⟩
· exact (hne (hi.symm.trans hj)).elim
@[simp] lemma standardFrame_face (f : Face n) : (standardFrame f).face = f :=
(standardFrame f).face_unique f (cycle_faceSide f)
end
end WitnessedSeparation.Grid
end OAI
import OAI.Computability.WitnessedChoice.GridGeometry
namespace OAI
namespace WitnessedChoice
noncomputable section
open Classical
namespace AnchoredTree
variable {V : Type} [Fintype V]
def key (G : SimpleGraph V) (α : Fin 4 → V) (v : V) : Lex (Fin 4 → ℕ) :=
toLex (fun i => G.dist (α i) v)
def Resolving (G : SimpleGraph V) (α : Fin 4 → V) : Prop := Function.Injective (key G α)
def Eligible (G : SimpleGraph V) (r v w : V) : Prop := G.Adj v w ∧ G.dist r w + 1 = G.dist r v
omit [Fintype V] in
lemma root_lt (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V)
(v : V) (hv : v ≠ α 0) : key G α (α 0) < key G α v := by
refine ⟨0,?_,?_⟩
· intro j hj; exact (Fin.not_lt_zero j hj).elim
· change G.dist (α 0) (α 0) < G.dist (α 0) v
rw [G.dist_self]
exact Nat.pos_of_ne_zero (fun h => hv ((hG (α 0) v).dist_eq_zero_iff.mp h).symm)
omit [Fintype V] in
lemma least_iff_root (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V) (v : V) :
(∀ w, ¬key G α w < key G α v) ↔ v = α 0 := by
constructor
· intro h; by_contra hn; exact h _ (root_lt G hG α v hn)
· rintro rfl w hw
by_cases h : w = α 0
· subst w; exact lt_irrefl _ hw
· exact (lt_asymm hw (root_lt G hG α w h))
omit [Fintype V] in
lemma exists_eligible (G : SimpleGraph V) (hG : G.Connected) (r v : V) (hv : v ≠ r) :
∃ w, Eligible G r v w := by
obtain ⟨p,hp⟩ := hG.exists_walk_length_eq_dist v r
cases p with
| nil => exact (hv rfl).elim
| @cons _ w _ hadj q =>
refine ⟨w,hadj,?_⟩
have hle := G.dist_le q
have hd := hadj.diff_dist_adj (u := r)
simp only [SimpleGraph.Walk.length_cons] at hp
rw [G.dist_comm (u := v) (v := r)] at hp
rw [G.dist_comm (u := w) (v := r)] at hle
omega
omit [Fintype V] in
lemma exists_min_key (G : SimpleGraph V) (α : Fin 4 → V) (D : Finset V) (hD : D.Nonempty) :
∃ v ∈ D, ∀ w ∈ D, ¬key G α w < key G α v := by
let K := D.image (key G α)
have hK : K.Nonempty := hD.image _
obtain ⟨v,hv,he⟩ := Finset.mem_image.mp (Finset.min'_mem K hK)
refine ⟨v,hv,?_⟩
intro w hw hlt
have hm := Finset.min'_le K (key G α w) (Finset.mem_image.mpr ⟨w,hw,rfl⟩)
rw [←he] at hm
exact (not_lt_of_ge hm) hlt
lemma exists_parent (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V)
(v : V) (hv : v ≠ α 0) :
∃ w, Eligible G (α 0) v w ∧ ∀ z, Eligible G (α 0) v z → ¬key G α z < key G α w := by
obtain ⟨w,hw⟩ := exists_eligible G hG (α 0) v hv
obtain ⟨z,hz,hm⟩ := exists_min_key G α (Finset.univ.filter (Eligible G (α 0) v))
⟨w,Finset.mem_filter.mpr ⟨Finset.mem_univ _,hw⟩⟩
exact ⟨z,(Finset.mem_filter.mp hz).2,fun y hy => hm y (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hy⟩)⟩
def parent (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V) (v : V) : V :=
if hv : v = α 0 then α 0 else (exists_parent G hG α v hv).choose
lemma parent_property (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V)
(v : V) (hv : v ≠ α 0) :
Eligible G (α 0) v (parent G hG α v) ∧
∀ z, Eligible G (α 0) v z → ¬key G α z < key G α (parent G hG α v) := by
rw [parent,dite_eq_right hv]
exact (exists_parent G hG α v hv).choose_spec
def rooted (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V) : TreeTest.RootedTree V where
root := α 0
parent := parent G hG α
level := G.dist (α 0)
parent_lower v hv := by have h := (parent_property G hG α v hv).1.2; omega
lemma parent_iff (G : SimpleGraph V) (hG : G.Connected) (α : Fin 4 → V)
(hα : Resolving G α) (v w : V) :
(Eligible G (α 0) v w ∧ ∀ z, Eligible G (α 0) v z → ¬key G α z < key G α w) ↔
v ≠ α 0 ∧ (rooted G hG α).parent v = w := by
constructor
· rintro ⟨hw,hm⟩
have hv : v ≠ α 0 := by intro hh; have hd := hw.2; rw [hh,G.dist_self] at hd; omega
refine ⟨hv,?_⟩