| import OAI.MathematicalPhysics.RapidForcing.RatOperations |
| import OAI.MathematicalPhysics.RapidForcing.ComputableProfiles |
| import OAI.MathematicalPhysics.RapidForcing.TypedPrograms |
|
|
| namespace OAI |
|
|
| section |
| open Encodable Nat.Partrec |
| open scoped BigOperators |
| namespace RapidForcing.EffectiveArithmetic |
|
|
| @[fun_prop] lemma computable_rat_min : Computable (fun p : ℚ × ℚ => min p.1 p.2) := by |
| simpa only [min_def] using (show Computable (fun p : ℚ × ℚ => if p.1 ≤ p.2 then p.1 else p.2) by fun_prop) |
|
|
| @[fun_prop] lemma computable_fin_app {S : Type} [Primcodable S] {d : ℕ} : |
| Computable (fun p : (Fin d → S) × Fin d => p.1 p.2) := Computable.fin_app |
|
|
| lemma computable_fin_lambda {A S : Type} [Primcodable A] [Primcodable S] {d : ℕ} |
| {f : A → Fin d → S} (hf : ∀ i, Computable (fun a => f a i)) : Computable f := by |
| exact (Primrec.vector_get'.to_comp.comp (Computable.vector_ofFn hf)).of_eq |
| (fun a => by ext i; simp) |
|
|
| lemma computable_fin_sum {A S : Type} [Primcodable A] [Primcodable S] [AddCommMonoid S] |
| (hadd : Computable (fun p : S × S => p.1 + p.2)) {d : ℕ} |
| {f : A → Fin d → S} (hf : ∀ i, Computable (fun a => f a i)) : |
| Computable (fun a => ∑ i, f a i) := by |
| have h := computable_list_foldr (Computable.list_ofFn hf) (Computable.const (0 : S)) |
| (hadd.comp Computable.snd).to₂ |
| exact h.of_eq (fun a => by simpa [List.sum_ofFn] using |
| (show (List.ofFn (f a)).foldr (fun a b => a + b) 0 = (List.ofFn (f a)).sum by rfl)) |
|
|
| end RapidForcing.EffectiveArithmetic |
| namespace RapidForcing.EffectiveProfile.Formula |
| open EffectiveArithmetic |
| attribute [local irreducible] runTyped |
| variable {d : ℕ} |
|
|
| @[fun_prop] lemma computable_bound : Computable (fun p : Formula d × ℚ => p.1.bound p.2) := by |
| have h := computable_recOn (e := fun p : Formula d × ℚ => p.1) (by fun_prop) |
| (c := fun _ q => |q|) (by unfold Computable₂; fun_prop) |
| (v := fun p _ => |p.2|) (by unfold Computable₂; fun_prop) |
| (a := fun _ p => p.2.2.1 + p.2.2.2) (by unfold Computable₂; fun_prop) |
| (m := fun _ p => p.2.2.1 * p.2.2.2) (by unfold Computable₂; fun_prop) |
| (p := fun _ p => p.1.bound) (by unfold Computable₂; fun_prop) |
| exact h.of_eq (fun p => by induction p.1 <;> simp [bound, *]) |
|
|
| @[fun_prop] lemma computable_diff : Computable (fun p : Formula d × Fin d => p.1.diff p.2) := by |
| have h := computable_recOn (e := fun p : Formula d × Fin d => p.1) (by fun_prop) |
| (c := fun _ _ => Formula.const 0) (by unfold Computable₂; fun_prop) |
| (v := fun p j => Formula.const (if j = p.2 then 1 else 0)) (by unfold Computable₂; fun_prop) |
| (a := fun _ p => Formula.add p.2.2.1 p.2.2.2) (by unfold Computable₂; fun_prop) |
| (m := fun _ p => Formula.add (.mul p.2.2.1 p.2.1) (.mul p.1 p.2.2.2)) (by unfold Computable₂; fun_prop) |
| (p := fun _ p => Formula.mul (.profile p.1.diff p.2.1) p.2.2) (by unfold Computable₂; fun_prop) |
| exact h.of_eq (fun p => by induction p.1 <;> simp [diff, *]) |
|
|
| abbrev EvalArgs (d : ℕ) := (Fin d → ℚ) × ℚ |
|
|
| def evalConst (p : ℚ × EvalArgs d) : Part Ball := Part.some (Ball.exact p.1) |
| def evalVar (p : Fin d × EvalArgs d) : Part Ball := Part.some (Ball.exact (p.2.1 p.1)) |
| def evalAdd (p : (Code × Code) × EvalArgs d) : Part Ball := do |
| let u : Ball ← runTyped p.1.1 (p.2.1, p.2.2 / 2) |
| let v : Ball ← runTyped p.1.2 (p.2.1, p.2.2 / 2) |
| pure (u.add v) |
| def evalMul (p : (Formula d × Formula d × Code × Code) × EvalArgs d) : Part Ball := |
| let R := 1 + ∑ i, |p.2.1 i| |
| let η := min 1 (p.2.2 / (4 * (p.1.1.bound R + p.1.2.1.bound R + 2))) |
| do |
| let u : Ball ← runTyped p.1.2.2.1 (p.2.1, η) |
| let v : Ball ← runTyped p.1.2.2.2 (p.2.1, η) |
| pure (u.mul v) |
| def evalProfile (p : (Expr × Code) × EvalArgs d) : Part Ball := do |
| let u : Ball ← runTyped p.1.2 (p.2.1, p.2.2 / (2 * (p.1.1.diff.bound + 1))) |
| let v ← p.1.1.approx u.center (p.2.2 / 2) |
| pure ⟨v.center, v.radius + p.1.1.diff.bound * u.radius⟩ |
|
|
| lemma partrec_evalConst : Partrec (@evalConst d) := |
| (computable_ball_exact.comp Computable.fst).partrec |
| lemma partrec_evalVar : Partrec (@evalVar d) := |
| (computable_ball_exact.comp (Computable.fin_app.comp |
| (Computable.fst.comp Computable.snd) Computable.fst)).partrec |
| lemma partrec_evalAdd : Partrec (@evalAdd d) := by |
| have ha : Computable (fun p : (Code × Code) × EvalArgs d => (p.2.1, p.2.2 / 2)) := by fun_prop |
| have hu := (partrec_runTyped (B := Ball)).comp |
| ((show Computable (fun p : (Code × Code) × EvalArgs d => p.1.1) by fun_prop).pair ha) |
| have hv := (partrec_runTyped (B := Ball)).comp |
| ((show Computable (fun p : (Code × Code) × EvalArgs d => p.1.2) by fun_prop).pair ha) |
| have h := hu.bind (((hv.comp Computable.fst).bind |
| (computable_ball_add.comp ((Computable.snd.comp Computable.fst).pair Computable.snd)).partrec.to₂).to₂) |
| exact h.of_eq (fun _ => rfl) |
|
|
| lemma computable_operandBox : Computable (fun q : Fin d → ℚ => 1 + ∑ i, |q i|) := by |
| have h := computable_fin_sum computable_rat_add (f := fun q : Fin d → ℚ => fun i => |q i|) |
| (fun i => computable_rat_abs.comp (Computable.fin_app.comp Computable.id (Computable.const i))) |
| have h' := computable_rat_add.comp ((Computable.const 1).pair h) |
| exact h'.of_eq (fun _ => rfl) |
|
|
| private def mulTolerance (p : ℚ × ℚ × ℚ) : ℚ := min 1 (p.1 / (4 * (p.2.1 + p.2.2 + 2))) |
| private lemma computable_mulTolerance : Computable mulTolerance := by |
| unfold mulTolerance; fun_prop |
|
|
| lemma computable_evalMul_args : Computable (fun p : |
| (Formula d × Formula d × Code × Code) × EvalArgs d => |
| (p.2.1, min 1 (p.2.2 / (4 * (p.1.1.bound (1 + ∑ i, |p.2.1 i|) + |
| p.1.2.1.bound (1 + ∑ i, |p.2.1 i|) + 2))))) := by |
| have hR := computable_operandBox.comp (show Computable (fun p : |
| (Formula d × Formula d × Code × Code) × EvalArgs d => p.2.1) by fun_prop) |
| have ha := computable_bound.comp ((show Computable (fun p : |
| (Formula d × Formula d × Code × Code) × EvalArgs d => p.1.1) by fun_prop).pair hR) |
| have hb := computable_bound.comp ((show Computable (fun p : |
| (Formula d × Formula d × Code × Code) × EvalArgs d => p.1.2.1) by fun_prop).pair hR) |
| have ht := computable_mulTolerance.comp ((Computable.snd.comp Computable.snd).pair (ha.pair hb)) |
| have h := (Computable.fst.comp Computable.snd).pair ht |
| exact h.of_eq (fun _ => rfl) |
|
|
| lemma partrec_evalMul : Partrec (@evalMul d) := by |
| have hu := (partrec_runTyped (B := Ball)).comp ((show |
| Computable (fun p : (Formula d × Formula d × Code × Code) × EvalArgs d => p.1.2.2.1) by fun_prop).pair computable_evalMul_args) |
| have hv := (partrec_runTyped (B := Ball)).comp ((show |
| Computable (fun p : (Formula d × Formula d × Code × Code) × EvalArgs d => p.1.2.2.2) by fun_prop).pair computable_evalMul_args) |
| have h := hu.bind (((hv.comp Computable.fst).bind |
| (computable_ball_mul.comp ((Computable.snd.comp Computable.fst).pair Computable.snd)).partrec.to₂).to₂) |
| exact h.of_eq (fun _ => rfl) |
|
|
| lemma partrec_evalProfile : Partrec (@evalProfile d) := by |
| have ha : Computable (fun p : (Expr × Code) × EvalArgs d => |
| (p.2.1, p.2.2 / (2 * (p.1.1.diff.bound + 1)))) := by fun_prop |
| have hu := (partrec_runTyped (B := Ball)).comp |
| ((show Computable (fun p : (Expr × Code) × EvalArgs d => p.1.2) by fun_prop).pair ha) |
| have hv := Expr.partrec_approx.comp (show Computable |
| (fun p : ((Expr × Code) × EvalArgs d) × Ball => |
| (p.1.1.1, p.2.center, p.1.2.2 / 2)) by fun_prop) |
| have hresult : Computable (fun p : (((Expr × Code) × EvalArgs d) × Ball) × Ball => |
| (⟨p.2.center, p.2.radius + p.1.1.1.1.diff.bound * p.1.2.radius⟩ : Ball)) := by fun_prop |
| exact (hu.bind (hv.bind hresult.partrec.to₂).to₂).of_eq (fun _ => rfl) |
|
|
| noncomputable def constProgram (d : ℕ) : Code := typedCode (@evalConst d) partrec_evalConst |
| noncomputable def varProgram (d : ℕ) : Code := typedCode (@evalVar d) partrec_evalVar |
| noncomputable def addProgram (d : ℕ) : Code := typedCode (@evalAdd d) partrec_evalAdd |
| noncomputable def mulProgram (d : ℕ) : Code := typedCode (@evalMul d) partrec_evalMul |
| noncomputable def profileProgram (d : ℕ) : Code := typedCode (@evalProfile d) partrec_evalProfile |
|
|
| noncomputable def evaluator : Formula d → Code |
| | .const q => (constProgram d).curry (encode q) |
| | .var i => (varProgram d).curry (encode i) |
| | .add a b => (addProgram d).curry (encode (a.evaluator, b.evaluator)) |
| | .mul a b => (mulProgram d).curry (encode (a, b, a.evaluator, b.evaluator)) |
| | .profile e a => (profileProgram d).curry (encode (e, a.evaluator)) |
|
|
| @[fun_prop] lemma computable_evaluator : Computable (@evaluator d) := by |
| have h := computable_recOn (e := (id : Formula d → Formula d)) Computable.id |
| (c := fun _ q => (constProgram d).curry (encode q)) (by exact computable_specialize.comp ((Computable.const _).pair Computable.snd)) |
| (v := fun _ i => (varProgram d).curry (encode i)) (by exact computable_specialize.comp ((Computable.const _).pair (by fun_prop))) |
| (a := fun _ p => (addProgram d).curry (encode (p.2.2.1, p.2.2.2))) (by exact computable_specialize.comp ((Computable.const _).pair (by fun_prop))) |
| (m := fun _ p => (mulProgram d).curry (encode p)) (by exact computable_specialize.comp ((Computable.const _).pair (by fun_prop))) |
| (p := fun _ p => (profileProgram d).curry (encode (p.1, p.2.2))) (by exact computable_specialize.comp ((Computable.const _).pair (by fun_prop))) |
| exact h.of_eq (fun a => by induction a <;> simp_all only [id_eq, evaluator]) |
|
|
| lemma runTyped_evaluator (a : Formula d) (q : Fin d → ℚ) (ε : ℚ) : |
| runTyped a.evaluator (q, ε) = a.evalAt q ε := by |
| induction a generalizing q ε with |
| | const r => |
| simp only [evaluator, constProgram, runTyped_curry, runTyped_typedCode, evalConst, evalAt] |
| | var i => |
| simp only [evaluator, varProgram, runTyped_curry, runTyped_typedCode, evalVar, evalAt] |
| | add a b ha hb => |
| simp only [evaluator, addProgram, runTyped_curry, runTyped_typedCode, evalAdd, evalAt, ha, hb] |
| | mul a b ha hb => |
| simp only [evaluator, mulProgram, runTyped_curry, runTyped_typedCode, evalMul, evalAt, ha, hb] |
| | profile e a ha => |
| simp only [evaluator, profileProgram, runTyped_curry, runTyped_typedCode, evalProfile, evalAt, ha] |
|
|
| lemma partrec_evalAt : Partrec (fun p : Formula d × EvalArgs d => p.1.evalAt p.2.1 p.2.2) := by |
| exact ((partrec_runTyped (B := Ball)).comp |
| ((computable_evaluator.comp Computable.fst).pair Computable.snd)).of_eq |
| (fun p => runTyped_evaluator p.1 p.2.1 p.2.2) |
|
|
| end RapidForcing.EffectiveProfile.Formula |
|
|
| end |
|
|
| end OAI |
|
|
