math / data /lean /OAI /MathematicalPhysics /RapidForcing /RecursiveComputable.lean
introvoyz045's picture
Migrated from GitHub
4a56cd6 verified
Raw History Blame Contribute Delete
6.94 kB
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