Module Imandra_prelude

type 'a printer = Format.formatter -> 'a -> unit
module Caml : sig ... end
module Caml_unix = Unix
module Caml_sys = Sys
module Unix : sig ... end
module Sys : sig ... end

Bare minimum needed for ordinals and validation

type nonrec int = Z.t

Builtin integer type, using arbitrary precision integers.

This type is an alias to Z.t (using Zarith).

NOTE: here Imandra diverges from normal OCaml, where integers width is bounded by native machine integers. "Normal" OCaml integers have type Caml.Int.t and can be entered using the 'i' suffix: 0i

type nonrec float = float
type nonrec real = Q.t
type nonrec string = string
type nonrec nativeint = nativeint
val (=) : 'a -> 'a -> bool

Equality. Must be applied to non-function types.

val (<) : int -> int -> bool
val (<=) : int -> int -> bool
val (>) : int -> int -> bool
val (>=) : int -> int -> bool
val min : int -> int -> int
val max : int -> int -> int
val (<.) : real -> real -> bool
val (<=.) : real -> real -> bool
val (>.) : real -> real -> bool
val (>=.) : real -> real -> bool
val min_r : real -> real -> real
val max_r : real -> real -> real
val (<>) : 'a -> 'a -> bool
val not : bool -> bool
val implies : bool -> bool -> bool
val explies : bool -> bool -> bool
val iff : bool -> bool -> bool
val (+) : Z.t -> Z.t -> Z.t
val (~-) : Z.t -> Z.t
val abs : int -> int
val mk_nat : int -> int
val (-) : Z.t -> Z.t -> Z.t
val (~+) : Z.t -> Z.t
val (*) : Z.t -> Z.t -> Z.t
val (/) : Z.t -> Z.t -> Z.t

Euclidian division on integers, see http://smtlib.cs.uiowa.edu/theories-Ints.shtml

val (mod) : Z.t -> Z.t -> Z.t

Euclidian remainder on integers

val const : 'a -> 'b -> 'a

const x y returns x. In other words, const x is the constant function that always returns x.

val compare : int -> int -> Z.t

Total order

Ordinals

module Ordinal : sig ... end

We need to define ordinals before any recursive function is defined, because ordinals are used for termination proofs.

module Peano_nat : sig ... end

Other builtin types

type nonrec unit = unit =
| (())
type ('a, 'b) result = ('a'b) Pervasives.result =
| Ok of 'a
| Error of 'b

Result type, representing either a successul result Ok x or an error Error x.

module Result : sig ... end
type ('a, 'b) either =
| Left of 'a
| Right of 'b

A familiar type for Haskellers

val (|>) : 'a -> ('a -> 'b) -> 'b

Pipeline operator.

x |> f is the same as f x, but it composes nicely: x |> f |> g |> h can be more readable than h(g(f x)).

val (@@) : ('a -> 'b) -> 'a -> 'b

Right-associative application operator.

f @@ x is the same as f x, but it binds to the right: f @@ g @@ h @@ x is the same as f (g (h x)) but with fewer parentheses.

val id : 'a -> 'a

Identity function. id x = x always holds.

val (%>) : ('a -> 'b) -> ('b -> 'c) -> 'a -> 'c

Mathematical composition operator.

f %> g is fun x -> g (f x)

val (==) : 'a -> 'b -> Caml.use_normal_equality
val (!=) : 'a -> 'b -> Caml.use_normal_equality
val (+.) : real -> real -> real
val (-.) : real -> real -> real
val (~-.) : Q.t -> Q.t
val (*.) : real -> real -> real
val (/.) : real -> real -> real
val (==>) : bool -> bool -> bool
val (<==) : bool -> bool -> bool
val (<==>) : bool -> bool -> bool
module List : sig ... end
val (@) : 'a list -> 'a list -> 'a list

Infix alias to List.append

val (--) : int -> int -> int list

Alias to List.(--)

module Int : sig ... end
module Array : sig ... end
module Option : sig ... end
module Real : sig ... end
module Map : sig ... end
module Multiset : sig ... end

Sets

module Set : sig ... end
module String : sig ... end
val (^) : String.t -> String.t -> String.t

Alias to String.append

val succ : Z.t -> Z.t

Next integer

val pred : Z.t -> Z.t

Previous integer

val fst : ('a * 'b) -> 'a
val snd : ('a * 'b) -> 'b
module Float : sig ... end
module Pervasives : sig ... end