File size: 7,811 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 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | import OAI.MathematicalPhysics.RapidForcing.FieldExpressions
import OAI.MathematicalPhysics.RapidForcing.RecursiveComputable
namespace OAI
section
open Encodable Denumerable Nat.Partrec
namespace RapidForcing.EffectiveArithmetic
local instance : DecidableEq Code := Encodable.decidableEqOfEncodable Code
def codeUnary (c : Code) : Code := match c with | .rfind' a => a | _ => .zero
@[simp] lemma codeUnary_rfind (a : Code) : codeUnary (.rfind' a) = a := rfl
@[fun_prop] lemma primrec_codeUnary : Primrec codeUnary := by
have h := Code.primrec_recOn Primrec.id
(Primrec.const Code.zero) (Primrec.const Code.zero)
(Primrec.const Code.zero) (Primrec.const Code.zero)
(pr := fun _ _ _ _ _ => Code.zero) (by fun_prop)
(co := fun _ _ _ _ _ => Code.zero) (by fun_prop)
(pc := fun _ _ _ _ _ => Code.zero) (by fun_prop)
(rf := fun _ a _ => a) (by fun_prop)
exact h.of_eq (fun c => by cases c <;> rfl)
end RapidForcing.EffectiveArithmetic
namespace RapidForcing.EffectiveProfile.Formula
open EffectiveArithmetic
local instance : DecidableEq Code := Encodable.decidableEqOfEncodable Code
variable {d : ℕ}
def toCode : Formula d → Code
| .const q => .pair .zero (.ofNatCode (encode q))
| .var i => .pair .succ (.ofNatCode (encode i))
| .add a b => .comp a.toCode b.toCode
| .mul a b => .prec a.toCode b.toCode
| .profile e a => .pair (.rfind' e.toCode) a.toCode
def fromCode : Code → Formula d
| .pair t v => if t = .zero then .const ((decode (encode v)).getD 0)
else if t = .succ then ((decode (encode v)).map Formula.var).getD (.const 0)
else .profile (Expr.fromCode (codeUnary t)) (fromCode v)
| .comp a b => .add (fromCode a) (fromCode b)
| .prec a b => .mul (fromCode a) (fromCode b)
| _ => .const 0
@[simp] lemma fromCode_toCode (a : Formula d) : fromCode a.toCode = a := by
induction a <;> simp [toCode, fromCode, *]
lemma primrec_normalize : Primrec (fun c => toCode (fromCode (d := d) c)) := by
let z : Code := .pair .zero (.ofNatCode (encode (0 : ℚ)))
have H := Code.primrec_recOn (σ := Code) Primrec.id
(Primrec.const z) (Primrec.const z) (Primrec.const z) (Primrec.const z)
(pr := fun _ t v _ w => if t = .zero then .pair .zero (.ofNatCode (encode ((decode (α := ℚ) (encode v)).getD 0)))
else if t = .succ then ((decode (α := Fin d) (encode v)).map
(fun i => Code.pair .succ (.ofNatCode (encode i)))).getD z
else .pair (.rfind' (Expr.toCode (Expr.fromCode (codeUnary t)))) w)
(by
apply Primrec.ite (by fun_prop) _ _
· exact primrec_code_pair.comp ((Primrec.const _).pair (primrec_code_ofNat.comp
(Primrec.encode.comp (Primrec.option_getD.comp
(Primrec.decode.comp (Primrec.encode.comp (by fun_prop))) (Primrec.const 0)))))
· apply Primrec.ite (by fun_prop) _ _
· apply Primrec.option_getD.comp _ (Primrec.const z)
apply Primrec.option_map (Primrec.decode.comp (Primrec.encode.comp (by fun_prop)))
unfold Primrec₂
fun_prop
· fun_prop)
(co := fun _ _ _ a b => .comp a b) (by fun_prop)
(pc := fun _ _ _ a b => .prec a b) (by fun_prop)
(rf := fun _ _ _ => z) (by fun_prop)
apply H.of_eq
intro c
induction c <;> simp_all only [id_eq, fromCode, toCode]
all_goals first | rfl | skip
rename_i t v ih₁ ih₂
split_ifs with ht hs
· rfl
· cases decode (α := Fin d) (encode v) <;> rfl
· simp only [toCode]
instance : Primcodable (Formula d) :=
primcodable_retract toCode fromCode fromCode_toCode primrec_normalize
@[simp] lemma encode_toCode (a : Formula d) : encode a.toCode = encode a := rfl
@[fun_prop] lemma primrec_toCode : Primrec (@toCode d) := by
apply Primrec.encode_iff.mp
exact (Primrec.encode : Primrec (@encode (Formula d) _))
@[fun_prop] lemma primrec_fromCode : Primrec (@fromCode d) := by
apply Primrec.encode_iff.mp
exact Primrec.encode.comp primrec_normalize
@[fun_prop] lemma primrec_const : Primrec (@Formula.const d) := by
apply Primrec.encode_iff.mp
change Primrec (fun q => encode (toCode (d := d) (.const q)))
unfold toCode
fun_prop
@[fun_prop] lemma primrec_var : Primrec (@Formula.var d) := by
apply Primrec.encode_iff.mp
change Primrec (fun i : Fin d => encode (toCode (.var i)))
unfold toCode
fun_prop
@[fun_prop] lemma primrec_add : Primrec (fun p : Formula d × Formula d => Formula.add p.1 p.2) := by
apply Primrec.encode_iff.mp
change Primrec (fun p : Formula d × Formula d => encode (toCode (.add p.1 p.2)))
unfold toCode
fun_prop
@[fun_prop] lemma primrec_mul : Primrec (fun p : Formula d × Formula d => Formula.mul p.1 p.2) := by
apply Primrec.encode_iff.mp
change Primrec (fun p : Formula d × Formula d => encode (toCode (.mul p.1 p.2)))
unfold toCode
fun_prop
@[fun_prop] lemma primrec_profile : Primrec (fun p : Expr × Formula d => Formula.profile p.1 p.2) := by
apply Primrec.encode_iff.mp
change Primrec (fun p : Expr × Formula d => encode (toCode (.profile p.1 p.2)))
unfold toCode
fun_prop
lemma computable_recOn {A S : Type} [Primcodable A] [Primcodable S]
{e : A → Formula d} (he : Computable e)
{c : A → ℚ → S} (hc : Computable₂ c)
{v : A → Fin d → S} (hv : Computable₂ v)
{a m : A → Formula d × Formula d × S × S → S} (ha : Computable₂ a) (hm : Computable₂ m)
{p : A → Expr × Formula d × S → S} (hp : Computable₂ p) :
Computable (fun x => Formula.recOn (motive := fun _ => S) (e x) (c x) (v x)
(fun e₁ e₂ v₁ v₂ => a x (e₁, e₂, v₁, v₂))
(fun e₁ e₂ v₁ v₂ => m x (e₁, e₂, v₁, v₂))
(fun u e h => p x (u, e, h))) := by
let z := fun x => c x 0
let pr := fun (x : A) (q : Code × Code × S × S) =>
if q.1 = .zero then c x ((decode (encode q.2.1)).getD 0)
else if q.1 = .succ then ((decode (α := Fin d) (encode q.2.1)).map (v x)).getD (z x)
else p x (Expr.fromCode (codeUnary q.1), fromCode q.2.1, q.2.2.2)
let co := fun (x : A) (q : Code × Code × S × S) =>
a x (fromCode q.1, fromCode q.2.1, q.2.2.1, q.2.2.2)
let pc := fun (x : A) (q : Code × Code × S × S) =>
m x (fromCode q.1, fromCode q.2.1, q.2.2.1, q.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) _ (hp.comp Computable.fst (by fun_prop))
apply Computable.option_getD _ (hz.comp Computable.fst)
apply Computable.option_map (by fun_prop)
exact (hv.comp (Computable.fst.comp Computable.fst) Computable.snd).to₂
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) =
Formula.recOn (motive := fun _ => S) (fromCode (d := d) b) (c x) (v x)
(fun e₁ e₂ v₁ v₂ => a x (e₁, e₂, v₁, v₂))
(fun e₁ e₂ v₁ v₂ => m x (e₁, e₂, v₁, v₂))
(fun u e h => p x (u, e, h)) := by
induction b <;> simp_all only [fromCode, pr, co, pc, z]
rename_i t u ih₁ ih₂
split_ifs with ht hs
· rfl
· cases decode (α := Fin d) (encode u) <;> rfl
· rfl
simpa only [fromCode_toCode] using hh (toCode (e x))
end RapidForcing.EffectiveProfile.Formula
end
end OAI
|