| 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 |
|
|
