lean/OAI/Computability/FiniteCompiler/SelfReference.lean

import OAI.Computability.FiniteCompiler.UniformPaths
import OAI.GroupTheory.BooneHigman.PartialAffine

namespace OAI

/-!
Controlled shorter-input evaluator calls, fixed points, totality, and tested-class realization.
-/

namespace FiniteAlgebraicEnvelopes.Bootstrap
namespace Projection
variable {A B : Type*}
def left (w : List (A ⊕ B)) : List A :=
  w.filterMap (fun a => match a with | .inl a => some a | .inr _ => none)
def right (w : List (A ⊕ B)) : List B :=
  w.filterMap (fun a => match a with | .inl _ => none | .inr b => some b)

@[simp] theorem left_append (u v : List (A ⊕ B)) : left (u++v)=left u++left v := List.filterMap_append
@[simp] theorem right_append (u v : List (A ⊕ B)) : right (u++v)=right u++right v := List.filterMap_append
 theorem left_length (w : List (A ⊕ B)) : (left w).length≤w.length := List.length_filterMap_le _ _
 theorem right_length (w : List (A ⊕ B)) : (right w).length≤w.length := List.length_filterMap_le _ _

variable [Primcodable A] [Primcodable B]
 theorem primrec_left : Primrec (left (A:=A) (B:=B)) := by
  have hh : Primrec (fun a : A ⊕ B => match a with | .inl a => some a | .inr _ => none) :=
    (Primrec.sumCasesOn Primrec.id (Primrec.option_some.comp Primrec.snd).to₂
      (Primrec.const none).to₂).of_eq (by intro a; cases a <;> rfl)
  exact Primrec.listFilterMap Primrec.id (hh.comp Primrec.snd).to₂
 theorem primrec_right : Primrec (right (A:=A) (B:=B)) := by
  have hh : Primrec (fun a : A ⊕ B => match a with | .inl _ => none | .inr b => some b) :=
    (Primrec.sumCasesOn Primrec.id (Primrec.const none).to₂
      (Primrec.option_some.comp Primrec.snd).to₂).of_eq (by intro a; cases a <;> rfl)
  exact Primrec.listFilterMap Primrec.id (hh.comp Primrec.snd).to₂
end Projection

namespace Tested
open Compiler Compiler.Simulator MachineRealization MachineRealization.ParameterCode
open scoped Compiler.HeadCodec

variable {S T Γ Q : Type*} [Fintype T] [Fintype Γ] [Fintype Q]
  [DecidableEq T] [DecidableEq Γ] [DecidableEq Q]
  [Primcodable T] [Primcodable Γ] [Primcodable Q]
variable (A : Alphabet S Γ) (M : Machine Q Γ) (p : S) (B : Alphabet T (Bool×Γ))

abbrev X (T Γ Q : Type*) := Word.Letter T (Bool×Γ) (ParameterCode.Control Q)
abbrev Y (T Γ Q : Type*) := X T Γ Q ⊕ PartialAffine.Letter
abbrev Class (T Γ Q : Type*) := List (X T Γ Q) × List PartialAffine.Letter

def combine (q : Class T Γ Q) : Option (Class T Γ Q) :=
  if q.1=[.zero] then none else some q

omit [Fintype Q] [Primcodable T] [Primcodable Γ] in
 theorem primrec_combine : Primrec (combine (T:=T) (Γ:=Γ) (Q:=Q)) := by
  let : DecidablePred (fun q : Class T Γ Q => q.1=([Path.Letter.zero] : List (X T Γ Q))) :=
    fun _ => inferInstance
  have hp : PrimrecPred (fun q : Class T Γ Q => q.1=([Path.Letter.zero] : List (X T Γ Q))) :=
    Primrec.eq.comp Primrec.fst (Primrec.const _)
  exact Primrec.ite hp (Primrec.const none) (Primrec.option_some.comp Primrec.id)

/-- The literal tested class from the self-reference construction: zero precisely for the compiler
    zero output, and otherwise the compiler word together with a canonical,
    decidable coding of the actual auxiliary partial affine map. -/
noncomputable def family (f : ℕ × List T → Part (List T)) (n : ℕ) (w : List (Y T Γ Q)) :
    Part (Option (Class T Γ Q)) :=
  (codedNormal A M p B f (n,Projection.left w)).map
    (fun o => combine (o,PartialAffine.testedClass (Projection.right w)))

 theorem partrec_family {f : ℕ × List T → Part (List T)} (hf : Partrec f) :
    Partrec₂ (family A M p B f) := by
  have hh : Partrec (fun x : ℕ × List (Y T Γ Q) =>
      codedNormal A M p B f (x.1,Projection.left x.2)) :=
    (partrec_codedNormal A M p B hf).comp
    (Computable.fst.pair ((Projection.primrec_left (A:=X T Γ Q) (B:=PartialAffine.Letter)).to_comp.comp Computable.snd))
  exact (hh.map (primrec_combine.to_comp.comp
    (Computable.snd.pair (PartialAffine.computable_testedClass.comp
      (Projection.primrec_right.to_comp.comp (Computable.snd.comp Computable.fst))))).to₂).to₂

noncomputable def letters (n : ℕ) : List (Y T Γ Q) :=
  (ParameterCode.letters (T:=T) (Γ:=Γ) (Q:=Q) n).map Sum.inl ++
    (Static.letters PartialAffine.Letter).map Sum.inr

omit [DecidableEq T] [DecidableEq Γ] [DecidableEq Q] [Primcodable T] [Primcodable Γ] in
 theorem primrec_letters : Primrec (letters (T:=T) (Γ:=Γ) (Q:=Q)) :=
  Primrec.list_append.comp (Primrec.list_map ParameterCode.primrec_letters
    (Primrec.sumInl.comp Primrec.snd).to₂) (Primrec.const _)

omit [Primcodable T] [Primcodable Γ] in
 theorem family_mem {f : ℕ × List T → Part (List T)} {n : ℕ} {w : List (Y T Γ Q)}
    {o : List (X T Γ Q)} (ho : o∈codedNormal A M p B f (n,Projection.left w)) :
    combine (o,PartialAffine.testedClass (Projection.right w))∈family A M p B f n w :=
  Part.mem_map _ ho

end Tested
end FiniteAlgebraicEnvelopes.Bootstrap

namespace FiniteAlgebraicEnvelopes.Bootstrap.Uniform

section
variable {A B S : Type*} [DecidableEq A]

def tail (a c : S) (ls : List A) (x : A) : List S :=
  List.replicate (ls.idxOf x) a ++ c :: List.replicate (ls.length+1-ls.idxOf x) a

def encode (b a c : S) (ls : List A) (w : List A) : List S :=
  w.flatMap (fun x => b :: tail a c ls x)

 theorem tail_length (a c : S) (ls : List A) (x : A) :
    (tail a c ls x).length=ls.length+2 := by
  have h := List.idxOf_le_length (a := x) (l := ls)
  simp only [tail,List.length_append,List.length_replicate,List.length_cons]
  omega

 theorem code_length (b a c : S) (ls : List A) (w : List A) :
    (encode b a c ls w).length=(ls.length+3)*w.length := by
  induction w with
  | nil => simp [encode]
  | cons x w ih =>
    simp only [encode,List.flatMap_cons,List.length_append,List.length_cons,tail_length] at *
    simp only [Nat.mul_add, Nat.mul_one]
    omega

