You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
150 lines
3.2 KiB
150 lines
3.2 KiB
(*
|
|
* Copyright (c) Facebook, Inc. and its affiliates.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*)
|
|
|
|
(** Terms *)
|
|
module rec Term : sig
|
|
type t [@@deriving compare, equal, sexp]
|
|
|
|
(* pretty-printing *)
|
|
val ppx : Var.strength -> t pp
|
|
val pp : t pp
|
|
|
|
module Set : Set.S with type elt := t
|
|
module Map : Map.S with type key := t
|
|
|
|
(** Construct *)
|
|
|
|
(* variables *)
|
|
val var : Var.t -> t
|
|
|
|
(* arithmetic *)
|
|
val zero : t
|
|
val one : t
|
|
val integer : Z.t -> t
|
|
val rational : Q.t -> t
|
|
val neg : t -> t
|
|
val add : t -> t -> t
|
|
val sub : t -> t -> t
|
|
val mulq : Q.t -> t -> t
|
|
val mul : t -> t -> t
|
|
val div : t -> t -> t
|
|
val pow : t -> int -> t
|
|
|
|
(* sequences (of flexible size) *)
|
|
val splat : t -> t
|
|
(** Iterated concatenation of a single byte *)
|
|
|
|
val sized : seq:t -> siz:t -> t
|
|
(** Size-tagged sequence *)
|
|
|
|
val extract : seq:t -> off:t -> len:t -> t
|
|
(** Extract a slice of a sequence *)
|
|
|
|
val concat : t array -> t
|
|
(** Concatenation of sequences *)
|
|
|
|
(* uninterpreted *)
|
|
val apply : Funsym.t -> t array -> t
|
|
|
|
(* if-then-else *)
|
|
val ite : cnd:Formula.t -> thn:t -> els:t -> t
|
|
|
|
(* Trm.t is embedded into Term.t *)
|
|
val of_trm : Trm.t -> t
|
|
val get_trm : t -> Trm.t option
|
|
|
|
(** Destruct *)
|
|
|
|
val get_z : t -> Z.t option
|
|
(** [get_z a] is [Some z] iff [equal a (integer z)] *)
|
|
|
|
val get_q : t -> Q.t option
|
|
(** [get_q a] is [Some q] iff [equal a (rational q)] *)
|
|
|
|
(** Access *)
|
|
|
|
val split_const : t -> t * Q.t
|
|
(** Splits a term into the sum of its constant and non-constant parts.
|
|
That is, [split_const a] is [(b, c)] such that [a = b + c] and the
|
|
absolute value of [c] is maximal. *)
|
|
|
|
(** Query *)
|
|
|
|
val fv : t -> Var.Set.t
|
|
|
|
(** Traverse *)
|
|
|
|
val vars : t -> Var.t iter
|
|
val atoms : t -> t iter
|
|
|
|
(** Transform *)
|
|
|
|
val map_vars : t -> f:(Var.t -> Var.t) -> t
|
|
val map_trms : t -> f:(Trm.t -> Trm.t) -> t
|
|
val fold_map_vars : t -> 's -> f:(Var.t -> 's -> Var.t * 's) -> t * 's
|
|
val rename : Var.Subst.t -> t -> t
|
|
end
|
|
|
|
(** Formulas *)
|
|
and Formula : sig
|
|
type t = Fml.t [@@deriving compare, equal, sexp]
|
|
|
|
val inject : t -> Term.t
|
|
val project : Term.t -> t option
|
|
|
|
(* pretty-printing *)
|
|
val ppx : Var.strength -> t pp
|
|
val pp : t pp
|
|
|
|
(** Construct *)
|
|
|
|
(* constants *)
|
|
val tt : t
|
|
val ff : t
|
|
|
|
(* equality *)
|
|
val eq : Term.t -> Term.t -> t
|
|
val dq : Term.t -> Term.t -> t
|
|
|
|
(* arithmetic *)
|
|
val eq0 : Term.t -> t
|
|
val dq0 : Term.t -> t
|
|
val pos : Term.t -> t
|
|
val gt : Term.t -> Term.t -> t
|
|
val ge : Term.t -> Term.t -> t
|
|
val lt : Term.t -> Term.t -> t
|
|
val le : Term.t -> Term.t -> t
|
|
|
|
(* uninterpreted *)
|
|
val lit : Predsym.t -> Term.t array -> t
|
|
|
|
(* connectives *)
|
|
val not_ : t -> t
|
|
val and_ : t -> t -> t
|
|
val andN : t list -> t
|
|
val or_ : t -> t -> t
|
|
val orN : t list -> t
|
|
val iff : t -> t -> t
|
|
val xor : t -> t -> t
|
|
val cond : cnd:t -> pos:t -> neg:t -> t
|
|
|
|
(** Query *)
|
|
|
|
val fv : t -> Var.Set.t
|
|
|
|
(** Traverse *)
|
|
|
|
val vars : t -> Var.t iter
|
|
|
|
(** Transform *)
|
|
|
|
val map_terms : f:(Term.t -> Term.t) -> t -> t
|
|
val map_vars : t -> f:(Var.t -> Var.t) -> t
|
|
val fold_map_vars : t -> 's -> f:(Var.t -> 's -> Var.t * 's) -> t * 's
|
|
val rename : Var.Subst.t -> t -> t
|
|
end
|