File size: 6,943 Bytes
caec230 | 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 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 | import OAI.MathematicalPhysics.RapidForcing.ExprCoding
namespace OAI
section
open Encodable Denumerable Function Nat.Partrec
namespace RapidForcing.EffectiveArithmetic
attribute [fun_prop] Computable.option_getD
Primrec.list_length Primrec.list_reverse Primrec.list_head? Primrec.list_tail
Primrec.list_range
@[fun_prop] lemma primrec_list_cons {A : Type} [Primcodable A] :
Primrec (fun p : A × List A => p.1 :: p.2) := Primrec.list_cons
lemma computable_list_casesOn {A B S : Type} [Primcodable A] [Primcodable B] [Primcodable S]
{f : A → List B} {g : A → S} {h : A → B × List B → S}
(hf : Computable f) (hg : Computable g) (hh : Computable₂ h) :
Computable (fun a => List.casesOn (motive := fun _ => S) (f a) (g a) fun b l => h a (b, l)) := by
have hd : Computable (fun a => (f a).head?) := Primrec.list_head?.to_comp.comp hf
have ht : Computable (fun a => (f a).tail) := Primrec.list_tail.to_comp.comp hf
exact (Computable.option_casesOn hd hg
(hh.comp Computable.fst (Computable.snd.pair (ht.comp Computable.fst))).to₂).of_eq
(fun a => by cases hfa : f a <;> simp [hfa])
lemma computable_nat_iterate {A S : Type} [Primcodable A] [Primcodable S]
{f : A → ℕ} {g : A → S} {h : A → S → S}
(hf : Computable f) (hg : Computable g) (hh : Computable₂ h) :
Computable (fun a => (h a)^[f a] (g a)) := by
exact (Computable.nat_rec hf hg
((hh.comp Computable.fst (Computable.snd.comp Computable.snd)).to₂)).of_eq
(fun a => by induction f a <;> simp [Function.iterate_succ_apply', *])
lemma computable_list_foldl {A B S : Type} [Primcodable A] [Primcodable B] [Primcodable S]
{f : A → List B} {g : A → S} {h : A → S × B → S}
(hf : Computable f) (hg : Computable g) (hh : Computable₂ h) :
Computable (fun a => (f a).foldl (fun s b => h a (s, b)) (g a)) := by
let G (a : A) (v : S × List B) : S × List B :=
List.casesOn v.2 v fun b l => (h a (v.1, b), l)
have hG : Computable₂ G := computable_list_casesOn
(Computable.snd.comp Computable.snd) Computable.snd
((hh.comp (Computable.fst.comp Computable.fst)
(((Computable.fst.comp Computable.snd).comp Computable.fst).pair (Computable.fst.comp Computable.snd))).pair
(Computable.snd.comp Computable.snd)).to₂
have F := computable_nat_iterate (Computable.list_length.comp hf) (hg.pair hf) hG
have he (a : A) (n : ℕ) (l : List B) (x : S) :
(G a)^[n] (x, l) = ((l.take n).foldl (fun s b => h a (s, b)) x, l.drop n) := by
induction n generalizing l x with
| zero => rfl
| succ n ih => cases l <;> simp [iterate_succ, comp_apply, G, ih]
exact (Computable.fst.comp F).of_eq (fun a => by rw [he]; simp)
lemma computable_list_foldr {A B S : Type} [Primcodable A] [Primcodable B] [Primcodable S]
{f : A → List B} {g : A → S} {h : A → B × S → S}
(hf : Computable f) (hg : Computable g) (hh : Computable₂ h) :
Computable (fun a => (f a).foldr (fun b s => h a (b, s)) (g a)) := by
exact (computable_list_foldl (Computable.list_reverse.comp hf) hg
(hh.comp Computable.fst ((Computable.snd.pair Computable.fst).comp Computable.snd)).to₂).of_eq
(fun a => by rw [List.foldl_reverse])
lemma computable_list_rec {A B S : Type} [Primcodable A] [Primcodable B] [Primcodable S]
{f : A → List B} {g : A → S} {h : A → B × List B × S → S}
(hf : Computable f) (hg : Computable g) (hh : Computable₂ h) :
Computable (fun a => List.recOn (motive := fun _ => S) (f a) (g a) fun b l s => h a (b, l, s)) := by
have hstep : Computable (fun v : A × B × List B × S =>
(v.2.1 :: v.2.2.1, h v.1 (v.2.1, v.2.2.1, v.2.2.2))) :=
(Computable.list_cons.comp (Computable.fst.comp Computable.snd)
(Computable.fst.comp (Computable.snd.comp Computable.snd))).pair hh
have hr := computable_list_foldr hf ((Computable.const ([] : List B)).pair hg) hstep.to₂
apply (Computable.snd.comp hr).of_eq
intro a
have haux (l : List B) :
l.foldr (fun b p => (b :: p.1, h a (b, p.1, p.2))) ([], g a) =
(l, List.recOn (motive := fun _ => S) l (g a) fun b l s => h a (b, l, s)) := by
induction l <;> simp [*]
rw [haux]
end RapidForcing.EffectiveArithmetic
namespace RapidForcing.EffectiveProfile.Expr
open EffectiveArithmetic
local instance recursiveCodeDecidableEq : DecidableEq Code :=
Encodable.decidableEqOfEncodable Code
lemma computable_recOn {A S : Type} [Primcodable A] [Primcodable S]
{e : A → Expr} (he : Computable e)
{c : A → ℚ → S} (hc : Computable₂ c)
{l r : A → GluePoly → S} (hl : Computable₂ l) (hr : Computable₂ r)
{d : A → ℕ → S} (hd : Computable₂ d)
{a m : A → Expr × Expr × S × S → S} (ha : Computable₂ a) (hm : Computable₂ m) :
Computable (fun x => Expr.recOn (motive := fun _ => S) (e x) (c x) (l x) (r x) (d x)
(fun e₁ e₂ v₁ v₂ => a x (e₁, e₂, v₁, v₂))
(fun e₁ e₂ v₁ v₂ => m x (e₁, e₂, v₁, v₂))) := by
let z := fun x => c x 0
let pr := fun (x : A) (p : Code × Code × S × S) =>
if p.1 = .zero then c x ((decode (encode p.2.1)).getD 0)
else if p.1 = .succ then l x ((decode (encode p.2.1)).getD [])
else if p.1 = .left then r x ((decode (encode p.2.1)).getD [])
else d x (encode p.2.1)
let co := fun (x : A) (p : Code × Code × S × S) =>
a x (fromCode p.1, fromCode p.2.1, p.2.2.1, p.2.2.2)
let pc := fun (x : A) (p : Code × Code × S × S) =>
m x (fromCode p.1, fromCode p.2.1, p.2.2.1, p.2.2.2)
have hz : Computable z := hc.comp Computable.id (Computable.const 0)
have hpr : Computable₂ pr := by
unfold pr Computable₂
apply computable_ite (by fun_prop) (hc.comp Computable.fst (by fun_prop))
apply computable_ite (by fun_prop) (hl.comp Computable.fst (by fun_prop))
exact computable_ite (by fun_prop) (hr.comp Computable.fst (by fun_prop))
(hd.comp Computable.fst (by fun_prop))
have hco : Computable₂ co := ha.comp Computable.fst (by fun_prop)
have hpc : Computable₂ pc := hm.comp Computable.fst (by fun_prop)
have H := Code.computable_recOn (primrec_toCode.to_comp.comp he) hz hz hz hz
hpr hco hpc (rf := fun x _ => z x) (hz.comp Computable.fst).to₂
apply H.of_eq
intro x
have hh (b : Code) : Code.recOn b (z x) (z x) (z x) (z x)
(fun c₁ c₂ v₁ v₂ => pr x (c₁, c₂, v₁, v₂))
(fun c₁ c₂ v₁ v₂ => co x (c₁, c₂, v₁, v₂))
(fun c₁ c₂ v₁ v₂ => pc x (c₁, c₂, v₁, v₂)) (fun _ _ => z x) =
Expr.recOn (motive := fun _ => S) (fromCode b) (c x) (l x) (r x) (d x)
(fun e₁ e₂ v₁ v₂ => a x (e₁, e₂, v₁, v₂))
(fun e₁ e₂ v₁ v₂ => m x (e₁, e₂, v₁, v₂)) := by
induction b <;> simp_all only [fromCode, pr, co, pc, z]
split_ifs <;> rfl
simpa only [fromCode_toCode] using hh (toCode (e x))
end RapidForcing.EffectiveProfile.Expr
end
end OAI
|