/-- A genuine block code on any finite alphabet injected into the displayed
support. No choice of an enumeration at the parameter is used. -/
def localCode [DecidableEq S] (b a c : S) (hba : b≠a) (hbc : b≠c) (hac : a≠c)
    (ls : List A) (i : B → A) (hi : Function.Injective i) (hm : ∀ x,i x∈ls) : BlockCode B S where
  marker := b
  tail x := tail a c ls (i x)
  width := ls.length+2
  tail_length x := tail_length a c ls (i x)
  tail_avoids x := by simp [tail,hba,hbc]
  injective := by
    intro x y he
    apply hi
    apply (List.idxOf_inj (hm x)).mp
    have he' : binaryTail a c ls.length ⟨ls.idxOf (i x),List.idxOf_lt_length_of_mem (hm x)⟩ =
        binaryTail a c ls.length ⟨ls.idxOf (i y),List.idxOf_lt_length_of_mem (hm y)⟩ := he
    exact congrArg Fin.val (binaryTail_injective hac ls.length he')

 theorem localCode_encode [DecidableEq S] (b a c : S) (hba : b≠a) (hbc : b≠c) (hac : a≠c)
    (ls : List A) (i : B → A) (hi : Function.Injective i) (hm : ∀ x,i x∈ls) (w : List B) :
    (localCode b a c hba hbc hac ls i hi hm).encode w=encode b a c ls (w.map i) := by
  simp only [BlockCode.encode,localCode,encode,List.flatMap_map]
  rfl

variable [Primcodable A] [Primcodable S]
 theorem primrec_tail (a c : S) : Primrec₂ (tail a c (A := A)) := by
  have hi : Primrec (fun p : List A × A => p.1.idxOf p.2) :=
    Primrec.list_idxOf.comp Primrec.snd Primrec.fst
  exact (Primrec.list_append.comp ((Selectors.primrec_replicate a).comp hi)
    (Primrec.list_cons.comp (Primrec.const c) ((Selectors.primrec_replicate a).comp
      (Primrec.nat_sub.comp (Primrec.succ.comp (Primrec.list_length.comp Primrec.fst)) hi)))).to₂

 theorem primrec_encode (b a c : S) : Primrec₂ (encode b a c (A := A)) := by
  exact (Primrec.list_flatMap Primrec.snd
    (Primrec.list_cons.comp (Primrec.const b)
      ((primrec_tail a c).comp (Primrec.fst.comp Primrec.fst) Primrec.snd)).to₂).to₂

end

section
variable {P A S Q : Type*} [DecidableEq A] [DecidableEq S] [DecidableEq Q]

def pickStep (lt : List A → List A → Bool) (q : Option Q) (best : List A)
    (v : List A × Option Q) : List A :=
  if v.2=q ∧ lt v.1 best=true then v.1 else best

def pick (lt : List A → List A → Bool) (ps : List (List A × Option Q))
    (w : List A) (q : Option Q) : List A := ps.foldl (pickStep lt q) w

def output (code : List A → List S) (lt : List A → List A → Bool) (z : S)
    (ps : List (List A × Option Q)) (v : List A × Option Q) : List S :=
  if v.2=none then [z] else code (pick lt ps v.1 v.2)

def table (code : List A → List S) (lt : List A → List A → Bool) (z : S)
    (ps : List (List A × Option Q)) : List (List S × List S) :=
  ps.flatMap fun v => if v.1≠[] ∧ output code lt z ps v≠code v.1 then
    [(code v.1,output code lt z ps v)] else []

def compute (ls : List A) (code : List A → List S) (lt : List A → List A → Bool)
    (z : S) (f : List A → Part (Option Q)) (n : ℕ) : Part (List (List S × List S)) :=
  (Effect.traverse (fun w => (f w).map (w,·)) (words ls n)).map (table code lt z)

section Computability
variable [Primcodable P] [Primcodable A] [Primcodable S] [Primcodable Q]
  (code : P → List A → List S) (lt : P → List A → List A → Bool) (z : S)
  (hc : Primrec₂ code) (hl : Primrec (fun x : P × List A × List A => lt x.1 x.2.1 x.2.2))
variable {X : Type*} [Primcodable X]

omit [DecidableEq A] in
include hl in
 theorem primrec_pickStep {p : X → P} {q : X → Option Q} {best : X → List A}
    {v : X → List A × Option Q} (hp : Primrec p) (hq : Primrec q)
    (hb : Primrec best) (hv : Primrec v) :
    Primrec (fun x => pickStep (lt (p x)) (q x) (best x) (v x)) :=
  Primrec.ite ((Primrec.eq.comp (Primrec.snd.comp hv) hq).and
    (Primrec.eq.comp (hl.comp (hp.pair ((Primrec.fst.comp hv).pair hb))) (Primrec.const true)))
    (Primrec.fst.comp hv) hb

omit [DecidableEq A] in
include hl in
 theorem primrec_pick {p : X → P} {q : X → Option Q} {w : X → List A}
    {ps : X → List (List A × Option Q)} (hp : Primrec p) (hq : Primrec q)
    (hw : Primrec w) (hps : Primrec ps) :
    Primrec (fun x => pick (lt (p x)) (ps x) (w x) (q x)) :=
  Primrec.list_foldl hps hw (primrec_pickStep lt hl (hp.comp Primrec.fst)
    (hq.comp Primrec.fst) (Primrec.fst.comp Primrec.snd) (Primrec.snd.comp Primrec.snd)).to₂

omit [DecidableEq A] [DecidableEq S] in
include hc hl in
 theorem primrec_output : Primrec (fun x : P × List (List A × Option Q) × (List A × Option Q) =>
    output (code x.1) (lt x.1) z x.2.1 x.2.2) := by
  have hv : Primrec (fun x : P × List (List A × Option Q) × (List A × Option Q) => x.2.2) :=
    Primrec.snd.comp Primrec.snd
  exact Primrec.ite (Primrec.eq.comp (Primrec.snd.comp hv) (Primrec.const none))
    (Primrec.const [z]) (hc.comp Primrec.fst (primrec_pick lt hl Primrec.fst
      (Primrec.snd.comp hv) (Primrec.fst.comp hv) (Primrec.fst.comp Primrec.snd)))

omit [DecidableEq A] in
include hc hl in
 theorem primrec_table : Primrec (fun x : P × List (List A × Option Q) => table (code x.1) (lt x.1) z x.2) := by
  apply Primrec.list_flatMap Primrec.snd
  have hp : Primrec (fun x : (P × List (List A × Option Q)) × (List A × Option Q) => x.1.1) :=
    Primrec.fst.comp Primrec.fst
  have hout := (primrec_output code lt z hc hl).comp
    (hp.pair ((Primrec.snd.comp Primrec.fst).pair Primrec.snd))
  have hcode := hc.comp hp (Primrec.fst.comp Primrec.snd)
  exact (Primrec.ite ((Primrec.eq.comp (Primrec.fst.comp Primrec.snd) (Primrec.const [])).not.and
    (Primrec.eq.comp hout hcode).not)
    (Primrec.list_cons.comp (hcode.pair hout) (Primrec.const [])) (Primrec.const [])).to₂

omit [DecidableEq A] in
include hc hl in
 theorem partrec_compute {ls : P → List A} (hs : Primrec ls)
    {f : P → List A → Part (Option Q)} (hf : Partrec₂ f) :
    Partrec₂ (fun p => compute (ls p) (code p) (lt p) z (f p)) := by
  have hp : Partrec₂ (fun p w => (f p w).map (w,·)) :=
    (hf.map ((Computable.snd.comp Computable.fst).pair Computable.snd).to₂).to₂
  have hw : Primrec (fun x : P × ℕ => words (ls x.1) x.2) :=
    Uniform.primrec_words.comp (hs.comp Primrec.fst) Primrec.snd
  exact (((Effect.partrec_traverse_parameter hp).comp Computable.fst hw.to_comp).map
    ((primrec_table code lt z hc hl).to_comp.comp
      ((Computable.fst.comp Computable.fst).pair Computable.snd)).to₂).to₂
end Computability

omit [DecidableEq A] in
 theorem compute_specialize [Fintype A] {r : A → A → Prop} [DecidableRel (List.Shortlex r)]
    (C : BlockCode A S) (z : S) (f : List A → Part (Option Q)) (n : ℕ) :
    compute (Static.letters A) C.encode (fun u v => decide (List.Shortlex r u v)) z f n =
      Search.compute (r := r) C z f n := by
  have hp : pickStep (Q := Q) (fun u v => decide (List.Shortlex r u v))=Canonical.pickStep (r := r) := by
    funext q w v
    simp only [pickStep,Canonical.pickStep,decide_eq_true_eq]
  have ht : table (Q := Q) C.encode (fun u v => decide (List.Shortlex r u v)) z = Search.table (r := r) C z := by
    funext ps
    simp only [table,Search.table,output,Search.output,pick,Canonical.pick,hp]
    rfl
  simp only [compute,words_specialize,Search.compute,ht]

end

variable {P S A B Q R : Type*} [Primcodable S] [Fintype S]
  [DecidableEq S] [DecidableEq A] [DecidableEq B] [DecidableEq Q] [DecidableEq R]

noncomputable def bases (z : S) (ls : List A) (ms : List B)
    (code : List A → List S) (code' : List B → List S)
    (lt : List A → List A → Bool) (lt' : List B → List B → Bool)
    (d e : ℕ) (f : List A → Part (Option Q)) (g : List B → Part (Option R)) (n : ℕ) :
    Part (List (List S × List S)) :=
  (compute ls code lt z f (n/d)).bind fun rc =>
    (compute ms code' lt' z g (n/e)).map fun rd => Base.absorption z ++ rc ++ rd

noncomputable def tables (a : Selectors.Markers S) (ls : List A) (ms : List B)
    (code : List A → List S) (code' : List B → List S)
    (lt : List A → List A → Bool) (lt' : List B → List B → Bool)
    (d e : ℕ) (f : List A → Part (Option Q)) (g : List B → Part (Option R)) (n : ℕ) :
    Part (List (List S × List S)) :=
  (bases a.zero ls ms code code' lt lt' d e f g n).map fun b =>
    Selectors.process (a:=a) b (Selectors.stages a.zero) n n

section Computability
variable [Primcodable P] [Primcodable A] [Primcodable B] [Primcodable Q] [Primcodable R]
variable (a : Selectors.Markers S) (ls : P → List A) (ms : P → List B)
    (code : P → List A → List S) (code' : P → List B → List S)
    (lt : P → List A → List A → Bool) (lt' : P → List B → List B → Bool)
    (d e : P → ℕ) (f : P → List A → Part (Option Q)) (g : P → List B → Part (Option R))
variable (hls : Primrec ls) (hms : Primrec ms) (hc : Primrec₂ code) (hc' : Primrec₂ code')
    (hlt : Primrec (fun x : P × List A × List A => lt x.1 x.2.1 x.2.2))
    (hlt' : Primrec (fun x : P × List B × List B => lt' x.1 x.2.1 x.2.2))
    (hd : Primrec d) (he : Primrec e) (hf : Partrec₂ f) (hg : Partrec₂ g)
include hls hms hc hc' hlt hlt' hd he hf hg in
omit [DecidableEq A] [DecidableEq B] in
 theorem partrec_bases : Partrec₂ (fun p => bases a.zero (ls p) (ms p) (code p) (code' p)
    (lt p) (lt' p) (d p) (e p) (f p) (g p)) := by
  have h1 : Partrec (fun x : P × ℕ => compute (ls x.1) (code x.1) (lt x.1) a.zero (f x.1) (x.2/d x.1)) :=
    (partrec_compute code lt a.zero hc hlt hls hf).comp Computable.fst
      (Primrec.nat_div.to_comp.comp Computable.snd (hd.to_comp.comp Computable.fst))
  have h2 : Partrec (fun x : (P × ℕ) × List (List S × List S) =>
        compute (ms x.1.1) (code' x.1.1) (lt' x.1.1) a.zero (g x.1.1) (x.1.2/e x.1.1)) :=
    (partrec_compute code' lt' a.zero hc' hlt' hms hg).comp (Computable.fst.comp Computable.fst)
      (Primrec.nat_div.to_comp.comp (Computable.snd.comp Computable.fst)
        (he.to_comp.comp (Computable.fst.comp Computable.fst)))
  exact (h1.bind (h2.map (Primrec.list_append.to_comp.comp
    (Primrec.list_append.to_comp.comp (Computable.const (Base.absorption a.zero))
      (Computable.snd.comp Computable.fst)) Computable.snd).to₂).to₂).to₂

include hls hms hc hc' hlt hlt' hd he hf hg in
omit [DecidableEq A] [DecidableEq B] in
 theorem partrec_tables : Partrec₂ (fun p => tables a (ls p) (ms p) (code p) (code' p)
    (lt p) (lt' p) (d p) (e p) (f p) (g p)) := by
  have hb := partrec_bases a ls ms code code' lt lt' d e f g hls hms hc hc' hlt hlt' hd he hf hg
  exact (hb.map ((Selectors.primrec_process a _ (Selectors.primrec_stages a.zero)).to_comp.comp
    (Computable.snd.pair (Computable.snd.comp Computable.fst))
    (Computable.snd.comp Computable.fst)).to₂).to₂
end Computability

omit [DecidableEq A] [DecidableEq B] in
 theorem tables_specialize [Fintype A] [Fintype B]
    {r : A → A → Prop} {s : B → B → Prop} [DecidableRel (List.Shortlex r)] [DecidableRel (List.Shortlex s)]
    (a : Selectors.Markers S) (C : BlockCode A S) (D : BlockCode B S)
    (f : List A → Part (Option Q)) (g : List B → Part (Option R)) (n : ℕ) :
    tables a (Static.letters A) (Static.letters B) C.encode D.encode
      (fun u v => decide (List.Shortlex r u v)) (fun u v => decide (List.Shortlex s u v))
      (C.width+1) (D.width+1) f g n=Build.tables (r:=r) (s:=s) a C D f g n := by
  simp only [tables,bases,Build.tables,Build.bases,compute_specialize]

end FiniteAlgebraicEnvelopes.Bootstrap.Uniform

namespace FiniteAlgebraicEnvelopes.Bootstrap.LexBinary
variable {A B S : Type*}

/-- Binary tails in their literal lexicographic order, with `a` before `c`. -/
def words (a c : S) : ℕ → List (List S)
  | 0 => [[]]
  | n+1 => (words a c n).map (a::·) ++ (words a c n).map (c::·)

 theorem length_words (a c : S) (n : ℕ) : (words a c n).length=2^n := by
  induction n with
  | zero => rfl
  | succ n ih => simp [words,ih,pow_succ,Nat.mul_two]

 theorem mem_length {a c : S} {n : ℕ} {w : List S} (h : w∈words a c n) : w.length=n := by
  induction n generalizing w with
  | zero => simpa [words] using h
  | succ n ih =>
    simp only [words,List.mem_append,List.mem_map] at h
    rcases h with ⟨u,hu,rfl⟩ | ⟨u,hu,rfl⟩ <;> simp [ih hu]

 theorem mem_letters {a c s : S} {n : ℕ} {w : List S} (h : w∈words a c n) (hs : s∈w) : s=a ∨ s=c := by
  induction n generalizing w with
  | zero => simp [words] at h; subst w; cases hs
  | succ n ih =>
    simp only [words,List.mem_append,List.mem_map] at h
    rcases h with ⟨u,hu,rfl⟩ | ⟨u,hu,rfl⟩
    · rcases List.mem_cons.mp hs with rfl | hs
      · exact Or.inl rfl
      · exact ih hu hs
    · rcases List.mem_cons.mp hs with rfl | hs
      · exact Or.inr rfl
      · exact ih hu hs

 theorem nodup {a c : S} (hac : a≠c) (n : ℕ) : (words a c n).Nodup := by
  induction n with
  | zero => simp [words]
  | succ n ih =>
    rw [words,List.nodup_append]
    refine ⟨ih.map (by intro u v h; exact (List.cons.inj h).2),
      ih.map (by intro u v h; exact (List.cons.inj h).2),?_⟩
    intro u hu v hv he
    obtain ⟨x,_,rfl⟩ := List.mem_map.mp hu
    obtain ⟨y,_,rfl⟩ := List.mem_map.mp hv
    exact hac (List.cons.inj he).1

 theorem ordered {r : S → S → Prop} {a c : S} (hac : r a c) (n : ℕ) :
    (words a c n).Pairwise (List.Lex r) := by
  induction n with
  | zero => simp [words]
  | succ n ih =>
    rw [words,List.pairwise_append]
    refine ⟨?_,?_,?_⟩
    · rw [List.pairwise_map]; exact ih.imp (fun h => List.Lex.cons h)
    · rw [List.pairwise_map]; exact ih.imp (fun h => List.Lex.cons h)
    · intro u hu v hv
      obtain ⟨x,_,rfl⟩ := List.mem_map.mp hu
      obtain ⟨y,_,rfl⟩ := List.mem_map.mp hv
      exact List.Lex.rel hac

variable [DecidableEq A]
def tail (a c : S) (d : ℕ) (ls : List A) (x : A) : List S :=
  (words a c d).getD (ls.idxOf x) []

def encode (b a c : S) (d : ℕ) (ls : List A) (w : List A) : List S :=
  w.flatMap (fun x => b :: tail a c d ls x)

 theorem index_bound {firstSymbol secondSymbol : S} (d : ℕ) (ls : List A)
    (hls : ls.length≤2^d) {x : A} (hx : x∈ls) :
    ls.idxOf x < (words firstSymbol secondSymbol d).length := by
  rw [length_words]
  exact (List.idxOf_lt_length_of_mem hx).trans_le hls

variable [DecidableEq S]
def code (b a c : S) (hba : b≠a) (hbc : b≠c) (hac : a≠c)
    (d : ℕ) (ls : List A) (hls : ls.length≤2^d)
    (i : B → A) (hi : Function.Injective i) (hm : ∀ x,i x∈ls) : BlockCode B S where
  marker := b
  tail x := tail a c d ls (i x)
  width := d
  tail_length x := by
    rw [tail,List.getD_eq_getElem _ _ (index_bound d ls hls (hm x))]
    exact mem_length (List.getElem_mem _)
  tail_avoids x := by
    rw [tail,List.getD_eq_getElem _ _ (index_bound d ls hls (hm x))]
    intro hb
    rcases mem_letters (List.getElem_mem _) hb with h | h
    · exact hba h
    · exact hbc h
  injective := by
    intro x y h
    apply hi
    apply (List.idxOf_inj (hm x)).mp
    simp only [tail] at h
    rw [List.getD_eq_getElem _ _ (index_bound d ls hls (hm x)),
      List.getD_eq_getElem _ _ (index_bound d ls hls (hm y))] at h
    exact (nodup hac d).getElem_inj_iff.mp h

omit [DecidableEq S] in
 theorem code_encode (b a c : S) (hba : b≠a) (hbc : b≠c) (hac : a≠c)
    (d : ℕ) (ls : List A) (hls : ls.length≤2^d)
    (i : B → A) (hi : Function.Injective i) (hm : ∀ x,i x∈ls) (w : List B) :
    (code b a c hba hbc hac d ls hls i hi hm).encode w=encode b a c d ls (w.map i) := by
  simp only [BlockCode.encode,code,encode,List.flatMap_map]
  rfl

omit [DecidableEq S] in
 theorem code_order {r : S → S → Prop} (b a c : S) (hba : b≠a) (hbc : b≠c) (hac : a≠c)
    (hr : r a c) (d : ℕ) (ls : List A) (hls : ls.length≤2^d)
    (i : B → A) (hi : Function.Injective i) (hm : ∀ x,i x∈ls) {x y : B}
    (hxy : ls.idxOf (i x)<ls.idxOf (i y)) :
    List.Lex r ((code b a c hba hbc hac d ls hls i hi hm).block x)
      ((code b a c hba hbc hac d ls hls i hi hm).block y) := by
  apply List.Lex.cons
  change List.Lex r (tail a c d ls (i x)) (tail a c d ls (i y))
  rw [tail,tail,List.getD_eq_get _ _ ⟨_,index_bound d ls hls (hm x)⟩,
    List.getD_eq_get _ _ ⟨_,index_bound d ls hls (hm y)⟩]
  exact (ordered hr d).rel_get_of_lt (a := ⟨_,index_bound d ls hls (hm x)⟩)
    (b := ⟨_,index_bound d ls hls (hm y)⟩) hxy

omit [DecidableEq S]
variable [Primcodable A] [Primcodable S]
 theorem primrec_words (a c : S) : Primrec (words a c) := by
  have h (z : S) : Primrec (fun x : ℕ × List (List S) => x.2.map (z::·)) :=
    Primrec.list_map Primrec.snd (Primrec.list_cons.comp (Primrec.const z) Primrec.snd).to₂
  exact (Primrec.nat_rec₁ [[]] (Primrec.list_append.comp (h a) (h c)).to₂).of_eq (by
    intro n; induction n <;> simp_all [words])

 theorem primrec_tail (a c : S) : Primrec (fun x : ℕ × List A × A => tail a c x.1 x.2.1 x.2.2) :=
  (Primrec.list_getD []).comp ((primrec_words a c).comp Primrec.fst)
    (Primrec.list_idxOf.comp (Primrec.snd.comp Primrec.snd) (Primrec.fst.comp Primrec.snd))

 theorem primrec_encode (b a c : S) : Primrec (fun x : ℕ × List A × List A => encode b a c x.1 x.2.1 x.2.2) := by
  exact Primrec.list_flatMap (Primrec.snd.comp Primrec.snd)
    (Primrec.list_cons.comp (Primrec.const b) ((primrec_tail a c).comp
      ((Primrec.fst.comp Primrec.fst).pair ((Primrec.fst.comp (Primrec.snd.comp Primrec.fst)).pair Primrec.snd)))).to₂

end FiniteAlgebraicEnvelopes.Bootstrap.LexBinary

namespace FiniteAlgebraicEnvelopes.Bootstrap.Rank
variable {P A B C : Type*} [DecidableEq A]

def word (ls : List A) (w : List A) : List ℕ := w.map ls.idxOf

noncomputable def less (ls : List A) (u v : List A) : Bool := by
  classical
  exact decide (List.Shortlex (fun a b : ℕ => a < b) (word ls u) (word ls v))

 theorem lex_map_iff {f : B → C} (hf : Function.Injective f) {r : C → C → Prop} (u v : List B) :
    List.Lex r (u.map f) (v.map f) ↔ List.Lex (fun a b => r (f a) (f b)) u v := by
  induction u generalizing v with
  | nil => cases v <;> simp
  | cons a u ih => cases v with
    | nil => simp
    | cons b v => simp only [List.map_cons,List.cons_lex_cons_iff,hf.eq_iff,ih]

 theorem shortlex_map_iff {f : B → C} (hf : Function.Injective f) {r : C → C → Prop} (u v : List B) :
    List.Shortlex r (u.map f) (v.map f) ↔ List.Shortlex (fun a b => r (f a) (f b)) u v := by
  simp only [List.shortlex_def,List.length_map,lex_map_iff hf]

 theorem index_injective (ls : List A) (i : B → A) (hi : Function.Injective i) (hm : ∀ b,i b∈ls) :
    Function.Injective (fun b => ls.idxOf (i b)) := by
  intro x y h
  exact hi ((List.idxOf_inj (hm x)).mp h)

 theorem less_map (ls : List A) (i : B → A) (hi : Function.Injective i) (hm : ∀ b,i b∈ls)
    (u v : List B) : less ls (u.map i) (v.map i)=true ↔
      List.Shortlex (fun a b => ls.idxOf (i a)<ls.idxOf (i b)) u v := by
  classical
  simp only [less,word,List.map_map,decide_eq_true_eq]
  exact shortlex_map_iff (index_injective ls i hi hm) u v

variable [Primcodable P] [Primcodable A]

 theorem primrec_word : Primrec₂ (word (A:=A)) :=
  Primrec.list_map Primrec.snd (Primrec.list_idxOf.comp Primrec.snd (Primrec.fst.comp Primrec.fst)).to₂

 theorem primrec_less (ls : P → List A) (hls : Primrec ls) :
    Primrec (fun x : P × List A × List A => less (ls x.1) x.2.1 x.2.2) := by
  classical
  exact (Search.primrec_shortlex Primrec.nat_lt).decide.comp
    (primrec_word.comp (hls.comp Primrec.fst) (Primrec.fst.comp Primrec.snd))
    (primrec_word.comp (hls.comp Primrec.fst) (Primrec.snd.comp Primrec.snd))

end FiniteAlgebraicEnvelopes.Bootstrap.Rank

namespace FiniteAlgebraicEnvelopes.MachineRealization.UniversalMachine
open Compiler.Simulator OneSided ParameterMachine
variable {S Γ Q : Type*} [DecidableEq Γ]

/-- Forget the parameter delimiter as an input/output letter. Work symbols and
    transitions are not changed. -/
def restrict (A : Alphabet (S ⊕ Unit) Γ) : Alphabet S Γ where
  blank := A.blank
  input s := A.input (.inl s)
  output g := (A.output g).bind fun a => match a with | .inl s => some s | .inr _ => none
  output_input s := by simp [A.output_input]
  output_blank := by simp [A.output_blank]

omit [DecidableEq Γ] in
 theorem restrict_decode (A : Alphabet (S ⊕ Unit) Γ)
    (hA : ∀ g a, A.output g=some a → g=A.input a) :
    ∀ g a, (restrict A).output g=some a → g=(restrict A).input a := by
  intro g a h
  obtain ⟨b,hb,hba⟩ := Option.bind_eq_some_iff.mp h
  cases b with
  | inr u => cases hba
  | inl s => cases hba; exact hA _ _ hb

omit [DecidableEq Γ] in
 theorem restrict_content (A : Alphabet (S ⊕ Unit) Γ) (w : List S) :
    content (restrict A) w=content A (w.map Sum.inl) := by
  simp only [content,List.map_map,Function.comp_def,restrict]
  rfl

omit [DecidableEq Γ] in
 theorem restrict_realizes (A : Alphabet (S ⊕ Unit) Γ) (M : Machine Q Γ)
    {f : List S → Part (List S)} {g : List (S ⊕ Unit) → Part (List (S ⊕ Unit))}
    (hM : Compiler.Word.Realizes A M g)
    (hg : ∀ w, g (w.map Sum.inl)=(f w).map (List.map Sum.inl)) :
    Compiler.Word.Realizes (restrict A) M f := by
  intro w out
  have hi : (List.map Sum.inl : List S → List (S ⊕ Unit)) out ∈ g (w.map Sum.inl) ↔ out ∈ f w := by
    rw [hg]
    constructor
    · intro h
      obtain ⟨y,hy,he⟩ := (Part.mem_map_iff _).mp h
      have hyout : y=out := List.map_injective_iff.mpr Sum.inl_injective he
      exact hyout ▸ hy
    · exact Part.mem_map _
  rw [←hi,hM,returns_iff A M,returns_iff (restrict A) M,restrict_content]
  simp only [List.map_map,Function.comp_def,restrict]

def letters (w : List (S ⊕ Unit)) : List S :=
  w.filterMap fun a => match a with | .inl s => some s | .inr _ => none

def parameter (w : List (S ⊕ Unit)) : ℕ :=
  (w.filterMap fun a => match a with | .inl _ => none | .inr _ => some ()).length - 1

 theorem letters_input (w : List S) (n : ℕ) :
    letters (w.map Sum.inl ++ List.replicate (n+1) (.inr ()))=w := by
  simp [letters,List.filterMap_map]

 theorem parameter_input (w : List S) (n : ℕ) :
    parameter (w.map Sum.inl ++ List.replicate (n+1) (.inr ()))=n := by
  simp [parameter,List.filterMap_map]

variable [Primcodable S]

 theorem primrec_letters : Primrec (letters (S := S)) := by
  have h : Primrec (fun a : S ⊕ Unit => match a with | .inl s => some s | .inr _ => none) :=
    (Primrec.sumCasesOn Primrec.id (Primrec.option_some.comp Primrec.snd).to₂ (Primrec.const none).to₂).of_eq
      (fun a => by cases a <;> rfl)
  exact Primrec.listFilterMap Primrec.id (h.comp Primrec.snd).to₂

 theorem primrec_parameter : Primrec (parameter (S := S)) := by
  have h : Primrec (fun a : S ⊕ Unit => match a with | .inl _ => none | .inr _ => some ()) :=
    (Primrec.sumCasesOn Primrec.id (Primrec.const none).to₂ (Primrec.const (some ())).to₂).of_eq
      (fun a => by cases a <;> rfl)
  exact Primrec.nat_sub.comp (Primrec.list_length.comp
    (Primrec.listFilterMap Primrec.id (h.comp Primrec.snd).to₂)) (Primrec.const 1)

def universal (f : ℕ → List S → Part (List S)) (w : List (S ⊕ Unit)) :
    Part (List (S ⊕ Unit)) := (f (parameter w) (letters w)).map (List.map Sum.inl)

omit [Primcodable S] in
 theorem universal_input (f : ℕ → List S → Part (List S)) (w : List S) (n : ℕ) :
    universal f (w.map Sum.inl ++ List.replicate (n+1) (.inr ()))=
      (f n w).map (List.map Sum.inl) := by
  rw [universal,parameter_input,letters_input]

 theorem partrec_universal {f : ℕ → List S → Part (List S)} (hf : Partrec₂ f) :
    Partrec (universal f) :=
  (hf.comp primrec_parameter.to_comp primrec_letters.to_comp).map
    ((Primrec.list_map Primrec.id (Primrec.sumInl.comp Primrec.snd).to₂).to_comp.comp Computable.snd).to₂

/-- The alphabet and all non-initializer control are now fixed once for the whole
    partial-recursive family. The only variable finite control is the explicit
    unary counter `Fin (n+2)`, not a choice of an evaluator for each index. -/
theorem exists_parameter_machine {S : Type} [Fintype S] [Primcodable S]
    {f : ℕ → List S → Part (List S)} (hf : Partrec₂ f) :
    ∃ (Γ Q : Type) (_ : Fintype Γ) (_ : Fintype Q) (_ : DecidableEq Γ)
      (A : Alphabet (S ⊕ Unit) Γ) (M : Machine Q Γ),
      (∀ g a, A.output g=some a → g=A.input a) ∧
      ∀ n, Compiler.Word.Realizes (restrict (alphabet A)) (machine A M (.inr ()) n) (f n) := by
  classical
  obtain ⟨Γ,Q,hΓ,hQ,A,M,hA,hM⟩ := WordEvaluator.exists_machine (partrec_universal hf)
  let : Fintype Γ := hΓ
  let : Fintype Q := hQ
  refine ⟨Γ,Q,hΓ,hQ,inferInstance,A,M,hA,?_⟩
  intro n
  exact restrict_realizes (alphabet A) (machine A M (.inr ()) n)
    (ParameterMachine.realizes A M (.inr ()) n hM) (fun w => universal_input f w n)

end FiniteAlgebraicEnvelopes.MachineRealization.UniversalMachine

namespace FiniteAlgebraicEnvelopes.Bootstrap.Source
open Compiler Compiler.Simulator MachineRealization
open scoped Compiler.HeadCodec

abbrev Sigma := Fin 12

def markers : Selectors.Markers Sigma := ⟨11,7,8,9,10,by decide⟩

def raw (n : ℕ) (w : List Sigma) : Part (List Sigma) :=
  WordProgramming.eval ((Encodable.decode n : Option Nat.Partrec.Code).getD .zero) w

 theorem raw_encode (c : Nat.Partrec.Code) : raw (Encodable.encode c)=WordProgramming.eval c := by
  funext w
  simp [raw]

 theorem partrec_raw : Partrec₂ raw :=
  WordProgramming.partrec_eval.comp
    (Primrec.option_getD.comp (Primrec.decode.comp Primrec.fst) (Primrec.const .zero)).to_comp Computable.snd

variable {G : Type*} [Group G] {k : ℕ} (s : Fin k → G)
variable {Γ Q : Type*} [Fintype Γ] [Fintype Q] [DecidableEq Γ] [DecidableEq Q]
  [Primcodable Γ] [Primcodable Q]
variable (A : Alphabet (Sigma ⊕ Unit) Γ) (M : Machine Q Γ)

local instance : DecidableEq (Tested.X Sigma Γ Q) := inferInstance

abbrev Y := Tested.Y Sigma Γ Q
abbrev Z (k : ℕ) := Fin k × Bool

noncomputable def yLetters (n : ℕ) : List (Y (Γ:=Γ) (Q:=Q)) := Tested.letters n
noncomputable def zLetters (k : ℕ) : List (Z k) := Static.letters (Z k)

/-- A single common width, chosen effectively only from finite alphabets. -/
noncomputable def width (k n : ℕ) : ℕ :=
  (yLetters (Γ:=Γ) (Q:=Q) n).length+(zLetters k).length+2

noncomputable def codeT (n : ℕ) : List (Y (Γ:=Γ) (Q:=Q)) → List Sigma :=
  LexBinary.encode 0 1 2 (width (Γ:=Γ) (Q:=Q) k n) (yLetters n)
noncomputable def codeG (n : ℕ) : List (Z k) → List Sigma :=
  LexBinary.encode 3 4 5 (width (Γ:=Γ) (Q:=Q) k n) (zLetters k)

noncomputable def testT (n : ℕ) : List (Y (Γ:=Γ) (Q:=Q)) → Part (Option (Tested.Class Sigma Γ Q)) :=
  Tested.family A M (.inr ()) (UniversalMachine.restrict (ParameterMachine.alphabet A))
    (fun p => raw p.1 p.2) n

noncomputable def testG (_ : ℕ) (w : List (Z k)) : Part (Option (List (Z k))) :=
  Part.some (some (WordProblem.testedClass s w))

noncomputable def tables (n : ℕ) : ℕ → Part (List (List Sigma × List Sigma)) :=
  Uniform.tables markers (yLetters n) (zLetters k) (codeT (k:=k) n) (codeG (Γ:=Γ) (Q:=Q) n)
    (Rank.less (yLetters n)) (Rank.less (zLetters k))
    (width (Γ:=Γ) (Q:=Q) k n+1) (width (Γ:=Γ) (Q:=Q) k n+1) (testT A M n) (testG s n)

omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] in
 theorem primrec_width : Primrec (width (Γ:=Γ) (Q:=Q) k) :=
  Primrec.nat_add.comp (Primrec.nat_add.comp
    (Primrec.list_length.comp Tested.primrec_letters) (Primrec.const _)) (Primrec.const 2)

omit [Primcodable Γ] in
 theorem primrec_codeT : Primrec₂ (codeT (Γ:=Γ) (Q:=Q) (k:=k)) :=
  (LexBinary.primrec_encode 0 1 2).comp
    ((primrec_width.comp Primrec.fst).pair
      ((Tested.primrec_letters.comp Primrec.fst).pair Primrec.snd))

omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] in
 theorem primrec_codeG : Primrec₂ (codeG (Γ:=Γ) (Q:=Q) (k:=k)) :=
  (LexBinary.primrec_encode 3 4 5).comp
    ((primrec_width.comp Primrec.fst).pair ((Primrec.const _).pair Primrec.snd))

 theorem partrec_testT : Partrec₂ (testT A M) :=
  Tested.partrec_family A M (.inr ()) (UniversalMachine.restrict (ParameterMachine.alphabet A)) partrec_raw

 theorem partrec_tables (h : ComputablePred (fun w : FiniteAlgebraicEnvelopes.Word k => FiniteAlgebraicEnvelopes.evalWord s w=1)) :
    Partrec₂ (tables s A M) := by
  have hg : Partrec₂ (testG s) :=
    (Primrec.option_some.to_comp.comp ((WordProblem.computable_testedClass s h).comp Computable.snd)).partrec
  exact Uniform.partrec_tables markers yLetters (fun _ => zLetters k)
    codeT (codeG (Γ:=Γ) (Q:=Q)) (fun n => Rank.less (yLetters n)) (fun _ => Rank.less (zLetters k))
    (fun n => width (Γ:=Γ) (Q:=Q) k n+1) (fun n => width (Γ:=Γ) (Q:=Q) k n+1) (testT A M) (testG s)
    Tested.primrec_letters (Primrec.const _) primrec_codeT primrec_codeG
    (Rank.primrec_less _ Tested.primrec_letters) (Rank.primrec_less _ (Primrec.const _))
    (Primrec.nat_add.comp primrec_width (Primrec.const 1))
    (Primrec.nat_add.comp primrec_width (Primrec.const 1)) (partrec_testT A M) hg

/-- Literal source fixed point. No termination or contextual correctness is
    assumed: equality here also preserves divergence of the two procedures. -/
 theorem exists_fixed_point (h : ComputablePred (fun w : FiniteAlgebraicEnvelopes.Word k => FiniteAlgebraicEnvelopes.evalWord s w=1)) :
    ∃ n,raw n=tableNormal (tables s A M n) := by
  have hh := partrec_tableNormal_parameter (partrec_tables s A M h)
  have hc : Partrec₂ (fun c : Nat.Partrec.Code => tableNormal (tables s A M (Encodable.encode c))) :=
    hh.comp (Computable.encode.comp Computable.fst) Computable.snd
  obtain ⟨c,hc⟩ := WordProgramming.fixed_point hc
  exact ⟨Encodable.encode c,(raw_encode c).trans hc⟩

end FiniteAlgebraicEnvelopes.Bootstrap.Source

namespace FiniteAlgebraicEnvelopes
namespace Effect
variable {A B C : Type*}
theorem traverse_map_output (f : A → Part B) (g : B → C) (ls : List A) :
    traverse (fun a => (f a).map g) ls = (traverse f ls).map (List.map g) := by
  induction ls with
  | nil => simp [traverse]
  | cons a ls ih =>
    simp only [traverse,ih,Part.bind_map,Part.map_bind,Part.map_map,Function.comp_def,List.map_cons]
end Effect

namespace Bootstrap.Uniform
variable {A B S Q : Type*} [DecidableEq A] [DecidableEq B] [DecidableEq S] [DecidableEq Q]
variable (i : A → B) (hi : Function.Injective i)
variable (lt : List A → List A → Bool) (lt' : List B → List B → Bool)
variable (hlt : ∀ u v,lt' (u.map i) (v.map i)=lt u v)

def answerMap (v : List A × Option Q) : List B × Option Q := (v.1.map i,v.2)

include hlt

omit [DecidableEq A] [DecidableEq B] in
 theorem pickStep_map (q : Option Q) (w : List A) (v : List A × Option Q) :
    pickStep lt' q (w.map i) (answerMap i v)=(pickStep lt q w v).map i := by
  simp only [pickStep,answerMap,hlt]
  split <;> rfl

omit [DecidableEq A] [DecidableEq B] in
 theorem pick_map (ps : List (List A × Option Q)) (w : List A) (q : Option Q) :
    pick lt' (ps.map (answerMap i)) (w.map i) q=(pick lt ps w q).map i := by
  unfold pick
  induction ps generalizing w with
  | nil => rfl
  | cons p ps ih =>
    simp only [List.map_cons,List.foldl_cons,pickStep_map i lt lt' hlt,ih]

omit [DecidableEq A] [DecidableEq B] [DecidableEq S] in
 theorem output_map (code : List A → List S) (code' : List B → List S)
    (hc : ∀ w,code' (w.map i)=code w) (z : S) (ps : List (List A × Option Q)) (v : List A × Option Q) :
    output code' lt' z (ps.map (answerMap i)) (answerMap i v)=output code lt z ps v := by
  simp only [output,answerMap,pick_map i lt lt' hlt,hc]

omit [DecidableEq A] [DecidableEq B] in
 theorem table_map (code : List A → List S) (code' : List B → List S)
    (hc : ∀ w,code' (w.map i)=code w) (z : S) (ps : List (List A × Option Q)) :
    table code' lt' z (ps.map (answerMap i))=table code lt z ps := by
  simp only [table,List.flatMap_map]
  apply List.flatMap_congr
  intro v _
  rw [output_map i lt lt' hlt code code' hc z ps v]
  simp only [answerMap,hc,ne_eq,List.map_eq_nil_iff]

omit [DecidableEq A] [DecidableEq B] in
 theorem compute_map (code : List A → List S) (code' : List B → List S)
    (hc : ∀ w,code' (w.map i)=code w) (z : S) (ls : List A)
    (f : List A → Part (Option Q)) (g : List B → Part (Option Q))
    (hf : ∀ w,g (w.map i)=f w) (n : ℕ) :
    compute (ls.map i) code' lt' z g n=compute ls code lt z f n := by
  simp only [compute,words_map,←Effect.traverse_comp,hf]
  have hh : (fun w : List A => (f w).map (fun q => (w.map i,q))) =
      (fun w => ((f w).map (w,·)).map (answerMap i)) := by
    funext w
    simp only [Part.map_map,answerMap,Function.comp_def]
  rw [hh,Effect.traverse_map_output,Part.map_map]
  congr 1
  funext ps
  exact table_map i lt lt' hlt code code' hc z ps
end Bootstrap.Uniform
end FiniteAlgebraicEnvelopes

namespace FiniteAlgebraicEnvelopes.Bootstrap.Uniform
variable {A S Q : Type*} [DecidableEq A] [DecidableEq S] [DecidableEq Q]
variable {r : A → A → Prop} [DecidableRel (List.Shortlex r)]

omit [DecidableEq A] in
 theorem pick_eq_canonical (ps : List (List A × Option Q)) (w : List A) (q : Option Q) :
    pick (fun u v => decide (List.Shortlex r u v)) ps w q=Canonical.pick (r:=r) ps w q := by
  have hh : pickStep (Q:=Q) (fun u v => decide (List.Shortlex r u v))=Canonical.pickStep (r:=r) := by
    funext q w v
    simp only [pickStep,Canonical.pickStep,decide_eq_true_eq]
  simp only [pick,Canonical.pick,hh]

variable [Fintype A] [Std.Trichotomous r] (wf : WellFounded r)
variable (C : BlockCode A S) (z : S) (q : List A → Option Q)
variable (ls : List A) (hls : ∀ a,a∈ls)
include hls

omit [DecidableEq A] [DecidableEq S] [Fintype A] in
 theorem output_full_support {n : ℕ} {w : List A} (hw : w.length≤n) :
    output C.encode (fun u v => decide (List.Shortlex r u v)) z
      ((words ls n).map fun v => (v,q v)) (w,q w)=Static.output C wf q z w := by
  have hps : ∀ p∈(words ls n).map (fun v => (v,q v)),p.2=q p.1 := by
    intro p hp
    obtain ⟨v,_,rfl⟩ := List.mem_map.mp hp
    rfl
  have hm : (Canonical.least wf q w,q w)∈(words ls n).map (fun v => (v,q v)) :=
    List.mem_map.mpr ⟨Canonical.least wf q w,(mem_words _ _ _).mpr
      ⟨(Canonical.least_length wf q w).trans hw,fun a _ => hls a⟩,
      by simp only [Canonical.least_class]⟩
  simp only [output,Static.output,pick_eq_canonical,Canonical.pick_eq_least wf q hps hm]

omit [DecidableEq A] in
 theorem table_full_support {n : ℕ} (p : List S × List S) :
    p∈table C.encode (fun u v => decide (List.Shortlex r u v)) z
      ((words ls n).map fun v => (v,q v)) ↔ p∈Static.table C wf q z n := by
  simp only [table,List.flatMap_map,List.mem_flatMap]
  constructor
  · rintro ⟨w,hw,h⟩
    have hlen := ((mem_words _ _ _).mp hw).1
    rw [output_full_support wf C z q ls hls hlen] at h
    split at h
    next hh =>
      obtain rfl := List.mem_singleton.mp h
      exact (Static.mem_table C wf q z).mpr ⟨w,hlen,hh.1,hh.2,rfl,rfl⟩
    next hh => simp at h
  · intro hp
    obtain ⟨w,hlen,hne,hout,ha,hb⟩ := (Static.mem_table C wf q z).mp hp
    refine ⟨w,(mem_words _ _ _).mpr ⟨hlen,fun a _ => hls a⟩,?_⟩
    rw [output_full_support wf C z q ls hls hlen,ite_eq_left ⟨hne,hout⟩]
    exact List.mem_singleton.mpr (Prod.ext ha hb)

omit [DecidableEq A] [Fintype A] [Std.Trichotomous r] hls in
 theorem compute_full_support {f : List A → Part (Option Q)} {n : ℕ}
    (hf : ∀ w,w.length≤n → q w∈f w) :
    table C.encode (fun u v => decide (List.Shortlex r u v)) z
      ((words ls n).map fun v => (v,q v))∈
        compute ls C.encode (fun u v => decide (List.Shortlex r u v)) z f n := by
  apply Part.mem_map
  apply Search.traverse_map
  intro w hw
  exact Part.mem_map _ (hf w ((mem_words _ _ _).mp hw).1)

omit [DecidableEq A] [Fintype A] [Std.Trichotomous r] in
 theorem compute_domain_support {f : List A → Part (Option Q)} {n : ℕ}
    (h : (compute ls C.encode (fun u v => decide (List.Shortlex r u v)) z f n).Dom) :
    ∀ w,w.length≤n → (f w).Dom := by
  obtain ⟨rs,hrs⟩ := Part.dom_iff_mem.mp h
  obtain ⟨ps,hps,_⟩ := (Part.mem_map_iff _).mp hrs
  intro w hw
  have hh := Effect.traverse_domain hps.1 w ((mem_words _ _ _).mpr ⟨hw,fun a _ => hls a⟩)
  obtain ⟨v,hv⟩ := Part.dom_iff_mem.mp hh
  obtain ⟨a,ha,_⟩ := (Part.mem_map_iff _).mp hv
  exact ha.1

omit [DecidableEq A] in
 theorem compute_members_support {f : List A → Part (Option Q)} {n : ℕ}
    {rs : List (List S × List S)}
    (hrs : rs∈compute ls C.encode (fun u v => decide (List.Shortlex r u v)) z f n)
    (p : List S × List S) :
    p∈rs ↔ p∈Static.table C wf (Search.value f) z n := by
  have ht := compute_full_support (r:=r) C z (Search.value f) ls
    (fun w hw => Search.value_mem (compute_domain_support (r:=r) C z ls hls hrs.1 w hw))
  rw [Part.mem_unique hrs ht]
  exact table_full_support wf C z (Search.value f) ls hls p

end FiniteAlgebraicEnvelopes.Bootstrap.Uniform

namespace FiniteAlgebraicEnvelopes.Bootstrap
variable {S : Type*}
def RulesEq (rs rt : List (List S × List S)) : Prop := ∀ p,p∈rs ↔ p∈rt

 theorem step_rulesEq {rs rt : List (List S × List S)} (h : RulesEq rs rt) : Step rs=Step rt := by
  funext u v
  apply propext
  constructor <;> intro hs
  · cases hs with | apply hp x y => exact Step.apply ((h _).mp hp) x y
  · cases hs with | apply hp x y => exact Step.apply ((h _).mpr hp) x y

 theorem critical_rulesEq {rs rt : List (List S × List S)} (h : RulesEq rs rt) (n : ℕ) :
    Critical rs n ↔ Critical rt n := by
  simp only [Critical,Steps,step_rulesEq h,show ∀ p,p∈rs ↔ p∈rt from h]

namespace Selectors
variable [DecidableEq S] {a : Markers S}
 theorem allowed_rulesEq {rs rt : List (List S × List S)} (h : RulesEq rs rt) (s : Stage S) :
    allowed rs s=allowed rt s := by
  apply Bool.eq_iff_iff.mpr
  simp only [allowed_iff,step_rulesEq h]

 theorem choose_rulesEq {rs rt : List (List S × List S)} (h : RulesEq rs rt) (s : Stage S) (n : ℕ) :
    RulesEq (choose (a:=a) rs s n) (choose (a:=a) rt s n) := by
  intro p
  simp only [choose,allowed_rulesEq h s]
  split
  · simpa only [List.mem_append] using or_congr (h p) (Iff.rfl : p∈rules a s.size s.bodies ↔ p∈rules a s.size s.bodies)
  · exact h p

 theorem process_rulesEq {rs rt : List (List S × List S)} (h : RulesEq rs rt)
    (ss : ℕ → Stage S) (n j : ℕ) :
    RulesEq (process (a:=a) rs ss n j) (process (a:=a) rt ss n j) := by
  induction j with
  | zero => exact h
  | succ j ih => exact choose_rulesEq ih (ss j) n
end Selectors
end FiniteAlgebraicEnvelopes.Bootstrap

namespace FiniteAlgebraicEnvelopes.Bootstrap.Uniform
variable {S A B Q R : Type*} [Primcodable S] [Fintype S] [Fintype A] [Fintype B]
  [DecidableEq S] [DecidableEq A] [DecidableEq B] [DecidableEq Q] [DecidableEq R]
variable {r : A → A → Prop} {s : B → B → Prop}
  [DecidableRel (List.Shortlex r)] [DecidableRel (List.Shortlex s)]
  [Std.Trichotomous r] [Std.Trichotomous s]
variable (a : Selectors.Markers S) (C : BlockCode A S) (D : BlockCode B S)
  (wf : WellFounded r) (wg : WellFounded s)
variable (ls : List A) (ms : List B) (hls : ∀ x,x∈ls) (hms : ∀ x,x∈ms)
variable (f : List A → Part (Option Q)) (g : List B → Part (Option R))

noncomputable def fullTables : ℕ → Part (List (List S × List S)) :=
  tables a ls ms C.encode D.encode (fun u v => decide (List.Shortlex r u v))
    (fun u v => decide (List.Shortlex s u v)) (C.width+1) (D.width+1) f g

include wf wg hls hms in
omit [DecidableEq A] [DecidableEq B] in
 theorem tables_members_support {n : ℕ} {rs : List (List S × List S)}
    (hrs : rs∈fullTables (r:=r) (s:=s) a C D ls ms f g n) :
    RulesEq rs (Selectors.process (a:=a)
      (Base.table C D wf wg (Search.value f) (Search.value g) a.zero n) (Selectors.stages a.zero) n n) := by
  obtain ⟨b,hb,rfl⟩ := (Part.mem_map_iff _).mp hrs
  obtain ⟨rc,hrc,h⟩ := Part.mem_bind_iff.mp hb
  obtain ⟨rd,hrd,rfl⟩ := (Part.mem_map_iff _).mp h
  apply Selectors.process_rulesEq
  intro p
  simp only [List.mem_append,Base.table,
    compute_members_support wf C a.zero ls hls hrc p,
    compute_members_support wg D a.zero ms hms hrd p]

omit [Fintype A] [Fintype B] [DecidableEq A] [DecidableEq B]
  [Std.Trichotomous r] [Std.Trichotomous s] in
 theorem tables_domain_support {n : ℕ}
    (hf : ∀ w,w.length≤n/(C.width+1) → (f w).Dom)
    (hg : ∀ w,w.length≤n/(D.width+1) → (g w).Dom) :
    (fullTables (r:=r) (s:=s) a C D ls ms f g n).Dom := by
  have hc := compute_full_support (r:=r) C a.zero (Search.value f) ls
    (fun w hw => Search.value_mem (hf w hw))
  have hd := compute_full_support (r:=s) D a.zero (Search.value g) ms
    (fun w hw => Search.value_mem (hg w hw))
  apply Part.dom_iff_mem.mpr
  refine ⟨_,Part.mem_map _ (Part.mem_bind_iff.mpr ⟨_,hc,Part.mem_map _ hd⟩)⟩

include wf wg hls hms in
omit [DecidableEq A] [DecidableEq B] in
 theorem stable_support {k n : ℕ} (hkn : k≤n)
    {rk rn : List (List S × List S)}
    (hk : rk∈fullTables (r:=r) (s:=s) a C D ls ms f g k)
    (hn : rn∈fullTables (r:=r) (s:=s) a C D ls ms f g n) : Selectors.BoundedEq rk rn k := by
  have he := Selectors.tables_bounded (a:=a) (stages:=Selectors.stages a.zero)
    (fun _ _ hh => Base.bounded C D wf wg (Search.value f) (Search.value g) a.zero hh)
    (fun j w hw => Selectors.body_lt_size a.zero j hw) (Selectors.index_lt_size a.zero) hkn
  intro p hp
  exact (tables_members_support a C D wf wg ls ms hls hms f g hk p).trans
    ((he p hp).trans (tables_members_support a C D wf wg ls ms hls hms f g hn p).symm)

include wf wg hls hms in
omit [DecidableEq A] [DecidableEq B] in
 theorem good_support {t : S → S → Prop} (hcw : 1<C.width+1) (hdw : 1<D.width+1)
    (hc : ∀ a b,r a b → List.Lex t (C.block a) (C.block b))
    (hd : ∀ a b,s a b → List.Lex t (D.block a) (D.block b))
    (hC : ∀ b∈[a.zero,a.d,a.l,a.r,a.h],b∉C.Alphabet)
    (hD : ∀ b∈[a.zero,a.d,a.l,a.r,a.h],b∉D.Alphabet)
    (hCD : Disjoint C.Alphabet D.Alphabet) {n : ℕ}
    (hf : ∀ w,w.length≤n/(C.width+1) → (f w).Dom)
    (hg : ∀ w,w.length≤n/(D.width+1) → (g w).Dom)
    (hf0 : Search.value f []≠none) (hg0 : Search.value g []≠none)
    (hfc : Static.Contextual (Search.value f) (n/(C.width+1)))
    (hfi : Static.ZeroIdeal (Search.value f) (n/(C.width+1)))
    (hgc : Static.Contextual (Search.value g) (n/(D.width+1)))
    (hgi : Static.ZeroIdeal (Search.value g) (n/(D.width+1))) :
    GoodTable (r:=t) (fullTables (r:=r) (s:=s) a C D ls ms f g) n := by
  obtain ⟨rt,hrt,hdt,hct⟩ := Build.good a C D wf wg f g hcw hdw hc hd hC hD hCD hf hg hf0 hg0 hfc hfi hgc hgi
  obtain ⟨rs,hrs⟩ := Part.dom_iff_mem.mp (tables_domain_support (r:=r) (s:=s) a C D ls ms f g hf hg)
  have he : RulesEq rs rt := by
    rw [Build.tables_eq a C D wf wg hrt]
    exact tables_members_support a C D wf wg ls ms hls hms f g hrs
  exact ⟨rs,hrs,fun p hp => hdt p ((he p).mp hp),(critical_rulesEq he n).mpr hct⟩

end FiniteAlgebraicEnvelopes.Bootstrap.Uniform

namespace FiniteAlgebraicEnvelopes.Bootstrap.Source
open Compiler Compiler.Simulator MachineRealization MachineRealization.ParameterCode
open scoped Compiler.HeadCodec
variable {Γ Q : Type*} [Fintype Γ] [Fintype Q] [DecidableEq Γ] [DecidableEq Q]
  [Primcodable Γ] [Primcodable Q]

abbrev FiniteY (n : ℕ) := Word.Letter Sigma (Bool×Γ) (ParameterMachine.State Q n) ⊕ PartialAffine.Letter

def includeY (n : ℕ) : FiniteY (Γ:=Γ) (Q:=Q) n → Y (Γ:=Γ) (Q:=Q) :=
  Sum.map (Word.letterMap (encode n)) id

local instance : DecidableEq (Tested.X Sigma Γ Q) := inferInstance
local instance : DecidableEq (Y (Γ:=Γ) (Q:=Q)) := inferInstance
local instance (n : ℕ) : DecidableEq (Word.Letter Sigma (Bool×Γ) (ParameterMachine.State Q n)) := inferInstance
local instance (n : ℕ) : DecidableEq (FiniteY (Γ:=Γ) (Q:=Q) n) := inferInstance

omit [Fintype Γ] [Fintype Q] [DecidableEq Γ] [DecidableEq Q]
    [Primcodable Γ] [Primcodable Q] in
 theorem includeY_injective (n : ℕ) : Function.Injective (includeY (Γ:=Γ) (Q:=Q) n) := by
  exact Sum.map_injective.mpr ⟨Word.letterMap_injective (encode n) (encode_injective n),Function.injective_id⟩

omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] [Primcodable Q] in
 theorem includeY_mem (n : ℕ) (y : FiniteY (Γ:=Γ) (Q:=Q) n) : includeY n y∈yLetters n := by
  cases y with
  | inl y =>
    apply List.mem_append_left
    exact List.mem_map.mpr ⟨_,(mem_letters_iff n _).mpr ⟨y,rfl⟩,rfl⟩
  | inr y =>
    apply List.mem_append_right
    exact List.mem_map.mpr ⟨y,(by simp [Static.letters]),rfl⟩

omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] [Primcodable Q] in
 theorem mem_includeY_range (n : ℕ) {y : Y (Γ:=Γ) (Q:=Q)} (hy : y∈yLetters n) :
    ∃ v : FiniteY (Γ:=Γ) (Q:=Q) n,includeY n v=y := by
  rcases List.mem_append.mp hy with hy | hy
  · obtain ⟨c,hc,rfl⟩ := List.mem_map.mp hy
    obtain ⟨v,rfl⟩ := (mem_letters_iff n c).mp hc
    exact ⟨.inl v,rfl⟩
  · obtain ⟨v,_,rfl⟩ := List.mem_map.mp hy
    exact ⟨.inr v,rfl⟩

 theorem list_preimage {A B : Type*} (i : A → B) (ls : List B) (h : ∀ b∈ls,∃a,i a=b) :
    ∃ks : List A,ks.map i=ls := by
  induction ls with
  | nil => exact ⟨[],rfl⟩
  | cons b ls ih =>
    obtain ⟨a,rfl⟩ := h b (by simp)
    obtain ⟨ks,rfl⟩ := ih (fun x hx => h x (by simp [hx]))
    exact ⟨a::ks,rfl⟩

noncomputable def finiteLetters (n : ℕ) : List (FiniteY (Γ:=Γ) (Q:=Q) n) :=
  (list_preimage (includeY n) (yLetters n) (fun _ h => mem_includeY_range n h)).choose

omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] [Primcodable Q] in
 theorem map_finiteLetters (n : ℕ) : (finiteLetters (Γ:=Γ) (Q:=Q) n).map (includeY n)=yLetters n :=
  (list_preimage (includeY n) (yLetters n) (fun _ h => mem_includeY_range n h)).choose_spec

omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] [Primcodable Q] in
 theorem mem_finiteLetters (n : ℕ) (y : FiniteY (Γ:=Γ) (Q:=Q) n) : y∈finiteLetters n := by
  have h := includeY_mem n y
  rw [←map_finiteLetters n] at h
  obtain ⟨v,hv,he⟩ := List.mem_map.mp h
  exact (includeY_injective n he) ▸ hv

noncomputable def rankT (n : ℕ) (y : FiniteY (Γ:=Γ) (Q:=Q) n) : ℕ := @List.idxOf _ instBEqOfDecidableEq (includeY n y) (yLetters n)
noncomputable def rankG (k : ℕ) (z : Z k) : ℕ := @List.idxOf _ instBEqOfDecidableEq z (zLetters k)

omit [Primcodable Γ] [Primcodable Q] in
 theorem rankT_injective (n : ℕ) : Function.Injective (rankT (Γ:=Γ) (Q:=Q) n) := by
  exact Rank.index_injective _ _ (includeY_injective n) (includeY_mem n)
 theorem rankG_injective (k : ℕ) : Function.Injective (rankG k) := by
  exact Rank.index_injective _ id Function.injective_id (by intro x; simp [zLetters,Static.letters])

noncomputable def relT (n : ℕ) (u v : FiniteY (Γ:=Γ) (Q:=Q) n) : Prop := rankT n u<rankT n v
noncomputable def relG (k : ℕ) (u v : Z k) : Prop := rankG k u<rankG k v

omit [Primcodable Γ] [Primcodable Q] in
 theorem wf_relT (n : ℕ) : WellFounded (relT (Γ:=Γ) (Q:=Q) n) := InvImage.wf _ Nat.lt_wfRel.wf
 theorem wf_relG (k : ℕ) : WellFounded (relG k) := InvImage.wf _ Nat.lt_wfRel.wf

instance tri_relT (n : ℕ) : Std.Trichotomous (relT (Γ:=Γ) (Q:=Q) n) := ⟨fun a b hab hba =>
  rankT_injective n (by change ¬rankT n a < rankT n b at hab; change ¬rankT n b < rankT n a at hba; omega)⟩
instance tri_relG (k : ℕ) : Std.Trichotomous (relG k) := ⟨fun a b hab hba =>
  rankG_injective k (by change ¬rankG k a < rankG k b at hab; change ¬rankG k b < rankG k a at hba; omega)⟩
noncomputable instance dec_relT (n : ℕ) : DecidableRel (relT (Γ:=Γ) (Q:=Q) n) := fun _ _ => Nat.decLt _ _
noncomputable instance dec_relG (k : ℕ) : DecidableRel (relG k) := fun _ _ => Nat.decLt _ _

noncomputable instance dec_shortlexT (n : ℕ) : DecidableRel (List.Shortlex (relT (Γ:=Γ) (Q:=Q) n)) := Classical.decRel _
noncomputable instance dec_shortlexG (k : ℕ) : DecidableRel (List.Shortlex (relG k)) := Classical.decRel _

omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] [Primcodable Q] in
 theorem widthBoundT (k n : ℕ) : (yLetters (Γ:=Γ) (Q:=Q) n).length≤2^(width (Γ:=Γ) (Q:=Q) k n) := by
  have h : width (Γ:=Γ) (Q:=Q) k n < 2^(width (Γ:=Γ) (Q:=Q) k n) := Nat.lt_two_pow_self
  unfold width at *
  omega
omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] [Primcodable Q] in
 theorem widthBoundG (k n : ℕ) : (zLetters k).length≤2^(width (Γ:=Γ) (Q:=Q) k n) := by
  have h : width (Γ:=Γ) (Q:=Q) k n < 2^(width (Γ:=Γ) (Q:=Q) k n) := Nat.lt_two_pow_self
  unfold width at *
  omega

noncomputable def finiteCodeT (k n : ℕ) : BlockCode (FiniteY (Γ:=Γ) (Q:=Q) n) Sigma :=
  LexBinary.code 0 1 2 (by decide) (by decide) (by decide) (width k n) (yLetters n)
    (widthBoundT k n) (includeY n) (includeY_injective n) (includeY_mem n)
noncomputable def finiteCodeG (k n : ℕ) : BlockCode (Z k) Sigma :=
  LexBinary.code 3 4 5 (by decide) (by decide) (by decide) (width (Γ:=Γ) (Q:=Q) k n) (zLetters k)
    (widthBoundG k n) id Function.injective_id (by intro x; simp [zLetters,Static.letters])

omit [Primcodable Γ] [Primcodable Q] in
 theorem finiteCodeT_encode (k n : ℕ) (w : List (FiniteY (Γ:=Γ) (Q:=Q) n)) :
    (finiteCodeT k n).encode w=codeT (k:=k) n (w.map (includeY n)) :=
  LexBinary.code_encode ..
omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] [Primcodable Q] in
 theorem finiteCodeG_encode (k n : ℕ) (w : List (Z k)) :
    (finiteCodeG (Γ:=Γ) (Q:=Q) k n).encode w=codeG (Γ:=Γ) (Q:=Q) n w := by
  simpa [finiteCodeG,codeG] using LexBinary.code_encode 3 4 5 (by decide) (by decide) (by decide)
    (width (Γ:=Γ) (Q:=Q) k n) (zLetters k) (widthBoundG k n) id Function.injective_id (by intro x; simp [zLetters,Static.letters]) w

omit [Primcodable Γ] [Primcodable Q] in
 theorem lessT_map (n : ℕ) (u v : List (FiniteY (Γ:=Γ) (Q:=Q) n)) :
    Rank.less (yLetters n) (u.map (includeY n)) (v.map (includeY n))=decide (List.Shortlex (relT n) u v) := by
  classical
  apply Bool.eq_iff_iff.mpr
  simp only [decide_eq_true_eq]
  change _ ↔ List.Shortlex (fun a b => @List.idxOf _ instBEqOfDecidableEq (includeY n a) (yLetters n)<@List.idxOf _ instBEqOfDecidableEq (includeY n b) (yLetters n)) u v
  exact Rank.less_map (yLetters n) (includeY n) (includeY_injective n) (includeY_mem n) u v
 theorem lessG_eq (k : ℕ) (u v : List (Z k)) :
    Rank.less (zLetters k) u v=decide (List.Shortlex (relG k) u v) := by
  classical
  apply Bool.eq_iff_iff.mpr
  simp only [decide_eq_true_eq]
  change _ ↔ List.Shortlex (fun a b => @List.idxOf _ instBEqOfDecidableEq a (zLetters k)<@List.idxOf _ instBEqOfDecidableEq b (zLetters k)) u v
  simpa using Rank.less_map (zLetters k) id Function.injective_id (by intro x; simp [zLetters,Static.letters]) u v

end FiniteAlgebraicEnvelopes.Bootstrap.Source

namespace FiniteAlgebraicEnvelopes.Bootstrap
namespace LexBinary
variable {A B S : Type*} [DecidableEq A] [DecidableEq S]
omit [DecidableEq S] in
 theorem alphabet_bound (b a c : S) (hba : b≠a) (hbc : b≠c) (hac : a≠c)
    (d : ℕ) (ls : List A) (hls : ls.length≤2^d)
    (i : B → A) (hi : Function.Injective i) (hm : ∀ x,i x∈ls) {s : S}
    (hs : s∈(code b a c hba hbc hac d ls hls i hi hm).Alphabet) : s=b ∨ s=a ∨ s=c := by
  obtain ⟨x,hx⟩ := hs
  rcases List.mem_cons.mp hx with rfl | hx
  · exact Or.inl rfl
  · right
    change s∈tail a c d ls (i x) at hx
    rw [tail,List.getD_eq_getElem _ _ (index_bound d ls hls (hm x))] at hx
    exact mem_letters (List.getElem_mem _) hx
end LexBinary

namespace Source
open Compiler Compiler.Simulator MachineRealization MachineRealization.ParameterCode
open scoped Compiler.HeadCodec
variable {Γ Q : Type*} [Fintype Γ] [Fintype Q] [DecidableEq Γ] [DecidableEq Q]
  [Primcodable Γ] [Primcodable Q]
variable {G : Type*} [Group G] {k : ℕ} (s : Fin k → G)
variable (A : Alphabet (Sigma ⊕ Unit) Γ) (M : Machine Q Γ)

local instance : DecidableEq (Tested.X Sigma Γ Q) := inferInstance
local instance : DecidableEq (Y (Γ:=Γ) (Q:=Q)) := inferInstance
local instance (n : ℕ) : DecidableEq (Word.Letter Sigma (Bool×Γ) (ParameterMachine.State Q n)) := inferInstance
local instance (n : ℕ) : DecidableEq (FiniteY (Γ:=Γ) (Q:=Q) n) := inferInstance
local instance (n : ℕ) : Fintype (Word.Letter Sigma (Bool×Γ) (ParameterMachine.State Q n)) := inferInstance

noncomputable def finiteTest (n : ℕ) (w : List (FiniteY (Γ:=Γ) (Q:=Q) n)) := testT A M n (w.map (includeY n))

noncomputable def finiteTables (n : ℕ) :=
  Uniform.fullTables (r:=relT n) (s:=relG k) markers (finiteCodeT (Γ:=Γ) (Q:=Q) k n) (finiteCodeG (Γ:=Γ) (Q:=Q) k n)
    (finiteLetters n) (zLetters k) (finiteTest A M n) (testG s n)

omit [Primcodable Γ] in
 theorem tables_eq_finite (n : ℕ) : tables s A M n=finiteTables s A M n := by
  have hT (j : ℕ) : Uniform.compute (yLetters n) (codeT (k:=k) n) (Rank.less (yLetters n)) markers.zero (testT A M n) j=
      Uniform.compute (finiteLetters n) (finiteCodeT (Γ:=Γ) (Q:=Q) k n).encode (fun u v => decide (List.Shortlex (relT n) u v))
        markers.zero (finiteTest A M n) j := by
    simpa only [map_finiteLetters] using Uniform.compute_map (includeY n) _ _ (lessT_map n) _ _ (fun w => (finiteCodeT_encode k n w).symm)
      markers.zero (finiteLetters n) (finiteTest A M n) (testT A M n) (fun _ => rfl) j
  have hG : codeG (Γ:=Γ) (Q:=Q) (k:=k) n=(finiteCodeG (Γ:=Γ) (Q:=Q) k n).encode :=
    funext (fun w => (finiteCodeG_encode k n w).symm)
  have hlG : Rank.less (zLetters k)=(fun u v => decide (List.Shortlex (relG k) u v)) :=
    funext (fun u => funext (lessG_eq k u))
  funext j
  simp only [tables,finiteTables,Uniform.fullTables,Uniform.tables,Uniform.bases,hT,hG,hlG]
  rfl

omit [Primcodable Γ] in
 theorem stable (n : ℕ) {a b : ℕ} (hab : a≤b) {ra rb : List (List Sigma × List Sigma)}
    (ha : ra∈tables s A M n a) (hb : rb∈tables s A M n b) : Selectors.BoundedEq ra rb a := by
  rw [tables_eq_finite] at ha hb
  exact Uniform.stable_support markers (finiteCodeT (Γ:=Γ) (Q:=Q) k n) (finiteCodeG (Γ:=Γ) (Q:=Q) k n) (wf_relT n) (wf_relG k)
    (finiteLetters n) (zLetters k) (mem_finiteLetters n) (by intro x; simp [zLetters,Static.letters])
    (finiteTest A M n) (testG s n) hab ha hb

omit [Primcodable Γ] [Primcodable Q] in
 theorem codeT_order (k n : ℕ) (a b : FiniteY (Γ:=Γ) (Q:=Q) n) (hab : relT n a b) :
    List.Lex (fun u v : Sigma => u<v) ((finiteCodeT (Γ:=Γ) (Q:=Q) k n).block a) ((finiteCodeT (Γ:=Γ) (Q:=Q) k n).block b) :=
  LexBinary.code_order 0 1 2 (by decide) (by decide) (by decide) (by decide) _ _ _ _ _ _ hab
omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] [Primcodable Q] in
 theorem codeG_order (k n : ℕ) (a b : Z k) (hab : relG k a b) :
    List.Lex (fun u v : Sigma => u<v) ((finiteCodeG (Γ:=Γ) (Q:=Q) k n).block a) ((finiteCodeG (Γ:=Γ) (Q:=Q) k n).block b) :=
  LexBinary.code_order 3 4 5 (by decide) (by decide) (by decide) (by decide) _ _ _ _ _ _ hab

omit [Primcodable Γ] [Primcodable Q] in
 theorem codeT_alphabet (k n : ℕ) {u : Sigma} (hu : u∈(finiteCodeT (Γ:=Γ) (Q:=Q) k n).Alphabet) :
    u=0 ∨ u=1 ∨ u=2 := by
  exact LexBinary.alphabet_bound _ _ _ _ _ _ _ _ _ _ _ _ hu
omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] [Primcodable Q] in
 theorem codeG_alphabet (k n : ℕ) {u : Sigma} (hu : u∈(finiteCodeG (Γ:=Γ) (Q:=Q) k n).Alphabet) :
    u=3 ∨ u=4 ∨ u=5 := by
  exact LexBinary.alphabet_bound _ _ _ _ _ _ _ _ _ _ _ _ hu

omit [Primcodable Γ] [Primcodable Q] in
 theorem codeT_avoid (k n : ℕ) : ∀ b∈[markers.zero,markers.d,markers.l,markers.r,markers.h],
    b∉(finiteCodeT (Γ:=Γ) (Q:=Q) k n).Alphabet := by
  intro b hb hc
  have h := codeT_alphabet k n hc
  simp [markers] at hb
  rcases hb with rfl|rfl|rfl|rfl|rfl <;> norm_num [Fin.ext_iff] at h
omit [DecidableEq Γ] [DecidableEq Q] [Primcodable Γ] [Primcodable Q] in
 theorem codeG_avoid (k n : ℕ) : ∀ b∈[markers.zero,markers.d,markers.l,markers.r,markers.h],
    b∉(finiteCodeG (Γ:=Γ) (Q:=Q) k n).Alphabet := by
  intro b hb hc
  have h := codeG_alphabet k n hc
  simp [markers] at hb
  rcases hb with rfl|rfl|rfl|rfl|rfl <;> norm_num [Fin.ext_iff] at h
omit [Primcodable Γ] [Primcodable Q] in
 theorem codes_disjoint (k n : ℕ) : Disjoint (finiteCodeT (Γ:=Γ) (Q:=Q) k n).Alphabet (finiteCodeG (Γ:=Γ) (Q:=Q) k n).Alphabet := by
  apply Set.disjoint_left.mpr
  intro b hb hc
  have h := codeT_alphabet k n hb
  have j := codeG_alphabet k n hc
  rcases h with rfl|rfl|rfl <;> norm_num [Fin.ext_iff] at j

omit [Primcodable Γ] in
 theorem good_of_tests (n j : ℕ)
    (hf : ∀ w : List (FiniteY (Γ:=Γ) (Q:=Q) n),w.length≤j/(width (Γ:=Γ) (Q:=Q) k n+1) → (finiteTest A M n w).Dom)
    (hf0 : Search.value (finiteTest A M n) []≠none)
    (hfc : Static.Contextual (Search.value (finiteTest A M n)) (j/(width (Γ:=Γ) (Q:=Q) k n+1)))
    (hfi : Static.ZeroIdeal (Search.value (finiteTest A M n)) (j/(width (Γ:=Γ) (Q:=Q) k n+1)))
    (hg0 : Search.value (testG s n) []≠none)
    (hgc : Static.Contextual (Search.value (testG s n)) (j/(width (Γ:=Γ) (Q:=Q) k n+1)))
    (hgi : Static.ZeroIdeal (Search.value (testG s n)) (j/(width (Γ:=Γ) (Q:=Q) k n+1))) :
    GoodTable (r:=fun u v : Sigma => u<v) (tables s A M n) j := by
  rw [tables_eq_finite]
  apply Uniform.good_support markers (finiteCodeT (Γ:=Γ) (Q:=Q) k n) (finiteCodeG (Γ:=Γ) (Q:=Q) k n) (wf_relT n) (wf_relG k)
    (finiteLetters n) (zLetters k) (mem_finiteLetters n) (by intro x; simp [zLetters,Static.letters])
    (finiteTest A M n) (testG s n)
  · change 1<width (Γ:=Γ) (Q:=Q) k n+1
    unfold width
    omega
  · change 1<width (Γ:=Γ) (Q:=Q) k n+1
    unfold width
    omega
  · exact codeT_order k n
  · exact codeG_order k n
  · exact codeT_avoid k n
  · exact codeG_avoid k n
  · exact codes_disjoint k n
  · exact hf
  · intro w hw; trivial
  · exact hf0
  · exact hg0
  · exact hfc
  · exact hfi
  · exact hgc
  · exact hgi

end Source
end FiniteAlgebraicEnvelopes.Bootstrap

end OAI