| 1 |
(* ========================================================================== *) |
| 2 |
(* Formal verification of nonlinear inequalities in HOL Light *) |
| 3 |
(* *) |
| 4 |
(* Copyright (c) 2014 Alexey Solovyev *) |
| 5 |
(* *) |
| 6 |
(* This file is distributed under the terms of the MIT licence *) |
| 7 |
(* ========================================================================== *) |
| 8 |
|
| 9 |
(* -------------------------------------------------------------------------- *) |
| 10 |
(* Informal arithmetic procedures: asn, acs *) |
| 11 |
(* -------------------------------------------------------------------------- *) |
| 12 |
|
| 13 |
(* Dependencies *) |
| 14 |
needs "Formal_ineqs/informal/informal_atn.hl";; |
| 15 |
|
| 16 |
module type Informal_asn_acs_sig = |
| 17 |
sig |
| 18 |
val asn_float_lo : int -> Informal_float.ifloat -> Informal_float.ifloat |
| 19 |
val asn_float_hi : int -> Informal_float.ifloat -> Informal_float.ifloat |
| 20 |
val asn_interval : int -> Informal_interval.interval -> Informal_interval.interval |
| 21 |
|
| 22 |
val acs_float_lo : int -> Informal_float.ifloat -> Informal_float.ifloat |
| 23 |
val acs_float_hi : int -> Informal_float.ifloat -> Informal_float.ifloat |
| 24 |
val acs_interval : int -> Informal_interval.interval -> Informal_interval.interval |
| 25 |
end;; |
| 26 |
|
| 27 |
module Informal_asn_acs : Informal_asn_acs_sig = struct |
| 28 |
|
| 29 |
open Informal_float;; |
| 30 |
open Informal_interval;; |
| 31 |
open Informal_atn;; |
| 32 |
|
| 33 |
let neg_one = mk_float (-1) 0;; |
| 34 |
|
| 35 |
let asn_float_hi pp x = |
| 36 |
if not (sign_float x) then |
| 37 |
let b = pow_float_hi pp 2 x in |
| 38 |
let c = sub_float_lo pp float1 b in |
| 39 |
let r = sqrt_float_lo pp c in |
| 40 |
let t = div_float_hi pp x r in |
| 41 |
let hi = atn_float_hi pp t in |
| 42 |
if not (gt0_float r) then |
| 43 |
failwith "asn_float_hi: r <= 0" |
| 44 |
else |
| 45 |
hi |
| 46 |
else |
| 47 |
let b = pow_float_lo pp 2 x in |
| 48 |
let c = sub_float_hi pp float1 b in |
| 49 |
let r = sqrt_float_hi pp c in |
| 50 |
let t = div_float_hi pp x r in |
| 51 |
let hi = atn_float_hi pp t in |
| 52 |
if not (lt_float neg_one x) then |
| 53 |
failwith "asn_float_hi: x <= -1" |
| 54 |
else |
| 55 |
hi;; |
| 56 |
|
| 57 |
let asn_float_lo pp x = |
| 58 |
if sign_float x then |
| 59 |
let b = pow_float_hi pp 2 x in |
| 60 |
let c = sub_float_lo pp float1 b in |
| 61 |
let r = sqrt_float_lo pp c in |
| 62 |
let t = div_float_lo pp x r in |
| 63 |
let lo = atn_float_lo pp t in |
| 64 |
if not (gt0_float r) then |
| 65 |
failwith "asn_float_lo: r <= 0" |
| 66 |
else |
| 67 |
lo |
| 68 |
else |
| 69 |
let b = pow_float_lo pp 2 x in |
| 70 |
let c = sub_float_hi pp float1 b in |
| 71 |
let r = sqrt_float_hi pp c in |
| 72 |
let t = div_float_lo pp x r in |
| 73 |
let lo = atn_float_lo pp t in |
| 74 |
if not (lt_float x float1) then |
| 75 |
failwith "asn_float_lo: 1 <= x" |
| 76 |
else |
| 77 |
lo;; |
| 78 |
|
| 79 |
let acs_float_hi pp x = |
| 80 |
let flag1 = le_float x float1 in |
| 81 |
let flag2 = le_float neg_one x in |
| 82 |
if flag1 && flag2 then |
| 83 |
let _, b = dest_interval pi2_approx_array.(pp) in |
| 84 |
let c = asn_float_lo pp x in |
| 85 |
let hi = sub_float_hi pp b c in |
| 86 |
hi |
| 87 |
else |
| 88 |
failwith "acs_float_hi: x < -1 || x > 1";; |
| 89 |
|
| 90 |
let acs_float_lo pp x = |
| 91 |
let flag1 = le_float x float1 in |
| 92 |
let flag2 = le_float neg_one x in |
| 93 |
if flag1 && flag2 then |
| 94 |
let a, _ = dest_interval pi2_approx_array.(pp) in |
| 95 |
let c = asn_float_hi pp x in |
| 96 |
let lo = sub_float_lo pp a c in |
| 97 |
lo |
| 98 |
else |
| 99 |
failwith "acs_float_lo: x < -1 || x > 1";; |
| 100 |
|
| 101 |
let asn_interval pp i = |
| 102 |
let a, b = dest_interval i in |
| 103 |
let flag1 = le_float neg_one a in |
| 104 |
let flag2 = le_float b float1 in |
| 105 |
if flag1 && flag2 then |
| 106 |
let lo = asn_float_lo pp a and |
| 107 |
hi = asn_float_hi pp b in |
| 108 |
mk_interval (lo, hi) |
| 109 |
else |
| 110 |
failwith "asn_interval: x < -1 || x > 1";; |
| 111 |
|
| 112 |
let acs_interval pp i = |
| 113 |
let a, b = dest_interval i in |
| 114 |
let flag1 = le_float neg_one a in |
| 115 |
let flag2 = le_float b float1 in |
| 116 |
if flag1 && flag2 then |
| 117 |
let lo = acs_float_lo pp b and |
| 118 |
hi = acs_float_hi pp a in |
| 119 |
mk_interval (lo, hi) |
| 120 |
else |
| 121 |
failwith "acs_interval: x < -1 || x > 1";; |
| 122 |
|
| 123 |
end;; |
| 124 |
|
| 125 |
(*************************) |
| 126 |
|
| 127 |
(* |
| 128 |
|
| 129 |
needs "Formal_ineqs/trig/asn_acs_eval.hl";; |
| 130 |
|
| 131 |
open Informal_asn_acs;; |
| 132 |
|
| 133 |
#install_printer print_ifloat;; |
| 134 |
#install_printer print_interval;; |
| 135 |
|
| 136 |
let x = mk_float 1 (-1) and |
| 137 |
y = mk_float (-1) (-1);; |
| 138 |
|
| 139 |
let i1 = mk_interval (y, x) and |
| 140 |
i2 = mk_interval (x, x) and |
| 141 |
i3 = mk_interval (y, y);; |
| 142 |
|
| 143 |
let x_tm, y_tm = |
| 144 |
let mk = Arith_float.mk_float in |
| 145 |
mk 1 (-1), mk (-1) (-1);; |
| 146 |
|
| 147 |
Interval_arith.mk_interval;; |
| 148 |
|
| 149 |
let i1_th, i2_th, i3_th = |
| 150 |
let mk a b = ASSUME (Interval_arith.mk_interval `z:real` (mk_pair (a, b))) in |
| 151 |
mk y_tm x_tm, |
| 152 |
mk x_tm x_tm, |
| 153 |
mk y_tm y_tm;; |
| 154 |
|
| 155 |
let pp = 10;; |
| 156 |
|
| 157 |
asn_interval pp i1;; |
| 158 |
Asn_acs_eval.float_interval_asn pp i1_th;; |
| 159 |
|
| 160 |
asn_interval pp i2;; |
| 161 |
Asn_acs_eval.float_interval_asn pp i2_th;; |
| 162 |
|
| 163 |
asn_interval pp i3;; |
| 164 |
Asn_acs_eval.float_interval_asn pp i3_th;; |
| 165 |
|
| 166 |
acs_interval pp i1;; |
| 167 |
Asn_acs_eval.float_interval_acs pp i1_th;; |
| 168 |
|
| 169 |
acs_interval pp i2;; |
| 170 |
Asn_acs_eval.float_interval_acs pp i2_th;; |
| 171 |
|
| 172 |
acs_interval pp i3;; |
| 173 |
Asn_acs_eval.float_interval_acs pp i3_th;; |
| 174 |
|
| 175 |
*) |