Module Fol


module Fol: sig .. end
apply do_exp on each sub expression of the predicate. quantif_do_exp is called to change do_exp if needed when we go under a quantification.

subst_vars_in_pred prop_in_data var_subst p



type pure_type =
| PTint
| PTbool
| PTreal
| PTunit
| PTvar of string
| PTexternal of pure_type list * string

type constant =
| ConstInt of string
| ConstBool of bool
| ConstUnit
| ConstFloat of string

type variable =
| VarL of Cil_types.logic_var * pure_type
| VarT of string * int option * pure_type
val mk_lvar_variable : Cil_types.logic_var -> pure_type -> variable
val lvar_of_variable : variable -> Cil_types.logic_var option
val var_type : variable -> pure_type
val var_name : variable -> string

type 'a d_term =
| Tconst of constant
| Tvar of variable
| Tdata of 'a
| Tapp of string * 'a d_term list
| Tif of 'a d_term * 'a d_term * 'a d_term

type 'a t_pred =
| Pvar of string
| Papp of string * 'a list
| Ptrue
| Pfalse
| Pimplies of 'a t_pred * 'a t_pred
| Pif of 'a * 'a t_pred * 'a t_pred
| Pand of 'a t_pred * 'a t_pred
| Por of 'a t_pred * 'a t_pred
| Pxor of 'a t_pred * 'a t_pred
| Piff of 'a t_pred * 'a t_pred
| Pnot of 'a t_pred
| Pforall of variable * 'a t_pred
| Pexists of variable * 'a t_pred
| Plet of variable * 'a * 'a t_pred
| Pnamed of string * 'a t_pred
type 'a d_pred = 'a d_term t_pred 

type 'a gen_decl =
| Function of string * pure_type list * pure_type
| Predicate of string * pure_type list
| Axiom of string * 'a t_pred
| Goal of string * 'a t_pred
| Type of pure_type
val pand : 'a t_pred * 'a t_pred -> 'a t_pred
val pands : 'a t_pred list -> 'a t_pred -> 'a t_pred
val conj_list : 'a t_pred list -> 'a t_pred
val pimplies : 'a t_pred * 'a t_pred -> 'a t_pred
val pnot : 'a t_pred -> 'a t_pred
val por : 'a t_pred * 'a t_pred -> 'a t_pred
val pxor : 'a t_pred * 'a t_pred -> 'a t_pred
val pors : 'a t_pred list -> 'a t_pred -> 'a t_pred
val pif : 'a * 'a t_pred * 'a t_pred -> 'a t_pred
val piff : 'a t_pred * 'a t_pred -> 'a t_pred
val papp : string * 'a list -> 'a t_pred
val change_exp_in_pred : ('a -> 'b) -> 'c -> 'a t_pred -> 'b t_pred
apply do_exp on each sub expression of the predicate. quantif_do_exp is called to change do_exp if needed when we go under a quantification.

change_exp_in_pred do_exp quantif_do_exp p

val fold_exp_in_pred : ('a -> 'b -> 'a) -> 'a -> 'b t_pred -> 'a
fold_exp_in_pred do_exp acc p
val fold_data_in_exp : ('a -> variable -> 'a) -> ('a -> 'b -> 'a) -> 'a -> 'b d_term -> 'a
fold_data_in_exp do_var do_data acc exp
val change_in_exp : (variable -> 'a d_term option) ->
('b -> 'a d_term) -> 'b d_term -> 'a d_term
change_in_exp do_var do_data exp
val eq_var : variable -> variable -> bool
val eq_term : ('a -> 'b -> bool) -> 'a d_term -> 'b d_term -> bool
val change_vars_in_exp : (('a d_term -> 'b d_term) -> 'a -> 'b d_term) ->
(variable -> 'b d_term option) -> 'a d_term -> 'b d_term
val subst_in_exp : (('a d_term -> 'b d_term) -> 'a -> 'b d_term) ->
variable -> 'b d_term -> 'a d_term -> 'b d_term
subst_in_exp prop_in_data x e exp
val subst_vars_in_pred : (('a d_term -> 'b d_term) -> 'a -> 'b d_term) ->
(variable -> 'b d_term option) ->
'a d_term t_pred -> 'b d_term t_pred
subst_vars_in_pred prop_in_data var_subst p
val subst_in_pred : (('a d_term -> 'b d_term) -> 'a -> 'b d_term) ->
variable ->
'b d_term -> 'a d_term t_pred -> 'b d_term t_pred
subst_in_pred prop_in_data x exp p
val translate_data_in_term : ('a -> 'b d_term) -> 'a d_term -> 'b d_term
translate_data_in_term do_data exp

translate_data_in_pred do_data p

val translate_data_in_pred : ('a -> 'b d_term) -> 'a d_term t_pred -> 'b d_term t_pred
val var_counter : int Pervasives.ref
val fresh_named_var : string -> pure_type -> variable
val fresh_var : variable -> variable
val fresh_var_in_pred : (('a d_term -> 'b d_term) -> 'a -> 'b d_term) ->
variable ->
'a d_term t_pred -> variable * 'b d_term t_pred
fresh_var_in_pred prop_in_data v p : build a fresh var v' from v, and subst v -> v' in p
val nb_var_in_pred : (('a d_term -> 'a d_term) -> 'a -> 'b) ->
variable -> 'a d_term t_pred -> int
val forall_pred : (('a d_term -> 'a d_term) -> 'a -> 'a d_term) ->
fresh:bool ->
variable -> 'a d_term t_pred -> 'a d_term t_pred
forall_pred prop_in_data ~fresh v p
val let_pred : (('a d_term -> 'a d_term) -> 'a -> 'a d_term) ->
fresh:bool ->
variable ->
'a d_term -> 'a d_term t_pred -> 'a d_term t_pred
let_pred prop_in_data ~fresh v e p
type data = unit 
type term = data d_term 
type predicate = term t_pred 
type decl = term gen_decl 
val subst_vars_in_predicate : (variable -> 'a d_term option) ->
'b d_term t_pred -> 'a d_term t_pred
val subst_in_predicate : variable ->
'a d_term -> 'b d_term t_pred -> 'a d_term t_pred
val plet : variable ->
'a -> 'b d_term -> 'b d_term t_pred -> 'b d_term t_pred
val pforall : variable * 'a * 'b d_term t_pred -> 'b d_term t_pred
val pexists : variable * 'a * 'b d_term t_pred -> 'c d_term t_pred