| import OAI.Probability.SATComputability.ArithmeticSyntax |
|
|
| namespace OAI |
|
|
| namespace FixedClauseThreshold.Computability.FiniteArithmetic |
|
|
| open Encodable Denumerable Nat.Partrec |
| open scoped BigOperators |
| local instance arithmeticConstructorsRatPrimcodable : Primcodable ℚ := PeriodicLattice.RecursiveArithmetic.ratPrimcodable |
|
|
| noncomputable def rationalExpression (q : ℚ) : Code := |
| .prec .zero (ofNat Code (encode q)) |
|
|
| @[fun_prop] theorem rationalExpression_computable : Computable rationalExpression := by |
| have : Computable (ofNat Code) := (Primrec.ofNat Code).to_comp |
| unfold rationalExpression |
| fun_prop |
|
|
| @[simp] theorem rationalExpression_value (q : ℚ) : |
| expressionValue (rationalExpression q) = q := by |
| simp only [rationalExpression, expressionValue, ite_true, decodedRational, |
| encode_ofNat, encodek, Option.getD_some] |
|
|
| def exponentialExpression (e : Code) : Code := .prec .succ e |
| def positiveLogExpression (e : Code) : Code := .prec .left e |
| def reciprocalExpression (e : Code) : Code := .prec .right e |
|
|
| @[simp] theorem exponentialExpression_value (e : Code) : |
| expressionValue (exponentialExpression e) = Real.exp (expressionValue e) := by |
| simp [exponentialExpression, expressionValue] |
| @[simp] theorem positiveLogExpression_value (e : Code) : |
| expressionValue (positiveLogExpression e) = Real.log (max 1 (expressionValue e)) := by |
| simp [positiveLogExpression, expressionValue] |
| @[simp] theorem reciprocalExpression_value (e : Code) : |
| expressionValue (reciprocalExpression e) = (max 1 (expressionValue e))⁻¹ := by |
| simp [reciprocalExpression, expressionValue] |
|
|
| noncomputable def scaledLogExpression (q : ℚ) (e : Code) : Code := |
| .pair (.rfind' (positiveLogExpression (rationalExpression q⁻¹))) |
| (positiveLogExpression (.comp (rationalExpression q⁻¹) e)) |
|
|
| theorem scaledLogExpression_value {q : ℚ} {e : Code} |
| (hq : 0 < q) (hq1 : q ≤ 1) (he : (q : ℝ) ≤ expressionValue e) : |
| expressionValue (scaledLogExpression q e) = Real.log (expressionValue e) := by |
| have hq' : (0 : ℝ) < q := by exact_mod_cast hq |
| have hq1' : (q : ℝ) ≤ 1 := by exact_mod_cast hq1 |
| have hi : (1 : ℝ) ≤ (q : ℝ)⁻¹ := (one_le_inv₀ hq').mpr hq1' |
| have he' : (1 : ℝ) ≤ (q : ℝ)⁻¹ * expressionValue e := by |
| calc |
| 1 = (q : ℝ)⁻¹ * q := (inv_mul_cancel₀ hq'.ne').symm |
| _ ≤ _ := mul_le_mul_of_nonneg_left he (inv_nonneg.mpr hq'.le) |
| simp only [scaledLogExpression, expressionValue, positiveLogExpression_value, |
| rationalExpression_value, Rat.cast_inv, max_eq_right hi, max_eq_right he'] |
| rw [Real.log_mul (inv_ne_zero hq'.ne') (ne_of_gt (hq'.trans_le he))] |
| ring |
|
|
| def sumExpressions (es : List Code) : Code := es.foldr Code.pair .zero |
| def productExpressions (es : List Code) : Code := es.foldr Code.comp .succ |
|
|
| @[fun_prop] theorem sumExpressions_computable : Computable sumExpressions := by |
| exact (Primrec.list_foldr Primrec.id (Primrec.const Code.zero) |
| ((Code.primrec₂_pair.comp Primrec.fst Primrec.snd).comp Primrec.snd).to₂).to_comp |
|
|
| @[fun_prop] theorem productExpressions_computable : Computable productExpressions := by |
| exact (Primrec.list_foldr Primrec.id (Primrec.const Code.succ) |
| ((Code.primrec₂_comp.comp Primrec.fst Primrec.snd).comp Primrec.snd).to₂).to_comp |
|
|
| @[simp] theorem sumExpressions_value (es : List Code) : |
| expressionValue (sumExpressions es) = (es.map expressionValue).sum := by |
| induction es with |
| | nil => rfl |
| | cons e es ih => simpa only [sumExpressions, List.foldr_cons, expressionValue, |
| List.map_cons, List.sum_cons] using congrArg (expressionValue e + ·) ih |
|
|
| @[simp] theorem productExpressions_value (es : List Code) : |
| expressionValue (productExpressions es) = (es.map expressionValue).prod := by |
| induction es with |
| | nil => rfl |
| | cons e es ih => simpa only [productExpressions, List.foldr_cons, expressionValue, |
| List.map_cons, List.prod_cons] using congrArg (expressionValue e * ·) ih |
|
|
| end FixedClauseThreshold.Computability.FiniteArithmetic |
|
|
| end OAI |
|
|
