Download data/lean/OAI/Computability/WitnessedChoice/TraceGraphs.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 47.9 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/TraceGraphs.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Computability/WitnessedChoice/TraceGraphs.lean
-
curl -L -o TraceGraphs.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Computability/WitnessedChoice/TraceGraphs.lean
47.9 kB
import OAI.Computability.WitnessedChoice.EvaluationTrace
namespace OAI
namespace WitnessedSeparation.Operational.Rule
noncomputable section
open Classical Hereditary Counting HFCoding Finset
variable {A R F : Type} {arity : F → ℕ} [Fintype A]
local instance {C : Type} : DecidableEq (HF C) := Classical.decEq _
def Graph (d : Set (HF A)) (K : ℕ) (rel : R → A → A → Bool) (s : State F arity A) :
{k : ℕ} → Rule R F arity k → (f : F) → Domain d → (Fin (arity f) → Domain d) → (Fin k → Domain d) → Prop
| _,.skip,_,_,_,_ => False
| _,.update g args value,f,z,a,v => if h : g = f then
Term.Graph d K rel s value z v ∧ ∀ j, Term.Graph d K rel s (args j) (a (Fin.cast (congrArg arity h) j)) v else False
| _,.parallel r t,f,z,a,v => Graph d K rel s r f z a v ∨ Graph d K rel s t f z a v
| _,.conditional c r t,f,z,a,v => ∃ b, Term.Graph d K rel s c b v ∧
((b.val = truth ∧ Graph d K rel s r f z a v) ∨ (b.val ≠ truth ∧ Graph d K rel s t f z a v))
| _,.forall b r,f,z,a,v => ∃ w x, Term.Graph d K rel s b w v ∧ x.val ∈ w.val ∧ Graph d K rel s r f z a (Fin.cons x v)
| _,.letValue b r,f,z,a,v => ∃ w, Term.Graph d K rel s b w v ∧ Graph d K rel s r f z a (Fin.cons w v)
variable (d : Set (HF A)) (K : ℕ) (rel : R → A → A → Bool) (s : State F arity A)
variable (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d)
include hd in
lemma graph_sound {k : ℕ} (r : Rule R F arity k) (f : F) (z : Domain d)
(a : Fin (arity f) → Domain d) (v : Fin k → Domain d)
(h : Graph d K rel s r f z a v) :
(⟨f,fun j => (a j).val⟩,z.val) ∈ r.updates rel s (fun j => (v j).val) := by
induction r generalizing f z a with
| skip => exact h.elim
| update g args value =>
unfold Graph at h
split at h
next he =>
subst g
obtain ⟨hz,ha⟩ := h
have hv := Term.graph_sound d K rel s hd value z v hz
have ha' : (fun j => (a j).val) = fun j => (args j).eval rel s (fun j => (v j).val) :=
funext (fun j => Term.graph_sound d K rel s hd (args j) (a j) v (ha j))
simp only [updates,Finset.mem_singleton,hv,ha']
next he => exact h.elim
| parallel r t ir it => exact h.elim (fun h => mem_union_left _ (ir _ _ _ _ h)) (fun h => mem_union_right _ (it _ _ _ _ h))
| conditional c r t ir it =>
obtain ⟨b,hb,h⟩ := h
have he := Term.graph_sound d K rel s hd c b v hb
rcases h with ⟨hc,hr⟩ | ⟨hc,ht⟩
· simpa only [updates,← he,ite_eq_left hc] using ir _ _ _ _ hr
· simpa only [updates,← he,ite_eq_right hc] using it _ _ _ _ ht
| @«forall» k b r ih =>
obtain ⟨w,x,hw,hx,hr⟩ := h
have he := Term.graph_sound d K rel s hd b w v hw
refine mem_biUnion.mpr ⟨x.val,by rwa [← he],?_⟩
have hv : (fun j => ((Fin.cons x v : Fin (k+1) → Domain d) j).val) = Fin.cons x.val (fun j => (v j).val) := by
funext j; refine Fin.cases rfl (fun _ => rfl) j
simpa only [hv] using ih f z a (Fin.cons x v) hr
| @letValue k b r ih =>
obtain ⟨w,hw,hr⟩ := h
have he := Term.graph_sound d K rel s hd b w v hw
have hv : (fun j => ((Fin.cons w v : Fin (k+1) → Domain d) j).val) = Fin.cons w.val (fun j => (v j).val) := by
funext j; refine Fin.cases rfl (fun _ => rfl) j
simpa only [updates,hv,he] using ih f z a (Fin.cons w v) hr
include hd in
lemma graph_complete {k : ℕ} (r : Rule R F arity k) (f : F) (z : Domain d)
(a : Fin (arity f) → Domain d) (v : Fin k → Domain d)
(ht : ∀ x ∈ r.trace rel s (fun j => (v j).val), x ∈ d ∧ (elements x).card ≤ K)
(hu : (⟨f,fun j => (a j).val⟩,z.val) ∈ r.updates rel s (fun j => (v j).val)) :
Graph d K rel s r f z a v := by
have witness {k} (t : Term R F arity k) (v : Fin k → Domain d)
(ht : ∀ x ∈ t.trace rel s (fun j => (v j).val), x ∈ d ∧ (elements x).card ≤ K) :=
Term.graph_complete d K rel s hd t v ht
have hv {k} (x : Domain d) (v : Fin k → Domain d) :
(fun j => ((Fin.cons x v : Fin (k+1) → Domain d) j).val) = Fin.cons x.val (fun j => (v j).val) := by
funext j; refine Fin.cases rfl (fun _ => rfl) j
induction r generalizing f z a with
| skip => simp [updates] at hu
| update g args value =>
have he := Finset.mem_singleton.mp hu
have hfg : f = g := congrArg (fun p => p.1.1) he
subst g
have haz := (Prod.mk.inj he)
have ha : (fun j => (a j).val) = fun j => (args j).eval rel s (fun j => (v j).val) := by
exact eq_of_heq (Sigma.mk.inj_iff.mp haz.1).2
simp only [Graph,Fin.cast_refl,id_eq]
constructor
· obtain ⟨w,hw,hew⟩ := witness value v (fun x hx => ht x (mem_union_left _ hx))
have hew' : w = z := Subtype.ext (hew.trans haz.2.symm)
rwa [← hew']
· intro j
obtain ⟨w,hw,hew⟩ := witness (args j) v (fun x hx => ht x (mem_union_right _ (mem_biUnion.mpr ⟨j,mem_univ _,hx⟩)))
have hew' : w = a j := Subtype.ext (hew.trans (congrFun ha j).symm)
rwa [← hew']
| parallel r t ir it =>
rcases mem_union.mp hu with h | h
· exact Or.inl (ir _ _ _ _ (fun x hx => ht x (mem_union_left _ hx)) h)
· exact Or.inr (it _ _ _ _ (fun x hx => ht x (mem_union_right _ hx)) h)
| conditional c r t ir it =>
obtain ⟨b,hb,he⟩ := witness c v (fun x hx => ht x (mem_union_left _ (mem_union_left _ hx)))
refine ⟨b,hb,?_⟩
by_cases hc : b.val = truth
· left; refine ⟨hc,ir _ _ _ _ (fun x hx => ht x (mem_union_left _ (mem_union_right _ hx))) ?_⟩
simpa only [updates,← he,ite_eq_left hc] using hu
· right; refine ⟨hc,it _ _ _ _ (fun x hx => ht x (mem_union_right _ hx)) ?_⟩
simpa only [updates,← he,ite_eq_right hc] using hu
| @«forall» k b r ih =>
obtain ⟨w,hw,he⟩ := witness b v (fun x hx => ht x (mem_union_left _ hx))
obtain ⟨x,hx,hu⟩ := mem_biUnion.mp hu
have hxd : x ∈ d := hd _ w.property _ (by rwa [he])
let xx : Domain d := ⟨x,hxd⟩
refine ⟨w,xx,hw,by change x ∈ w.val; rwa [he],ih _ _ _ (Fin.cons xx v) ?_ ?_⟩
· intro y hy
rw [hv] at hy
exact ht y (mem_union_right _ (mem_biUnion.mpr ⟨x,hx,hy⟩))
· simpa only [hv] using hu
| @letValue k b r ih =>
obtain ⟨w,hw,he⟩ := witness b v (fun x hx => ht x (mem_union_left _ hx))
refine ⟨w,hw,ih _ _ _ (Fin.cons w v) ?_ ?_⟩
· intro x hx
rw [hv,he] at hx; exact ht x (mem_union_right _ hx)
· simpa only [updates,hv,he] using hu
end
noncomputable section
open Classical Hereditary Counting HFCoding Finset
variable {R F : Type} {arity : F → ℕ}
def width : {k : ℕ} → Rule R F arity k → ℕ
| _,.skip => 6
| _,.update _ args value => 6+value.width+∑ j, (args j).width
| _,.parallel r t => 6+width r+width t
| _,.conditional c r t => 6+c.width+width r+width t
| _,.forall b r | _,.letValue b r => 6+b.width+width r
variable {ι L : Type} {A : ι → Type} [∀ i, Fintype (A i)]
variable (d : ∀ i, Set (HF (A i))) (S : ∀ i, Counting.Structure L (Domain (d i))) {m : ℕ}
variable (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i)
variable (hp : ∀ i k, ordinal (A := A i) k ∈ d i)
variable (ha : ∀ i a, atom a ∈ d i)
variable (hmem : UniformDefinable S m 2 (fun _ v => (v 0).val ∈ (v 1).val))
variable (hset : UniformDefinable S m 1 (fun _ v => isSet (v 0).val = true))
variable (rel : ∀ i, R → A i → A i → Bool) (s : ∀ i, State F arity (A i))
variable (hinput : ∀ r, UniformDefinable S m 2 (fun i v => inputRelation (rel i) r (v 0).val (v 1).val))
variable (hstate : ∀ f, UniformDefinable S m (arity f+1)
(fun i v => (v 0).val = (s i).value ⟨f,fun j => (v j.succ).val⟩))
include hd hp ha hmem hset hinput hstate in
lemma uniform_graph (K : ℕ) {k n : ℕ} (r : Rule R F arity k) (f : F)
(z : Fin n) (a : Fin (arity f) → Fin n) (v : Fin k → Fin n) (hm : n+r.width ≤ m) :
UniformDefinable S m n (fun i w => Graph (d i) K (rel i) (s i) r f (w z) (w ∘ a) (w ∘ v)) := by
have term {k n : ℕ} (t : Term R F arity k) (z : Fin n) (v : Fin k → Fin n) (ht : t.width ≤ m) :
UniformDefinable S m n (fun i w => Term.Graph (d i) K (rel i) (s i) t (w z) (w ∘ v)) := by
apply (Term.uniform_graph d S hd hp ha hmem hset rel s hinput hstate K t ht |>.reindex (Fin.cons z v)).congr
intro i w
simp only [Fin.comp_cons,Fin.cons_zero,Fin.tail_cons]
induction r generalizing n with
| skip => exact UniformDefinable.falsum
| update g args value =>
simp only [width] at hm
by_cases h : g = f
· subst g
have hv := term value z v (by omega)
have hag (j) := single_le_sum (fun j (_ : j ∈ (univ : Finset (Fin (arity f)))) => Nat.zero_le (Term.width (args j))) (mem_univ j)
have has := UniformDefinable.forall_finite (fun j => term (args j) (a j) v (by have := hag j; omega))
apply (hv.and has).congr
intro i w
simp [Graph]
· apply UniformDefinable.falsum.congr
intro i w; simp only [Graph,dite_eq_right h]
| parallel r t ir it =>
simp only [width] at hm
exact (ir z a v (by omega)).or (it z a v (by omega))
| @conditional k c r t ir it =>
simp only [width] at hm
let vv : Fin k → Fin (n+1) := Fin.succ ∘ v
have hc := term c (0 : Fin (n+1)) vv (by omega)
have hr := ir z.succ (Fin.succ ∘ a) vv (by omega)
have ht := it z.succ (Fin.succ ∘ a) vv (by omega)
have hb := (HFCoding.uniform_ordinal S hmem hset (by omega) hd hp 1).reindex (![0] : Fin 1 → Fin (n+1))
apply ((hc.and ((hb.and hr).or (hb.neg.and ht))).ex (by omega)).congr
intro i w
simp only [Graph,vv,Fin.cons_zero,Fin.cons_succ,Function.comp_apply]
rfl
| @«forall» k b r ih =>
simp only [width] at hm
let vv : Fin k → Fin (n+2) := fun j => (v j).succ.succ
have hb := term b (1 : Fin (n+2)) vv (by omega)
have hx := hmem.reindex (![0,1] : Fin 2 → Fin (n+2))
have hr := ih z.succ.succ (fun j => (a j).succ.succ) (Fin.cons 0 vv) (by omega)
apply (((hb.and (hx.and hr)).ex (by omega)).ex (by omega)).congr
intro i w
change (∃ b' x, _ ∧ _ ∧ _) ↔ _
simp only [Graph,vv,Fin.comp_cons,Fin.cons_zero,Fin.cons_succ,Function.comp_apply]
rfl
| @letValue k b r ih =>
simp only [width] at hm
let vv : Fin k → Fin (n+1) := Fin.succ ∘ v
have hb := term b (0 : Fin (n+1)) vv (by omega)
have hr := ih z.succ (Fin.succ ∘ a) (Fin.cons 0 vv) (by omega)
apply ((hb.and hr).ex (by omega)).congr
intro i w
simp only [Graph,vv,Fin.comp_cons,Fin.cons_zero,Fin.cons_succ]
rfl
end
end WitnessedSeparation.Operational.Rule
namespace WitnessedSeparation.Operational
noncomputable section
open Classical Hereditary Finset
variable {A R F : Type} {arity : F → ℕ} [Fintype A]
local instance {B : Type} : DecidableEq (HF B) := Classical.decEq _
def Closed (t : Finset (HF A)) : Prop := ∀ x ∈ t, ∀ y, y ∈ x → y ∈ t
namespace Closed
omit [Fintype A] in
lemma closure (x : HF A) : Closed (Hereditary.closure x) := fun _ hx _ hy => closure_transitive hx hy
omit [Fintype A] in
lemma union {s t : Finset (HF A)} (hs : Closed s) (ht : Closed t) : Closed (s ∪ t) := by
intro x hx y hy
rcases mem_union.mp hx with hx | hx
· exact mem_union_left _ (hs x hx y hy)
· exact mem_union_right _ (ht x hx y hy)
omit [Fintype A] in
lemma biUnion {I : Type} (s : Finset I) (t : I → Finset (HF A)) (h : ∀ i ∈ s, Closed (t i)) : Closed (s.biUnion t) := by
intro x hx y hy
obtain ⟨i,hi,hx⟩ := mem_biUnion.mp hx
exact mem_biUnion.mpr ⟨i,hi,h i hi x hx y hy⟩
omit [Fintype A] in
lemma insert {s : Finset (HF A)} {x : HF A} (hs : Closed s) (hx : ∀ y, y ∈ x → y ∈ s) : Closed (insert x s) := by
intro y hy z hz
rcases mem_insert.mp hy with rfl | hy
· exact mem_insert_of_mem (hx z hz)
· exact mem_insert_of_mem (hs y hy z hz)
end Closed
namespace Term
lemma trace_closed (rel : R → A → A → Bool) (s : State F arity A)
{k : ℕ} (t : Term R F arity k) (v : Fin k → HF A) : Closed (t.trace rel s v) := by
induction t with
| var i | constant n | atoms => exact Closed.closure _
| app f args ih => exact (Closed.closure _).union (Closed.biUnion univ _ (fun j _ => ih j v))
| pair a b ia ib | equal a b ia ib | member a b ia ib | input r a b ia ib | and a b ia ib =>
exact ((Closed.closure _).union (ia v)).union (ib v)
| union a ia | unique a ia | card a ia | isAtom a ia | not a ia => exact (Closed.closure _).union (ia v)
| conditional c a b ic ia ib => exact ((ic v).union (ia v)).union (ib v)
| comprehension b g t ib ig it =>
apply Closed.insert ((ib v).union (Closed.biUnion _ _ (fun x hx => (ig _).union (it _))))
intro y hy
rw [mem_ofFinset] at hy
obtain ⟨x,hx,rfl⟩ := mem_image.mp hy
exact mem_union_right _ (mem_biUnion.mpr ⟨x,(mem_filter.mp hx).1,mem_union_right _ (closure_eval_subset_trace rel s t _ (mem_closure_self _))⟩)
end Term
namespace Rule
lemma trace_closed (rel : R → A → A → Bool) (s : State F arity A)
{k : ℕ} (r : Rule R F arity k) (v : Fin k → HF A) : Closed (r.trace rel s v) := by
induction r with
| skip => intro x hx; exact (Finset.notMem_empty x hx).elim
| update f args value => exact (value.trace_closed rel s v).union (Closed.biUnion univ _ (fun j _ => (args j).trace_closed rel s v))
| parallel r t ir it => exact (ir v).union (it v)
| conditional c r t ir it => exact ((c.trace_closed rel s v).union (ir v)).union (it v)
| «forall» b r ih => exact (b.trace_closed rel s v).union (Closed.biUnion _ _ (fun x hx => ih _))
| letValue b r ih => exact (b.trace_closed rel s v).union (ih _)
end Rule
end
noncomputable section
open Classical Hereditary Counting HFCoding Finset
variable {A R F : Type} {arity : F → ℕ}
local instance {C : Type} : DecidableEq (HF C) := Classical.decEq _
namespace State
lemma value_apply_iff (d : Set (HF A)) (s : State F arity A) (u : Finset (Update F arity A))
(hc : Consistent u) (hv : ∀ l z, (l,z) ∈ u → z ∈ d)
(l : Location F arity A) (z : Domain d) :
z.val = (s.applyUpdates u).value l ↔
(l,z.val) ∈ u ∨ (z.val = s.value l ∧ ¬∃ x : Domain d, (l,x.val) ∈ u) := by
change z.val = s.updatedValue u l ↔ _
by_cases hu : ∃ x, (l,x) ∈ u
· obtain ⟨x,hx⟩ := hu
rw [s.updatedValue_eq u hc hx]
constructor
· intro he; exact Or.inl (he ▸ hx)
· rintro (h | ⟨_,h⟩)
· exact hc l _ _ h hx
· exact (h ⟨⟨x,hv l x hx⟩,hx⟩).elim
· rw [s.updatedValue_default u hu]
constructor
· intro h; exact Or.inr ⟨h,fun ⟨x,hx⟩ => hu ⟨x.val,hx⟩⟩
· rintro (h | ⟨h,_⟩)
· exact (hu ⟨z.val,h⟩).elim
· exact h
end State
variable {ι L : Type} {B : ι → Type} [∀ i, Fintype (B i)]
variable (d : ∀ i, Set (HF (B i))) (S : ∀ i, Counting.Structure L (Domain (d i))) {m : ℕ}
variable (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i)
variable (hp : ∀ i k, ordinal (A := B i) k ∈ d i)
variable (ha : ∀ i a, atom a ∈ d i)
variable (hmem : UniformDefinable S m 2 (fun _ v => (v 0).val ∈ (v 1).val))
variable (hset : UniformDefinable S m 1 (fun _ v => isSet (v 0).val = true))
variable (rel : ∀ i, R → B i → B i → Bool) (s : ∀ i, State F arity (B i))
variable (hinput : ∀ r, UniformDefinable S m 2 (fun i v => inputRelation (rel i) r (v 0).val (v 1).val))
variable (hstate : ∀ f, UniformDefinable S m (arity f+1)
(fun i v => (v 0).val = (s i).value ⟨f,fun j => (v j.succ).val⟩))
include hd hp ha hmem hset hinput hstate in
lemma uniform_updates (K : ℕ) (r : Rule R F arity 0) (f : F)
(hm : arity f+1+r.width ≤ m)
(ht : ∀ i x, x ∈ r.trace (rel i) (s i) Fin.elim0 → x ∈ d i ∧ (elements x).card ≤ K) :
UniformDefinable S m (arity f+1) (fun i v =>
(⟨f,fun j => (v j.succ).val⟩,(v 0).val) ∈ r.updates (rel i) (s i) Fin.elim0) := by
have h := Rule.uniform_graph d S hd hp ha hmem hset rel s hinput hstate K r f
(0 : Fin (arity f+1)) Fin.succ Fin.elim0 hm
apply h.congr
intro i v
have he : (fun j : Fin 0 => (v (Fin.elim0 j)).val) = Fin.elim0 := by funext j; exact Fin.elim0 j
constructor
· intro h
have hh := Rule.graph_sound (d i) K (rel i) (s i) (hd i) r f (v 0) (v ∘ Fin.succ) (v ∘ Fin.elim0) h
simpa only [Function.comp_apply,he] using hh
· intro h
apply Rule.graph_complete (d i) K (rel i) (s i) (hd i) r f (v 0) (v ∘ Fin.succ) (v ∘ Fin.elim0)
· simpa only [Function.comp_apply,he] using ht i
· simpa only [Function.comp_apply,he] using h
include hstate in
omit [(i : ι) → Fintype (B i)] in
lemma uniform_applyUpdates (u : ∀ i, Finset (Update F arity (B i)))
(hu : ∀ f, UniformDefinable S m (arity f+1) (fun i v =>
(⟨f,fun j => (v j.succ).val⟩,(v 0).val) ∈ u i))
(hc : ∀ i, State.Consistent (u i))
(hv : ∀ i l z, (l,z) ∈ u i → z ∈ d i)
(f : F) (hm : arity f+1 < m) :
UniformDefinable S m (arity f+1) (fun i v =>
(v 0).val = ((s i).applyUpdates (u i)).value ⟨f,fun j => (v j.succ).val⟩) := by
have hx := (hu f).reindex (Fin.cons 0 (fun j => j.succ.succ) : Fin (arity f+1) → Fin (arity f+2))
have hx' := hx.ex hm
apply ((hu f).or ((hstate f).and hx'.neg)).congr
intro i v
have he := State.value_apply_iff (d i) (s i) (u i) (hc i) (hv i)
⟨f,fun j => (v j.succ).val⟩ (v 0)
simp only [Fin.cons_zero,Fin.cons_succ,Function.comp_apply] at *
exact he.symm
end
noncomputable section
open Classical Hereditary Finset
variable {A B R F : Type} {arity : F → ℕ} [Fintype A] [Fintype B]
local instance {C : Type} : DecidableEq (HF C) := Classical.decEq _
omit [Fintype A] [Fintype B] in
lemma lift_closure (e : A ≃ B) (x : HF A) : closure (lift e x) = (closure x).image (lift e) := closure_map e x
omit [Fintype A] [Fintype B] in
lemma lift_cons (e : A ≃ B) {k : ℕ} (x : HF A) (v : Fin k → HF A) :
(fun j => lift e ((Fin.cons x v : Fin (k+1) → HF A) j)) = Fin.cons (lift e x) (fun j => lift e (v j)) := by
funext j; refine Fin.cases rfl (fun _ => rfl) j
namespace Term
lemma trace_transport (e : A ≃ B) (rel : R → A → A → Bool) (rel' : R → B → B → Bool)
(hrel : ∀ r a b, rel' r (e a) (e b) = rel r a b) (s : State F arity A)
{k : ℕ} (t : Term R F arity k) (v : Fin k → HF A) :
t.trace rel' (s.transport e) (fun j => lift e (v j)) = (t.trace rel s v).image (lift e) := by
have hev {k} (t : Term R F arity k) (v : Fin k → HF A) := eval_transport e rel rel' hrel s t v
induction t with
| var j => exact lift_closure e _
| constant n => simp only [trace,← lift_ordinal e n,lift_closure]
| atoms => rw [trace,trace,← lift_allAtoms e,lift_closure]
| app f args ih =>
simp only [trace,hev,ih,image_union,biUnion_image]
rw [show (s.transport e).value ⟨f,fun j => lift e ((args j).eval rel s v)⟩ = lift e (s.value ⟨f,fun j => (args j).eval rel s v⟩) from s.transport_value e ⟨f,fun j => (args j).eval rel s v⟩,lift_closure]
| pair a b ia ib => simp only [trace,hev,ia,ib,image_union,← lift_double,lift_closure]
| union a ia => simp only [trace,hev,ia,image_union,← lift_union,lift_closure]
| unique a ia => simp only [trace,hev,ia,image_union,← lift_unique,lift_closure]
| card a ia => simp only [trace,hev,ia,image_union,← lift_card,lift_closure]
| equal a b ia ib => simp only [trace,hev,ia,ib,image_union,Equiv.apply_eq_iff_eq,← lift_boolean e,lift_closure]
| member a b ia ib => simp only [trace,hev,ia,ib,image_union,lift_mem_iff,← lift_boolean e,lift_closure]
| isAtom a ia => simp only [trace,hev,ia,image_union,lift_isSet,← lift_boolean e,lift_closure]
| input r a b ia ib => simp only [trace,hev,ia,ib,image_union,lift_input e rel rel' hrel,← lift_boolean e,lift_closure]
| not a ia => simp only [trace,hev,ia,image_union,ne_eq,lift_truth_iff,← lift_boolean e,lift_closure]
| and a b ia ib => simp only [trace,hev,ia,ib,image_union,lift_truth_iff,← lift_boolean e,lift_closure]
| conditional c a b ic ia ib => simp only [trace,ic,ia,ib,image_union]
| comprehension b g t ib ig it =>
have hz := hev (comprehension b g t) v
change insert ((comprehension b g t).eval rel' (s.transport e) _) _ = Finset.image (lift e) (insert ((comprehension b g t).eval rel s v) _)
rw [hz,image_insert]
congr 1
simp only [ib,hev,lift_elements,biUnion_image,image_union,image_biUnion,biUnion_image]
congr 1
apply biUnion_congr rfl
intro x hx
rw [← lift_cons e x v,ig,it]
end Term
namespace Rule
lemma trace_transport (e : A ≃ B) (rel : R → A → A → Bool) (rel' : R → B → B → Bool)
(hrel : ∀ r a b, rel' r (e a) (e b) = rel r a b) (s : State F arity A)
{k : ℕ} (r : Rule R F arity k) (v : Fin k → HF A) :
r.trace rel' (s.transport e) (fun j => lift e (v j)) = (r.trace rel s v).image (lift e) := by
have ht {k} (t : Term R F arity k) (v : Fin k → HF A) := t.trace_transport e rel rel' hrel s v
have he {k} (t : Term R F arity k) (v : Fin k → HF A) := t.eval_transport e rel rel' hrel s v
induction r with
| skip => simp only [trace,image_empty]
| update f args value => simp only [trace,ht,image_union,biUnion_image]
| parallel r t ir it => simp only [trace,ir,it,image_union]
| conditional c r t ir it => simp only [trace,ht,ir,it,image_union]
| «forall» b r ih =>
simp only [trace,ht,he,image_union,lift_elements,biUnion_image,image_biUnion]
congr 1
apply biUnion_congr rfl
intro x hx
rw [← lift_cons e x v,ih]
| letValue b r ih =>
simp only [trace,ht,he,image_union]
rw [← lift_cons e (b.eval rel s v) v,ih]
end Rule
end
end WitnessedSeparation.Operational
namespace WitnessedSeparation.Operational.Machine
noncomputable section
open Classical Hereditary Counting HFCoding Finset
variable {R ι L : Type} {A : ι → Type} [∀ i, Fintype (A i)]
variable (P : Machine R)
variable (d : ∀ i, Set (HF (A i))) (S : ∀ i, Counting.Structure L (Domain (d i))) {m : ℕ}
variable (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i)
variable (hp : ∀ i k, ordinal (A := A i) k ∈ d i)
variable (ha : ∀ i a, atom a ∈ d i)
variable (hmem : UniformDefinable S m 2 (fun _ v => (v 0).val ∈ (v 1).val))
variable (hset : UniformDefinable S m 1 (fun _ v => isSet (v 0).val = true))
variable (rel : ∀ i, R → A i → A i → Bool) (s : ∀ i, P.Store (A := A i))
variable (hinput : ∀ r, UniformDefinable S m 2 (fun i v => inputRelation (rel i) r (v 0).val (v 1).val))
variable (hstate : ∀ f, UniformDefinable S m (P.functionArity f+1)
(fun i v => (v 0).val = (s i).value ⟨f,fun j => (v j.succ).val⟩))
include hd hp hmem hset hstate in
omit [(i : ι) → Fintype (A i)] in
lemma uniform_flag (hm : 6 ≤ m) (c : Control) :
UniformDefinable S m 0 (fun i _ => P.flag (s i) c) := by
have ht := HFCoding.uniform_ordinal S hmem hset hm hd hp 1
have hs := hstate (Sum.inl c)
simp only [functionArity,Sum.elim_inl] at hs
have hs' : UniformDefinable S m 1 (fun i v => (v 0).val = (s i).value ⟨Sum.inl c,Fin.elim0⟩) := by
apply hs.congr
intro i v
have hh : (fun j : Fin 0 => (v j.succ).val) = Fin.elim0 := by funext j; exact Fin.elim0 j
rw [hh]
rfl
apply (hs'.and ht).ex (by omega) |>.congr
intro i v
change (∃ x : Domain (d i), x.val = (s i).value ⟨Sum.inl c,_⟩ ∧ x.val = truth) ↔ _
constructor
· rintro ⟨x,hx,hxt⟩
exact hx.symm.trans hxt
· intro h
exact ⟨⟨truth,hp i 1⟩,h.symm,rfl⟩
include hd hp ha hmem hset hinput hstate in
lemma uniform_step (K : ℕ) (s' : ∀ i, P.Store (A := A i))
(hh : ∀ i, P.step (rel i) (s i) = some (s' i))
(hm : ∀ f, P.functionArity f+2+P.rule.width ≤ m)
(hroom : 6 ≤ m)
(ht : ∀ i x, x ∈ P.rule.trace (rel i) (s i) Fin.elim0 → x ∈ d i ∧ (elements x).card ≤ K)
(f : Control ⊕ P.Functions) :
UniformDefinable S m (P.functionArity f+1) (fun i v =>
(v 0).val = (s' i).value ⟨f,fun j => (v j.succ).val⟩) := by
have hu (f) := uniform_updates d S hd hp ha hmem hset rel s hinput hstate K P.rule f (by have := hm f; omega) ht
have hx := ((hu f).reindex (Fin.cons 0 (fun j => j.succ.succ) : Fin (P.functionArity f+1) → Fin (P.functionArity f+2))).ex (by have := hm f; omega)
have hadd := (hu f).or ((hstate f).and hx.neg)
have hhalt := (uniform_flag P d S hd hp hmem hset s hstate hroom .halt).reindex (Fin.elim0 : Fin 0 → Fin (P.functionArity f+1))
apply ((hhalt.and (hstate f)).or (hhalt.neg.and hadd)).congr
intro i v
have hh' := hh i
by_cases hf : P.flag (s i) .halt
· have he : s i = s' i := Option.some.inj (by simpa only [step,ite_eq_left hf] using hh')
simp only [hf,true_and,not_true_eq_false,false_and,or_false]
rw [he]
· have hc : State.Consistent (P.rule.updates (rel i) (s i) Fin.elim0) := by
by_contra hc
simp only [step,ite_eq_right hf,ite_eq_right hc] at hh'
contradiction
have he : (s i).applyUpdates (P.rule.updates (rel i) (s i) Fin.elim0) = s' i := Option.some.inj (by simpa only [step,ite_eq_right hf,ite_eq_left hc] using hh')
have hv : ∀ l z, (l,z) ∈ P.rule.updates (rel i) (s i) Fin.elim0 → z ∈ d i := by
intro l z hz
exact (ht i z ((P.rule.closure_update_subset_trace (rel i) (s i) Fin.elim0 hz).1 (mem_closure_self z))).1
have hvv := State.value_apply_iff (d i) (s i) _ hc hv ⟨f,fun j => (v j.succ).val⟩ (v 0)
rw [he] at hvv
simp only [hf,false_and,not_false_eq_true,true_and,false_or,Fin.cons_zero,Fin.cons_succ,Function.comp_apply]
exact hvv.symm
end
noncomputable section
open Classical Hereditary Finset
variable {A B R : Type} [Fintype A] [Fintype B]
local instance {C : Type} : DecidableEq (HF C) := Classical.decEq _
variable (P : Machine R)
def runTrace (rel : R → A → A → Bool) (h : ℕ) : Finset (HF A) :=
P.runActive rel h ∪ (range (h+1)).biUnion (fun j => match P.run rel j with
| none => ∅
| some s => P.rule.trace rel s Fin.elim0)
lemma rule_trace_subset (rel : R → A → A → Bool) {h j : ℕ} {s : P.Store (A := A)}
(hj : j ≤ h) (hs : P.run rel j = some s) :
P.rule.trace rel s Fin.elim0 ⊆ P.runTrace rel h := by
intro x hx
exact mem_union_right _ (mem_biUnion.mpr ⟨j,by simpa using hj,by simpa only [hs] using hx⟩)
lemma active_subset_trace (rel : R → A → A → Bool) {h j : ℕ} {s : P.Store (A := A)}
(hj : j ≤ h) (hs : P.run rel j = some s) : s.active ⊆ P.runTrace rel h :=
(P.state_active_subset rel hj hs).trans subset_union_left
lemma runTrace_closed (rel : R → A → A → Bool) (h : ℕ) : Closed (P.runTrace rel h) := by
apply Closed.union (fun _ hx _ hy => P.runActive_transitive rel h hx hy)
apply Closed.biUnion
intro j hj
cases hs : P.run rel j with
| none => intro x hx; exact (notMem_empty _ hx).elim
| some s => exact P.rule.trace_closed rel s Fin.elim0
lemma card_runTrace_le (rel : R → A → A → Bool) (h K : ℕ)
(hb : ∀ j ≤ h, ∀ s, P.run rel j = some s → s.active.card ≤ K) :
(P.runTrace rel h).card ≤ (h+1)*(K+P.rule.bound.eval K) := by
have hc : ((range (h+1)).biUnion (fun j => match P.run rel j with
| none => ∅ | some s => P.rule.trace rel s Fin.elim0)).card ≤ (h+1)*P.rule.bound.eval K := by
apply card_biUnion_le.trans
calc
_ ≤ ∑ _j ∈ range (h+1), P.rule.bound.eval K := by
apply sum_le_sum
intro j hj
cases hs : P.run rel j with
| none => simp
| some s =>
apply P.rule.card_trace_le rel s Fin.elim0 K
simpa only [Term.potential,Finset.univ_eq_empty,Finset.sum_empty,Nat.add_zero] using hb j (by simpa using hj) s hs
_ = _ := by simp
exact (card_union_le _ _).trans (by
have ha := P.runActive_card_le rel h K hb
nlinarith)
lemma runTrace_transport (e : A ≃ B) (rel : R → A → A → Bool) (rel' : R → B → B → Bool)
(hrel : ∀ r a b, rel' r (e a) (e b) = rel r a b) (h : ℕ) :
P.runTrace rel' h = (P.runTrace rel h).image (lift e) := by
unfold runTrace
rw [P.runActive_transport e rel rel' hrel,image_union,biUnion_image]
congr 1
apply biUnion_congr rfl
intro j hj
rw [P.run_transport e rel rel' hrel]
cases hs : P.run rel j with
| none => simp
| some s =>
have hv : (fun j : Fin 0 => lift e (Fin.elim0 j : HF A)) = Fin.elim0 := by funext j; exact Fin.elim0 j
simpa only [Option.map_some,hv] using P.rule.trace_transport e rel rel' hrel s Fin.elim0
end
noncomputable section
open Classical Hereditary Counting HFCoding Finset
variable {R ι L : Type} {A : ι → Type} [∀ i, Fintype (A i)]
variable (P : Machine R)
variable (d : ∀ i, Set (HF (A i))) (S : ∀ i, Counting.Structure L (Domain (d i))) {m : ℕ}
variable (hd : ∀ i, ∀ x ∈ d i, ∀ y, y ∈ x → y ∈ d i)
variable (hp : ∀ i k, ordinal (A := A i) k ∈ d i)
variable (ha : ∀ i a, atom a ∈ d i)
variable (hmem : UniformDefinable S m 2 (fun _ v => (v 0).val ∈ (v 1).val))
variable (hset : UniformDefinable S m 1 (fun _ v => isSet (v 0).val = true))
variable (rel : ∀ i, R → A i → A i → Bool)
variable (hinput : ∀ r, UniformDefinable S m 2 (fun i v => inputRelation (rel i) r (v 0).val (v 1).val))
include hd hp ha hmem hset hinput in
lemma uniform_run (ss : ∀ i, ℕ → P.Store (A := A i)) (h K : ℕ)
(hr : ∀ i j, j ≤ h → P.run (rel i) j = some (ss i j))
(hm : ∀ f, P.functionArity f+2+P.rule.width ≤ m) (hroom : 6 ≤ m)
(ht : ∀ i j, j < h → ∀ x ∈ P.rule.trace (rel i) (ss i j) Fin.elim0,
x ∈ d i ∧ (elements x).card ≤ K) :
∀ f, UniformDefinable S m (P.functionArity f+1)
(fun i v => (v 0).val = (ss i h).value ⟨f,fun j => (v j.succ).val⟩) := by
induction h with
| zero =>
intro f
have hz := (HFCoding.uniform_ordinal S hmem hset hroom hd hp 0).reindex
(fun _ : Fin 1 => (0 : Fin (P.functionArity f+1)))
apply hz.congr
intro i v
have he : State.initial = ss i 0 := Option.some.inj (hr i 0 (by omega))
rw [← he]
rfl
| succ h ih =>
have hs := ih (fun i j hj => hr i j (by omega)) (fun i j hj => ht i j (by omega))
apply P.uniform_step d S hd hp ha hmem hset rel (fun i => ss i h) hinput hs K (fun i => ss i (h+1))
· intro i
have hh := hr i (h+1) (by omega)
simpa only [run,hr i h (by omega),Option.bind_some] using hh
· exact hm
· exact hroom
· intro i x hx
exact ht i h (by omega) x hx
include hd hp ha hmem hset hinput in
lemma uniform_run_flag (ss : ∀ i, ℕ → P.Store (A := A i)) (h K : ℕ)
(hr : ∀ i j, j ≤ h → P.run (rel i) j = some (ss i j))
(hm : ∀ f, P.functionArity f+2+P.rule.width ≤ m) (hroom : 6 ≤ m)
(ht : ∀ i j, j < h → ∀ x ∈ P.rule.trace (rel i) (ss i j) Fin.elim0,
x ∈ d i ∧ (elements x).card ≤ K) (c : Control) :
UniformDefinable S m 0 (fun i _ => P.flag (ss i h) c) :=
P.uniform_flag d S hd hp hmem hset (fun i => ss i h)
(P.uniform_run d S hd hp ha hmem hset rel hinput ss h K hr hm hroom ht) hroom c
end
end WitnessedSeparation.Operational.Machine
namespace WitnessedSeparation.Grid
noncomputable section
open Classical Hereditary Counting HFCoding Operational Finset
local instance {C : Type} : DecidableEq (HF C) := Classical.decEq _
variable {n : ℕ} (b : Vertex n → Scalar) (P : Operational.Machine Symbol)
lemma opTrace_supported (hn : 1 ≤ n) (h K N : ℕ) (hN : 0 < N)
(ha : ∀ j ≤ h, ∀ st, P.run (atomInput b).rel j = some st → st.active.card ≤ K)
(q : ℝ) (hq : 0 ≤ q) (hb : ((h+1)*(K+P.rule.bound.eval K):ℝ) ≤ (N:ℝ)^q) :
∀ x ∈ P.runTrace (atomInput b).rel h,
HereditarilySupported (G := CentralGroup n) ⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊ x := by
have hi : ∀ g : BoxGroup n, ∀ x ∈ P.runTrace (atomInput b).rel h,
g • x ∈ P.runTrace (atomInput b).rel h := by
intro g x hx
have ht := P.runTrace_transport (actionIso (b := b) g).toEquiv
(atomInput b).rel (atomInput b).rel (fun r a b => (actionIso g).rel_eq r a b) h
have hm : g • x ∈ (P.runTrace (atomInput b).rel h).image (lift (actionIso (b := b) g).toEquiv) :=
mem_image.mpr ⟨x,hx,rfl⟩
exact (congrArg (fun t : Finset (HF (Atom b)) => g • x ∈ t) ht).mpr hm
apply invariant_family_hereditarily_supported hn _ hi (P.runTrace_closed _ h) N hN q hq
have hc : ((P.runTrace (atomInput b).rel h).card : ℝ) ≤ ((h+1)*(K+P.rule.bound.eval K):ℝ) := by
exact_mod_cast P.card_runTrace_le (atomInput b).rel h K ha
exact hc.trans hb
variable {ι : Type} (bs : ι → Vertex n → Scalar) {s m : ℕ}
lemma program_atom_mem (hs : 0 < s) (i : ι) (a : Atom (bs i)) :
atom a ∈ programDomain bs (s := s) i := by
apply hereditary_iff.mpr
constructor
· refine ⟨fun _ => a,?_⟩
intro g hg
rw [smul_atom,hg ⟨0,hs⟩]
· intro y hy
have hh : y ∈ (∅ : Finset (HF (Atom (bs i)))) := hy
exact (notMem_empty _ hh).elim
lemma op_input_uniform (r : Symbol) :
UniformDefinable (programHF bs (s := s)) m 2
(fun i v => inputRelation (atomInput (bs i)).rel r (v 0).val (v 1).val) := by
apply (UniformDefinable.relation (S := programHF bs) (.base (.input r)) 0 1).congr
intro i v
change (∃ a b, (v 0).val = atom a ∧ (v 1).val = atom b ∧ AtomRelation (bs i) r a b) ↔ _
simp only [inputRelation,atomInput,decide_eq_true_eq]
end
noncomputable section
open Classical Hereditary Counting HFCoding Operational Finset
local instance instDecidableEqHF2 {C : Type} : DecidableEq (HF C) := Classical.decEq _
variable {n m M N : ℕ} (P : Operational.Machine Symbol) (vstar : Vertex n)
lemma op_flag_agrees (hn : 1 ≤ n) (h K : ℕ) (hN : 0 < N)
(ss : ∀ i : Bool, ℕ → P.Store (A := Atom (twoCharges vstar i)))
(hr : ∀ i j, j ≤ h → P.run (atomInput (twoCharges vstar i)).rel j = some (ss i j))
(ha : ∀ i j, j ≤ h → (ss i j).active.card ≤ K)
(q : ℝ) (hq : 0 ≤ q) (hb : ((h+1)*(K+P.rule.bound.eval K):ℝ) ≤ (N:ℝ)^q)
(hm : ∀ f, P.functionArity f+2+P.rule.width ≤ m) (hroom : 6 ≤ m)
(hs : 0 < ⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊)
(hwidth : max 4 (m+1)*⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊ ≤ M)
(hhom : (7*(max 2 m*⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊):ℝ)+
7*((6*(max 2 m*⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊):ℝ)/boxConstant)^((3:ℝ)/2)+1 ≤ M)
(hgiant : GiantBound n M) (c : Control) :
P.flag (ss false h) c ↔ P.flag (ss true h) c := by
let s := ⌈2*(n+1:ℝ)*(q*Real.logb 3 N)^2⌉₊
let D := programDomain (twoCharges vstar) (s := s)
let C := programHF (twoCharges vstar) (s := s)
have hbound (i : Bool) : ∀ j ≤ h, ∀ st, P.run (atomInput (twoCharges vstar i)).rel j = some st → st.active.card ≤ K := by
intro j hj st hh
have he : st = ss i j := Option.some.inj (hh.symm.trans (hr i j hj))
exact he ▸ ha i j hj
have hfamily (i : Bool) : ∀ x ∈ P.runTrace (atomInput (twoCharges vstar i)).rel h, x ∈ D i :=
opTrace_supported (twoCharges vstar i) P hn h K N hN (hbound i) q hq hb
have ht : ∀ i j, j < h → ∀ x ∈ P.rule.trace (atomInput (twoCharges vstar i)).rel (ss i j) Fin.elim0,
x ∈ D i ∧ (elements x).card ≤ (h+1)*(K+P.rule.bound.eval K) := by
intro i j hj x hx
have hx' := P.rule_trace_subset (atomInput (twoCharges vstar i)).rel (Nat.le_of_lt hj) (hr i j (by omega)) hx
refine ⟨hfamily i x hx',?_⟩
have he : elements x ⊆ P.runTrace (atomInput (twoCharges vstar i)).rel h := by
intro y hy
exact P.runTrace_closed _ h x hx' y hy
exact (card_le_card he).trans (P.card_runTrace_le _ h K (hbound i))
have hd := P.uniform_run_flag D C (program_domain_transitive (twoCharges vstar))
(program_pure (twoCharges vstar) hn) (program_atom_mem (twoCharges vstar) hs)
(program_mem_uniform (twoCharges vstar)) (program_set_uniform (twoCharges vstar))
(fun i => (atomInput (twoCharges vstar i)).rel) (op_input_uniform (twoCharges vstar))
ss h ((h+1)*(K+P.rule.bound.eval K)) hr hm hroom ht c
obtain ⟨φ,hφ,hφsem⟩ := hd (Fin.elim0 : Fin 0 → Fin m)
have hfree : φ.free = ∅ := subset_empty.mp (by simpa using hφ)
let v : Fin m → Domain (D false) := fun _ => ⟨ordinal 0,program_pure (twoCharges vstar) hn false 0⟩
let w : Fin m → Domain (D true) := fun _ => ⟨ordinal 0,program_pure (twoCharges vstar) hn true 0⟩
let := atom_nonempty hn (0 : Vertex n → Scalar)
let := atom_nonempty hn (Pi.single vstar 1)
exact (hφsem false v).symm.trans ((grid_hf_transfer hn hs (by omega) vstar
hwidth hhom hgiant φ hfree v w).trans (hφsem true w))
end
end WitnessedSeparation.Grid
namespace WitnessedSeparation.PolynomialCost
open Finset
lemma eval_bound (p : Polynomial ℕ) : ∃ c d : ℕ, ∀ K, p.eval K ≤ c*(K+1)^d := by
induction p using Polynomial.induction_on' with
| add p r hp hr =>
obtain ⟨c,d,hp⟩ := hp
obtain ⟨e,f,hr⟩ := hr
refine ⟨c+e,d+f,fun K => ?_⟩
rw [Polynomial.eval_add]
have h1 : (K+1)^d ≤ (K+1)^(d+f) := Nat.pow_le_pow_right (by omega) (by omega)
have h2 : (K+1)^f ≤ (K+1)^(d+f) := Nat.pow_le_pow_right (by omega) (by omega)
calc
p.eval K + r.eval K ≤ c*(K+1)^d + e*(K+1)^f := add_le_add (hp K) (hr K)
_ ≤ c*(K+1)^(d+f)+e*(K+1)^(d+f) := add_le_add (Nat.mul_le_mul_left _ h1) (Nat.mul_le_mul_left _ h2)
_ = _ := by ring
| monomial n a =>
refine ⟨a,n,fun K => ?_⟩
rw [Polynomial.eval_monomial]
exact Nat.mul_le_mul_left a (Nat.pow_le_pow_left (by omega) n)
end WitnessedSeparation.PolynomialCost
namespace WitnessedSeparation.Operational.Machine
noncomputable section
open Classical Hereditary Finset
variable {A R : Type} [Fintype A]
local instance {C : Type} : DecidableEq (HF C) := Classical.decEq _
variable (P : Machine R)
lemma run_none (rel : R → A → A → Bool) {j : ℕ} (hj : P.run rel j = none) :
∀ k, j ≤ k → P.run rel k = none := by
intro k hk
obtain ⟨l,rfl⟩ := Nat.exists_eq_add_of_le hk
clear hk
induction l with
| zero => simpa using hj
| succ l ih =>
change (P.run rel (j+l)).bind (P.step rel) = none
rw [ih]
rfl
lemma run_prefix_exists (rel : R → A → A → Bool) {h : ℕ} {s : P.Store (A := A)}
(hh : P.run rel h = some s) {j : ℕ} (hj : j ≤ h) : ∃ t, P.run rel j = some t := by
cases hs : P.run rel j with
| some t => exact ⟨t,rfl⟩
| none => have he := P.run_none rel hs h hj; rw [hh] at he; contradiction
lemma halted_persists (rel : R → A → A → Bool) {h : ℕ} {s : P.Store (A := A)}
(hh : P.run rel h = some s) (hf : P.flag s .halt) :
∀ k, h ≤ k → P.run rel k = some s := by
intro k hk
obtain ⟨l,rfl⟩ := Nat.exists_eq_add_of_le hk
clear hk
induction l with
| zero => simpa using hh
| succ l ih =>
change (P.run rel (h+l)).bind (P.step rel) = some s
rw [ih]
simp only [Option.bind_some,step,ite_eq_left hf]
lemma run_total_of_halts (rel : R → A → A → Bool) {h : ℕ} {s : P.Store (A := A)}
(hh : P.run rel h = some s) (hf : P.flag s .halt) (j : ℕ) :
∃ t, P.run rel j = some t := by
by_cases hj : j ≤ h
· exact P.run_prefix_exists rel hh hj
· exact ⟨s,P.halted_persists rel hh hf j (by omega)⟩
lemma active_card_of_halts (rel : R → A → A → Bool) {h : ℕ} {s : P.Store (A := A)}
(hh : P.run rel h = some s) (hf : P.flag s .halt) {j : ℕ} {t : P.Store (A := A)}
(hj : P.run rel j = some t) : t.active.card ≤ (P.runActive rel h).card := by
by_cases hjh : j ≤ h
· exact card_le_card (P.state_active_subset rel hjh hj)
· have he := P.halted_persists rel hh hf j (by omega)
have ht : t = s := Option.some.inj (hj.symm.trans he)
subst t
exact card_le_card (P.state_active_subset rel (le_refl h) hh)
lemma flag_accept_eq_of_halts (rel : R → A → A → Bool) {h j : ℕ} {s t : P.Store (A := A)}
(hh : P.run rel h = some s) (hf : P.flag s .halt)
(hj : P.run rel j = some t) (hjh : h ≤ j) :
P.accepts rel ↔ P.flag t .accept := by
have he : t = s := Option.some.inj (hj.symm.trans (P.halted_persists rel hh hf j hjh))
subst t
constructor
· rintro ⟨k,u,hk,huf,hua⟩
by_cases hkh : k ≤ h
· have ht := P.halted_persists rel hk huf h hkh
have he : u = s := Option.some.inj (ht.symm.trans hh)
exact he ▸ hua
· have ht := P.halted_persists rel hh hf k (by omega)
have he : u = s := Option.some.inj (hk.symm.trans ht)
exact he ▸ hua
· intro ha; exact ⟨h,s,hh,hf,ha⟩
end
noncomputable section
open Classical Finset
variable {R : Type} (P : Machine R)
lemma exists_palette : ∃ m : ℕ, 6 ≤ m ∧ ∀ f, P.functionArity f+2+P.rule.width ≤ m := by
let := P.finiteFunctions
let total := ∑ f : Control ⊕ P.Functions, P.functionArity f
refine ⟨total+P.rule.width+8,by omega,?_⟩
intro f
have hf : P.functionArity f ≤ total := single_le_sum (fun _ _ => Nat.zero_le _) (mem_univ f)
omega
end
end WitnessedSeparation.Operational.Machine
namespace WitnessedSeparation.Grid
noncomputable section
open Classical Hereditary Counting HFCoding Operational Quantitative Finset
local instance {C : Type} : DecidableEq (HF C) := Classical.decEq _
theorem operational_agrees_on_some_box (P : Operational.Machine Symbol) (hP : P.PolynomiallyBounded) :
∃ (n : ℕ) (_hn : 1 ≤ n) (vstar : Vertex n),
P.accepts (atomInput (0 : Vertex n → Scalar)).rel ↔
P.accepts (atomInput (Pi.single vstar 1)).rel := by
obtain ⟨c,d,hcost⟩ := hP
obtain ⟨m,hroom,hm⟩ := P.exists_palette
let p : Polynomial ℕ := (Polynomial.X+1)*(Polynomial.X+P.rule.bound)
obtain ⟨cp,dp,hp⟩ := PolynomialCost.eval_bound p
let e := timeExponent c d
let a := timeExponent cp dp
let q := e*a
have he : 2 ≤ e := timeExponent_ge_two c d
have ha : 2 ≤ a := timeExponent_ge_two cp dp
have hq : 0 < q := Nat.mul_pos (by omega) (by omega)
obtain ⟨n,hn,hnum⟩ := exists_numeric_box q hq m
let N := atomSizeConstant*(n+1)^3
let B := N^e
let vstar : Vertex n := ⟨0,0,0⟩
let rel := fun i => (atomInput (twoCharges vstar i)).rel
have hN : 2 ≤ N := hnum.1
have hB : 2 ≤ B := (polynomial_bounds c d N hN).1
have hinput : ∀ i, Fintype.card (Atom (twoCharges vstar i)) ≤ N :=
fun i => (atom_card_bounds hn (twoCharges vstar i)).2
have hcostB (i : Bool) : ∃ j st, P.run (rel i) j = some st ∧ P.flag st .halt ∧
j+(P.runActive (rel i) j).card ≤ B := by
obtain ⟨j,st,hj,hf,hc⟩ := hcost (Atom (twoCharges vstar i)) inferInstance (rel i)
refine ⟨j,st,hj,hf,hc.trans ?_⟩
exact (Nat.mul_le_mul_left c (Nat.pow_le_pow_left (Nat.add_le_add_right (hinput i) 1) d)).trans
(polynomial_bounds c d N hN).2.2.1
choose jj tt hrun hhalt hbudget using hcostB
let h := max (jj false) (jj true)
have hjh (i : Bool) : jj i ≤ h := by cases i <;> simp only [h,le_max_left,le_max_right]
have hhB : h ≤ B := max_le (by have := hbudget false; omega) (by have := hbudget true; omega)
have htotal : ∀ i j, ∃ st, P.run (rel i) j = some st :=
fun i j => P.run_total_of_halts (rel i) (hrun i) (hhalt i) j
choose ss hrs using htotal
have hactive : ∀ i j, (ss i j).active.card ≤ B := by
intro i j
exact (P.active_card_of_halts (rel i) (hrun i) (hhalt i) (hrs i j)).trans (by have := hbudget i; omega)
have hpoly : (h+1)*(B+P.rule.bound.eval B) ≤ N^q := by
calc
(h+1)*(B+P.rule.bound.eval B) ≤ (B+1)*(B+P.rule.bound.eval B) := Nat.mul_le_mul_right _ (by omega)
_ = p.eval B := by simp only [p,Polynomial.eval_mul,Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_one]
_ ≤ cp*(B+1)^dp := hp B
_ ≤ B^a := (polynomial_bounds cp dp B hB).2.2.1
_ = N^q := by simp only [B,q,pow_mul]
have hh := op_flag_agrees (N := N) P vstar hn h B (by omega) ss
(fun i j _ => hrs i j) (fun i j _ => hactive i j) (q:ℝ) (by positivity)
(by rw [Real.rpow_natCast]; exact_mod_cast hpoly) hm hroom
hnum.2.1 hnum.2.2.1 (by simpa only [N,Nat.cast_mul] using hnum.2.2.2.1) hnum.2.2.2.2 .accept
refine ⟨n,hn,vstar,?_⟩
exact (P.flag_accept_eq_of_halts (rel false) (hrun false) (hhalt false) (hrs false h) (hjh false)).trans
(hh.trans (P.flag_accept_eq_of_halts (rel true) (hrun true) (hhalt true) (hrs true h) (hjh true)).symm)
end
end WitnessedSeparation.Grid
namespace WitnessedSeparation
theorem query_not_intrinsically_bounded_HF :
¬ ∃ P : Operational.Machine Symbol, P.PolynomiallyBounded ∧
∀ (A : Type) (fA : Fintype A) (S : Input A), @Input.query A fA S ↔ @Operational.Machine.accepts A Symbol P fA S.rel := by
rintro ⟨P,hP,hdecides⟩
obtain ⟨n,hn,vstar,hagree⟩ := Grid.operational_agrees_on_some_box P hP
obtain ⟨hz,hu⟩ := Grid.opposite_answers hn vstar
apply hu
exact (hdecides _ _ _).mpr (hagree.mp ((hdecides _ _ _).mp hz))
end WitnessedSeparation
namespace WitnessedSeparation.Hereditary
noncomputable section
open Classical Finset
variable {A : Type}
local instance : DecidableEq (HF A) := Classical.decEq _
def descendants (t : Finset (HF A)) : ℕ → Finset (HF A)
| 0 => t
| k+1 => descendants t k ∪ (descendants t k).biUnion elements
lemma descendants_mono (t : Finset (HF A)) (k : ℕ) : descendants t k ⊆ descendants t (k+1) := subset_union_left
lemma roots_subset_descendants (t : Finset (HF A)) (k : ℕ) : t ⊆ descendants t k := by
induction k with
| zero => exact subset_rfl
| succ k ih => exact ih.trans (descendants_mono t k)
lemma descendants_subset (t : Finset (HF A)) (k : ℕ) : descendants t k ⊆ familyClosure t := by
induction k with
| zero => exact fun _ hx => familyClosure_contains hx
| succ k ih =>
intro x hx
rcases mem_union.mp hx with hx | hx
· exact ih hx
· obtain ⟨y,hy,hxy⟩ := mem_biUnion.mp hx
exact familyClosure_transitive (ih hy) hxy
lemma descendants_stable (t : Finset (HF A)) (k : ℕ)
(hs : descendants t (k+1) ⊆ descendants t k) : descendants t k = familyClosure t := by
apply subset_antisymm (descendants_subset t k)
intro x hx
obtain ⟨y,hy,hxy⟩ := mem_familyClosure.mp hx
have h := (mem_closure_iff x y).mp hxy
have hc : ∀ {a b : HF A}, a ∈ b → b ∈ descendants t k → a ∈ descendants t k := by
intro a b hab hb
exact hs (mem_union_right _ (mem_biUnion.mpr ⟨b,hb,hab⟩))
have aux : ∀ {a b : HF A}, Relation.ReflTransGen (fun x y : HF A => x ∈ y) a b →
b ∈ descendants t k → a ∈ descendants t k := by
intro a b hr
induction hr with
| refl => exact fun ha => ha
| tail hab hbc ih => exact fun hb => ih (hc hbc hb)
exact aux h (roots_subset_descendants t k hy)
lemma descendants_card_lower (t : Finset (HF A)) (k : ℕ)
(hne : descendants t k ≠ familyClosure t) : k ≤ (descendants t k).card := by
induction k with
| zero => exact Nat.zero_le _
| succ k ih =>
have hproper : descendants t k ⊂ descendants t (k+1) := by
apply Finset.ssubset_iff_subset_ne.mpr
refine ⟨descendants_mono t k,?_⟩
intro he
exact hne (he.symm.trans (descendants_stable t k (he ▸ subset_rfl)))
have hprev : descendants t k ≠ familyClosure t := by
intro he
exact hne (subset_antisymm (descendants_subset t (k+1)) (he ▸ descendants_mono t k))
have hh := card_lt_card hproper
have hi := ih hprev
omega
lemma descendants_eq (t : Finset (HF A)) (K : ℕ) (hb : (familyClosure t).card ≤ K) :
descendants t K = familyClosure t := by
by_contra h
have hlt := card_lt_card (Finset.ssubset_iff_subset_ne.mpr ⟨descendants_subset t K,h⟩)
have hlow := descendants_card_lower t K h
omega
end
end WitnessedSeparation.Hereditary
end OAI
import OAI.Computability.WitnessedChoice.EvaluationTrace
namespace OAI
namespace WitnessedSeparation.Operational.Rule
noncomputable section
open Classical Hereditary Counting HFCoding Finset
variable {A R F : Type} {arity : F → ℕ} [Fintype A]
local instance {C : Type} : DecidableEq (HF C) := Classical.decEq _
def Graph (d : Set (HF A)) (K : ℕ) (rel : R → A → A → Bool) (s : State F arity A) :
{k : ℕ} → Rule R F arity k → (f : F) → Domain d → (Fin (arity f) → Domain d) → (Fin k → Domain d) → Prop
| _,.skip,_,_,_,_ => False
| _,.update g args value,f,z,a,v => if h : g = f then
Term.Graph d K rel s value z v ∧ ∀ j, Term.Graph d K rel s (args j) (a (Fin.cast (congrArg arity h) j)) v else False
| _,.parallel r t,f,z,a,v => Graph d K rel s r f z a v ∨ Graph d K rel s t f z a v
| _,.conditional c r t,f,z,a,v => ∃ b, Term.Graph d K rel s c b v ∧
((b.val = truth ∧ Graph d K rel s r f z a v) ∨ (b.val ≠ truth ∧ Graph d K rel s t f z a v))
| _,.forall b r,f,z,a,v => ∃ w x, Term.Graph d K rel s b w v ∧ x.val ∈ w.val ∧ Graph d K rel s r f z a (Fin.cons x v)
| _,.letValue b r,f,z,a,v => ∃ w, Term.Graph d K rel s b w v ∧ Graph d K rel s r f z a (Fin.cons w v)
variable (d : Set (HF A)) (K : ℕ) (rel : R → A → A → Bool) (s : State F arity A)
variable (hd : ∀ x ∈ d, ∀ y, y ∈ x → y ∈ d)
include hd in
lemma graph_sound {k : ℕ} (r : Rule R F arity k) (f : F) (z : Domain d)
(a : Fin (arity f) → Domain d) (v : Fin k → Domain d)
(h : Graph d K rel s r f z a v) :
(⟨f,fun j => (a j).val⟩,z.val) ∈ r.updates rel s (fun j => (v j).val) := by
induction r generalizing f z a with
| skip => exact h.elim
| update g args value =>
unfold Graph at h
split at h
next he =>
subst g
obtain ⟨hz,ha⟩ := h
have hv := Term.graph_sound d K rel s hd value z v hz
have ha' : (fun j => (a j).val) = fun j => (args j).eval rel s (fun j => (v j).val) :=
funext (fun j => Term.graph_sound d K rel s hd (args j) (a j) v (ha j))
simp only [updates,Finset.mem_singleton,hv,ha']
next he => exact h.elim
| parallel r t ir it => exact h.elim (fun h => mem_union_left _ (ir _ _ _ _ h)) (fun h => mem_union_right _ (it _ _ _ _ h))
| conditional c r t ir it =>
obtain ⟨b,hb,h⟩ := h
have he := Term.graph_sound d K rel s hd c b v hb
rcases h with ⟨hc,hr⟩ | ⟨hc,ht⟩
· simpa only [updates,← he,ite_eq_left hc] using ir _ _ _ _ hr
· simpa only [updates,← he,ite_eq_right hc] using it _ _ _ _ ht
| @«forall» k b r ih =>
obtain ⟨w,x,hw,hx,hr⟩ := h
have he := Term.graph_sound d K rel s hd b w v hw
refine mem_biUnion.mpr ⟨x.val,by rwa [← he],?_⟩
have hv : (fun j => ((Fin.cons x v : Fin (k+1) → Domain d) j).val) = Fin.cons x.val (fun j => (v j).val) := by
funext j; refine Fin.cases rfl (fun _ => rfl) j
simpa only [hv] using ih f z a (Fin.cons x v) hr
| @letValue k b r ih =>
obtain ⟨w,hw,hr⟩ := h
have he := Term.graph_sound d K rel s hd b w v hw
have hv : (fun j => ((Fin.cons w v : Fin (k+1) → Domain d) j).val) = Fin.cons w.val (fun j => (v j).val) := by
funext j; refine Fin.cases rfl (fun _ => rfl) j
simpa only [updates,hv,he] using ih f z a (Fin.cons w v) hr
include hd in
lemma graph_complete {k : ℕ} (r : Rule R F arity k) (f : F) (z : Domain d)
(a : Fin (arity f) → Domain d) (v : Fin k → Domain d)
(ht : ∀ x ∈ r.trace rel s (fun j => (v j).val), x ∈ d ∧ (elements x).card ≤ K)
(hu : (⟨f,fun j => (a j).val⟩,z.val) ∈ r.updates rel s (fun j => (v j).val)) :
Graph d K rel s r f z a v := by
have witness {k} (t : Term R F arity k) (v : Fin k → Domain d)
(ht : ∀ x ∈ t.trace rel s (fun j => (v j).val), x ∈ d ∧ (elements x).card ≤ K) :=
Term.graph_complete d K rel s hd t v ht
have hv {k} (x : Domain d) (v : Fin k → Domain d) :
(fun j => ((Fin.cons x v : Fin (k+1) → Domain d) j).val) = Fin.cons x.val (fun j => (v j).val) := by
funext j; refine Fin.cases rfl (fun _ => rfl) j
induction r generalizing f z a with
| skip => simp [updates] at hu
| update g args value =>
have he := Finset.mem_singleton.mp hu
have hfg : f = g := congrArg (fun p => p.1.1) he
subst g
have haz := (Prod.mk.inj he)
have ha : (fun j => (a j).val) = fun j => (args j).eval rel s (fun j => (v j).val) := by
exact eq_of_heq (Sigma.mk.inj_iff.mp haz.1).2
simp only [Graph,Fin.cast_refl,id_eq]
constructor
· obtain ⟨w,hw,hew⟩ := witness value v (fun x hx => ht x (mem_union_left _ hx))
have hew' : w = z := Subtype.ext (hew.trans haz.2.symm)
rwa [← hew']
· intro j
obtain ⟨w,hw,hew⟩ := witness (args j) v (fun x hx => ht x (mem_union_right _ (mem_biUnion.mpr ⟨j,mem_univ _,hx⟩)))
have hew' : w = a j := Subtype.ext (hew.trans (congrFun ha j).symm)
rwa [← hew']
| parallel r t ir it =>