| import OAI.Computability.MatchingCount.LengthRoutine |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace BinaryMatching.StackCode |
| open Polynomial |
| class Coding (α : Type) where |
| encode : α → List Bool |
| export Coding (encode) |
| instance : Coding ℕ := ⟨unary⟩ |
| instance : Coding Bool := ⟨fun b => [b]⟩ |
| instance : Coding Unit := ⟨fun _ => []⟩ |
| instance {α β : Type} [Coding α] [Coding β] : Coding (α×β) := |
| ⟨fun z => pairBits (encode z.1) (encode z.2)⟩ |
| |
| def listCode {α : Type} (ea : α → List Bool) : List α → List Bool |
| | [] => [] |
| | a::l => pairBits (ea a) (listCode ea l) |
| instance {α : Type} [Coding α] : Coding (List α) := ⟨listCode encode⟩ |
| |
| @[simp] lemma encode_nat (n : ℕ) : encode n=unary n := rfl |
| @[simp] lemma encode_bool (b : Bool) : encode b=[b] := rfl |
| @[simp] lemma encode_pair {α β : Type} [Coding α] [Coding β] (a : α) (b : β) : |
| encode (a,b)=pairBits (encode a) (encode b) := rfl |
| @[simp] lemma encode_prod {α β : Type} [Coding α] [Coding β] (z : α×β) : |
| encode z=pairBits (encode z.1) (encode z.2) := rfl |
| |
| @[simp] lemma code_nil {α : Type} [Coding α] : encode ([]:List α)=[] := rfl |
| @[simp] lemma code_cons {α : Type} [Coding α] (a : α) (l : List α) : |
| encode (a::l)=pairBits (encode a) (encode l) := rfl |
| |
| lemma pairBits_append (x y z : List Bool) : pairBits x (y++z)=pairBits x y++z := by |
| induction x with |
| | nil => rfl |
| | cons b x ih => simpa only [pairBits,List.cons_append,Function.comp_apply] using congrArg (List.cons false ∘ List.cons b) ih |
| |
| lemma code_append {α : Type} [Coding α] (l m : List α) : encode (l++m)=encode l++encode m := by |
| induction l with |
| | nil => rfl |
| | cons a l ih => simp only [List.cons_append,code_cons,ih,pairBits_append] |
| |
| lemma list_length_le_code {α : Type} [Coding α] (l : List α) : l.length≤(encode l).length := by |
| induction l with |
| | nil => simp |
| | cons a l ih => simp only [List.length_cons,code_cons,pairBits_length]; omega |
| |
| @[fun_prop] def Poly {α β : Type} [Coding α] [Coding β] (f : α → β) : Prop := |
| Nonempty (Routine encode encode f) |
| |
| namespace Poly |
| variable {α β γ : Type} [Coding α] [Coding β] [Coding γ] |
| noncomputable def routine {f : α → β} (h : Poly f) : Routine encode encode f := Classical.choice h |
| |
| @[fun_prop] theorem identity : Poly (fun a : α => a) := ⟨Routine.identity encode⟩ |
| @[fun_prop] theorem constant (b : β) : Poly (fun _ : α => b) := ⟨Routine.constant encode encode b⟩ |
| @[fun_prop] theorem comp (f : β → γ) (g : α → β) (hf : Poly f) (hg : Poly g) : |
| Poly (fun a => f (g a)) := ⟨hg.routine.comp hf.routine⟩ |
| @[fun_prop] theorem pair (f : α → β) (g : α → γ) (hf : Poly f) (hg : Poly g) : |
| Poly (fun a => (f a,g a)) := ⟨hf.routine.pair hg.routine⟩ |
| @[fun_prop] theorem first (f : α → β×γ) (hf : Poly f) : Poly (fun a => (f a).1) := |
| ⟨hf.routine.comp (Routine.first encode encode)⟩ |
| @[fun_prop] theorem second (f : α → β×γ) (hf : Poly f) : Poly (fun a => (f a).2) := |
| ⟨hf.routine.comp (Routine.second encode encode)⟩ |
| |
| @[fun_prop] theorem cond (b : α → Bool) (f g : α → β) (hb : Poly b) (hf : Poly f) (hg : Poly g) : |
| Poly (fun a => if b a then g a else f a) := by |
| let p := (hb.routine.pair (Routine.identity encode)).comp (hf.routine.select hg.routine) |
| exact ⟨p⟩ |
| |
| @[fun_prop] theorem codeLength : Poly (fun a : α => (encode a).length) := ⟨Routine.codeLength encode⟩ |
| |
| theorem boundedIterate (f : α → α) (hf : Poly f) (P : Polynomial ℕ) |
| (h : ∀ (z : ℕ×α) j,j≤z.1 → (encode (f^[j] z.2)).length≤P.eval (encode z).length) : |
| Poly (fun z : ℕ×α => f^[z.1] z.2) := |
| ⟨hf.routine.boundedIterate Prod.fst Prod.snd P h⟩ |
| |
| theorem congr {f g : α → β} (hf : Poly f) (h : ∀ a,f a=g a) : Poly g := by |
| have he : f=g := funext h |
| rwa [←he] |
| |
| end Poly |
| end BinaryMatching.StackCode |
| end |
| |
| end OAI |
| |
