| import OAI.Computability.WitnessedChoice.TreeCorrection |
|
|
| namespace OAI |
|
|
|
|
| namespace WitnessedSeparation.Grid |
|
|
| noncomputable section |
|
|
| open Classical WitnessedChoice WitnessedChoice.BGS Hereditary RelationPools |
|
|
| variable {n : ℕ} {b : Vertex n → Scalar} |
|
|
| namespace QuotedGrid |
|
|
| open QuotedTerm QuotedFormula SourceSyntax SourceProgram |
|
|
| attribute [local irreducible] QuotedTerm.nextEdges QuotedTerm.tree SourceSyntax.cycleRelations |
|
|
| lemma fundamentalPool_in_cycleSet (p : Polynomial ℝ) (hp : GridResources p b) |
| (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hn : 1 ≤ n) : |
| (anchoredParents α).fundamentalPool (leastEdges α (remainingEdges (anchoredParents α).treeEdges x)) ⊆ |
| SourceProgram.program.body.cycleSet (atomInput b) p |
| (tupleCode (List.ofFn (vertexCode b ∘ α))) (edgeState x) := by |
| let R := distancesCode b (boxGraph n) |
| let T := ofFinset ((anchoredParents α).treeEdges.image (edgeCode b)) |
| let H := connTableCode b (anchoredParents α).treeEdges |
| let env₀ : Fin 3 → HF (Atom b) := Fin.cons R |
| (Fin.cons (stateCode (edgeState x)) (Fin.cons (tupleCode (List.ofFn (vertexCode b ∘ α))) Fin.elim0)) |
| let env₁ : Fin 4 → HF (Atom b) := Fin.cons T env₀ |
| let env : Fin 5 → HF (Atom b) := Fin.cons H env₁ |
| have ht : (tree (var 2) QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 0)).meaning |
| (atomInput b) env₀ = T := |
| meaning_tree env₀ (var 2) _ _ (var 0) α hα rfl |
| (quoted_vertexBlocks hn env₀) (quoted_edgeBlocks env₀) rfl hn |
| have hh : (SourceProgram.connTable QuotedTerm.vertexBlocks (var 0)).value |
| (atomInput b) p env₁ = H := |
| value_connTable env₁ _ _ (anchoredParents α).treeEdges p hp |
| (quoted_vertexBlocks hn env₁) rfl hn |
| have hv : SourceProgram.cycles.value (atomInput b) p |
| (Fin.cons (stateCode (edgeState x)) (Fin.cons (tupleCode (List.ofFn (vertexCode b ∘ α))) Fin.elim0)) = |
| (cycleRelations QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks |
| (faces QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks) (var 2) (var 1) (var 0) |
| (nextEdges (var 4) QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 2) (var 1) (var 3))).meaning |
| (atomInput b) env := by |
| rw [SourceProgram.cycles,CPTTerm.value_letIn,value_distances _ p hp hn, CPTTerm.value_letIn,CPTTerm.value_quoted] |
| change ((SourceProgram.connTable QuotedTerm.vertexBlocks (var 0)).letIn _).value (atomInput b) p |
| (Fin.cons ((tree (var 2) QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 0)).meaning (atomInput b) env₀) env₀) = _ |
| rw [ht,CPTTerm.value_letIn] |
| change (CPTTerm.quoted _).value (atomInput b) p |
| (Fin.cons ((SourceProgram.connTable QuotedTerm.vertexBlocks (var 0)).value (atomInput b) p env₁) env₁) = _ |
| rw [hh,CPTTerm.value_quoted] |
| have hV := quoted_vertexBlocks (b := b) hn env |
| have hE := quoted_edgeBlocks (b := b) env |
| have hN := meaning_nextEdges env (var 4) QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 2) |
| (var 1) (var 3) α (anchoredParents α).treeEdges x hα rfl hV hE rfl rfl rfl hn |
| intro r hr |
| change r ∈ (elements (SourceProgram.cycles.value (atomInput b) p _)).image decodeRelation |
| rw [hv] |
| refine Finset.mem_image.mpr ⟨relationCode r,?_,decodeRelation_code r⟩ |
| apply fundamentalPool_in_cycles env QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks |
| (faces QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks) (var 2) (var 1) (var 0) _ |
| (anchoredParents α) _ hV hE (mem_faces env _ _ hV hE hn) rfl rfl rfl hN _ hn r hr |
| intro e he |
| exact (Finset.mem_sdiff.mp (Finset.mem_filter.mp (Finset.mem_filter.mp he).1).1).2 |
|
|
| end QuotedGrid |
|
|
| end |
|
|
| end WitnessedSeparation.Grid |
|
|
|
|
| section |
|
|
| namespace WitnessedChoice.RelationPools |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation |
|
|
| variable {A : Type} [Fintype A] |
|
|
| lemma witnessPool_mono (B : ℕ) (S : Input A) (valid : Prop) |
| (C D : Finset A → Finset (Relation A)) (x : Finset A) (hCD : C x ⊆ D x) : |
| witnessPool B S valid C x ⊆ witnessPool B S valid D x := by |
| unfold witnessPool |
| split_ifs |
| · intro g hg |
| rcases Finset.mem_insert.mp hg with hg | hg |
| · exact Finset.mem_insert.mpr (Or.inl hg) |
| · apply Finset.mem_insert_of_mem |
| simp only [Finset.mem_filter,Finset.mem_univ,true_and] at hg ⊢ |
| obtain ⟨hf,l,hl,c,hc,he⟩ := hg |
| exact ⟨hf,l,hl,c,hCD hc,he⟩ |
| · exact Finset.Subset.refl _ |
|
|
| end |
|
|
| end WitnessedChoice.RelationPools |
|
|
| namespace WitnessedSeparation.Grid |
|
|
| noncomputable section |
|
|
| open Classical WitnessedChoice WitnessedChoice.BGS Hereditary RelationPools |
|
|
| variable {n : ℕ} {b : Vertex n → Scalar} |
|
|
| namespace QuotedGrid |
|
|
| open SourceProgram |
|
|
| lemma selection_transitive (p : Polynomial ℝ) (hp : GridResources p b) |
| (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) |
| (hoff : ∀ r ∈ x, r.1 ∉ (anchoredParents α).treeEdges) (hn : 1 ≤ n) : |
| (SourceProgram.program.body.selection (atomInput b) p |
| (tupleCode (List.ofFn (vertexCode b ∘ α)))).TransitiveAt (edgeState x) := by |
| intro a ha d hd |
| rw [selection_candidates p hp α hα x hn] at ha hd |
| obtain ⟨r,hr,rfl⟩ := (mem_edgeState _ _).mp ha |
| obtain ⟨t,ht,rfl⟩ := (mem_edgeState _ _).mp hd |
| obtain ⟨g,hg,hgr⟩ := (anchoredParents α).grid_transitivity hn α hα x hoff r t hr ht |
| refine ⟨g,?_,hgr⟩ |
| change g ∈ witnessPool localBound (atomInput b) True |
| (program.body.cycleSet (atomInput b) p (tupleCode (List.ofFn (vertexCode b ∘ α)))) (edgeState x) |
| exact witnessPool_mono localBound (atomInput b) True _ _ (edgeState x) |
| (fundamentalPool_in_cycleSet p hp α hα x hn) hg |
|
|
| end QuotedGrid |
|
|
| end |
|
|
| end WitnessedSeparation.Grid |
|
|
| end |
|
|
|
|
| namespace WitnessedSeparation.Grid |
|
|
| noncomputable section |
|
|
| open Classical WitnessedChoice.TreeTest |
|
|
| variable {n : ℕ} {b : Vertex n → Scalar} |
|
|
| abbrev ConfigAtom (b : Vertex n → Scalar) := Σ v : Vertex n, Configuration b v |
|
|
| def configBlock (b : Vertex n → Scalar) (v : Vertex n) : Finset (ConfigAtom b) := |
| Finset.univ.image (Sigma.mk v) |
|
|
| lemma mem_configBlock (v : Vertex n) (a : ConfigAtom b) : |
| a ∈ configBlock b v ↔ a.1 = v := by |
| constructor |
| · rintro ha |
| obtain ⟨s,_,rfl⟩ := Finset.mem_image.mp ha |
| rfl |
| · intro h |
| rcases a with ⟨w,a⟩ |
| dsimp at h |
| subst w |
| exact Finset.mem_image.mpr ⟨a,Finset.mem_univ _,rfl⟩ |
|
|
| def atEdge (a : ConfigAtom b) (e : Edge n) (h : incident a.1 e) : LocalGroup e := a.2.state ⟨e,h⟩ |
|
|
| namespace ParentEdges |
|
|
| variable {T : RootedTree (Vertex n)} (P : ParentEdges T) |
|
|
| def allowedConfig (x : Finset (Σ e : Edge n, LocalGroup e)) (a : ConfigAtom b) : Prop := |
| ∀ e, e ∉ P.treeEdges → ∀ h : incident a.1 e, Sigma.mk e (atEdge a e h) ∈ x |
|
|
| def configCompatibility (a c : ConfigAtom b) : Prop := |
| ∀ e ∈ P.treeEdges, ∀ ha : incident a.1 e, ∀ hc : incident c.1 e, |
| atEdge a e ha = atEdge c e hc |
|
|
| def testProblem (x : Finset (Σ e : Edge n, LocalGroup e)) : Problem (Vertex n) (ConfigAtom b) where |
| tree := T |
| configs := Finset.univ |
| block := configBlock b |
| block_subset _ _ _ := Finset.mem_univ _ |
| block_unique v w a hv hw := (mem_configBlock v a).mp hv |>.symm.trans ((mem_configBlock w a).mp hw) |
| allowed := P.allowedConfig x |
| compatible _ _ := P.configCompatibility |
| compatible_symm _ _ _ _ h e he ha hc := (h e he hc ha).symm |
|
|
| lemma solution_configs (x : Finset (Σ e : Edge n, LocalGroup e)) |
| (ht : ∃ t, (P.testProblem (b := b) x).Solution t) : |
| ∃ t : (v : Vertex n) → Configuration b v, |
| (∀ v, P.allowedConfig x ⟨v,t v⟩) ∧ |
| ∀ v w, T.Adj v w → P.configCompatibility ⟨v,t v⟩ ⟨w,t w⟩ := by |
| obtain ⟨t,ht⟩ := ht |
| have hv (v : Vertex n) : (t v).1 = v := (mem_configBlock v _).mp (ht.1 v).1 |
| let tt (v : Vertex n) : Configuration b v := (hv v) ▸ (t v).2 |
| have he (v : Vertex n) : (⟨v,tt v⟩ : ConfigAtom b) = t v := by |
| have transport_pair {w : Vertex n} (a : Configuration b w) (h : w = v) : |
| (⟨v,h ▸ a⟩ : ConfigAtom b) = ⟨w,a⟩ := by cases h; rfl |
| exact transport_pair _ (hv v) |
| refine ⟨tt,?_,?_⟩ |
| · intro v |
| rw [he] |
| exact (ht.1 v).2 |
| · intro v w hadj |
| rw [he,he] |
| exact ht.2 v w hadj |
|
|
| lemma exists_globals_of_solution (x : Finset (Σ e : Edge n, LocalGroup e)) |
| (hx : ∀ r ∈ x, ∀ s ∈ x, r.1 = s.1 → r = s) |
| (ht : ∃ t, (P.testProblem (b := b) x).Solution t) : |
| ∃ (s : (e : Edge n) → LocalGroup e) (t : (v : Vertex n) → Configuration b v), |
| ∀ v (e : IncidentEdges v), (t v).state e = s e.val := by |
| obtain ⟨t,hta,htc⟩ := P.solution_configs x ht |
| let s (e : Edge n) := (t (head e)).state ⟨e,Or.inl rfl⟩ |
| refine ⟨s,t,?_⟩ |
| rintro v ⟨e,hi⟩ |
| rcases hi with hv | hv |
| · subst v |
| rfl |
| · subst v |
| by_cases he : e ∈ P.treeEdges |
| · have ha : (edgeGraph P.treeEdges).Adj (tail e) (head e) := |
| ⟨e,he,Or.inl ⟨rfl,rfl⟩⟩ |
| exact htc _ _ ((P.graph_adj _ _).mp ha) e he (Or.inr rfl) (Or.inl rfl) |
| · have h₁ := hta (tail e) e he (Or.inr rfl) |
| have h₂ := hta (head e) e he (Or.inl rfl) |
| have hh := hx _ h₁ _ h₂ rfl |
| exact eq_of_heq (Sigma.mk.inj hh).2 |
|
|
| lemma test_solution_of_zero (b : Vertex n → Scalar) (hb : ∑ v, b v = 0) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hx : ConsistentSelection x) |
| (hoff : ∀ r ∈ x, r.1 ∉ P.treeEdges) |
| (hcomplete : ∀ e, e ∉ P.treeEdges → ∃ r ∈ x, r.1 = e) : |
| ∃ t, (P.testProblem (b := b) x).Solution t := by |
| obtain ⟨s,t,hs,ht⟩ := extend_consistent_selection P b hb x hx hoff |
| refine ⟨fun v => ⟨v,t v⟩,?_,?_⟩ |
| · intro v |
| refine ⟨(mem_configBlock _ _).mpr rfl,?_⟩ |
| intro e he hi |
| obtain ⟨⟨f,r⟩,hr,hfe⟩ := hcomplete e he |
| dsimp at hfe |
| subst f |
| have hse := hs _ hr |
| simpa only [atEdge,ht,hse] using hr |
| · intro v w _ e he hv hw |
| exact (ht v ⟨e,hv⟩).trans (ht w ⟨e,hw⟩).symm |
|
|
| lemma zero_of_test_solution (x : Finset (Σ e : Edge n, LocalGroup e)) |
| (hx : ∀ r ∈ x, ∀ s ∈ x, r.1 = s.1 → r = s) |
| (ht : ∃ t, (P.testProblem (b := b) x).Solution t) : ∑ v, b v = 0 := by |
| obtain ⟨s,t,ht⟩ := P.exists_globals_of_solution x hx ht |
| exact total_charge_of_global_configurations b s t ht |
|
|
| theorem test_iff_zero (b : Vertex n → Scalar) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hx : ConsistentSelection x) |
| (hoff : ∀ r ∈ x, r.1 ∉ P.treeEdges) |
| (hcomplete : ∀ e, e ∉ P.treeEdges → ∃ r ∈ x, r.1 = e) : |
| (∀ v, ((P.testProblem (b := b) x).survivors v).Nonempty) ↔ ∑ v, b v = 0 := by |
| rw [(P.testProblem x).all_survive_iff_solution] |
| exact ⟨P.zero_of_test_solution x hx.1,fun hb => P.test_solution_of_zero b hb x hx hoff hcomplete⟩ |
|
|
| end ParentEdges |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary |
|
|
| variable {n : ℕ} {b : Vertex n → Scalar} |
|
|
| lemma atom_mem_state (a : Atom b) (s : Finset (Atom b)) : atom a ∈ elements (stateCode s) ↔ a ∈ s := by |
| simp only [stateCode,elements_ofFinset,Finset.mem_image,atom_injective.eq_iff,exists_eq_right] |
|
|
| lemma chosen_incident_iff (x : Finset (Σ e : Edge n, LocalGroup e)) (v : Vertex n) |
| (a : Configuration b v) (e : Edge n) (hi : incident v e) : |
| (∃ z ∈ elements (stateCode (x.image Sum.inl : Finset (Atom b))) ∩ elements (edgeCode b e), |
| inputHF (atomInput b) .I (atom (.inr ⟨v,a⟩)) z = true) ↔ |
| Sigma.mk e (a.state ⟨e,hi⟩) ∈ x := by |
| simp only [Finset.mem_inter,stateCode,elements_ofFinset,Finset.image_image, Finset.mem_image,Function.comp_apply] |
| constructor |
| · rintro ⟨z,⟨⟨r,hr,rfl⟩,he⟩,hinc⟩ |
| have hre := (atom_mem_edgeCode _ _ _).mp he |
| rcases r with ⟨f,s⟩ |
| dsimp at hre |
| subst f |
| obtain ⟨hi',hs⟩ := (input_inc_iff _ _ _ _).mp hinc |
| rwa [hs] |
| · intro h |
| exact ⟨atom (.inl ⟨e,a.state ⟨e,hi⟩⟩),⟨⟨⟨e,a.state ⟨e,hi⟩⟩,h,rfl⟩, |
| (atom_mem_edgeCode _ _ _).mpr rfl⟩,(input_inc_iff _ _ _ _).mpr ⟨hi,rfl⟩⟩ |
| |
| namespace QuotedGrid |
| |
| open QuotedTerm QuotedFormula SourceSyntax |
| |
| variable {k : ℕ} |
| |
| lemma meaning_edgeDiff (env : Fin k → HF (Atom b)) (E T : QuotedTerm k) (D : Finset (Edge n)) |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) |
| (hT : T.meaning (atomInput b) env = ofFinset (D.image (edgeCode b))) : |
| (E.diff T).meaning (atomInput b) env = ofFinset ((Finset.univ \ D).image (edgeCode b)) := by |
| simp only [meaning_diff,hE,hT,elements_ofFinset] |
| apply ofFinset_inj.mpr |
| ext z |
| simp only [Finset.mem_filter,Finset.mem_image,Finset.mem_univ,true_and,Finset.mem_sdiff, |
| not_exists,not_and] |
| constructor |
| · rintro ⟨⟨e,rfl⟩,he⟩ |
| exact ⟨e,fun ht => he e ht rfl,rfl⟩ |
| · rintro ⟨e,he,rfl⟩ |
| exact ⟨⟨e,rfl⟩,fun f hf hfe => he ((edgeCode_injective hfe) ▸ hf)⟩ |
| |
| lemma meaning_allowed {T₀ : RootedTree (Vertex n)} (env : Fin k → HF (Atom b)) |
| (E T xt vt at₀ : QuotedTerm k) (P : ParentEdges T₀) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (v : Vertex n) (a : Configuration b v) |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) |
| (hT : T.meaning (atomInput b) env = ofFinset (P.treeEdges.image (edgeCode b))) |
| (hx : xt.meaning (atomInput b) env = stateCode (x.image Sum.inl)) |
| (hv : vt.meaning (atomInput b) env = vertexCode b v) |
| (ha : at₀.meaning (atomInput b) env = atom (.inr ⟨v,a⟩)) (hn : 1 ≤ n) : |
| (allowed E T xt vt at₀).meaning (atomInput b) env ↔ P.allowedConfig x ⟨v,a⟩ := by |
| have hd := meaning_edgeDiff env E T P.treeEdges hE hT |
| have hi (e : Edge n) := meaning_incident (Fin.cons (edgeCode b e) env) vt.up (var 0) v e hv rfl hn |
| simp only [allowed,meaning_allIn,hd,elements_ofFinset,Finset.forall_mem_image, |
| Finset.mem_sdiff,Finset.mem_univ,true_and,meaning_imp,hi,meaning_existsIn,meaning_inter, |
| QuotedTerm.meaning_up,hx,meaning_var,Fin.cons_zero,meaning_input,ha] |
| constructor |
| · intro h e he hi |
| exact (chosen_incident_iff x v a e hi).mp (h he hi) |
| · intro h e he hi |
| exact (chosen_incident_iff x v a e hi).mpr (h e he hi) |
| |
| end QuotedGrid |
| |
| end |
| |
| |
| |
| |
| |
| noncomputable section |
| |
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary |
| |
| variable {n : ℕ} {b : Vertex n → Scalar} |
| |
| lemma common_edge_unique (e f : Edge n) (v w : Vertex n) (hvw : v ≠ w) |
| (he : incident v e) (he' : incident w e) (hf : incident v f) (hf' : incident w f) : e=f := by |
| have heq := (endpoints_incident_iff e v w).mpr ⟨hvw,he,he'⟩ |
| have hfq := (endpoints_incident_iff f v w).mpr ⟨hvw,hf,hf'⟩ |
| apply edge_eq_of_endpoints |
| rcases heq with ⟨h₁,h₂⟩ | ⟨h₂,h₁⟩ <;> rcases hfq with ⟨h₃,h₄⟩ | ⟨h₄,h₃⟩ |
| · exact Or.inl ⟨h₁.symm.trans h₃,h₂.symm.trans h₄⟩ |
| · exact Or.inr ⟨h₁.symm.trans h₃,h₂.symm.trans h₄⟩ |
| · exact Or.inr ⟨h₂.symm.trans h₄,h₁.symm.trans h₃⟩ |
| · exact Or.inl ⟨h₂.symm.trans h₄,h₁.symm.trans h₃⟩ |
| |
| lemma atom_config_mem (a : ConfigAtom b) (s : Finset (ConfigAtom b)) : |
| atom (.inr a) ∈ elements (stateCode (s.image Sum.inr : Finset (Atom b))) ↔ a ∈ s := by |
| rw [atom_mem_state] |
| simp only [Finset.mem_image,Sum.inr.injEq,exists_eq_right] |
| |
| namespace ParentEdges |
| |
| variable {T₀ : RootedTree (Vertex n)} (P : ParentEdges T₀) |
| |
| lemma compatible_edge_iff (v w : Vertex n) (a : Configuration b v) (c : Configuration b w) |
| (e : Edge n) (he : e ∈ P.treeEdges) (hne : v ≠ w) (hv : incident v e) (hw : incident w e) : |
| P.configCompatibility ⟨v,a⟩ ⟨w,c⟩ ↔ a.state ⟨e,hv⟩ = c.state ⟨e,hw⟩ := by |
| constructor |
| · exact fun h => h e he hv hw |
| · intro h f _ hf hg |
| have heq := common_edge_unique e f v w hne hv hw hf hg |
| subst f |
| exact h |
| |
| end ParentEdges |
| |
| namespace QuotedGrid |
| |
| open QuotedTerm QuotedFormula SourceSyntax |
| |
| variable {k : ℕ} |
| |
| lemma meaning_support (env : Fin k → HF (Atom b)) (wt St et at₀ : QuotedTerm k) |
| (s : Finset (ConfigAtom b)) (v w : Vertex n) (a : Configuration b v) (e : Edge n) |
| (hv : incident v e) (hw : incident w e) |
| (hW : wt.meaning (atomInput b) env = vertexCode b w) |
| (hS : St.meaning (atomInput b) env = stateCode (s.image Sum.inr)) |
| (hE : et.meaning (atomInput b) env = edgeCode b e) |
| (hA : at₀.meaning (atomInput b) env = atom (.inr ⟨v,a⟩)) : |
| (existsIn (wt.diff St) (existsIn et.up |
| ((input .I at₀.up.up (var 0)).and (input .I (var 1) (var 0))))).meaning (atomInput b) env ↔ |
| ∃ c : Configuration b w, Sigma.mk w c ∉ s ∧ a.state ⟨e,hv⟩ = c.state ⟨e,hw⟩ := by |
| simp only [meaning_existsIn,meaning_diff,hW,elements_ofFinset,Finset.mem_filter,and_assoc, |
| exists_vertexCode,QuotedTerm.meaning_up,hS,atom_config_mem,hE,WitnessedSeparation.Grid.exists_edgeCode, |
| meaning_and,meaning_input,hA,meaning_var,Fin.cons_zero,Fin.cons_one,input_inc_iff] |
| constructor |
| · rintro ⟨c,hc,r,⟨hv',h₁⟩,⟨hw',h₂⟩⟩ |
| exact ⟨c,hc,h₁.trans h₂.symm⟩ |
| · rintro ⟨c,hc,h⟩ |
| exact ⟨c,hc,a.state ⟨e,hv⟩,⟨hv,rfl⟩,⟨hw,h.symm⟩⟩ |
| |
| lemma meaning_unsupported {T₀ : RootedTree (Vertex n)} (env : Fin k → HF (Atom b)) |
| (V T St vt at₀ : QuotedTerm k) (P : ParentEdges T₀) (s : Finset (ConfigAtom b)) |
| (v : Vertex n) (a : Configuration b v) |
| (hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) |
| (hT : T.meaning (atomInput b) env = ofFinset (P.treeEdges.image (edgeCode b))) |
| (hS : St.meaning (atomInput b) env = stateCode (s.image Sum.inr)) |
| (hv : vt.meaning (atomInput b) env = vertexCode b v) |
| (ha : at₀.meaning (atomInput b) env = atom (.inr ⟨v,a⟩)) (hn : 1 ≤ n) : |
| (unsupported V T St vt at₀).meaning (atomInput b) env ↔ |
| ∃ w, T₀.Adj v w ∧ ¬ ∃ c ∈ configBlock b w, c ∉ s ∧ P.configCompatibility ⟨v,a⟩ c := by |
| have hi (e : Edge n) (w : Vertex n) := meaning_incident |
| (Fin.cons (vertexCode b w) (Fin.cons (edgeCode b e) env)) vt.up.up (var 1) v e hv rfl hn |
| have hi' (e : Edge n) (w : Vertex n) := meaning_incident |
| (Fin.cons (vertexCode b w) (Fin.cons (edgeCode b e) env)) (var 0) (var 1) w e rfl rfl hn |
| simp only [unsupported,meaning_existsIn,hT,elements_ofFinset,Finset.mem_image, exists_exists_and_eq_and,QuotedTerm.meaning_up,hV,Finset.mem_univ,true_and, exists_exists_eq_and,meaning_allList,List.mem_cons,List.not_mem_nil,forall_eq_or_imp,forall_false,implies_true,and_true, meaning_neg,meaning_eq,meaning_var,Fin.cons_zero,hv,(vertexCode_injective hn).eq_iff,hi,hi'] |
| constructor |
| · rintro ⟨e,he,w,hvw,hve,hwe,hsup⟩ |
| have hne : v ≠ w := Ne.symm hvw |
| have hAdj : T₀.Adj v w := (P.graph_adj _ _).mp |
| ⟨e,he,(endpoints_incident_iff e v w).mpr ⟨hne,hve,hwe⟩⟩ |
| refine ⟨w,hAdj,?_⟩ |
| rintro ⟨⟨u,c⟩,hc,hcs,hcomp⟩ |
| have hu := (mem_configBlock w ⟨u,c⟩).mp hc |
| dsimp at hu |
| subst u |
| apply hsup |
| apply (meaning_support (Fin.cons (vertexCode b w) (Fin.cons (edgeCode b e) env)) |
| (var 0) St.up.up (var 1) at₀.up.up s v w a e hve hwe rfl hS rfl ha).mpr |
| exact ⟨c,hcs,(P.compatible_edge_iff v w a c e he hne hve hwe).mp hcomp⟩ |
| · rintro ⟨w,hadj,hsup⟩ |
| obtain ⟨e,he,hep⟩ := (P.graph_adj _ _).mpr hadj |
| obtain ⟨hne,hve,hwe⟩ := (endpoints_incident_iff e v w).mp hep |
| refine ⟨e,he,w,Ne.symm hne,hve,hwe,?_⟩ |
| intro hh |
| obtain ⟨c,hcs,hce⟩ := (meaning_support |
| (Fin.cons (vertexCode b w) (Fin.cons (edgeCode b e) env)) |
| (var 0) St.up.up (var 1) at₀.up.up s v w a e hve hwe rfl hS rfl ha).mp hh |
| exact hsup ⟨⟨w,c⟩,(mem_configBlock _ _).mpr rfl,hcs, |
| (P.compatible_edge_iff v w a c e he hne hve hwe).mpr hce⟩ |
| |
| end QuotedGrid |
| |
| end |
| |
| |
| |
| |
| |
| noncomputable section |
| |
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary |
| |
| variable {n : ℕ} {b : Vertex n → Scalar} |
| |
| lemma configAtoms_grid : WitnessedChoice.configAtoms (atomInput b) = |
| (Finset.univ : Finset (ConfigAtom b)).image Sum.inr := by |
| ext a |
| simp only [WitnessedChoice.configAtoms,Finset.mem_filter,Finset.mem_univ,true_and, |
| atomInput,decide_eq_true_eq,Finset.mem_image] |
| constructor |
| · intro h |
| cases h with | cf v c => exact ⟨⟨v,c⟩,rfl⟩ |
| · rintro ⟨⟨v,c⟩,rfl⟩ |
| exact .cf v c |
| |
| lemma config_mem_vertexCode (a : ConfigAtom b) (v : Vertex n) : |
| atom (.inr a) ∈ elements (vertexCode b v) ↔ a.1 = v := by |
| rw [mem_vertexCode_iff] |
| constructor |
| · rintro ⟨c,hc⟩ |
| exact congrArg Sigma.fst (Sum.inr.inj (atom_injective hc)) |
| · intro h |
| rcases a with ⟨w,c⟩ |
| dsimp at h |
| subst w |
| exact ⟨c,rfl⟩ |
| |
| namespace QuotedGrid |
| |
| open QuotedTerm QuotedFormula SourceSyntax |
| |
| variable {k : ℕ} |
| |
| lemma meaning_deletedStep {T₀ : RootedTree (Vertex n)} (env : Fin k → HF (Atom b)) |
| (V E T xt St : QuotedTerm k) (P : ParentEdges T₀) (s : Finset (ConfigAtom b)) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) |
| (hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) |
| (hT : T.meaning (atomInput b) env = ofFinset (P.treeEdges.image (edgeCode b))) |
| (hx : xt.meaning (atomInput b) env = stateCode (x.image Sum.inl)) |
| (hS : St.meaning (atomInput b) env = stateCode (s.image Sum.inr)) (hn : 1 ≤ n) : |
| (deletedStep V E T xt St).meaning (atomInput b) env = |
| stateCode (((P.testProblem x).update s).image Sum.inr) := by |
| have hp (v : Vertex n) (a : Configuration b v) : |
| (existsIn V.up ((mem (var 1) (var 0)).and |
| ((allowed E.up.up T.up.up xt.up.up (var 0) (var 1)).neg.or |
| (unsupported V.up.up T.up.up St.up.up (var 0) (var 1))))).meaning (atomInput b) |
| (Fin.cons (atom (.inr ⟨v,a⟩)) env) ↔ |
| ¬ P.allowedConfig x ⟨v,a⟩ ∨ ∃ w, T₀.Adj v w ∧ |
| ¬ ∃ c ∈ configBlock b w, c ∉ s ∧ P.configCompatibility ⟨v,a⟩ c := by |
| have hex (Q : Vertex n → Prop) : (∃ w, v=w ∧ Q w) ↔ Q v := by |
| constructor |
| · rintro ⟨w,rfl,h⟩ |
| exact h |
| · exact fun h => ⟨v,rfl,h⟩ |
| simp only [meaning_existsIn,QuotedTerm.meaning_up,hV,elements_ofFinset,Finset.mem_image, |
| Finset.mem_univ,true_and,exists_exists_eq_and,meaning_and,meaning_mem,meaning_var, |
| Fin.cons_zero,Fin.cons_one,config_mem_vertexCode,hex, |
| meaning_or,meaning_neg] |
| rw [meaning_allowed (Fin.cons (vertexCode b v) (Fin.cons (atom (.inr ⟨v,a⟩)) env)) |
| E.up.up T.up.up xt.up.up (var 0) (var 1) P x v a hE hT hx rfl rfl hn, |
| meaning_unsupported (Fin.cons (vertexCode b v) (Fin.cons (atom (.inr ⟨v,a⟩)) env)) |
| V.up.up T.up.up St.up.up (var 0) (var 1) P s v a hV hT hS rfl rfl hn] |
| simp only [deletedStep,meaning_cup,hS,QuotedTerm.meaning_filter,meaning_configAtoms,configAtoms_grid, |
| stateCode,elements_ofFinset,Finset.image_image] |
| apply ofFinset_inj.mpr |
| ext z |
| simp only [Finset.mem_union,Finset.mem_image,Finset.mem_filter,Finset.mem_univ,true_and, |
| Problem.update,ParentEdges.testProblem,Finset.mem_union,Finset.mem_filter,Finset.mem_univ, |
| true_and,mem_configBlock] |
| constructor |
| · rintro (⟨a,ha,rfl⟩ | ⟨⟨⟨v,a⟩,rfl⟩,h⟩) |
| · exact ⟨a,Or.inl ha,rfl⟩ |
| · refine ⟨⟨v,a⟩,Or.inr ?_,rfl⟩ |
| rcases (hp v a).mp h with h | ⟨w,hw,hno⟩ |
| · exact Or.inl h |
| · exact Or.inr ⟨v,rfl,w,hw,by simpa only [mem_configBlock] using hno⟩ |
| · rintro ⟨⟨v,a⟩,(ha | ha),rfl⟩ |
| · exact Or.inl ⟨⟨v,a⟩,ha,rfl⟩ |
| · refine Or.inr ⟨⟨⟨v,a⟩,rfl⟩,(hp v a).mpr ?_⟩ |
| rcases ha with h | ⟨w,hw,u,hu,hno⟩ |
| · exact Or.inl h |
| · dsimp at hw |
| subst w |
| exact Or.inr ⟨u,hu,by simpa only [mem_configBlock] using hno⟩ |
| |
| end QuotedGrid |
| |
| end |
| |
| end WitnessedSeparation.Grid |
| |
| |
| section |
| |
| namespace WitnessedChoice.TreeTest.Problem |
| |
| open WitnessedChoice.BGS |
| |
| variable {V A : Type} (P : Problem V A) |
| |
| lemma run_eq_finite (k : ℕ) : P.run k = FiniteIteration.run P.update k := by |
| induction k with |
| | zero => rfl |
| | succ k ih => exact congrArg P.update ih |
| |
| end WitnessedChoice.TreeTest.Problem |
| |
| namespace WitnessedSeparation.Grid |
| |
| noncomputable section |
| |
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary |
| |
| variable {n : ℕ} {b : Vertex n → Scalar} |
| |
| namespace QuotedGrid |
| |
| open QuotedTerm QuotedFormula SourceSyntax |
| |
| variable {k : ℕ} |
| |
| lemma value_deletion {T₀ : RootedTree (Vertex n)} (env : Fin k → HF (Atom b)) |
| (V E T xt : QuotedTerm k) (P : ParentEdges T₀) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (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 (Finset.univ.image (edgeCode b))) |
| (hT : T.meaning (atomInput b) env = ofFinset (P.treeEdges.image (edgeCode b))) |
| (hx : xt.meaning (atomInput b) env = stateCode (x.image Sum.inl)) (hn : 1 ≤ n) : |
| (CPTTerm.quoted (deletedStep V.up E.up T.up xt.up (var 0))).iterate.value (atomInput b) p env = |
| stateCode ((P.testProblem x).deleted.image Sum.inr) := by |
| have hc : Fintype.card (ConfigAtom b) ≤ Fintype.card (Atom b) := by |
| exact Fintype.card_le_of_injective (fun c : ConfigAtom b => (Sum.inr c : Atom b)) Sum.inr_injective |
| have htime : Fintype.card (ConfigAtom b) ≤ resource p (Fintype.card (Atom b)) := by |
| have := hp.basic |
| omega |
| have hspace : (TC (ofFinset ((Finset.univ : Finset (ConfigAtom b)).image |
| (fun a => atom (Sum.inr a : Atom b))))).card ≤ resource p (Fintype.card (Atom b)) := by |
| have he : ofFinset ((Finset.univ : Finset (ConfigAtom b)).image (fun a => atom (Sum.inr a : Atom b))) = |
| stateCode ((Finset.univ : Finset (ConfigAtom b)).image Sum.inr) := by |
| simp only [stateCode,Finset.image_image,Function.comp_def] |
| rw [he,TC_stateCode,Finset.card_image_of_injective _ atom_injective, |
| Finset.card_image_of_injective _ Sum.inr_injective,Finset.card_univ] |
| exact htime |
| apply CPTTerm.value_eq |
| rw [CPTTerm.eval_iterate] |
| have h := ordinaryIteration_encoded (resource p (Fintype.card (Atom b))) |
| (fun a : ConfigAtom b => atom (Sum.inr a : Atom b)) (P.testProblem x).update |
| (fun s => (deletedStep V.up E.up T.up xt.up (var 0)).meaning (atomInput b) (Fin.cons s env)) |
| (fun s => some ((CPTTerm.quoted (deletedStep V.up E.up T.up xt.up (var 0))).value |
| (atomInput b) p (Fin.cons s env))) |
| (by intro s; rw [CPTTerm.value_quoted]) |
| (by |
| intro s |
| have hcode (s : Finset (ConfigAtom b)) : ofFinset (s.image (fun a => atom (Sum.inr a : Atom b))) = |
| stateCode (s.image Sum.inr) := by simp only [stateCode,Finset.image_image,Function.comp_def] |
| rw [hcode,hcode] |
| exact meaning_deletedStep (Fin.cons (stateCode (s.image Sum.inr)) env) |
| V.up E.up T.up xt.up (var 0) P s x hV hE hT hx rfl hn) |
| (P.testProblem x).le_update htime hspace |
| convert h using 2 |
| simp only [stateCode,Finset.image_image,Function.comp_def,Problem.deleted, |
| ParentEdges.testProblem,Finset.card_univ,Problem.run_eq_finite] |
| |
| end QuotedGrid |
| |
| end |
| |
| end WitnessedSeparation.Grid |
| |
| end |
| |
| |
| namespace WitnessedSeparation.Grid |
| |
| noncomputable section |
| |
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary |
| |
| variable {n : ℕ} {b : Vertex n → Scalar} |
| |
| lemma selected_inter_singleton (x : Finset (Σ e : Edge n, LocalGroup e)) |
| (hx : ∀ r ∈ x, ∀ t ∈ x, r.1=t.1 → r=t) (r : Σ e : Edge n, LocalGroup e) (hr : r ∈ x) : |
| elements (stateCode (x.image Sum.inl : Finset (Atom b))) ∩ elements (edgeCode b r.1) = |
| {atom (.inl r)} := by |
| ext z |
| simp only [Finset.mem_inter,stateCode,elements_ofFinset,Finset.image_image, |
| Finset.mem_image,Function.comp_apply,Finset.mem_singleton] |
| constructor |
| · rintro ⟨⟨t,ht,rfl⟩,he⟩ |
| have heq := (atom_mem_edgeCode _ _ _).mp he |
| rw [hx t ht r hr heq] |
| · rintro rfl |
| exact ⟨⟨r,hr,rfl⟩,(atom_mem_edgeCode _ _ _).mpr rfl⟩ |
| |
| lemma edgeState_subset_edgeAtoms (x : Finset (Σ e : Edge n, LocalGroup e)) : |
| edgeState (b := b) x ⊆ WitnessedChoice.edgeAtoms (atomInput b) := by |
| rw [edgeAtoms_grid] |
| exact Finset.image_subset_image (Finset.subset_univ _) |
| |
| namespace QuotedGrid |
| |
| open QuotedTerm QuotedFormula SourceSyntax |
| |
| variable {k : ℕ} |
| |
| lemma meaning_complete {T₀ : RootedTree (Vertex n)} (env : Fin k → HF (Atom b)) |
| (E T xt : QuotedTerm k) (P : ParentEdges T₀) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hx : ConsistentSelection x) |
| (hoff : ∀ r ∈ x, r.1 ∉ P.treeEdges) |
| (hc : ∀ e, e ∉ P.treeEdges → ∃ r ∈ x, r.1=e) |
| (hE : E.meaning (atomInput b) env = ofFinset (Finset.univ.image (edgeCode b))) |
| (hT : T.meaning (atomInput b) env = ofFinset (P.treeEdges.image (edgeCode b))) |
| (hX : xt.meaning (atomInput b) env = stateCode (x.image Sum.inl)) : |
| (complete E T xt).meaning (atomInput b) env := by |
| have hfirst : (eq xt (xt.inter QuotedTerm.edgeAtoms)).meaning (atomInput b) env := by |
| simp only [meaning_eq,meaning_inter,hX,meaning_edgeAtoms,stateCode,elements_ofFinset] |
| congr 1 |
| exact (Finset.inter_eq_left.mpr (Finset.image_subset_image (edgeState_subset_edgeAtoms x))).symm |
| have hone : (allIn (E.diff T) (eq (xt.up.inter (var 0)).card (nat 1))).meaning (atomInput b) env := by |
| simp only [meaning_allIn,meaning_edgeDiff env E T P.treeEdges hE hT,elements_ofFinset, |
| Finset.forall_mem_image,Finset.mem_sdiff,Finset.mem_univ,true_and] |
| intro e he |
| obtain ⟨r,hr,hre⟩ := hc e he |
| simp only [meaning_eq,meaning_card,meaning_inter,QuotedTerm.meaning_up,hX,meaning_var, |
| Fin.cons_zero,meaning_nat,cardHF,elements_ofFinset] |
| rw [←hre,selected_inter_singleton x hx.1 r hr,Finset.card_singleton] |
| have hzero : (allIn T (eq (xt.up.inter (var 0)) empty)).meaning (atomInput b) env := by |
| simp only [meaning_allIn,hT,elements_ofFinset,Finset.forall_mem_image,meaning_eq, |
| meaning_inter,QuotedTerm.meaning_up,hX,meaning_var,Fin.cons_zero,meaning_empty] |
| intro e he |
| apply (selected_inter_empty x e).mpr |
| intro r hr hh |
| exact hoff r hr (hh.symm ▸ he) |
| simpa only [complete,meaning_allList,List.mem_cons,List.not_mem_nil,forall_eq_or_imp, |
| forall_false,implies_true,and_true] using ⟨hfirst,hone,hzero⟩ |
| |
| lemma meaning_survives (env : Fin k → HF (Atom b)) (V D : QuotedTerm k) |
| (s : Finset (ConfigAtom b)) |
| (hV : V.meaning (atomInput b) env = ofFinset (Finset.univ.image (vertexCode b))) |
| (hD : D.meaning (atomInput b) env = stateCode (s.image Sum.inr)) : |
| (allIn V (nonempty ((var 0).diff D.up))).meaning (atomInput b) env ↔ |
| ∀ v, ((configBlock b v).filter (· ∉ s)).Nonempty := by |
| simp only [meaning_allIn,hV,elements_ofFinset,Finset.forall_mem_image,Finset.mem_univ, |
| forall_const,nonempty,meaning_neg,meaning_eq,meaning_diff,meaning_var,Fin.cons_zero, |
| QuotedTerm.meaning_up,hD,meaning_empty] |
| apply forall_congr' intro v rw [show (emptyHF : HF (Atom b)) = ofFinset ∅ from rfl,ofFinset_inj] |
| change ({z ∈ elements (vertexCode b v) | z ∉ elements (stateCode (s.image Sum.inr))} : Finset _) ≠ ∅ ↔ _ |
| rw [←Finset.nonempty_iff_ne_empty] |
| constructor |
| · rintro ⟨z,hz⟩ |
| obtain ⟨hz,hnot⟩ := Finset.mem_filter.mp hz |
| obtain ⟨c,rfl⟩ := (mem_vertexCode_iff v z).mp hz |
| exact ⟨⟨v,c⟩,Finset.mem_filter.mpr ⟨(mem_configBlock _ _).mpr rfl, |
| fun h => hnot ((atom_config_mem _ _).mpr h)⟩⟩ |
| · rintro ⟨⟨w,c⟩,hc⟩ |
| obtain ⟨hc,hn⟩ := Finset.mem_filter.mp hc |
| have hw := (mem_configBlock v ⟨w,c⟩).mp hc |
| dsimp at hw |
| subst w |
| exact ⟨atom (.inr ⟨v,c⟩),Finset.mem_filter.mpr ⟨(mem_vertexCode_iff _ _).mpr ⟨c,rfl⟩, |
| fun h => hn ((atom_config_mem _ _).mp h)⟩⟩ |
|
|
| end QuotedGrid |
|
|
| end |
|
|
|
|
|
|
|
|
|
|
| noncomputable section |
|
|
| open Classical WitnessedChoice WitnessedChoice.BGS WitnessedChoice.TreeTest Hereditary |
|
|
| variable {n : ℕ} {b : Vertex n → Scalar} |
|
|
| lemma testProblem_block {T₀ : RootedTree (Vertex n)} (P : ParentEdges T₀) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (v : Vertex n) : |
| (P.testProblem (b := b) x).block v = configBlock b v := rfl |
|
|
| lemma survivors_test_iff_zero {T₀ : RootedTree (Vertex n)} (P : ParentEdges T₀) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hx : ConsistentSelection x) |
| (hoff : ∀ r ∈ x, r.1 ∉ P.treeEdges) |
| (hc : ∀ e, e ∉ P.treeEdges → ∃ r ∈ x, r.1=e) : |
| (∀ v, ((configBlock b v).filter (· ∉ (P.testProblem (b := b) x).deleted)).Nonempty) ↔ |
| ∑ v, b v = 0 := by |
| have h := P.test_iff_zero b x hx hoff hc |
| have hs (v : Vertex n) : (P.testProblem (b := b) x).survivors v = |
| (configBlock b v).filter (· ∉ (P.testProblem (b := b) x).deleted) := by |
| ext a |
| simp only [Problem.survivors,Finset.mem_filter,testProblem_block] |
| simpa only [hs] using h |
|
|
| namespace QuotedGrid |
|
|
| open QuotedTerm QuotedFormula SourceSyntax SourceProgram |
|
|
| attribute [local irreducible] QuotedTerm.tree SourceSyntax.complete SourceSyntax.deletedStep |
|
|
| lemma value_output (p : Polynomial ℝ) (hp : GridResources p b) |
| (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) |
| (x : Finset (Σ e : Edge n, LocalGroup e)) (hx : ConsistentSelection x) |
| (hoff : ∀ r ∈ x, r.1 ∉ (anchoredParents α).treeEdges) |
| (hc : ∀ e, e ∉ (anchoredParents α).treeEdges → ∃ r ∈ x, r.1=e) (hn : 1 ≤ n) : |
| SourceProgram.output.value (atomInput b) p |
| (Fin.cons (stateCode (edgeState x)) (Fin.cons (tupleCode (List.ofFn (vertexCode b ∘ α))) Fin.elim0)) = |
| decide (∑ v, b v = 0) := by |
| let R := distancesCode b (boxGraph n) |
| let T := ofFinset ((anchoredParents α).treeEdges.image (edgeCode b)) |
| let D : HF (Atom b) := stateCode (((anchoredParents α).testProblem (b := b) x).deleted.image Sum.inr) |
| let env₀ : Fin 3 → HF (Atom b) := Fin.cons R |
| (Fin.cons (stateCode (edgeState x)) (Fin.cons (tupleCode (List.ofFn (vertexCode b ∘ α))) Fin.elim0)) |
| let env₁ : Fin 4 → HF (Atom b) := Fin.cons T env₀ |
| let env₂ : Fin 5 → HF (Atom b) := Fin.cons D env₁ |
| have ht : (tree (var 2) QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 0)).meaning |
| (atomInput b) env₀ = T := |
| meaning_tree env₀ (var 2) _ _ (var 0) α hα rfl |
| (quoted_vertexBlocks hn env₀) (quoted_edgeBlocks env₀) rfl hn |
| have hd : (CPTTerm.quoted |
| (deletedStep QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 1) (var 3) (var 0))).iterate.value |
| (atomInput b) p env₁ = D := by |
| exact value_deletion env₁ QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 0) (var 2) |
| (anchoredParents α) x p hp (quoted_vertexBlocks hn env₁) (quoted_edgeBlocks env₁) rfl rfl hn |
| have hcomplete := meaning_complete env₂ QuotedTerm.edgeBlocks (var 1) (var 3) |
| (anchoredParents α) x hx hoff hc (quoted_edgeBlocks env₂) rfl rfl |
| have hsurvive := meaning_survives env₂ QuotedTerm.vertexBlocks (var 0) |
| ((anchoredParents α).testProblem (b := b) x).deleted (quoted_vertexBlocks hn env₂) rfl |
| have hm : ((complete QuotedTerm.edgeBlocks (var 1) (var 3)).and |
| (allIn QuotedTerm.vertexBlocks (nonempty ((var 0).diff (var 1))))).meaning (atomInput b) env₂ ↔ |
| ∑ v, b v = 0 := by |
| rw [meaning_and,and_iff_right hcomplete] |
| change (allIn QuotedTerm.vertexBlocks (nonempty ((var 0).diff (var 1)))).meaning |
| (atomInput b) env₂ ↔ _ at hsurvive |
| exact hsurvive.trans (survivors_test_iff_zero (b := b) (anchoredParents α) x hx hoff hc) |
| rw [SourceProgram.output,CPTFormula.value_letIn,value_distances _ p hp hn, CPTFormula.value_letIn,CPTTerm.value_quoted] |
| change (CPTFormula.letIn _ _).value (atomInput b) p |
| (Fin.cons ((tree (var 2) QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 0)).meaning |
| (atomInput b) env₀) env₀) = _ |
| rw [ht,CPTFormula.value_letIn] |
| change (CPTFormula.quoted _).value (atomInput b) p |
| (Fin.cons ((CPTTerm.quoted |
| (deletedStep QuotedTerm.vertexBlocks QuotedTerm.edgeBlocks (var 1) (var 3) (var 0))).iterate.value |
| (atomInput b) p env₁) env₁) = _ |
| rw [hd,CPTFormula.value_quoted] |
| apply Bool.eq_iff_iff.mpr |
| simpa only [decide_eq_true_eq] using hm |
|
|
| end QuotedGrid |
|
|
| end |
|
|
| end WitnessedSeparation.Grid |
|
|
|
|
|
|
| namespace WitnessedChoice.BGS |
|
|
| noncomputable section |
|
|
| open Classical WitnessedSeparation WitnessedSeparation.Hereditary |
|
|
| namespace Realizes |
|
|
| variable {A : Type} [Fintype A] {P : Selection A} |
| {step : HF A → HF A → Result (HF A)} {choice : HF A → Result (HF A)} |
| {witness : HF A → HF A → Result (HF A)} |
| (hr : Realizes P step choice witness) |
|
|
| include hr |
|
|
| lemma first_encode {b : ℕ → Finset A} {c : ℕ → Option A} {t : ℕ} |
| (hb : P.FirstStabilization b c t) : |
| FirstPath step choice (stateCode ∘ b) (choiceCode ∘ c) t := by |
| refine ⟨⟨?_,?_⟩,?_,?_⟩ |
| · simp only [Function.comp_apply,hb.1.1,stateCode,Finset.image_empty] |
| rfl |
| · intro i hi |
| obtain ⟨hc,hs⟩ := hb.1.2 i hi |
| refine ⟨⟨ofFinset ((P.choices (b i)).image choiceCode),hr.choice_eq _,?_⟩,?_⟩ |
| · exact (elements_ofFinset _ ▸ Finset.mem_image.mpr ⟨c i,hc,rfl⟩) |
| · simpa only [Function.comp_apply,hs] using hr.step_eq (b i) (c i) hc |
| · intro i hi he |
| exact hb.2.1 i hi (stateCode_inj.mp he) |
| · exact congrArg stateCode hb.2.2 |
|
|
| lemma value_constant {S : Input A} {α : HF A} (hf : P.Filtered S α) |
| (p : ℕ) (hp : Fintype.card A+2 ≤ p) (free : Finset (Fin 1)) |
| (output : HF A → Result Bool) (hout : ∀ x : Finset A, (output (stateCode x)).isSome) |
| (v : Bool) |
| (ht : ∀ b c t, P.FirstStabilization b c t → output (stateCode (b t)) = some v) : |
| witnessedIteration S p free (Fin.cons α Fin.elim0) step choice witness output = some v := by |
| have ht' : ∀ b c t, FirstPath step choice b c t → output (b t) = some v := by |
| intro b c t hh |
| obtain ⟨_,hb,_⟩ := hr.prefix_decode hh.1 |
| rw [hb t (by omega)] |
| exact ht _ _ t (hr.first_decode hh) |
| have hiff : (∀ b c t, FirstPath step choice b c t → output (b t) = some true) ↔ v = true := by |
| constructor |
| · intro h |
| obtain ⟨b,c,t,hb⟩ := P.exists_path |
| have h₁ := h _ _ t (hr.first_encode hb) |
| have h₂ := ht' _ _ t (hr.first_encode hb) |
| exact Option.some.inj (h₂.symm.trans h₁) |
| · intro hv b c t hh |
| exact (ht' b c t hh).trans (congrArg some hv) |
| unfold witnessedIteration |
| rw [ite_eq_left (hr.good hf p hp free output hout)] |
| rw [propext hiff] |
| cases v <;> simp |
| |
| end Realizes |
| |
| namespace GuardedProgram |
| |
| open WitnessedChoice.RelationPools |
| |
| lemma value_constant {A : Type} [Fintype A] (G : GuardedProgram) (S : Input A) (p : Polynomial ℝ) |
| (α₀ : Fin 4 → Finset A) (hα : ∀ i, α₀ i ∈ blocks S) |
| (hp : Fintype.card A+2 ≤ resource p (Fintype.card A)) (v : Bool) |
| (ht : ∀ B c t, (G.selection S p (parameterCode α₀)).FirstStabilization B c t → |
| G.output.value S p (Fin.cons (stateCode (B t)) (Fin.cons (parameterCode α₀) Fin.elim0)) = v) : |
| G.formula.eval S p (Fin.cons (parameterCode α₀) Fin.elim0) = some v := by |
| apply (G.realizes S p (parameterCode α₀)).value_constant |
| (guardedSelection_filtered G.localBound S True _ _ α₀ hα) |
| (resource p (Fintype.card A)) hp |
| · intro x |
| rw [G.output.eval_value] |
| simp |
| · intro B c t h |
| rw [G.output.eval_value,ht B c t h] |
| |
| end GuardedProgram |
| |
| end |
| |
| end WitnessedChoice.BGS |
| |
| |
| |
| namespace WitnessedSeparation.Grid |
| |
| noncomputable section |
| |
| open Classical WitnessedChoice WitnessedChoice.BGS Hereditary RelationPools |
| |
| variable {n : ℕ} {b : Vertex n → Scalar} |
| |
| namespace QuotedGrid |
| |
| open SourceProgram |
| |
| attribute [local irreducible] SourceProgram.candidates SourceProgram.cycles SourceProgram.output |
| |
| lemma terminal_output (p : Polynomial ℝ) (hp : GridResources p b) |
| (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) (hn : 1 ≤ n) |
| (B : ℕ → Finset (Atom b)) (c : ℕ → Option (Atom b)) (t : ℕ) |
| (hh : (program.body.selection (atomInput b) p |
| (tupleCode (List.ofFn (vertexCode b ∘ α)))).FirstStabilization B c t) : |
| program.body.output.value (atomInput b) p |
| (Fin.cons (stateCode (B t)) (Fin.cons (tupleCode (List.ofFn (vertexCode b ∘ α))) Fin.elim0)) = |
| decide (∑ v, b v = 0) := by |
| obtain ⟨x,hx,hcons,hoff,hc⟩ := (anchoredParents α).terminal_complete α |
| (program.body.selection (atomInput b) p (tupleCode (List.ofFn (vertexCode b ∘ α)))) |
| (fun x => selection_candidates p hp α hα x hn) |
| (fun x _ hoff => selection_transitive p hp α hα x hoff hn) hh |
| rw [hx] |
| exact value_output p hp α hα x hcons hoff hc hn |
| |
| lemma body_value (p : Polynomial ℝ) (hp : GridResources p b) |
| (α : Fin 4 → Vertex n) (hα : AnchoredTree.Resolving (boxGraph n) α) (hn : 1 ≤ n) : |
| program.body.formula.eval (atomInput b) p |
| (Fin.cons (tupleCode (List.ofFn (vertexCode b ∘ α))) Fin.elim0) = |
| some (decide (∑ v, b v = 0)) := by |
| apply program.body.value_constant (atomInput b) p (fun i => vertexBlockSet b (α i)) |
| (fun i => ?_) hp.basic |
| · exact terminal_output p hp α hα hn |
| · apply Finset.mem_union_right |
| rw [vertexBlocks_grid hn] |
| exact Finset.mem_image.mpr ⟨α _,Finset.mem_univ _,rfl⟩ |
| |
| end QuotedGrid |
| |
| end |
| |
| |
| |
| |
| |
| noncomputable section |
| |
| open Classical WitnessedChoice WitnessedChoice.BGS Hereditary |
| |
| variable {n : ℕ} {b : Vertex n → Scalar} |
| |
| namespace QuotedGrid |
| |
| open QuotedTerm QuotedFormula SourceSyntax SourceProgram |
| |
| attribute [local irreducible] QuotedFormula.resolving |
| |
| lemma mem_grid_blockParameters {k : ℕ} (env : Fin k → HF (Atom b)) (hn : 1 ≤ n) (z : HF (Atom b)) : |
| z ∈ elements ((QuotedTerm.blockParameters : QuotedTerm k).meaning (atomInput b) env) ↔ |
| ∃ α : Fin 4 → Vertex n, tupleCode (List.ofFn (vertexCode b ∘ α)) = z := by |
| rw [blockParameters,mem_tupleProduct,quoted_vertexBlocks hn env,elements_ofFinset] |
| constructor |
| · rintro ⟨f,hf,hz⟩ |
| have hh (i : Fin 4) : ∃ v : Vertex n, vertexCode b v = f i := by |
| obtain ⟨v,_,hv⟩ := Finset.mem_image.mp (hf i) |
| exact ⟨v,hv⟩ |
| choose α hα using hh |
| exact ⟨α,(congrArg (fun f => tupleCode (List.ofFn f)) (funext hα)).trans hz⟩ |
| · rintro ⟨α,hz⟩ |
| exact ⟨vertexCode b ∘ α,fun i => Finset.mem_image.mpr ⟨α i,Finset.mem_univ _,rfl⟩,hz⟩ |
| |
| lemma mem_parameters (p : Polynomial ℝ) (hp : GridResources p b) (hn : 1 ≤ n) (z : HF (Atom b)) : |
| z ∈ elements (SourceProgram.parameters.value (atomInput b) p Fin.elim0) ↔ |
| ∃ α : Fin 4 → Vertex n, AnchoredTree.Resolving (boxGraph n) α ∧ |
| tupleCode (List.ofFn (vertexCode b ∘ α)) = z := by |
| let env : Fin 1 → HF (Atom b) := Fin.cons (distancesCode b (boxGraph n)) Fin.elim0 |
| have hm (α : Fin 4 → Vertex n) : |
| (resolving (var 0) QuotedTerm.vertexBlocks (var 1)).meaning (atomInput b) |
| (Fin.cons (tupleCode (List.ofFn (vertexCode b ∘ α))) env) ↔ |
| AnchoredTree.Resolving (boxGraph n) α := by |
| exact meaning_resolving (atomInput b) _ (var 0) QuotedTerm.vertexBlocks (var 1) |
| (vertexCode b) (vertexCode_injective hn) (boxGraph n) (boxGraph_connected n) α rfl |
| (quoted_vertexBlocks hn _) rfl (vertex_card_le_atoms hn) |
| rw [SourceProgram.parameters,CPTTerm.value_letIn,value_distances _ p hp hn,CPTTerm.value_quoted] |
| simp only [QuotedTerm.meaning_filter,elements_ofFinset,Finset.mem_filter] |
| rw [mem_grid_blockParameters env hn z] |
| constructor |
| · rintro ⟨⟨α,rfl⟩,hr⟩ |
| exact ⟨α,(hm α).mp hr,rfl⟩ |
| · rintro ⟨α,hα,rfl⟩ |
| exact ⟨⟨α,rfl⟩,(hm α).mpr hα⟩ |
| |
| lemma mem_parameterTerm (p : Polynomial ℝ) (hp : GridResources p b) (hn : 1 ≤ n) (z : HF (Atom b)) : |
| z ∈ elements (program.parameterTerm.value (atomInput b) p Fin.elim0) ↔ |
| ∃ α : Fin 4 → Vertex n, AnchoredTree.Resolving (boxGraph n) α ∧ |
| tupleCode (List.ofFn (vertexCode b ∘ α)) = z := by |
| rw [ClosedGuardedProgram.parameterTerm,CPTTerm.value_letIn,CPTTerm.value_quoted] |
| simp only [QuotedTerm.meaning_filter,elements_ofFinset,Finset.mem_filter,meaning_mem,meaning_var, |
| Fin.cons_zero,Fin.cons_one] |
| change (z ∈ elements (QuotedTerm.blockParameters.meaning (atomInput b) _) ∧ |
| z ∈ elements (SourceProgram.parameters.value (atomInput b) p Fin.elim0)) ↔ _ |
| rw [mem_parameters p hp hn z] |
| constructor |
| · exact fun h => h.2 |
| · rintro ⟨α,hα,hz⟩ |
| exact ⟨(mem_grid_blockParameters _ hn z).mpr ⟨α,hz⟩,α,hα,hz⟩ |
| |
| lemma parameterTerm_nonempty (p : Polynomial ℝ) (hp : GridResources p b) (hn : 1 ≤ n) : |
| (elements (program.parameterTerm.value (atomInput b) p Fin.elim0)).Nonempty := by |
| refine ⟨tupleCode (List.ofFn (vertexCode b ∘ cornerAnchors n)),(mem_parameterTerm p hp hn _).mpr |
| ⟨cornerAnchors n,?_,rfl⟩⟩ |
| intro u v h |
| exact cornerAnchors_resolve u v (fun i => congrFun h i) |
| |
| end QuotedGrid |
| |
| end |
| |
| |
| |
| |
| |
| noncomputable section |
| |
| open Classical WitnessedChoice WitnessedChoice.BGS Hereditary |
| |
| variable {n : ℕ} {b : Vertex n → Scalar} |
| |
| namespace QuotedGrid |
| |
| open SourceProgram |
| |
| attribute [local irreducible] SourceProgram.parameters SourceProgram.candidates |
| SourceProgram.cycles SourceProgram.output |
| |
| lemma formula_value (p : Polynomial ℝ) (hp : GridResources p b) (hn : 1 ≤ n) : |
| program.formula.eval (atomInput b) p Fin.elim0 = some (decide (∑ v, b v = 0)) := by |
| have he (z : HF (Atom b)) (hz : z ∈ elements (program.parameterTerm.value (atomInput b) p Fin.elim0)) : |
| program.body.formula.eval (atomInput b) p (Fin.cons z Fin.elim0) = |
| some (decide (∑ v, b v = 0)) := by |
| obtain ⟨α,hα,rfl⟩ := (mem_parameterTerm p hp hn z).mp hz |
| exact body_value p hp α hα hn |
| rw [ClosedGuardedProgram.formula, |
| Formula.eval_existsIn_on _ p _ _ _ (program.parameterTerm.eval_value _ p _) he] |
| apply congrArg some |
| apply Bool.eq_iff_iff.mpr |
| simp only [decide_eq_true_eq] |
| constructor |
| · exact fun ⟨_,_,h⟩ => h |
| · intro h |
| obtain ⟨z,hz⟩ := parameterTerm_nonempty p hp hn |
| exact ⟨z,hz,h⟩ |
| |
| end QuotedGrid |
| |
| end |
| |
| end WitnessedSeparation.Grid |
| |
| end OAI |
| |
