File size: 3,863 Bytes
ea76aac | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 | 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
|