| import OAI.Probability.SATComputability.ArithmeticEnclosures |
|
|
| namespace OAI |
|
|
| namespace FixedClauseThreshold.Computability.FiniteArithmetic |
|
|
| open Encodable Nat.Partrec RapidForcing.EffectiveProfile RapidForcing.EffectiveArithmetic |
| open PeriodicLattice.CertifiedReal Filter |
| open scoped Topology |
| local instance arithmeticSyntaxRatPrimcodable : Primcodable ℚ := PeriodicLattice.RecursiveArithmetic.ratPrimcodable |
| local instance arithmeticSyntaxCodeEq : DecidableEq Code := Encodable.decidableEqOfEncodable Code |
|
|
| noncomputable def clampBall (b : Ball) : Ball := ⟨max 1 b.center, b.radius⟩ |
|
|
| @[fun_prop] theorem clampBall_computable : Computable clampBall := by |
| unfold clampBall |
| fun_prop |
|
|
| theorem clampBall_covers {b : Ball} {x : ℝ} (hb : b.Covers x) : |
| (clampBall b).Covers (max 1 x) := by |
| have h := abs_max_sub_max_le_abs (b.center : ℝ) x 1 |
| simpa only [clampBall, Ball.Covers, Rat.cast_max, Rat.cast_one, max_comm] using h.trans hb |
|
|
| theorem encloses_clamp {b : ℕ → Ball} {x : ℝ} (hb : Encloses b x) : |
| Encloses (fun n => clampBall (b n)) (max 1 x) := |
| ⟨fun n => clampBall_covers (hb.1 n), hb.2⟩ |
|
|
| noncomputable def decodedRational (e : Code) : ℚ := (decode (encode e)).getD 0 |
|
|
| @[fun_prop] theorem decodedRational_computable : Computable decodedRational := by |
| unfold decodedRational |
| fun_prop |
|
|
| noncomputable def expressionValue : Code → ℝ |
| | .zero => 0 |
| | .succ => 1 |
| | .left => 2 |
| | .right => 3 |
| | .pair a b => expressionValue a + expressionValue b |
| | .comp a b => expressionValue a * expressionValue b |
| | .prec tag b => if tag = .zero then (decodedRational b : ℝ) |
| else if tag = .succ then Real.exp (expressionValue b) |
| else if tag = .left then Real.log (max 1 (expressionValue b)) |
| else (max 1 (expressionValue b))⁻¹ |
| | .rfind' a => -expressionValue a |
|
|
| noncomputable def expressionBall : Code → ℕ → Ball |
| | .zero, _ => Ball.exact 0 |
| | .succ, _ => Ball.exact 1 |
| | .left, _ => Ball.exact 2 |
| | .right, _ => Ball.exact 3 |
| | .pair a b, n => (expressionBall a n).add (expressionBall b n) |
| | .comp a b, n => (expressionBall a n).mul (expressionBall b n) |
| | .prec tag b, n => if tag = .zero then Ball.exact (decodedRational b) |
| else if tag = .succ then expBall (expressionBall b n) n |
| else if tag = .left then logBall (expressionBall b n) n |
| else (clampBall (expressionBall b n)).denInv |
| | .rfind' a, n => (Ball.exact (-1)).mul (expressionBall a n) |
|
|
| @[fun_prop] theorem expressionBall_computable : |
| Computable (fun p : Code × ℕ => expressionBall p.1 p.2) := by |
| have h := Code.computable_recOn (c := fun p : Code × ℕ => p.1) Computable.fst |
| (z := fun _ => Ball.exact 0) (by fun_prop) |
| (s := fun _ => Ball.exact 1) (by fun_prop) |
| (l := fun _ => Ball.exact 2) (by fun_prop) |
| (r := fun _ => Ball.exact 3) (by fun_prop) |
| (pr := fun _ p => p.2.2.1.add p.2.2.2) (by unfold Computable₂; fun_prop) |
| (co := fun _ p => p.2.2.1.mul p.2.2.2) (by unfold Computable₂; fun_prop) |
| (pc := fun x p => if p.1 = .zero then Ball.exact (decodedRational p.2.1) |
| else if p.1 = .succ then expBall p.2.2.2 x.2 |
| else if p.1 = .left then logBall p.2.2.2 x.2 |
| else (clampBall p.2.2.2).denInv) (by unfold Computable₂; fun_prop) |
| (rf := fun _ p => (Ball.exact (-1)).mul p.2) (by unfold Computable₂; fun_prop) |
| apply h.of_eq |
| intro p |
| induction p.1 <;> simp_all only [expressionBall] |
|
|
| theorem expressionBall_encloses (e : Code) : Encloses (expressionBall e) (expressionValue e) := by |
| induction e with |
| | zero => simpa only [expressionBall, expressionValue, Rat.cast_zero] using encloses_exact 0 |
| | succ => simpa only [expressionBall, expressionValue, Rat.cast_one] using encloses_exact 1 |
| | left => exact encloses_exact 2 |
| | right => exact encloses_exact 3 |
| | pair a b ha hb => exact ha.add hb |
| | comp a b ha hb => exact ha.mul hb |
| | prec tag b _ hb => |
| by_cases hz : tag = .zero |
| · simpa only [expressionBall, expressionValue, hz, ite_true] using encloses_exact (decodedRational b) |
| · by_cases he : tag = .succ |
| · simpa [expressionBall, expressionValue, he] using Encloses.exp hb |
| · by_cases hl : tag = .left |
| · simpa [expressionBall, expressionValue, hl] using Encloses.log hb |
| · simpa only [expressionBall, expressionValue, hz, he, hl, ite_false] using |
| (encloses_clamp hb).denInv (show (1/16 : ℝ) ≤ max 1 (expressionValue b) from |
| (by norm_num : (1/16 : ℝ) ≤ 1).trans (le_max_left _ _)) |
| | rfind' a ha => |
| simpa only [expressionBall, expressionValue, Rat.cast_neg, Rat.cast_one, neg_one_mul] using |
| (encloses_exact (-1)).mul ha |
|
|
| theorem expressionValue_effective : Effective expressionValue := by |
| apply of_enclosures |
| (q := fun p => (expressionBall p.1 p.2).center) |
| (e := fun p => (expressionBall p.1 p.2).radius) |
| · exact primrec_ball_center.to_comp.comp expressionBall_computable |
| · exact primrec_ball_radius.to_comp.comp expressionBall_computable |
| · intro a n |
| simpa only [Ball.Covers, abs_sub_comm] using (expressionBall_encloses a).1 n |
| · intro a |
| exact (expressionBall_encloses a).2 |
|
|
| end FixedClauseThreshold.Computability.FiniteArithmetic |
|
|
| end OAI |
|
|
