module Q
use real.RealInfix
use int.Int
use real.FromInt
use Z as Z
type t = private {
num: int;
den: int;
}
invariant { 0 < den }
invariant { Z.prime_to_one_another num den }
Valid (14ms) (colibri2)
by { num = 1; den = 1 }
function real (q:t) : real = ((from_int q.num) /. (from_int q.den))
meta coercion function real
predicate equal (a b:t) = (a.real = b.real)
val (=) (a:t) (b:t) : bool
ensures { equal a b = result }
axiom equal_is_eq: forall a b. equal a b -> a = b
predicate (<=) (a:t) (b:t) = (a.real <=. b.real)
predicate (<) (a:t) (b:t) = (a.real <. b.real)
val (<=) (a:t) (b:t) : bool
ensures { result = (a <= b) }
val (<) (a:t) (b:t) : bool
ensures { result = (a < b) }
use real.Abs
val abs (a:t) : t
ensures { result.real = abs a.real }
use Ord as Ord
val compare (a:t) (b:t) : Ord.t
ensures { match result with
| Ord.Eq -> equal a b
| Ord.Lt -> a < b
| Ord.Gt -> b < a
end
}
val function (+) (a b:t) : t
ensures { a.real +. b.real = result.real }
val function (-) (a b:t) : t
ensures { a.real -. b.real = result.real }
val function (*) (a b:t) : t
ensures { a.real *. b.real = result.real }
val function (/) (a b:t) : t
requires { b.real <> 0. }
ensures { a.real /. b.real = result.real }
function make (num den:int): t
axiom make_def:
forall num den: int. den <> 0 -> (make num den).real = (from_int num) /. (from_int den)
val make (num den: int): t
requires { den <> 0 }
ensures { result = make num den }
val make_exact (num den: int): t
requires { Int.(<) 0 den } requires { Z.prime_to_one_another num den }
ensures { result.num = num }
ensures { result.den = den }
use real.Truncate
val to_int (a:t) : int
ensures { result = truncate a.real }
val of_int (a:int) : t
ensures { result.real = from_int a }
Valid (739ms) (cvc5)
let floor (a:t) : int
ensures { result = floor a.real } =
Z.fdiv a.num a.den
Valid (780ms) (cvc5)
let ceil (a:t) : int
ensures { result = ceil a.real } =
Z.cdiv a.num a.den
end