lean/OAI/Computability/WitnessedChoice/TraceGraphs.lean

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