diff --git a/src/api/ml/z3.ml b/src/api/ml/z3.ml index 76536ef43..4d391c06f 100644 --- a/src/api/ml/z3.ml +++ b/src/api/ml/z3.ml @@ -293,13 +293,12 @@ let reset_memory () = () (** Exceptions raised by Z3. It is safe to continue interacting with Z3 after catching [Error] exceptions. - - {b See also}: {!get_error_msg} *) exception Error of context * error_code - +(* Register dynamically-generated exception tag for use from C *) let _ = Callback.register_exception "Z3.Error" (Error (Obj.magic None, OK)) external mk_context: (string * string) list -> context = "caml_z3_mk_context" @@ -349,7 +348,6 @@ external param_descrs_to_string : context -> param_descrs -> string (** Refined view of a {!symbol}. - - {b See also}: {!mk_symbol} - {b See also}: {!symbol_refine} *) @@ -368,33 +366,28 @@ external mk_string_symbol : context -> string -> symbol A datatype constructor descriptor. *) type datatype_constructor_desc = { - constructor_desc : symbol; (** name of the constructor function *) - recognizer_desc : symbol; (** name of the recognizer function *) - accessor_descs : (symbol * sort) array; (** names and sorts of the fields *) + constructor_desc : symbol; (** name of the constructor function *) + recognizer_desc : symbol; (** name of the recognizer function *) + accessor_descs : (symbol * sort) array; (** names and sorts of the fields *) } - (** A datatype is described by a name and constructor descriptors. *) type datatype_desc = symbol * datatype_constructor_desc array - (** A datatype constructor representation. *) type datatype_constructor = { - constructor : func_decl; (** constructor function *) - recognizer : func_decl; (** recognizer function *) - accessors : func_decl array; (** field accessor functions *) + constructor : func_decl; (** constructor function *) + recognizer : func_decl; (** recognizer function *) + accessors : func_decl array; (** field accessor functions *) } - (** A datatype is represented by a sort and constructors. *) type datatype = sort * datatype_constructor array - (** Refined view of a {!sort}. - - {b See also}: {!mk_sort} - {b See also}: {!sort_refine} *) @@ -751,9 +744,9 @@ external mk_set_subset : context -> ast -> ast -> ast Summary: \[ [ numeral_refined ] \] is the refined view of a numeral . *) type numeral_refined = - | Numeral_int of int * sort - | Numeral_int64 of int64 * sort - | Numeral_large of string * sort + | Numeral_int of int * sort + | Numeral_int64 of int64 * sort + | Numeral_large of string * sort | Numeral_rational of numeral_refined * numeral_refined external mk_numeral : context -> string -> sort -> ast @@ -930,21 +923,18 @@ external get_app_arg : context -> app -> int -> ast (** Summary: \[ [ binder_type ] \] is a universal or existential quantifier. - - {b See also}: {!term_refined} *) type binder_type = Forall | Exists - (** Summary: \[ [ term_refined ] \] is the refinement of a {!ast} . - - {b See also}: {!term_refine} *) type term_refined = - | Term_numeral of numeral_refined - | Term_app of decl_kind * func_decl * ast array + | Term_numeral of numeral_refined + | Term_app of decl_kind * func_decl * ast array | Term_quantifier of binder_type * int * ast array array * (symbol * sort) array * ast - | Term_var of int * sort + | Term_var of int * sort external is_eq_ast : context -> ast -> ast -> bool = "camlidl_z3_Z3_is_eq_ast" @@ -1220,12 +1210,6 @@ external get_smtlib_sort : context -> int -> sort external get_smtlib_error : context -> string = "camlidl_z3_Z3_get_smtlib_error" -external parse_z3_string : context -> string -> ast - = "camlidl_z3_Z3_parse_z3_string" - -external parse_z3_file : context -> string -> ast - = "camlidl_z3_Z3_parse_z3_file" - external set_error : context -> error_code -> unit = "camlidl_z3_Z3_set_error" @@ -1235,6 +1219,12 @@ external get_error_msg_ex : context -> error_code -> string external get_version : unit -> int * int * int * int = "camlidl_z3_Z3_get_version" +external enable_trace : string -> unit + = "camlidl_z3_Z3_enable_trace" + +external disable_trace : string -> unit + = "camlidl_z3_Z3_disable_trace" + external mk_fixedpoint : context -> fixedpoint = "camlidl_z3_Z3_mk_fixedpoint" @@ -1280,8 +1270,11 @@ external fixedpoint_register_relation : context -> fixedpoint -> func_decl -> un external fixedpoint_set_predicate_representation : context -> fixedpoint -> func_decl -> symbol array -> unit = "camlidl_z3_Z3_fixedpoint_set_predicate_representation" -external fixedpoint_simplify_rules : context -> fixedpoint -> ast array -> func_decl array -> ast_vector - = "camlidl_z3_Z3_fixedpoint_simplify_rules" +external fixedpoint_get_rules : context -> fixedpoint -> ast_vector + = "camlidl_z3_Z3_fixedpoint_get_rules" + +external fixedpoint_get_assertions : context -> fixedpoint -> ast_vector + = "camlidl_z3_Z3_fixedpoint_get_assertions" external fixedpoint_set_params : context -> fixedpoint -> params -> unit = "camlidl_z3_Z3_fixedpoint_set_params" @@ -1295,6 +1288,12 @@ external fixedpoint_get_param_descrs : context -> fixedpoint -> param_descrs external fixedpoint_to_string : context -> fixedpoint -> ast array -> string = "camlidl_z3_Z3_fixedpoint_to_string" +external fixedpoint_from_string : context -> fixedpoint -> string -> ast_vector + = "camlidl_z3_Z3_fixedpoint_from_string" + +external fixedpoint_from_file : context -> fixedpoint -> string -> ast_vector + = "camlidl_z3_Z3_fixedpoint_from_file" + external fixedpoint_push : context -> fixedpoint -> unit = "camlidl_z3_Z3_fixedpoint_push" @@ -1544,6 +1543,9 @@ external solver_get_num_scopes : context -> solver -> int external solver_assert : context -> solver -> ast -> unit = "camlidl_z3_Z3_solver_assert" +external solver_assert_and_track : context -> solver -> ast -> ast -> unit + = "camlidl_z3_Z3_solver_assert_and_track" + external solver_get_assertions : context -> solver -> ast_vector = "camlidl_z3_Z3_solver_get_assertions" @@ -1597,18 +1599,15 @@ external stats_get_double_value : context -> stats -> int -> float = "camlidl_z3_Z3_stats_get_double_value" - (* Internal auxiliary functions: *) (* (* Transform a pair of arrays into an array of pairs *) let array_combine a b = if Array.length a <> Array.length b then raise (Invalid_argument "array_combine"); Array.init (Array.length a) (fun i -> (a.(i), b.(i))) - (* [a |> b] is the pipeline operator for [b(a)] *) let ( |> ) x f = f x *) - (* Find the index of an element in an array, raises Not_found is missing *) let find equal x a = let len = Array.length a in @@ -1622,24 +1621,17 @@ let find equal x a = find_ (i+1) in find_ 0 - - (* Symbols *) - let symbol_refine c s = match get_symbol_kind c s with | INT_SYMBOL -> Symbol_int (get_symbol_int c s) | STRING_SYMBOL -> Symbol_string (get_symbol_string c s) - let mk_symbol c = function | Symbol_int(i) -> mk_int_symbol c i | Symbol_string(s) -> mk_string_symbol c s - - (* Sorts *) - -let get_datatype_sort c s = - Array.init (get_datatype_sort_num_constructors c s) (fun i -> +let get_datatype_sort c s = + Array.init (get_datatype_sort_num_constructors c s) (fun i -> let constructor = get_datatype_sort_constructor c s i in let recognizer = get_datatype_sort_recognizer c s i in let accessors = @@ -1648,7 +1640,6 @@ let get_datatype_sort c s = ) in {constructor; recognizer; accessors} ) - let sort_refine c s = match get_sort_kind c s with | UNINTERPRETED_SORT -> Sort_uninterpreted (get_sort_name c s) @@ -1665,7 +1656,6 @@ let sort_refine c s = | DATATYPE_SORT -> Sort_datatype (get_datatype_sort c s) | RELATION_SORT -> Sort_relation (Array.init (get_relation_arity c s) (fun i -> get_relation_column c s i)) | UNKNOWN_SORT -> Sort_unknown - let mk_sort c = function | Sort_uninterpreted(s) -> mk_uninterpreted_sort c s | Sort_bool -> mk_bool_sort c @@ -1677,10 +1667,7 @@ let mk_sort c = function | Sort_datatype(constructors) -> get_range c constructors.(0).constructor | Sort_relation(_) -> invalid_arg "Z3.mk_sort: cannot construct relation sorts" | Sort_unknown(_) -> invalid_arg "Z3.mk_sort: cannot construct unknown sorts" - - (* Replacement datatypes creation API *) - let mk_datatypes ctx generator = let usort0 = mk_uninterpreted_sort ctx (mk_int_symbol ctx 0) in @@ -1749,19 +1736,16 @@ let mk_datatypes ctx generator = ) ctorss ; datatypes - - (* Numerals *) - let rec numeral_refine c t = assert( get_ast_kind c t = NUMERAL_AST ); let sort = get_sort c t in let is_int, i = get_numeral_int c t in - if is_int then + if is_int then Numeral_int (i, sort) else let is_int64, i = get_numeral_int64 c t in - if is_int64 then + if is_int64 then Numeral_int64 (i, sort) else if get_sort_kind c sort <> REAL_SORT then @@ -1770,14 +1754,11 @@ let rec numeral_refine c t = let n = numeral_refine c (get_numerator c t) in let d = numeral_refine c (get_denominator c t) in Numeral_rational (n, d) - - let to_real c x = if get_sort_kind c (get_sort c x) = REAL_SORT then x else mk_int2real c x - let rec embed_numeral c = function | Numeral_int (i, s) -> mk_int c i s | Numeral_int64 (i, s) -> mk_int64 c i s @@ -1790,21 +1771,14 @@ let rec embed_numeral c = function let d_str = get_numeral_string c (embed_numeral c d) in mk_numeral c (n_str ^ " / " ^ d_str) (mk_real_sort c) *) - (* Terms *) - let get_app_args c a = Array.init (get_app_num_args c a) (get_app_arg c a);; - let get_domains c d = Array.init (get_domain_size c d) (get_domain c d);; - - -let get_pattern_terms c p = +let get_pattern_terms c p = Array.init (get_pattern_num_terms c p) (get_pattern c p) - - -let term_refine c t = +let term_refine c t = match get_ast_kind c t with | NUMERAL_AST -> Term_numeral (numeral_refine c t) @@ -1815,35 +1789,29 @@ let term_refine c t = let args = Array.init num_args (get_app_arg c t') in let k = get_decl_kind c f in Term_app (k, f, args) - | QUANTIFIER_AST -> + | QUANTIFIER_AST -> let bt = if is_quantifier_forall c t then Forall else Exists in - let w = get_quantifier_weight c t in - let np = get_quantifier_num_patterns c t in - let pats = Array.init np (get_quantifier_pattern_ast c t) in - let pats = Array.map (get_pattern_terms c) pats in - let nb = get_quantifier_num_bound c t in + let w = get_quantifier_weight c t in + let np = get_quantifier_num_patterns c t in + let pats = Array.init np (get_quantifier_pattern_ast c t) in + let pats = Array.map (get_pattern_terms c) pats in + let nb = get_quantifier_num_bound c t in let bound = Array.init nb (fun i -> (get_quantifier_bound_name c t i, get_quantifier_bound_sort c t i) ) in let body = get_quantifier_body c t in Term_quantifier (bt, w, pats, bound, body) - | VAR_AST -> + | VAR_AST -> Term_var (get_index_value c t, get_sort c t) | _ -> assert false - - (* let mk_term c = function *) -(* | Term_numeral (numeral, sort) -> mk_numeral c numeral sort *) -(* | Term_app (kind, decl, args) -> *) -(* | Term_quantifier (strength, weight, pats, bound, body) -> *) -(* | Term_var (index, sort) -> *) - - - +(* | Term_numeral (numeral, sort) -> mk_numeral c numeral sort *) +(* | Term_app (kind, decl, args) -> *) +(* | Term_quantifier (strength, weight, pats, bound, body) -> *) +(* | Term_var (index, sort) -> *) (* Refined model API *) - let model_refine c m = let num_sorts = model_get_num_sorts c m in let sorts = Hashtbl.create num_sorts in @@ -1903,49 +1871,33 @@ let model_refine c m = () done; {sorts; consts; arrays; funcs} - - (* Extended parser API *) - -let get_smtlib_formulas c = +let get_smtlib_formulas c = Array.init (get_smtlib_num_formulas c) (get_smtlib_formula c) - -let get_smtlib_assumptions c = +let get_smtlib_assumptions c = Array.init (get_smtlib_num_assumptions c) (get_smtlib_assumption c) - let get_smtlib_decls c = Array.init (get_smtlib_num_decls c) (get_smtlib_decl c) - let get_smtlib_parse_results c = (get_smtlib_formulas c, get_smtlib_assumptions c, get_smtlib_decls c) - -let parse_smtlib_string_x c a1 a2 a3 a4 a5 = +let parse_smtlib_string_x c a1 a2 a3 a4 a5 = parse_smtlib_string c a1 a2 a3 a4 a5 ; get_smtlib_parse_results c - -let parse_smtlib_file_x c a1 a2 a3 a4 a5 = +let parse_smtlib_file_x c a1 a2 a3 a4 a5 = parse_smtlib_file c a1 a2 a3 a4 a5 ; get_smtlib_parse_results c - -let parse_smtlib_string_formula c a1 a2 a3 a4 a5 = +let parse_smtlib_string_formula c a1 a2 a3 a4 a5 = parse_smtlib_string c a1 a2 a3 a4 a5 ; match get_smtlib_formulas c with [|f|] -> f | _ -> failwith "Z3: parse_smtlib_string_formula" - -let parse_smtlib_file_formula c a1 a2 a3 a4 a5 = +let parse_smtlib_file_formula c a1 a2 a3 a4 a5 = parse_smtlib_file c a1 a2 a3 a4 a5 ; match get_smtlib_formulas c with [|f|] -> f | _ -> failwith "Z3: parse_smtlib_file_formula" - - (* Error handling *) - let get_error_msg c e = match e with | PARSER_ERROR -> (get_error_msg_ex c e) ^ ": " ^ (get_smtlib_error c) | _ -> get_error_msg_ex c e - - (* Refined stats API *) - let stats_refine c s = let num_stats = stats_size c s in let tbl = Hashtbl.create num_stats in @@ -1970,7 +1922,7 @@ let _ = module V3 = struct -(* File generated from z3.idl *) +(* File generated from z3V3.idl *) type symbol and literals @@ -2205,6 +2157,15 @@ and ast_print_mode = | PRINT_SMTLIB2_COMPLIANT +external global_param_set : string -> string -> unit + = "camlidl_z3V3_Z3_global_param_set" + +external global_param_reset_all : unit -> unit + = "camlidl_z3V3_Z3_global_param_reset_all" + +external global_param_get : string -> string option + = "camlidl_z3V3_Z3_global_param_get" + external mk_config : unit -> config = "camlidl_z3V3_Z3_mk_config" @@ -2263,7 +2224,7 @@ external mk_list_sort : context -> symbol -> sort -> sort * func_decl * func_dec = "camlidl_z3V3_Z3_mk_list_sort" external mk_constructor : context -> symbol -> symbol -> symbol array -> sort array -> int array -> constructor - = "camlidl_z3_Z3_mk_constructor_bytecode" "camlidl_z3V3_Z3_mk_constructor" + = "camlidl_z3V3_Z3_mk_constructor_bytecode" "camlidl_z3V3_Z3_mk_constructor" external del_constructor : context -> constructor -> unit = "camlidl_z3V3_Z3_del_constructor" @@ -2587,16 +2548,16 @@ external mk_bound : context -> int -> sort -> ast = "camlidl_z3V3_Z3_mk_bound" external mk_forall : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast - = "camlidl_z3_Z3_mk_forall_bytecode" "camlidl_z3V3_Z3_mk_forall" + = "camlidl_z3V3_Z3_mk_forall_bytecode" "camlidl_z3V3_Z3_mk_forall" external mk_exists : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast - = "camlidl_z3_Z3_mk_exists_bytecode" "camlidl_z3V3_Z3_mk_exists" + = "camlidl_z3V3_Z3_mk_exists_bytecode" "camlidl_z3V3_Z3_mk_exists" external mk_quantifier : context -> bool -> int -> pattern array -> sort array -> symbol array -> ast -> ast - = "camlidl_z3_Z3_mk_quantifier_bytecode" "camlidl_z3V3_Z3_mk_quantifier" + = "camlidl_z3V3_Z3_mk_quantifier_bytecode" "camlidl_z3V3_Z3_mk_quantifier" external mk_quantifier_ex : context -> bool -> int -> symbol -> symbol -> pattern array -> ast array -> sort array -> symbol array -> ast -> ast - = "camlidl_z3_Z3_mk_quantifier_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_ex" + = "camlidl_z3V3_Z3_mk_quantifier_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_ex" external mk_forall_const : context -> int -> app array -> pattern array -> ast -> ast = "camlidl_z3V3_Z3_mk_forall_const" @@ -2605,10 +2566,10 @@ external mk_exists_const : context -> int -> app array -> pattern array -> ast - = "camlidl_z3V3_Z3_mk_exists_const" external mk_quantifier_const : context -> bool -> int -> app array -> pattern array -> ast -> ast - = "camlidl_z3_Z3_mk_quantifier_const_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const" + = "camlidl_z3V3_Z3_mk_quantifier_const_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const" external mk_quantifier_const_ex : context -> bool -> int -> symbol -> symbol -> app array -> pattern array -> ast array -> ast -> ast - = "camlidl_z3_Z3_mk_quantifier_const_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const_ex" + = "camlidl_z3V3_Z3_mk_quantifier_const_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const_ex" external get_symbol_kind : context -> symbol -> symbol_kind = "camlidl_z3V3_Z3_get_symbol_kind" @@ -2890,19 +2851,19 @@ external model_to_string : context -> model -> string = "camlidl_z3V3_Z3_model_to_string" external benchmark_to_smtlib_string : context -> string -> string -> string -> string -> ast array -> ast -> string - = "camlidl_z3_Z3_benchmark_to_smtlib_string_bytecode" "camlidl_z3V3_Z3_benchmark_to_smtlib_string" + = "camlidl_z3V3_Z3_benchmark_to_smtlib_string_bytecode" "camlidl_z3V3_Z3_benchmark_to_smtlib_string" external parse_smtlib2_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast - = "camlidl_z3_Z3_parse_smtlib2_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_string" + = "camlidl_z3V3_Z3_parse_smtlib2_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_string" external parse_smtlib2_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast - = "camlidl_z3_Z3_parse_smtlib2_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_file" + = "camlidl_z3V3_Z3_parse_smtlib2_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_file" external parse_smtlib_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit - = "camlidl_z3_Z3_parse_smtlib_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib_string" + = "camlidl_z3V3_Z3_parse_smtlib_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib_string" external parse_smtlib_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit - = "camlidl_z3_Z3_parse_smtlib_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib_file" + = "camlidl_z3V3_Z3_parse_smtlib_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib_file" external get_smtlib_num_formulas : context -> int = "camlidl_z3V3_Z3_get_smtlib_num_formulas" @@ -2931,15 +2892,15 @@ external get_smtlib_sort : context -> int -> sort external get_smtlib_error : context -> string = "camlidl_z3V3_Z3_get_smtlib_error" -external parse_z3_string : context -> string -> ast - = "camlidl_z3_Z3_parse_z3V3_string" - -external parse_z3_file : context -> string -> ast - = "camlidl_z3_Z3_parse_z3V3_file" - external get_version : unit -> int * int * int * int = "camlidl_z3V3_Z3_get_version" +external enable_trace : string -> unit + = "camlidl_z3V3_Z3_enable_trace" + +external disable_trace : string -> unit + = "camlidl_z3V3_Z3_disable_trace" + external reset_memory : unit -> unit = "camlidl_z3V3_Z3_reset_memory" @@ -3121,114 +3082,85 @@ external get_context_assignment : context -> ast = "camlidl_z3V3_Z3_get_context_assignment" - - (* Internal auxillary functions: *) - (* Transform a pair of arrays into an array of pairs *) let array_combine a b = if Array.length a <> Array.length b then raise (Invalid_argument "array_combine"); Array.init (Array.length a) (fun i->(a.(i),b.(i)));; - (* [a |> b] is the pipeline operator for [b(a)] *) let ( |> ) x f = f x;; - - (* Extensions, except for refinement: *) -let mk_context_x configs = +let mk_context_x configs = let config = mk_config() in let f(param_id,param_value) = set_param_value config param_id param_value in Array.iter f configs; let context = mk_context config in del_config config; context;; - let get_app_args c a = Array.init (get_app_num_args c a) (get_app_arg c a);; - let get_domains c d = Array.init (get_domain_size c d) (get_domain c d);; - let get_array_sort c t = (get_array_sort_domain c t, get_array_sort_range c t);; - -let get_tuple_sort c ty = +let get_tuple_sort c ty = (get_tuple_sort_mk_decl c ty, Array.init (get_tuple_sort_num_fields c ty) (get_tuple_sort_field_decl c ty));; - -type datatype_constructor_refined = { - constructor : func_decl; - recognizer : func_decl; - accessors : func_decl array +type datatype_constructor_refined = { + constructor : func_decl; + recognizer : func_decl; + accessors : func_decl array } - -let get_datatype_sort c ty = +let get_datatype_sort c ty = Array.init (get_datatype_sort_num_constructors c ty) - (fun idx_c -> + (fun idx_c -> let constr = get_datatype_sort_constructor c ty idx_c in - let recog = get_datatype_sort_recognizer c ty idx_c in + let recog = get_datatype_sort_recognizer c ty idx_c in let num_acc = get_domain_size c constr in { constructor = constr; recognizer = recog; accessors = Array.init num_acc (get_datatype_sort_constructor_accessor c ty idx_c); }) - let get_model_constants c m = Array.init (get_model_num_constants c m) (get_model_constant c m);; - - let get_model_func_entry c m i j = (Array.init (get_model_func_entry_num_args c m i j) (get_model_func_entry_arg c m i j), get_model_func_entry_value c m i j);; - let get_model_func_entries c m i = Array.init (get_model_func_num_entries c m i) (get_model_func_entry c m i);; - let get_model_funcs c m = Array.init (get_model_num_funcs c m) (fun i->(get_model_func_decl c m i |> get_decl_name c, get_model_func_entries c m i, get_model_func_else c m i));; - -let get_smtlib_formulas c = +let get_smtlib_formulas c = Array.init (get_smtlib_num_formulas c) (get_smtlib_formula c);; - -let get_smtlib_assumptions c = +let get_smtlib_assumptions c = Array.init (get_smtlib_num_assumptions c) (get_smtlib_assumption c);; - let get_smtlib_decls c = Array.init (get_smtlib_num_decls c) (get_smtlib_decl c);; - let get_smtlib_parse_results c = (get_smtlib_formulas c, get_smtlib_assumptions c, get_smtlib_decls c);; - -let parse_smtlib_string_formula c a1 a2 a3 a4 a5 = +let parse_smtlib_string_formula c a1 a2 a3 a4 a5 = (parse_smtlib_string c a1 a2 a3 a4 a5; match get_smtlib_formulas c with [|f|] -> f | _ -> failwith "Z3: parse_smtlib_string_formula");; - -let parse_smtlib_file_formula c a1 a2 a3 a4 a5 = +let parse_smtlib_file_formula c a1 a2 a3 a4 a5 = (parse_smtlib_file c a1 a2 a3 a4 a5; match get_smtlib_formulas c with [|f|] -> f | _ -> failwith "Z3: parse_smtlib_file_formula");; - -let parse_smtlib_string_x c a1 a2 a3 a4 a5 = +let parse_smtlib_string_x c a1 a2 a3 a4 a5 = (parse_smtlib_string c a1 a2 a3 a4 a5; get_smtlib_parse_results c);; - -let parse_smtlib_file_x c a1 a2 a3 a4 a5 = +let parse_smtlib_file_x c a1 a2 a3 a4 a5 = (parse_smtlib_file c a1 a2 a3 a4 a5; get_smtlib_parse_results c);; - (* Refinement: *) - type symbol_refined = | Symbol_int of int | Symbol_string of string | Symbol_unknown;; - let symbol_refine c s = match get_symbol_kind c s with | INT_SYMBOL -> Symbol_int (get_symbol_int c s) | STRING_SYMBOL -> Symbol_string (get_symbol_string c s);; - type sort_refined = | Sort_uninterpreted of symbol | Sort_bool @@ -3240,7 +3172,6 @@ type sort_refined = | Sort_relation | Sort_finite_domain | Sort_unknown of symbol;; - let sort_refine c ty = match get_sort_kind c ty with | UNINTERPRETED_SORT -> Sort_uninterpreted (get_sort_name c ty) @@ -3250,56 +3181,50 @@ let sort_refine c ty = | BV_SORT -> Sort_bv (get_bv_sort_size c ty) | ARRAY_SORT -> Sort_array (get_array_sort_domain c ty, get_array_sort_range c ty) | DATATYPE_SORT -> Sort_datatype (get_datatype_sort c ty) - | RELATION_SORT -> Sort_relation + | RELATION_SORT -> Sort_relation | FINITE_DOMAIN_SORT -> Sort_finite_domain | UNKNOWN_SORT -> Sort_unknown (get_sort_name c ty);; - -let get_pattern_terms c p = +let get_pattern_terms c p = Array.init (get_pattern_num_terms c p) (get_pattern c p) - -type binder_type = | Forall | Exists - -type numeral_refined = - | Numeral_small of int64 * int64 - | Numeral_large of string - -type term_refined = - | Term_app of decl_kind * func_decl * ast array +type binder_type = | Forall | Exists +type numeral_refined = + | Numeral_small of int64 * int64 + | Numeral_large of string +type term_refined = + | Term_app of decl_kind * func_decl * ast array | Term_quantifier of binder_type * int * ast array array * (symbol *sort) array * ast - | Term_numeral of numeral_refined * sort - | Term_var of int * sort - -let term_refine c t = + | Term_numeral of numeral_refined * sort + | Term_var of int * sort +let term_refine c t = match get_ast_kind c t with - | NUMERAL_AST -> + | NUMERAL_AST -> let (is_small, n, d) = get_numeral_small c t in - if is_small then - Term_numeral(Numeral_small(n,d), get_sort c t) + if is_small then + Term_numeral(Numeral_small(n,d), get_sort c t) else - Term_numeral(Numeral_large(get_numeral_string c t), get_sort c t) - | APP_AST -> + Term_numeral(Numeral_large(get_numeral_string c t), get_sort c t) + | APP_AST -> let t' = to_app c t in - let f = get_app_decl c t' in + let f = get_app_decl c t' in let num_args = get_app_num_args c t' in let args = Array.init num_args (get_app_arg c t') in let k = get_decl_kind c f in Term_app (k, f, args) - | QUANTIFIER_AST -> + | QUANTIFIER_AST -> let bt = if is_quantifier_forall c t then Forall else Exists in - let w = get_quantifier_weight c t in - let np = get_quantifier_num_patterns c t in - let pats = Array.init np (get_quantifier_pattern_ast c t) in - let pats = Array.map (get_pattern_terms c) pats in - let nb = get_quantifier_num_bound c t in - let bound = Array.init nb - (fun i -> (get_quantifier_bound_name c t i, get_quantifier_bound_sort c t i)) in + let w = get_quantifier_weight c t in + let np = get_quantifier_num_patterns c t in + let pats = Array.init np (get_quantifier_pattern_ast c t) in + let pats = Array.map (get_pattern_terms c) pats in + let nb = get_quantifier_num_bound c t in + let bound = Array.init nb + (fun i -> (get_quantifier_bound_name c t i, get_quantifier_bound_sort c t i)) in let body = get_quantifier_body c t in Term_quantifier(bt, w, pats, bound, body) - | VAR_AST -> + | VAR_AST -> Term_var(get_index_value c t, get_sort c t) | _ -> assert false - -type theory_callbacks = +type theory_callbacks = { mutable delete_theory : unit -> unit; mutable reduce_eq : ast -> ast -> ast option; @@ -3318,8 +3243,7 @@ type theory_callbacks = mutable new_assignment: ast -> bool -> unit; mutable new_relevant : ast -> unit; } - -let mk_theory_callbacks() = +let mk_theory_callbacks() = { delete_theory = (fun () -> ()); reduce_eq = (fun _ _ -> None); @@ -3338,8 +3262,6 @@ let mk_theory_callbacks() = new_assignment = (fun _ _ -> ()); new_relevant = (fun _ -> ()); } - - external get_theory_callbacks : theory -> theory_callbacks = "get_theory_callbacks" external mk_theory_register : context -> string -> theory_callbacks -> theory = "mk_theory_register" external set_delete_callback_register : theory -> unit = "set_delete_callback_register" @@ -3358,146 +3280,116 @@ external set_new_eq_callback_register : theory -> unit = "set_new_eq_callback_re external set_new_diseq_callback_register : theory -> unit = "set_new_diseq_callback_register" external set_new_assignment_callback_register : theory -> unit = "set_new_assignment_callback_register" external set_new_relevant_callback_register : theory -> unit = "set_new_relevant_callback_register" - -let is_some opt = +let is_some opt = match opt with | Some v -> true - | None -> false - -let get_some opt = + | None -> false +let get_some opt = match opt with | Some v -> v - | None -> failwith "None unexpected" - - - - + | None -> failwith "None unexpected" let apply_delete (th:theory_callbacks) = th.delete_theory () -let set_delete_callback th cb = +let set_delete_callback th cb = let cbs = get_theory_callbacks th in cbs.delete_theory <- cb; set_delete_callback_register th - -let mk_theory context name = +let mk_theory context name = Callback.register "is_some" is_some; Callback.register "get_some" get_some; Callback.register "apply_delete" apply_delete; let cbs = mk_theory_callbacks() in mk_theory_register context name cbs - - let apply_reduce_app (th:theory_callbacks) f args = th.reduce_app f args -let set_reduce_app_callback th cb = +let set_reduce_app_callback th cb = Callback.register "apply_reduce_app" apply_reduce_app; let cbs = get_theory_callbacks th in cbs.reduce_app <- cb; set_reduce_app_callback_register th - let apply_reduce_eq (th:theory_callbacks) a b = th.reduce_eq a b -let set_reduce_eq_callback th cb = +let set_reduce_eq_callback th cb = Callback.register "apply_reduce_eq" apply_reduce_eq; let cbs = get_theory_callbacks th in cbs.reduce_eq <- cb; set_reduce_eq_callback_register th - let apply_reduce_distinct (th:theory_callbacks) args = th.reduce_distinct args -let set_reduce_distinct_callback th cb = +let set_reduce_distinct_callback th cb = Callback.register "apply_reduce_distinct" apply_reduce_distinct; let cbs = get_theory_callbacks th in cbs.reduce_distinct <- cb; set_reduce_distinct_callback_register th - - let apply_new_app (th:theory_callbacks) a = th.new_app a -let set_new_app_callback th cb = +let set_new_app_callback th cb = Callback.register "apply_new_app" apply_new_app; let cbs = get_theory_callbacks th in cbs.new_app <- cb; set_new_app_callback_register th - let apply_new_elem (th:theory_callbacks) a = th.new_elem a -let set_new_elem_callback th cb = +let set_new_elem_callback th cb = Callback.register "apply_new_elem" apply_new_elem; let cbs = get_theory_callbacks th in cbs.new_elem <- cb; set_new_elem_callback_register th - - let apply_init_search (th:theory_callbacks) = th.init_search() -let set_init_search_callback th cb = +let set_init_search_callback th cb = Callback.register "apply_init_search" apply_init_search; let cbs = get_theory_callbacks th in cbs.init_search <- cb; set_init_search_callback_register th - - let apply_push (th:theory_callbacks) = th.push() -let set_push_callback th cb = +let set_push_callback th cb = Callback.register "apply_push" apply_push; let cbs = get_theory_callbacks th in cbs.push <- cb; set_push_callback_register th - let apply_pop (th:theory_callbacks) = th.pop() -let set_pop_callback th cb = +let set_pop_callback th cb = Callback.register "apply_pop" apply_pop; let cbs = get_theory_callbacks th in cbs.pop <- cb; set_pop_callback_register th - - let apply_restart (th:theory_callbacks) = th.restart() -let set_restart_callback th cb = +let set_restart_callback th cb = Callback.register "apply_restart" apply_restart; let cbs = get_theory_callbacks th in cbs.restart <- cb; set_restart_callback_register th - - let apply_reset (th:theory_callbacks) = th.reset() -let set_reset_callback th cb = +let set_reset_callback th cb = Callback.register "apply_reset" apply_reset; let cbs = get_theory_callbacks th in cbs.reset <- cb; set_reset_callback_register th - let apply_final_check (th:theory_callbacks) = th.final_check() -let set_final_check_callback th cb = +let set_final_check_callback th cb = Callback.register "apply_final_check" apply_final_check; let cbs = get_theory_callbacks th in cbs.final_check <- cb; set_final_check_callback_register th - let apply_new_eq (th:theory_callbacks) a b = th.new_eq a b -let set_new_eq_callback th cb = +let set_new_eq_callback th cb = Callback.register "apply_new_eq" apply_new_eq; let cbs = get_theory_callbacks th in cbs.new_eq <- cb; set_new_eq_callback_register th - - let apply_new_diseq (th:theory_callbacks) a b = th.new_diseq a b -let set_new_diseq_callback th cb = +let set_new_diseq_callback th cb = Callback.register "apply_new_diseq" apply_new_diseq; let cbs = get_theory_callbacks th in cbs.new_diseq <- cb; set_new_diseq_callback_register th - let apply_new_assignment (th:theory_callbacks) a b = th.new_assignment a b -let set_new_assignment_callback th cb = +let set_new_assignment_callback th cb = Callback.register "apply_new_assignment" apply_new_assignment; let cbs = get_theory_callbacks th in cbs.new_assignment <- cb; set_new_assignment_callback_register th - let apply_new_relevant (th:theory_callbacks) a = th.new_relevant a -let set_new_relevant_callback th cb = +let set_new_relevant_callback th cb = Callback.register "apply_new_relevant" apply_new_relevant; let cbs = get_theory_callbacks th in cbs.new_relevant <- cb; set_new_relevant_callback_register th - end diff --git a/src/api/ml/z3.mli b/src/api/ml/z3.mli index b0935f03c..4dd3d5b14 100644 --- a/src/api/ml/z3.mli +++ b/src/api/ml/z3.mli @@ -268,24 +268,17 @@ and goal_prec = (** - - *) (** {2 {L Types}} - - - Most of the types in the API are abstract. - - + Most of the types in the API are abstract. - [context]: manager of all other Z3 objects, global configuration options, etc. - - [symbol]: Lisp-like symbol used to name types, constants, and functions. A symbol can be created using string or integers. + - [symbol]: Lisp-like symbol used to name types, constants, and functions. A symbol can be created using string or integers. - [ast]: abstract syntax tree node. That is, the data-structure used in Z3 to represent terms, formulas and types. - [sort]: kind of AST used to represent types. - [func_decl]: kind of AST used to represent function symbols. - [app]: kind of AST used to represent function applications. - [pattern]: kind of AST used to represent pattern and multi-patterns used to guide quantifier instantiation. - - [params]: parameter set used to configure many components such as: simplifiers, tactics, solvers, etc. - [model]: model for the constraints asserted into the logical context. - [func_interp]: interpretation of a function in a model. @@ -301,23 +294,21 @@ and goal_prec = - [stats]: statistical data for a solver. *) (** - {!lbool} + {!lbool} Lifted Boolean type: [false], [undefined], [true]. *) (** - {!symbol_kind} + {!symbol_kind} The different kinds of symbol. In Z3, a symbol can be represented using integers and strings (See {!get_symbol_kind}). - - {b See also}: {!mk_int_symbol} - {b See also}: {!mk_string_symbol} *) (** - {!parameter_kind} + {!parameter_kind} The different kinds of parameters that can be associated with function symbols. - {b See also}: {!get_decl_num_parameters} - {b See also}: {!get_decl_parameter_kind} - - PARAMETER_INT is used for integer parameters. - PARAMETER_DOUBLE is used for double parameters. - PARAMETER_RATIONAL is used for parameters that are rational numbers. @@ -327,229 +318,131 @@ and goal_prec = - PARAMETER_FUNC_DECL is used for function declaration parameters. *) (** - {!sort_kind} + {!sort_kind} The different kinds of Z3 types (See {!get_sort_kind}). *) (** - {!ast_kind} + {!ast_kind} The different kinds of Z3 AST (abstract syntax trees). That is, terms, formulas and types. - - - APP_AST: constant and applications - - NUMERAL_AST: numeral constants - - VAR_AST: bound variables - - QUANTIFIER_AST: quantifiers - - SORT_AST: sort - - FUNC_DECL_AST: function declaration - - UNKNOWN_AST: internal + - APP_AST: constant and applications + - NUMERAL_AST: numeral constants + - VAR_AST: bound variables + - QUANTIFIER_AST: quantifiers + - SORT_AST: sort + - FUNC_DECL_AST: function declaration + - UNKNOWN_AST: internal *) (** - {!decl_kind} + {!decl_kind} The different kinds of interpreted function kinds. - - OP_TRUE The constant true. - - OP_FALSE The constant false. - - OP_EQ The equality predicate. - - OP_DISTINCT The n-ary distinct predicate (every argument is mutually distinct). - - OP_ITE The ternary if-then-else term. - - OP_AND n-ary conjunction. - - OP_OR n-ary disjunction. - - OP_IFF equivalence (binary). - - OP_XOR Exclusive or. - - OP_NOT Negation. - - OP_IMPLIES Implication. - - OP_OEQ Binary equivalence modulo namings. This binary predicate is used in proof terms. It captures equisatisfiability and equivalence modulo renamings. - - OP_ANUM Arithmetic numeral. - - OP_AGNUM Arithmetic algebraic numeral. Algebraic numbers are used to represent irrational numbers in Z3. - - OP_LE <=. - - OP_GE >=. - - OP_LT <. - - OP_GT >. - - OP_ADD Addition - Binary. - - OP_SUB Binary subtraction. - - OP_UMINUS Unary minus. - - OP_MUL Multiplication - Binary. - - OP_DIV Division - Binary. - - OP_IDIV Integer division - Binary. - - OP_REM Remainder - Binary. - - OP_MOD Modulus - Binary. - - OP_TO_REAL Coercion of integer to real - Unary. - - OP_TO_INT Coercion of real to integer - Unary. - - OP_IS_INT Check if real is also an integer - Unary. - - OP_POWER Power operator x^y. - - OP_STORE Array store. It satisfies select(store(a,i,v),j) = if i = j then v else select(a,j). - Array store takes at least 3 arguments. - - - OP_SELECT Array select. - + Array store takes at least 3 arguments. + - OP_SELECT Array select. - OP_CONST_ARRAY The constant array. For example, select(const(v),i) = v holds for every v and i. The function is unary. - - OP_ARRAY_DEFAULT Default value of arrays. For example default(const(v)) = v. The function is unary. - - OP_ARRAY_MAP Array map operator. It satisfies map[f](a1,..,a_n)[i] = f(a1[i],...,a_n[i]) for every i. - - OP_SET_UNION Set union between two Booelan arrays (two arrays whose range type is Boolean). The function is binary. - - OP_SET_INTERSECT Set intersection between two Boolean arrays. The function is binary. - - OP_SET_DIFFERENCE Set difference between two Boolean arrays. The function is binary. - - OP_SET_COMPLEMENT Set complement of a Boolean array. The function is unary. - - OP_SET_SUBSET Subset predicate between two Boolean arrays. The relation is binary. - - OP_AS_ARRAY An array value that behaves as the function graph of the function passed as parameter. - - OP_BNUM Bit-vector numeral. - - OP_BIT1 One bit bit-vector. - - OP_BIT0 Zero bit bit-vector. - - OP_BNEG Unary minus. - - OP_BADD Binary addition. - - OP_BSUB Binary subtraction. - - OP_BMUL Binary multiplication. - - OP_BSDIV Binary signed division. - - OP_BUDIV Binary unsigned int division. - - OP_BSREM Binary signed remainder. - - OP_BUREM Binary unsigned int remainder. - - OP_BSMOD Binary signed modulus. - - OP_BSDIV0 Unary function. bsdiv(x,0) is congruent to bsdiv0(x). - - OP_BUDIV0 Unary function. budiv(x,0) is congruent to budiv0(x). - - OP_BSREM0 Unary function. bsrem(x,0) is congruent to bsrem0(x). - - OP_BUREM0 Unary function. burem(x,0) is congruent to burem0(x). - - OP_BSMOD0 Unary function. bsmod(x,0) is congruent to bsmod0(x). - - OP_ULEQ Unsigned bit-vector <= - Binary relation. - - - OP_SLEQ Signed bit-vector <= - Binary relation. - - - OP_UGEQ Unsigned bit-vector >= - Binary relation. - - - OP_SGEQ Signed bit-vector >= - Binary relation. - - - OP_ULT Unsigned bit-vector < - Binary relation. - + - OP_SLEQ Signed bit-vector <= - Binary relation. + - OP_UGEQ Unsigned bit-vector >= - Binary relation. + - OP_SGEQ Signed bit-vector >= - Binary relation. + - OP_ULT Unsigned bit-vector < - Binary relation. - OP_SLT Signed bit-vector < - Binary relation. - - OP_UGT Unsigned bit-vector > - Binary relation. - - OP_SGT Signed bit-vector > - Binary relation. - - OP_BAND Bit-wise and - Binary. - - OP_BOR Bit-wise or - Binary. - - OP_BNOT Bit-wise not - Unary. - - OP_BXOR Bit-wise xor - Binary. - - OP_BNAND Bit-wise nand - Binary. - - OP_BNOR Bit-wise nor - Binary. - - OP_BXNOR Bit-wise xnor - Binary. - - OP_CONCAT Bit-vector concatenation - Binary. - - OP_SIGN_EXT Bit-vector sign extension. - - OP_ZERO_EXT Bit-vector zero extension. - - OP_EXTRACT Bit-vector extraction. - - OP_REPEAT Repeat bit-vector n times. - - OP_BREDOR Bit-vector reduce or - Unary. - - OP_BREDAND Bit-vector reduce and - Unary. - - OP_BCOMP . - - OP_BSHL Shift left. - - OP_BLSHR Logical shift right. - - OP_BASHR Arithmetical shift right. - - OP_ROTATE_LEFT Left rotation. - - OP_ROTATE_RIGHT Right rotation. - - OP_EXT_ROTATE_LEFT (extended) Left rotation. Similar to OP_ROTATE_LEFT, but it is a binary operator instead of a parametric one. - - OP_EXT_ROTATE_RIGHT (extended) Right rotation. Similar to OP_ROTATE_RIGHT, but it is a binary operator instead of a parametric one. - - OP_INT2BV Coerce integer to bit-vector. NB. This function is not supported by the decision procedures. Only the most rudimentary simplification rules are applied to this function. - - OP_BV2INT Coerce bit-vector to integer. NB. This function is not supported by the decision procedures. Only the most rudimentary simplification rules are applied to this function. - - - OP_CARRY Compute the carry bit in a full-adder. + - OP_CARRY Compute the carry bit in a full-adder. The meaning is given by the equivalence (carry l1 l2 l3) <=> (or (and l1 l2) (and l1 l3) (and l2 l3))) - - OP_XOR3 Compute ternary XOR. The meaning is given by the equivalence (xor3 l1 l2 l3) <=> (xor (xor l1 l2) l3) - - OP_PR_UNDEF: Undef/Null proof object. - - OP_PR_TRUE: Proof for the expression 'true'. - - OP_PR_ASSERTED: Proof for a fact asserted by the user. - - OP_PR_GOAL: Proof for a fact (tagged as goal) asserted by the user. - - OP_PR_MODUS_PONENS: Given a proof for p and a proof for (implies p q), produces a proof for q. {e T1: p @@ -557,19 +450,16 @@ and goal_prec = [mp T1 T2]: q } The second antecedents may also be a proof for (iff p q). - - OP_PR_REFLEXIVITY: A proof for (R t t), where R is a reflexive relation. This proof object has no antecedents. - The only reflexive relations that are used are + The only reflexive relations that are used are equivalence modulo namings, equality and equivalence. That is, R is either '~', '=' or 'iff'. - - OP_PR_SYMMETRY: Given an symmetric relation R and a proof for (R t s), produces a proof for (R s t). {e T1: (R t s) [symmetry T1]: (R s t) } T1 is the antecedent of this proof object. - - OP_PR_TRANSITIVITY: Given a transitive relation R, and proofs for (R t s) and (R s u), produces a proof for (R t u). {e @@ -577,10 +467,8 @@ and goal_prec = T2: (R s u) [trans T1 T2]: (R t u) } - - OP_PR_TRANSITIVITY_STAR: Condensed transitivity proof. This proof object is only used if the parameter PROOF_MODE is 1. - It combines several symmetry and transitivity proofs. - + It combines several symmetry and transitivity proofs. Example: {e T1: (R a b) @@ -589,13 +477,11 @@ and goal_prec = [trans* T1 T2 T3]: (R a d) } R must be a symmetric and transitive relation. - Assuming that this proof object is a proof for (R s t), then a proof checker must check if it is possible to prove (R s t) - using the antecedents, symmetry and transitivity. That is, + using the antecedents, symmetry and transitivity. That is, if there is a path from s to t, if we view every antecedent (R a b) as an edge between a and b. - - OP_PR_MONOTONICITY: Monotonicity proof object. {e T1: (R t_1 s_1) @@ -605,58 +491,42 @@ and goal_prec = } Remark: if t_i == s_i, then the antecedent Ti is suppressed. That is, reflexivity proofs are supressed to save space. - - OP_PR_QUANT_INTRO: Given a proof for (~ p q), produces a proof for (~ (forall (x) p) (forall (x) q)). - T1: (~ p q) [quant-intro T1]: (~ (forall (x) p) (forall (x) q)) - - - OP_PR_DISTRIBUTIVITY: Distributivity proof object. + - OP_PR_DISTRIBUTIVITY: Distributivity proof object. Given that f (= or) distributes over g (= and), produces a proof for - (= (f a (g c d)) (g (f a c) (f a d))) - If f and g are associative, this proof also justifies the following equality: - (= (f (g a b) (g c d)) (g (f a c) (f a d) (f b c) (f b d))) - where each f and g can have arbitrary number of arguments. - This proof object has no antecedents. - Remark. This rule is used by the CNF conversion pass and + Remark. This rule is used by the CNF conversion pass and instantiated by f = or, and g = and. - - OP_PR_AND_ELIM: Given a proof for (and l_1 ... l_n), produces a proof for l_i - {e T1: (and l_1 ... l_n) [and-elim T1]: l_i } - OP_PR_NOT_OR_ELIM: Given a proof for (not (or l_1 ... l_n)), produces a proof for (not l_i). - {e T1: (not (or l_1 ... l_n)) [not-or-elim T1]: (not l_i) } - - OP_PR_REWRITE: A proof for a local rewriting step (= t s). The head function symbol of t is interpreted. - This proof object has no antecedents. - The conclusion of a rewrite rule is either an equality (= t s), + The conclusion of a rewrite rule is either an equality (= t s), an equivalence (iff t s), or equi-satisfiability (~ t s). Remark: if f is bool, then = is iff. - - Examples: {e (= (+ x 0) x) (= (+ x 1 2) (+ 3 x)) (iff (or x false) x) } - - OP_PR_REWRITE_STAR: A proof for rewriting an expression t into an expression s. This proof object is used if the parameter PROOF_MODE is 1. This proof object can have n antecedents. @@ -666,44 +536,31 @@ and goal_prec = - When applying contextual simplification (CONTEXT_SIMPLIFIER=true) - When converting bit-vectors to Booleans (BIT2BOOL=true) - When pulling ite expression up (PULL_CHEAP_ITE_TREES=true) - - OP_PR_PULL_QUANT: A proof for (iff (f (forall (x) q(x)) r) (forall (x) (f (q x) r))). This proof object has no antecedents. - - OP_PR_PULL_QUANT_STAR: A proof for (iff P Q) where Q is in prenex normal form. - This proof object is only used if the parameter PROOF_MODE is 1. + This proof object is only used if the parameter PROOF_MODE is 1. This proof object has no antecedents. - - OP_PR_PUSH_QUANT: A proof for: - {e (iff (forall (x_1 ... x_m) (and p_1[x_1 ... x_m] ... p_n[x_1 ... x_m])) (and (forall (x_1 ... x_m) p_1[x_1 ... x_m]) - ... + ... (forall (x_1 ... x_m) p_n[x_1 ... x_m]))) } This proof object has no antecedents. - - - OP_PR_ELIM_UNUSED_VARS: + - OP_PR_ELIM_UNUSED_VARS: A proof for (iff (forall (x_1 ... x_n y_1 ... y_m) p[x_1 ... x_n]) - (forall (x_1 ... x_n) p[x_1 ... x_n])) - + (forall (x_1 ... x_n) p[x_1 ... x_n])) It is used to justify the elimination of unused variables. This proof object has no antecedents. - - OP_PR_DER: A proof for destructive equality resolution: (iff (forall (x) (or (not (= x t)) P[x])) P[t]) if x does not occur in t. - This proof object has no antecedents. - Several variables can be eliminated simultaneously. - - OP_PR_QUANT_INST: A proof of (or (not (forall (x) (P x))) (P a)) - - OP_PR_HYPOTHESIS: Mark a hypothesis in a natural deduction style proof. - - - OP_PR_LEMMA: - + - OP_PR_LEMMA: {e T1: false [lemma T1]: (or (not l_1) ... (not l_n)) @@ -711,22 +568,19 @@ and goal_prec = This proof object has one antecedent: a hypothetical proof for false. It converts the proof in a proof for (or (not l_1) ... (not l_n)), when T1 contains the hypotheses: l_1, ..., l_n. - - - OP_PR_UNIT_RESOLUTION: + - OP_PR_UNIT_RESOLUTION: {e - T1: (or l_1 ... l_n l_1' ... l_m') - T2: (not l_1) + T1: (or l_1 ... l_n l_1' ... l_m') + T2: (not l_1) ... - T(n+1): (not l_n) + T(n+1): (not l_n) [unit-resolution T1 ... T(n+1)]: (or l_1' ... l_m') } - - - OP_PR_IFF_TRUE: + - OP_PR_IFF_TRUE: {e T1: p [iff-true T1]: (iff p true) } - - OP_PR_IFF_FALSE: {e T1: (not p) @@ -736,14 +590,14 @@ and goal_prec = - OP_PR_COMMUTATIVITY: [comm]: (= (f a b) (f b a)) - + f is a commutative operator. This proof object has no antecedents. Remark: if f is bool, then = is iff. - + - OP_PR_DEF_AXIOM: Proof object used to justify Tseitin's like axioms: - + {e (or (not (and p q)) p) (or (not (and p q)) q) @@ -772,7 +626,7 @@ and goal_prec = You can recover the propositional tautologies by unfolding the Boolean connectives in the axioms a small bounded number of steps (=3). - + - OP_PR_DEF_INTRO: Introduces a name for a formula/term. Suppose e is an expression with free variables x, and def-intro introduces the name n(x). The possible cases are: @@ -788,17 +642,17 @@ and goal_prec = [def-intro]: (and (or (not cond) (= n th)) (or cond (= n el))) Otherwise: - [def-intro]: (= n e) + [def-intro]: (= n e) - - OP_PR_APPLY_DEF: + - OP_PR_APPLY_DEF: [apply-def T1]: F ~ n F is 'equivalent' to n, given that T1 is a proof that n is a name for F. - + - OP_PR_IFF_OEQ: T1: (iff p q) [iff~ T1]: (~ p q) - + - OP_PR_NNF_POS: Proof for a (positive) NNF step. Example: {e T1: (not s_1) ~ r_1 @@ -813,7 +667,7 @@ and goal_prec = The quantifier is retained (unless the bound variables are eliminated). Example {e - T1: q ~ q_new + T1: q ~ q_new [nnf-pos T1]: (~ (forall (x T) q) (forall (x T) q_new)) } (b) When recursively creating NNF over Boolean formulas, where the top-level @@ -822,7 +676,7 @@ and goal_prec = NNF_NEG furthermore handles the case where negation is pushed over Boolean connectives 'and' and 'or'. - + - OP_PR_NFF_NEG: Proof for a (negative) NNF step. Examples: {e T1: (not s_1) ~ r_1 @@ -843,24 +697,24 @@ and goal_prec = (and (or r_1 r_2) (or r_1' r_2'))) } - OP_PR_NNF_STAR: A proof for (~ P Q) where Q is in negation normal form. - - This proof object is only used if the parameter PROOF_MODE is 1. - + + This proof object is only used if the parameter PROOF_MODE is 1. + This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. - OP_PR_CNF_STAR: A proof for (~ P Q) where Q is in conjunctive normal form. - This proof object is only used if the parameter PROOF_MODE is 1. - This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. + This proof object is only used if the parameter PROOF_MODE is 1. + This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. + + - OP_PR_SKOLEMIZE: Proof for: - - OP_PR_SKOLEMIZE: Proof for: - {e [sk]: (~ (not (forall x (p x y))) (not (p (sk y) y))) [sk]: (~ (exists x (p x y)) (p (sk y) y)) } This proof object has no antecedents. - + - OP_PR_MODUS_PONENS_OEQ: Modus ponens style rule for equi-satisfiability. {e T1: p @@ -873,9 +727,9 @@ and goal_prec = The theory lemma function comes with one or more parameters. The first parameter indicates the name of the theory. For the theory of arithmetic, additional parameters provide hints for - checking the theory lemma. + checking the theory lemma. The hints for arithmetic are: - + - farkas - followed by rational coefficients. Multiply the coefficients to the inequalities in the lemma, add the (negated) inequalities and obtain a contradiction. @@ -906,7 +760,7 @@ and goal_prec = {e (=> (and ln+1 ln+2 .. ln+m) (or l0 l1 .. ln-1)) } - In other words we use the following (Prolog style) convention for Horn + In other words we use the following (Prolog style) convention for Horn implications: The head of a Horn implication is position 0, the first conjunct in the body of an implication is position 1 @@ -929,16 +783,16 @@ and goal_prec = - OP_RA_STORE: Insert a record into a relation. - The function takes [n+1] arguments, where the first argument is the relation and the remaining [n] elements + The function takes [n+1] arguments, where the first argument is the relation and the remaining [n] elements correspond to the [n] columns of the relation. - - OP_RA_EMPTY: Creates the empty relation. - + - OP_RA_EMPTY: Creates the empty relation. + - OP_RA_IS_EMPTY: Tests if the relation is empty. - OP_RA_JOIN: Create the relational join. - - OP_RA_UNION: Create the union or convex hull of two relations. + - OP_RA_UNION: Create the union or convex hull of two relations. The function takes two arguments. - OP_RA_WIDEN: Widen two relations. @@ -948,7 +802,7 @@ and goal_prec = The function takes one argument. - OP_RA_FILTER: Filter (restrict) a relation with respect to a predicate. - The first argument is a relation. + The first argument is a relation. The second argument is a predicate with free de-Brujin indices corresponding to the columns of the relation. So the first column in the relation has index 0. @@ -963,23 +817,23 @@ and goal_prec = target are elements in x in pos, such that there is no y in neg that agrees with x on the columns c1, d1, .., cN, dN. - - - OP_RA_RENAME: rename columns in the relation. + + - OP_RA_RENAME: rename columns in the relation. The function takes one argument. The parameters contain the renaming as a cycle. - + - OP_RA_COMPLEMENT: Complement the relation. - OP_RA_SELECT: Check if a record is an element of the relation. The function takes [n+1] arguments, where the first argument is a relation, and the remaining [n] arguments correspond to a record. - - OP_RA_CLONE: Create a fresh copy (clone) of a relation. + - OP_RA_CLONE: Create a fresh copy (clone) of a relation. The function is logically the identity, but in the context of a register machine allows - for [OP_RA_UNION] + for [OP_RA_UNION] to perform destructive updates to the first argument. - + - OP_FD_LT: A less than predicate over the finite domain FINITE_DOMAIN_SORT. @@ -999,10 +853,10 @@ and goal_prec = - OP_UNINTERPRETED: kind used for uninterpreted symbols. *) (** - {!param_kind} + {!param_kind} The different kinds of parameters that can be associated with parameter sets. - (see {!mk_params}). + (see {!mk_params}). - PK_UINT integer parameters. - PK_BOOL boolean parameters. @@ -1013,140 +867,113 @@ and goal_prec = - PK_INVALID invalid parameter. *) (** - {!search_failure} + {!search_failure} The different kinds of search failure types. - - NO_FAILURE: The last search was successful - - UNKNOWN: Undocumented failure reason - - TIMEOUT: Timeout - - MEMOUT_WATERMAK: Search hit a memory high-watermak limit - - CANCELED: External cancel flag was set - - NUM_CONFLICTS: Maximum number of conflicts was reached - - THEORY: Theory is incomplete - - QUANTIFIERS: Logical context contains universal quantifiers + - NO_FAILURE: The last search was successful + - UNKNOWN: Undocumented failure reason + - TIMEOUT: Timeout + - MEMOUT_WATERMAK: Search hit a memory high-watermak limit + - CANCELED: External cancel flag was set + - NUM_CONFLICTS: Maximum number of conflicts was reached + - THEORY: Theory is incomplete + - QUANTIFIERS: Logical context contains universal quantifiers *) (** - {!ast_print_mode} + {!ast_print_mode} Z3 pretty printing modes (See {!set_ast_print_mode}). - - PRINT_SMTLIB_FULL: Print AST nodes in SMTLIB verbose format. - - PRINT_LOW_LEVEL: Print AST nodes using a low-level format. + - PRINT_SMTLIB_FULL: Print AST nodes in SMTLIB verbose format. + - PRINT_LOW_LEVEL: Print AST nodes using a low-level format. - PRINT_SMTLIB_COMPLIANT: Print AST nodes in SMTLIB 1.x compliant format. - PRINT_SMTLIB2_COMPLIANT: Print AST nodes in SMTLIB 2.x compliant format. *) (** - {!error_code} - Z3 error codes - - - OK: No error. - - SORT_ERROR: User tried to build an invalid (type incorrect) AST. - - IOB: Index out of bounds. - - INVALID_ARG: Invalid argument was provided. - - PARSER_ERROR: An error occurred when parsing a string or file. - - NO_PARSER: Parser output is not available, that is, user didn't invoke {!parse_smtlib_string} or {!parse_smtlib_file}. + {!error_code} + Z3 error codes + + - OK: No error. + - SORT_ERROR: User tried to build an invalid (type incorrect) AST. + - IOB: Index out of bounds. + - INVALID_ARG: Invalid argument was provided. + - PARSER_ERROR: An error occurred when parsing a string or file. + - NO_PARSER: Parser output is not available, that is, user didn't invoke {!parse_smtlib_string} or {!parse_smtlib_file}. - INVALID_PATTERN: Invalid pattern was used to build a quantifier. - - MEMOUT_FAIL: A memory allocation failure was encountered. + - MEMOUT_FAIL: A memory allocation failure was encountered. - FILE_ACCESS_ERRROR: A file could not be accessed. - - INVALID_USAGE: API call is invalid in the current state. + - INVALID_USAGE: API call is invalid in the current state. - INTERNAL_FATAL: An error internal to Z3 occurred. - DEC_REF_ERROR: Trying to decrement the reference counter of an AST that was deleted or the reference counter was not initialized. - - EXCEPTION: Internal Z3 exception. Additional details can be retrieved using {!get_error_msg}. + - EXCEPTION: Internal Z3 exception. Additional details can be retrieved using {!get_error_msg}. *) (** Definitions for update_api.py - - def_Type('CONFIG', 'config', 'Config') - def_Type('CONTEXT', 'context', 'ContextObj') - def_Type('AST', 'ast', 'Ast') - def_Type('APP', 'app', 'Ast') - def_Type('SORT', 'sort', 'Sort') - def_Type('FUNC_DECL', 'func_decl', 'FuncDecl') - def_Type('PATTERN', 'pattern', 'Pattern') - def_Type('MODEL', 'model', 'Model') - def_Type('LITERALS', 'literals', 'Literals') - def_Type('CONSTRUCTOR', 'constructor', 'Constructor') + + def_Type('CONFIG', 'config', 'Config') + def_Type('CONTEXT', 'context', 'ContextObj') + def_Type('AST', 'ast', 'Ast') + def_Type('APP', 'app', 'Ast') + def_Type('SORT', 'sort', 'Sort') + def_Type('FUNC_DECL', 'func_decl', 'FuncDecl') + def_Type('PATTERN', 'pattern', 'Pattern') + def_Type('MODEL', 'model', 'Model') + def_Type('LITERALS', 'literals', 'Literals') + def_Type('CONSTRUCTOR', 'constructor', 'Constructor') def_Type('CONSTRUCTOR_LIST', 'constructor_list', 'ConstructorList') - def_Type('THEORY', 'theory', 'ctypes.c_void_p') - def_Type('THEORY_DATA', 'theory_data', 'ctypes.c_void_p') - def_Type('SOLVER', 'solver', 'SolverObj') - def_Type('GOAL', 'goal', 'GoalObj') - def_Type('TACTIC', 'tactic', 'TacticObj') - def_Type('PARAMS', 'params', 'Params') - def_Type('PROBE', 'probe', 'ProbeObj') - def_Type('STATS', 'stats', 'StatsObj') - def_Type('AST_VECTOR', 'ast_vector', 'AstVectorObj') - def_Type('AST_MAP', 'ast_map', 'AstMapObj') - def_Type('APPLY_RESULT', 'apply_result', 'ApplyResultObj') - def_Type('FUNC_INTERP', 'func_interp', 'FuncInterpObj') - def_Type('FUNC_ENTRY', 'func_entry', 'FuncEntryObj') - def_Type('FIXEDPOINT', 'fixedpoint', 'FixedpointObj') - def_Type('PARAM_DESCRS', 'param_descrs', 'ParamDescrs') + def_Type('THEORY', 'theory', 'ctypes.c_void_p') + def_Type('THEORY_DATA', 'theory_data', 'ctypes.c_void_p') + def_Type('SOLVER', 'solver', 'SolverObj') + def_Type('GOAL', 'goal', 'GoalObj') + def_Type('TACTIC', 'tactic', 'TacticObj') + def_Type('PARAMS', 'params', 'Params') + def_Type('PROBE', 'probe', 'ProbeObj') + def_Type('STATS', 'stats', 'StatsObj') + def_Type('AST_VECTOR', 'ast_vector', 'AstVectorObj') + def_Type('AST_MAP', 'ast_map', 'AstMapObj') + def_Type('APPLY_RESULT', 'apply_result', 'ApplyResultObj') + def_Type('FUNC_INTERP', 'func_interp', 'FuncInterpObj') + def_Type('FUNC_ENTRY', 'func_entry', 'FuncEntryObj') + def_Type('FIXEDPOINT', 'fixedpoint', 'FixedpointObj') + def_Type('PARAM_DESCRS', 'param_descrs', 'ParamDescrs') *) (** Exceptions raised by Z3. It is safe to continue interacting with Z3 after catching [Error] exceptions. - - {b See also}: {!get_error_msg} *) exception Error of context * error_code (** - {!goal_prec} + {!goal_prec} A Goal is essentially a set of formulas. Z3 provide APIs for building strategies/tactics for solving and transforming Goals. Some of these transformations apply under/over approximations. - - - GOAL_PRECISE: Approximations/Relaxations were not applied on the goal (sat and unsat answers were preserved). - - GOAL_UNDER: Goal is the product of a under-approximation (sat answers are preserved). - - GOAL_OVER: Goal is the product of an over-approximation (unsat answers are preserved). + - GOAL_PRECISE: Approximations/Relaxations were not applied on the goal (sat and unsat answers were preserved). + - GOAL_UNDER: Goal is the product of a under-approximation (sat answers are preserved). + - GOAL_OVER: Goal is the product of an over-approximation (unsat answers are preserved). - GOAL_UNDER_OVER: Goal is garbage (it is the product of over- and under-approximations, sat and unsat answers are not preserved). *) (** {2 {L Create context}} *) (** - Summary: Create a context using the given configuration. - + Summary: Create a context using the given configuration. After a context is created, the configuration cannot be changed, although some parameters can be changed using {!update_param_value}. All main interaction with Z3 happens in the context of a [context]. - - - - - def_API('mk_context', CONTEXT, (_in(CONFIG),)) *) external mk_context: (string * string) list -> context = "caml_z3_mk_context" (** - Summary: Update a mutable configuration parameter. - - The list of all configuration parameters can be obtained using the Z3 executable: - - {v - z3.exe -ini? - v} - - Only a few configuration parameters are mutable once the context is created. - The error handler is invoked when trying to modify an immutable parameter. - - - - {b See also}: {!mk_context } - + Summary: Set a value of a context parameter. + - {b See also}: {!global_param_set} def_API('update_param_value', VOID, (_in(CONTEXT), _in(STRING), _in(STRING))) *) external update_param_value : context -> string -> string -> unit = "camlidl_z3_Z3_update_param_value" (** - Summary: Get a configuration parameter. - - Returns [None] - if the parameter value does not exist. - - - - - {b See also}: {!mk_context } - + Summary: Return the value of a context parameter. + - {b See also}: {!global_param_get} def_API('get_param_value', BOOL, (_in(CONTEXT), _in(STRING), _out(STRING))) *) external get_param_value : context -> string -> string option @@ -1155,7 +982,6 @@ external get_param_value : context -> string -> string option (** Summary: Interrupt the execution of a Z3 procedure. This procedure can be used to interrupt: solvers, simplifiers and tactics. - def_API('interrupt', VOID, (_in(CONTEXT),)) *) external interrupt : context -> unit @@ -1168,10 +994,6 @@ external interrupt : context -> unit Summary: Create a Z3 (empty) parameter set. Starting at Z3 4.0, parameter sets are used to configure many components such as: simplifiers, tactics, solvers, etc. - - - - def_API('mk_params', PARAMS, (_in(CONTEXT),)) *) external mk_params : context -> params @@ -1179,7 +1001,6 @@ external mk_params : context -> params (** Summary: Add a Boolean parameter [k] with value [v] to the parameter set [p]. - def_API('params_set_bool', VOID, (_in(CONTEXT), _in(PARAMS), _in(SYMBOL), _in(BOOL))) *) external params_set_bool : context -> params -> symbol -> bool -> unit @@ -1187,7 +1008,6 @@ external params_set_bool : context -> params -> symbol -> bool -> unit (** Summary: Add a unsigned int parameter [k] with value [v] to the parameter set [p]. - def_API('params_set_uint', VOID, (_in(CONTEXT), _in(PARAMS), _in(SYMBOL), _in(UINT))) *) external params_set_uint : context -> params -> symbol -> int -> unit @@ -1195,7 +1015,6 @@ external params_set_uint : context -> params -> symbol -> int -> unit (** Summary: Add a double parameter [k] with value [v] to the parameter set [p]. - def_API('params_set_double', VOID, (_in(CONTEXT), _in(PARAMS), _in(SYMBOL), _in(DOUBLE))) *) external params_set_double : context -> params -> symbol -> float -> unit @@ -1203,7 +1022,6 @@ external params_set_double : context -> params -> symbol -> float -> unit (** Summary: Add a symbol parameter [k] with value [v] to the parameter set [p]. - def_API('params_set_symbol', VOID, (_in(CONTEXT), _in(PARAMS), _in(SYMBOL), _in(SYMBOL))) *) external params_set_symbol : context -> params -> symbol -> symbol -> unit @@ -1212,7 +1030,6 @@ external params_set_symbol : context -> params -> symbol -> symbol -> unit (** Summary: Convert a parameter set into a string. This function is mainly used for printing the contents of a parameter set. - def_API('params_to_string', STRING, (_in(CONTEXT), _in(PARAMS))) *) external params_to_string : context -> params -> string @@ -1220,9 +1037,7 @@ external params_to_string : context -> params -> string (** Summary: Validate the parameter set [p] against the parameter description set [d]. - The procedure invokes the error handler if [p] is invalid. - def_API('params_validate', VOID, (_in(CONTEXT), _in(PARAMS), _in(PARAM_DESCRS))) *) external params_validate : context -> params -> param_descrs -> unit @@ -1233,7 +1048,6 @@ external params_validate : context -> params -> param_descrs -> unit *) (** Summary: Return the kind associated with the given parameter name [n]. - def_API('param_descrs_get_kind', UINT, (_in(CONTEXT), _in(PARAM_DESCRS), _in(SYMBOL))) *) external param_descrs_get_kind : context -> param_descrs -> symbol -> param_kind @@ -1241,7 +1055,6 @@ external param_descrs_get_kind : context -> param_descrs -> symbol -> param_kind (** Summary: Return the number of parameters in the given parameter description set. - def_API('param_descrs_size', UINT, (_in(CONTEXT), _in(PARAM_DESCRS))) *) external param_descrs_size : context -> param_descrs -> int @@ -1249,9 +1062,7 @@ external param_descrs_size : context -> param_descrs -> int (** Summary: Return the number of parameters in the given parameter description set. - - {b Precondition}: i < param_descrs_size c p - def_API('param_descrs_get_name', SYMBOL, (_in(CONTEXT), _in(PARAM_DESCRS), _in(UINT))) *) external param_descrs_get_name : context -> param_descrs -> int -> symbol @@ -1260,7 +1071,6 @@ external param_descrs_get_name : context -> param_descrs -> int -> symbol (** Summary: Convert a parameter description set into a string. This function is mainly used for printing the contents of a parameter description set. - def_API('param_descrs_to_string', STRING, (_in(CONTEXT), _in(PARAM_DESCRS))) *) external param_descrs_to_string : context -> param_descrs -> string @@ -1272,7 +1082,6 @@ external param_descrs_to_string : context -> param_descrs -> string (** Refined view of a {!symbol}. - - {b See also}: {!mk_symbol} - {b See also}: {!symbol_refine} *) @@ -1283,24 +1092,19 @@ type symbol_refined = (** Summary: \[ [ mk_symbol c sr ] \] constructs the symbol described by [sr]. - - {b See also}: {!symbol_refine} *) val mk_symbol: context -> symbol_refined -> symbol (** - {4 {L Redundant low-level API}} + {4 {L Redundant low-level API}} *) (** Summary: Create a Z3 symbol using an integer. - Symbols are used to name several term and type constructors. - NB. Not all integers can be passed to this function. The legal range of unsigned int integers is 0 to 2^30-1. - - {b See also}: {!mk_string_symbol} - def_API('mk_int_symbol', SYMBOL, (_in(CONTEXT), _in(INT))) *) external mk_int_symbol : context -> int -> symbol @@ -1308,11 +1112,8 @@ external mk_int_symbol : context -> int -> symbol (** Summary: Create a Z3 symbol using a C string. - Symbols are used to name several term and type constructors. - - {b See also}: {!mk_int_symbol} - def_API('mk_string_symbol', SYMBOL, (_in(CONTEXT), _in(STRING))) *) external mk_string_symbol : context -> string -> symbol @@ -1326,33 +1127,28 @@ external mk_string_symbol : context -> string -> symbol A datatype constructor descriptor. *) type datatype_constructor_desc = { - constructor_desc : symbol; (** name of the constructor function *) - recognizer_desc : symbol; (** name of the recognizer function *) - accessor_descs : (symbol * sort) array; (** names and sorts of the fields *) + constructor_desc : symbol; (** name of the constructor function *) + recognizer_desc : symbol; (** name of the recognizer function *) + accessor_descs : (symbol * sort) array; (** names and sorts of the fields *) } - (** A datatype is described by a name and constructor descriptors. *) type datatype_desc = symbol * datatype_constructor_desc array - (** A datatype constructor representation. *) type datatype_constructor = { - constructor : func_decl; (** constructor function *) - recognizer : func_decl; (** recognizer function *) - accessors : func_decl array; (** field accessor functions *) + constructor : func_decl; (** constructor function *) + recognizer : func_decl; (** recognizer function *) + accessors : func_decl array; (** field accessor functions *) } - (** A datatype is represented by a sort and constructors. *) type datatype = sort * datatype_constructor array - (** Refined view of a {!sort}. - - {b See also}: {!mk_sort} - {b See also}: {!sort_refine} *) @@ -1371,40 +1167,33 @@ type sort_refined = (** Summary: \[ [ mk_sort c sr ] \] constructs the sort described by [sr]. - - {b Precondition}: [sr] is not of form [Sort_relation] or [Sort_unknown], which cannot be directly constructed - {b See also}: {!mk_datatypes} - {b See also}: {!sort_refine} *) val mk_sort: context -> sort_refined -> sort - (** \[ [mk_datatypes ctx sorts_to_descriptors] \] creates mutually recursive datatypes described by [sorts_to_descriptors], which is a function from the sorts of the datatypes to be created to descriptors of the datatypes' constructors. - - {b See also}: {!Test_mlapi.forest_example} *) val mk_datatypes: context -> (sort array -> (datatype_desc array) option) -> datatype array (** - {4 {L Redundant low-level API}} + {4 {L Redundant low-level API}} *) (** Summary: Create a free (uninterpreted) type using the given name (symbol). - Two free types are considered the same iff the have the same name. - def_API('mk_uninterpreted_sort', SORT, (_in(CONTEXT), _in(SYMBOL))) *) external mk_uninterpreted_sort : context -> symbol -> sort = "camlidl_z3_Z3_mk_uninterpreted_sort" (** - Summary: Create the Boolean type. - + Summary: Create the Boolean type. This type is used to create propositional variables and predicates. - def_API('mk_bool_sort', SORT, (_in(CONTEXT), )) *) external mk_bool_sort : context -> sort @@ -1412,24 +1201,19 @@ external mk_bool_sort : context -> sort (** Summary: Create the integer type. - This type is not the int type found in programming languages. A machine integer can be represented using bit-vectors. The function {!mk_bv_sort} creates a bit-vector type. - - {b See also}: {!mk_bv_sort} - def_API('mk_int_sort', SORT, (_in(CONTEXT), )) *) external mk_int_sort : context -> sort = "camlidl_z3_Z3_mk_int_sort" (** - Summary: Create the real type. - + Summary: Create the real type. This type is not a floating point number. Z3 does not have support for floating point numbers yet. - def_API('mk_real_sort', SORT, (_in(CONTEXT), )) *) external mk_real_sort : context -> sort @@ -1437,11 +1221,8 @@ external mk_real_sort : context -> sort (** Summary: Create a bit-vector type of the given size. - This type can also be seen as a machine integer. - - {b Remarks}: The size of the bitvector type must be greater than zero. - def_API('mk_bv_sort', SORT, (_in(CONTEXT), _in(UINT))) *) external mk_bv_sort : context -> int -> sort @@ -1449,27 +1230,21 @@ external mk_bv_sort : context -> int -> sort (** Summary: Create a named finite domain sort. - - To create constants that belong to the finite domain, + To create constants that belong to the finite domain, use the APIs for creating numerals and pass a numeric constant together with the sort returned by this call. - - - {b See also}: {!get_finite_domain_sort_size.} - + - {b See also}: {!get_finite_domain_sort_size} def_API('mk_finite_domain_sort', SORT, (_in(CONTEXT), _in(SYMBOL), _in(UINT64))) *) external mk_finite_domain_sort : context -> symbol -> int64 -> sort = "camlidl_z3_Z3_mk_finite_domain_sort" (** - Summary: Create an array type. - + Summary: Create an array type. We usually represent the array type as: {e [domain -> range] }. Arrays are usually used to model the heap/memory in software verification. - - {b See also}: {!mk_select} - {b See also}: {!mk_store} - def_API('mk_array_sort', SORT, (_in(CONTEXT), _in(SORT), _in(SORT))) *) external mk_array_sort : context -> sort -> sort -> sort @@ -1477,14 +1252,8 @@ external mk_array_sort : context -> sort -> sort -> sort (** Summary: Create a tuple type. - [mk_tuple_sort c name field_names field_sorts] creates a tuple with a constructor named [name], a [n] fields, where [n] is the size of the arrays [field_names] and [field_sorts]. - - - - - @param c logical context @param mk_tuple_name name of the constructor function associated with the tuple type. @param num_fields number of fields in the tuple type. @@ -1492,7 +1261,6 @@ external mk_array_sort : context -> sort -> sort -> sort @param field_sorts type of the tuple fields. @param mk_tuple_decl output parameter that will contain the constructor declaration. @param proj_decl output parameter that will contain the projection function declarations. This field must be a buffer of size [num_fields] allocated by the user. - def_API('mk_tuple_sort', SORT, (_in(CONTEXT), _in(SYMBOL), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _out(FUNC_DECL), _out_array(2, FUNC_DECL))) *) external mk_tuple_sort : context -> symbol -> symbol array -> sort array -> sort * func_decl * func_decl array @@ -1500,28 +1268,20 @@ external mk_tuple_sort : context -> symbol -> symbol array -> sort array -> sort (** Summary: Create a enumeration sort. - - [mk_enumeration_sort c enums] creates an enumeration sort with enumeration names [enums], + [mk_enumeration_sort c enums] creates an enumeration sort with enumeration names [enums], it also returns [n] predicates, where [n] is the number of [enums] corresponding to testing whether an element is one of the enumerants. - - - - - @param c logical context @param name name of the enumeration sort. @param n number of elemenets in enumeration sort. @param enum_names names of the enumerated elements. @param enum_consts constants corresponding to the enumerated elements. @param enum_testers predicates testing if terms of the enumeration sort correspond to an enumeration. - - For example, if this function is called with three symbols A, B, C and the name S, then - [s] is a sort whose name is S, and the function returns three terms corresponding to A, B, C in + For example, if this function is called with three symbols A, B, C and the name S, then + [s] is a sort whose name is S, and the function returns three terms corresponding to A, B, C in [enum_consts]. The array [enum_testers] has three predicates of type {e (s -> Bool) }. The first predicate (corresponding to A) is true when applied to A, and false otherwise. Similarly for the other predicates. - def_API('mk_enumeration_sort', SORT, (_in(CONTEXT), _in(SYMBOL), _in(UINT), _in_array(2, SYMBOL), _out_array(2, FUNC_DECL), _out_array(2, FUNC_DECL))) *) external mk_enumeration_sort : context -> symbol -> symbol array -> sort * func_decl array * func_decl array @@ -1529,13 +1289,7 @@ external mk_enumeration_sort : context -> symbol -> symbol array -> sort * func_ (** Summary: Create a list sort - [mk_list_sort c name elem_sort] creates a list sort of [name], over elements of sort [elem_sort]. - - - - - @param c logical context @param name name of the list sort. @param elem_sort sort of list elements. @@ -1545,7 +1299,6 @@ external mk_enumeration_sort : context -> symbol -> symbol array -> sort * func_ @param is_cons_decl cons cell test. @param head_decl list head. @param tail_decl list tail. - def_API('mk_list_sort', SORT, (_in(CONTEXT), _in(SYMBOL), _in(SORT), _out(FUNC_DECL), _out(FUNC_DECL), _out(FUNC_DECL), _out(FUNC_DECL), _out(FUNC_DECL), _out(FUNC_DECL))) *) external mk_list_sort : context -> symbol -> sort -> sort * func_decl * func_decl * func_decl * func_decl * func_decl * func_decl @@ -1554,19 +1307,17 @@ external mk_list_sort : context -> symbol -> sort -> sort * func_decl * func_dec (* (** Summary: Create a constructor. - @param c logical context. @param name constructor name. @param recognizer name of recognizer function. @param num_fields number of fields in constructor. @param field_names names of the constructor fields. - @param sorts field sorts, [None] + @param sorts field sorts, [None] if the field sort refers to a recursive sort. @param sort_refs reference to datatype sort that is an argument to the constructor; if the corresponding - sort reference is [None], - then the value in sort_refs should be an index referring to - one of the recursive datatypes that is declared. - + sort reference is [None], + then the value in sort_refs should be an index referring to + one of the recursive datatypes that is declared. def_API('mk_constructor', CONSTRUCTOR, (_in(CONTEXT), _in(SYMBOL), _in(SYMBOL), _in(UINT), _in_array(3, SYMBOL), _in_array(3, SORT), _in_array(3, UINT))) *) external mk_constructor : context -> symbol -> symbol -> symbol array -> sort option array -> int array -> constructor @@ -1574,24 +1325,20 @@ external mk_constructor : context -> symbol -> symbol -> symbol array -> sort op (** Summary: Reclaim memory allocated to constructor. - @param c logical context. @param constr constructor. - def_API('del_constructor', VOID, (_in(CONTEXT), _in(CONSTRUCTOR))) *) external del_constructor : context -> constructor -> unit = "camlidl_z3_Z3_del_constructor" (** - Summary: Create datatype, such as lists, trees, records, enumerations or unions of records. + Summary: Create datatype, such as lists, trees, records, enumerations or unions of records. The datatype may be recursive. Return the datatype sort. - @param c logical context. - @param name name of datatype. + @param name name of datatype. @param num_constructors number of constructors passed in. @param constructors array of constructor containers. - def_API('mk_datatype', SORT, (_in(CONTEXT), _in(SYMBOL), _in(UINT), _inout_array(2, CONSTRUCTOR))) *) external mk_datatype : context -> symbol -> constructor array -> sort * constructor array @@ -1599,11 +1346,9 @@ external mk_datatype : context -> symbol -> constructor array -> sort * construc (** Summary: Create list of constructors. - @param c logical context. @param num_constructors number of constructors in list. @param constructors list of constructors. - def_API('mk_constructor_list', CONSTRUCTOR_LIST, (_in(CONTEXT), _in(UINT), _in_array(1, CONSTRUCTOR))) *) external mk_constructor_list : context -> constructor array -> constructor_list @@ -1611,12 +1356,9 @@ external mk_constructor_list : context -> constructor array -> constructor_list (** Summary: Reclaim memory allocated for constructor list. - Each constructor inside the constructor list must be independently reclaimed using {!del_constructor}. - @param c logical context. @param clist constructor list container. - def_API('del_constructor_list', VOID, (_in(CONTEXT), _in(CONSTRUCTOR_LIST))) *) external del_constructor_list : context -> constructor_list -> unit @@ -1624,28 +1366,24 @@ external del_constructor_list : context -> constructor_list -> unit (** Summary: Create mutually recursive datatypes. - @param c logical context. @param num_sorts number of datatype sorts. @param sort_names names of datatype sorts. - @param sorts array of datattype sorts. + @param sorts array of datatype sorts. @param constructor_lists list of constructors, one list per sort. - def_API('mk_datatypes', VOID, (_in(CONTEXT), _in(UINT), _in_array(1, SYMBOL), _out_array(1, SORT), _inout_array(1, CONSTRUCTOR_LIST))) *) external mk_datatypes : context -> symbol array -> constructor_list array -> sort array * constructor_list array = "camlidl_z3_Z3_mk_datatypes" (** - Summary: Query constructor for declared functions. - + Summary: Query constructor for declared functions. @param c logical context. @param constr constructor container. The container must have been passed in to a {!mk_datatype} call. @param num_fields number of accessor fields in the constructor. @param constructor constructor function declaration. @param tester constructor test function declaration. @param accessors array of accessor function declarations. - def_API('query_constructor', VOID, (_in(CONTEXT), _in(CONSTRUCTOR), _in(UINT), _out(FUNC_DECL), _out(FUNC_DECL), _out_array(2, FUNC_DECL))) *) external query_constructor : context -> constructor -> int -> func_decl * func_decl * func_decl array @@ -1657,22 +1395,17 @@ external query_constructor : context -> constructor -> int -> func_decl * func_d *) (** Summary: Declare a constant or function. - [mk_func_decl c n d r] creates a function with name [n], domain [d], and range [r]. - The arity of the function is the size of the array [d]. - + The arity of the function is the size of the array [d]. @param c logical context. @param s name of the constant or function. @param domain_size number of arguments. It is 0 when declaring a constant. @param domain array containing the sort of each argument. The array must contain domain_size elements. It is 0 when declaring a constant. @param range sort of the constant or the return sort of the function. - After declaring a constant or function, the function {!mk_app} can be used to create a constant or function application. - - {b See also}: {!mk_app} - def_API('mk_func_decl', FUNC_DECL, (_in(CONTEXT), _in(SYMBOL), _in(UINT), _in_array(2, SORT), _in(SORT))) *) external mk_func_decl : context -> symbol -> sort array -> sort -> func_decl @@ -1680,9 +1413,7 @@ external mk_func_decl : context -> symbol -> sort array -> sort -> func_decl (** Summary: Create a constant or function application. - - {b See also}: {!mk_func_decl} - def_API('mk_app', AST, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT), _in_array(2, AST))) *) external mk_app : context -> func_decl -> ast array -> ast @@ -1690,18 +1421,9 @@ external mk_app : context -> func_decl -> ast array -> ast (** Summary: Declare and create a constant. - - - - - - - - [mk_const c s t] is a shorthand for [mk_app c (mk_func_decl c s [||] t) [||]] - + [mk_const c s t] is a shorthand for [mk_app c (mk_func_decl c s [||] t) [||]] - {b See also}: {!mk_func_decl} - {b See also}: {!mk_app} - def_API('mk_const', AST, (_in(CONTEXT), _in(SYMBOL), _in(SORT))) *) external mk_const : context -> symbol -> sort -> ast @@ -1709,14 +1431,8 @@ external mk_const : context -> symbol -> sort -> ast (** Summary: Declare a fresh constant or function. - Z3 will generate an unique name for this function declaration. - - - - - {b See also}: {!mk_func_decl} - def_API('mk_fresh_func_decl', FUNC_DECL, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SORT), _in(SORT))) *) external mk_fresh_func_decl : context -> string -> sort array -> sort -> func_decl @@ -1724,17 +1440,9 @@ external mk_fresh_func_decl : context -> string -> sort array -> sort -> func_de (** Summary: Declare and create a fresh constant. - - - - - [mk_fresh_const c p t] is a shorthand for [mk_app c (mk_fresh_func_decl c p [||] t) [||]]. - - - + [mk_fresh_const c p t] is a shorthand for [mk_app c (mk_fresh_func_decl c p [||] t) [||]]. - {b See also}: {!mk_func_decl} - {b See also}: {!mk_app} - def_API('mk_fresh_const', AST, (_in(CONTEXT), _in(STRING), _in(SORT))) *) external mk_fresh_const : context -> string -> sort -> ast @@ -1745,7 +1453,6 @@ external mk_fresh_const : context -> string -> sort -> ast *) (** Summary: Create an AST node representing [true]. - def_API('mk_true', AST, (_in(CONTEXT), )) *) external mk_true : context -> ast @@ -1753,7 +1460,6 @@ external mk_true : context -> ast (** Summary: Create an AST node representing [false]. - def_API('mk_false', AST, (_in(CONTEXT), )) *) external mk_false : context -> ast @@ -1762,51 +1468,40 @@ external mk_false : context -> ast (** Summary: \[ [ mk_eq c l r ] \] Create an AST node representing {e l = r }. - - The nodes [l] and [r] must have the same type. - + The nodes [l] and [r] must have the same type. def_API('mk_eq', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_eq : context -> ast -> ast -> ast = "camlidl_z3_Z3_mk_eq" (** - Summary: \[ [mk_distinct c [| t_1; ...; t_n |]] \] Create an AST node represeting a distinct construct. It is used for declaring - the arguments t_i pairwise distinct. - + the arguments t_i pairwise distinct. The [distinct] construct is used for declaring the arguments pairwise distinct. That is, {e Forall 0 <= i < j < num_args. not args[i] = args[j] }. - All arguments must have the same sort. - - {b Remarks}: The number of arguments of a distinct construct must be greater than one. - def_API('mk_distinct', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_distinct : context -> ast array -> ast = "camlidl_z3_Z3_mk_distinct" (** - Summary: \[ [ mk_not c a ] \] + Summary: \[ [ mk_not c a ] \] Create an AST node representing {e not(a) }. - The node [a] must have Boolean sort. - def_API('mk_not', AST, (_in(CONTEXT), _in(AST))) *) external mk_not : context -> ast -> ast = "camlidl_z3_Z3_mk_not" (** - Summary: \[ [ mk_ite c t1 t2 t2 ] \] + Summary: \[ [ mk_ite c t1 t2 t2 ] \] Create an AST node representing an if-then-else: {e ite(t1, t2, t3) }. - The node [t1] must have Boolean sort, [t2] and [t3] must have the same sort. The sort of the new node is equal to the sort of [t2] and [t3]. - def_API('mk_ite', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(AST))) *) external mk_ite : context -> ast -> ast -> ast -> ast @@ -1815,9 +1510,7 @@ external mk_ite : context -> ast -> ast -> ast -> ast (** Summary: \[ [ mk_iff c t1 t2 ] \] Create an AST node representing {e t1 iff t2 }. - The nodes [t1] and [t2] must have Boolean sort. - def_API('mk_iff', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_iff : context -> ast -> ast -> ast @@ -1826,9 +1519,7 @@ external mk_iff : context -> ast -> ast -> ast (** Summary: \[ [ mk_implies c t1 t2 ] \] Create an AST node representing {e t1 implies t2 }. - The nodes [t1] and [t2] must have Boolean sort. - def_API('mk_implies', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_implies : context -> ast -> ast -> ast @@ -1837,37 +1528,25 @@ external mk_implies : context -> ast -> ast -> ast (** Summary: \[ [ mk_xor c t1 t2 ] \] Create an AST node representing {e t1 xor t2 }. - The nodes [t1] and [t2] must have Boolean sort. - def_API('mk_xor', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_xor : context -> ast -> ast -> ast = "camlidl_z3_Z3_mk_xor" (** - - Summary: \[ [mk_and c [| t_1; ...; t_n |]] \] Create the conjunction: {e t_1 and ... and t_n}. - - + Summary: \[ [mk_and c [| t_1; ...; t_n |]] \] Create the conjunction: {e t_1 and ... and t_n}. All arguments must have Boolean sort. - - {b Remarks}: The number of arguments must be greater than zero. - def_API('mk_and', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_and : context -> ast array -> ast = "camlidl_z3_Z3_mk_and" (** - - Summary: \[ [mk_or c [| t_1; ...; t_n |]] \] Create the disjunction: {e t_1 or ... or t_n}. - - + Summary: \[ [mk_or c [| t_1; ...; t_n |]] \] Create the disjunction: {e t_1 or ... or t_n}. All arguments must have Boolean sort. - - {b Remarks}: The number of arguments must be greater than zero. - def_API('mk_or', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_or : context -> ast array -> ast @@ -1877,110 +1556,78 @@ external mk_or : context -> ast array -> ast {2 {L Arithmetic: Integers and Reals}} *) (** - - Summary: \[ [mk_add c [| t_1; ...; t_n |]] \] Create the term: {e t_1 + ... + t_n}. - - + Summary: \[ [mk_add c [| t_1; ...; t_n |]] \] Create the term: {e t_1 + ... + t_n}. All arguments must have int or real sort. - - {b Remarks}: The number of arguments must be greater than zero. - def_API('mk_add', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_add : context -> ast array -> ast = "camlidl_z3_Z3_mk_add" (** - - Summary: \[ [mk_mul c [| t_1; ...; t_n |]] \] Create the term: {e t_1 * ... * t_n}. - - + Summary: \[ [mk_mul c [| t_1; ...; t_n |]] \] Create the term: {e t_1 * ... * t_n}. All arguments must have int or real sort. - - {b Remarks}: Z3 has limited support for non-linear arithmetic. - {b Remarks}: The number of arguments must be greater than zero. - def_API('mk_mul', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_mul : context -> ast array -> ast = "camlidl_z3_Z3_mk_mul" (** - - Summary: \[ [mk_sub c [| t_1; ...; t_n |]] \] Create the term: {e t_1 - ... - t_n}. - - + Summary: \[ [mk_sub c [| t_1; ...; t_n |]] \] Create the term: {e t_1 - ... - t_n}. All arguments must have int or real sort. - - {b Remarks}: The number of arguments must be greater than zero. - def_API('mk_sub', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_sub : context -> ast array -> ast = "camlidl_z3_Z3_mk_sub" (** - - Summary: \[ [mk_unary_minus c arg] \] Create the term: {e - arg}. - + Summary: \[ [mk_unary_minus c arg] \] Create the term: {e - arg}. The arguments must have int or real type. - def_API('mk_unary_minus', AST, (_in(CONTEXT), _in(AST))) *) external mk_unary_minus : context -> ast -> ast = "camlidl_z3_Z3_mk_unary_minus" (** - - Summary: \[ [mk_div c t_1 t_2] \] Create the term: {e t_1 div t_2}. - + Summary: \[ [mk_div c t_1 t_2] \] Create the term: {e t_1 div t_2}. The arguments must either both have int type or both have real type. If the arguments have int type, then the result type is an int type, otherwise the the result type is real. - def_API('mk_div', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_div : context -> ast -> ast -> ast = "camlidl_z3_Z3_mk_div" (** - - Summary: \[ [mk_mod c t_1 t_2] \] Create the term: {e t_1 mod t_2}. - + Summary: \[ [mk_mod c t_1 t_2] \] Create the term: {e t_1 mod t_2}. The arguments must have int type. - def_API('mk_mod', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_mod : context -> ast -> ast -> ast = "camlidl_z3_Z3_mk_mod" (** - - Summary: \[ [mk_rem c t_1 t_2] \] Create the term: {e t_1 rem t_2}. - + Summary: \[ [mk_rem c t_1 t_2] \] Create the term: {e t_1 rem t_2}. The arguments must have int type. - def_API('mk_rem', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_rem : context -> ast -> ast -> ast = "camlidl_z3_Z3_mk_rem" (** - - The arguments must have int or real type. - def_API('mk_power', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_power : context -> ast -> ast -> ast = "camlidl_z3_Z3_mk_power" (** - Summary: \[ [ mk_lt c t1 t2 ] \] + Summary: \[ [ mk_lt c t1 t2 ] \] Create less than. - The nodes [t1] and [t2] must have the same sort, and must be int or real. - def_API('mk_lt', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_lt : context -> ast -> ast -> ast @@ -1989,9 +1636,7 @@ external mk_lt : context -> ast -> ast -> ast (** Summary: \[ [ mk_le c t1 t2 ] \] Create less than or equal to. - The nodes [t1] and [t2] must have the same sort, and must be int or real. - def_API('mk_le', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_le : context -> ast -> ast -> ast @@ -2000,9 +1645,7 @@ external mk_le : context -> ast -> ast -> ast (** Summary: \[ [ mk_gt c t1 t2 ] \] Create greater than. - The nodes [t1] and [t2] must have the same sort, and must be int or real. - def_API('mk_gt', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_gt : context -> ast -> ast -> ast @@ -2011,9 +1654,7 @@ external mk_gt : context -> ast -> ast -> ast (** Summary: \[ [ mk_ge c t1 t2 ] \] Create greater than or equal to. - The nodes [t1] and [t2] must have the same sort, and must be int or real. - def_API('mk_ge', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_ge : context -> ast -> ast -> ast @@ -2022,19 +1663,14 @@ external mk_ge : context -> ast -> ast -> ast (** Summary: \[ [ mk_int2real c t1 ] \] Coerce an integer to a real. - There is also a converse operation exposed. It follows the semantics prescribed by the SMT-LIB standard. - - You can take the floor of a real by + You can take the floor of a real by creating an auxiliary integer constant [k] and - and asserting {e mk_int2real(k) <= t1 < mk_int2real(k)+1 }. - + and asserting {e mk_int2real(k) <= t1 < mk_int2real(k)+1 }. The node [t1] must have sort integer. - - {b See also}: {!mk_real2int} - {b See also}: {!mk_is_int} - def_API('mk_int2real', AST, (_in(CONTEXT), _in(AST))) *) external mk_int2real : context -> ast -> ast @@ -2043,13 +1679,10 @@ external mk_int2real : context -> ast -> ast (** Summary: \[ [ mk_real2int c t1 ] \] Coerce a real to an integer. - The semantics of this function follows the SMT-LIB standard for the function to_int - - {b See also}: {!mk_int2real} - {b See also}: {!mk_is_int} - def_API('mk_real2int', AST, (_in(CONTEXT), _in(AST))) *) external mk_real2int : context -> ast -> ast @@ -2058,10 +1691,8 @@ external mk_real2int : context -> ast -> ast (** Summary: \[ [ mk_is_int c t1 ] \] Check if a real number is an integer. - - {b See also}: {!mk_int2real} - {b See also}: {!mk_real2int} - def_API('mk_is_int', AST, (_in(CONTEXT), _in(AST))) *) external mk_is_int : context -> ast -> ast @@ -2073,9 +1704,7 @@ external mk_is_int : context -> ast -> ast (** Summary: \[ [ mk_bvnot c t1 ] \] Bitwise negation. - The node [t1] must have a bit-vector sort. - def_API('mk_bvnot', AST, (_in(CONTEXT), _in(AST))) *) external mk_bvnot : context -> ast -> ast @@ -2084,9 +1713,7 @@ external mk_bvnot : context -> ast -> ast (** Summary: \[ [ mk_bvredand c t1 ] \] Take conjunction of bits in vector, return vector of length 1. - The node [t1] must have a bit-vector sort. - def_API('mk_bvredand', AST, (_in(CONTEXT), _in(AST))) *) external mk_bvredand : context -> ast -> ast @@ -2095,9 +1722,7 @@ external mk_bvredand : context -> ast -> ast (** Summary: \[ [ mk_bvredor c t1 ] \] Take disjunction of bits in vector, return vector of length 1. - The node [t1] must have a bit-vector sort. - def_API('mk_bvredor', AST, (_in(CONTEXT), _in(AST))) *) external mk_bvredor : context -> ast -> ast @@ -2106,9 +1731,7 @@ external mk_bvredor : context -> ast -> ast (** Summary: \[ [ mk_bvand c t1 t2 ] \] Bitwise and. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvand', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvand : context -> ast -> ast -> ast @@ -2117,9 +1740,7 @@ external mk_bvand : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvor c t1 t2 ] \] Bitwise or. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvor', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvor : context -> ast -> ast -> ast @@ -2128,9 +1749,7 @@ external mk_bvor : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvxor c t1 t2 ] \] Bitwise exclusive-or. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvxor', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvxor : context -> ast -> ast -> ast @@ -2138,10 +1757,8 @@ external mk_bvxor : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvnand c t1 t2 ] \] - Bitwise nand. - + Bitwise nand. The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvnand', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvnand : context -> ast -> ast -> ast @@ -2149,10 +1766,8 @@ external mk_bvnand : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvnor c t1 t2 ] \] - Bitwise nor. - + Bitwise nor. The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvnor', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvnor : context -> ast -> ast -> ast @@ -2160,10 +1775,8 @@ external mk_bvnor : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvxnor c t1 t2 ] \] - Bitwise xnor. - + Bitwise xnor. The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvxnor', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvxnor : context -> ast -> ast -> ast @@ -2172,9 +1785,7 @@ external mk_bvxnor : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvneg c t1 ] \] Standard two's complement unary minus. - The node [t1] must have bit-vector sort. - def_API('mk_bvneg', AST, (_in(CONTEXT), _in(AST))) *) external mk_bvneg : context -> ast -> ast @@ -2183,9 +1794,7 @@ external mk_bvneg : context -> ast -> ast (** Summary: \[ [ mk_bvadd c t1 t2 ] \] Standard two's complement addition. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvadd', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvadd : context -> ast -> ast -> ast @@ -2194,9 +1803,7 @@ external mk_bvadd : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsub c t1 t2 ] \] Standard two's complement subtraction. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsub', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsub : context -> ast -> ast -> ast @@ -2205,9 +1812,7 @@ external mk_bvsub : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvmul c t1 t2 ] \] Standard two's complement multiplication. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvmul', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvmul : context -> ast -> ast -> ast @@ -2215,14 +1820,11 @@ external mk_bvmul : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvudiv c t1 t2 ] \] - Unsigned division. - + Unsigned division. It is defined as the [floor] of {e t1/t2 } if [t2] is different from zero. If {e t2 } is zero, then the result is undefined. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvudiv', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvudiv : context -> ast -> ast -> ast @@ -2231,17 +1833,11 @@ external mk_bvudiv : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsdiv c t1 t2 ] \] Two's complement signed division. - It is defined in the following way: - - The [floor] of {e t1/t2 } if [t2] is different from zero, and {e t1*t2 >= 0 }. - - The [ceiling] of {e t1/t2 } if [t2] is different from zero, and {e t1*t2 < 0 }. - If {e t2 } is zero, then the result is undefined. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsdiv', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsdiv : context -> ast -> ast -> ast @@ -2250,13 +1846,9 @@ external mk_bvsdiv : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvurem c t1 t2 ] \] Unsigned remainder. - It is defined as {e t1 - (t1 /u t2) * t2 }, where {e /u } represents unsigned int division. - If {e t2 } is zero, then the result is undefined. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvurem', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvurem : context -> ast -> ast -> ast @@ -2265,16 +1857,11 @@ external mk_bvurem : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsrem c t1 t2 ] \] Two's complement signed remainder (sign follows dividend). - It is defined as {e t1 - (t1 /s t2) * t2 }, where {e /s } represents signed division. The most significant bit (sign) of the result is equal to the most significant bit of [t1]. - If {e t2 } is zero, then the result is undefined. - The nodes [t1] and [t2] must have the same bit-vector sort. - - {b See also}: {!mk_bvsmod} - def_API('mk_bvsrem', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsrem : context -> ast -> ast -> ast @@ -2283,13 +1870,9 @@ external mk_bvsrem : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsmod c t1 t2 ] \] Two's complement signed remainder (sign follows divisor). - If {e t2 } is zero, then the result is undefined. - The nodes [t1] and [t2] must have the same bit-vector sort. - - {b See also}: {!mk_bvsrem} - def_API('mk_bvsmod', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsmod : context -> ast -> ast -> ast @@ -2298,9 +1881,7 @@ external mk_bvsmod : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvult c t1 t2 ] \] Unsigned less than. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvult', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvult : context -> ast -> ast -> ast @@ -2309,17 +1890,14 @@ external mk_bvult : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvslt c t1 t2 ] \] Two's complement signed less than. - It abbreviates: - {v + {v (or (and (= (extract[|m-1|:|m-1|] t1) bit1) (= (extract[|m-1|:|m-1|] t2) bit0)) (and (= (extract[|m-1|:|m-1|] t1) (extract[|m-1|:|m-1|] t2)) (bvult t1 t2))) v} - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvslt', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvslt : context -> ast -> ast -> ast @@ -2328,9 +1906,7 @@ external mk_bvslt : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvule c t1 t2 ] \] Unsigned less than or equal to. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvule', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvule : context -> ast -> ast -> ast @@ -2339,9 +1915,7 @@ external mk_bvule : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsle c t1 t2 ] \] Two's complement signed less than or equal to. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsle', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsle : context -> ast -> ast -> ast @@ -2350,9 +1924,7 @@ external mk_bvsle : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvuge c t1 t2 ] \] Unsigned greater than or equal to. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvuge', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvuge : context -> ast -> ast -> ast @@ -2361,9 +1933,7 @@ external mk_bvuge : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsge c t1 t2 ] \] Two's complement signed greater than or equal to. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsge', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsge : context -> ast -> ast -> ast @@ -2372,9 +1942,7 @@ external mk_bvsge : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvugt c t1 t2 ] \] Unsigned greater than. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvugt', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvugt : context -> ast -> ast -> ast @@ -2383,9 +1951,7 @@ external mk_bvugt : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsgt c t1 t2 ] \] Two's complement signed greater than. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsgt', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsgt : context -> ast -> ast -> ast @@ -2394,12 +1960,9 @@ external mk_bvsgt : context -> ast -> ast -> ast (** Summary: \[ [ mk_concat c t1 t2 ] \] Concatenate the given bit-vectors. - The nodes [t1] and [t2] must have (possibly different) bit-vector sorts - The result is a bit-vector of size {e n1+n2 }, where [n1] ([n2)] is the size of [t1] ([t2)]. - def_API('mk_concat', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_concat : context -> ast -> ast -> ast @@ -2410,9 +1973,7 @@ external mk_concat : context -> ast -> ast -> ast Extract the bits [high] down to [low] from a bitvector of size [m] to yield a new bitvector of size [n], where {e n = high - low + 1 }. - The node [t1] must have a bit-vector sort. - def_API('mk_extract', AST, (_in(CONTEXT), _in(UINT), _in(UINT), _in(AST))) *) external mk_extract : context -> int -> int -> ast -> ast @@ -2423,9 +1984,7 @@ external mk_extract : context -> int -> int -> ast -> ast Sign-extend of the given bit-vector to the (signed) equivalent bitvector of size {e m+i }, where [m] is the size of the given bit-vector. - The node [t1] must have a bit-vector sort. - def_API('mk_sign_ext', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_sign_ext : context -> int -> ast -> ast @@ -2433,12 +1992,10 @@ external mk_sign_ext : context -> int -> ast -> ast (** Summary: \[ [ mk_zero_ext c i t1 ] \] - Extend the given bit-vector with zeros to the (unsigned int) equivalent + Extend the given bit-vector with zeros to the (unsigned) equivalent bitvector of size {e m+i }, where [m] is the size of the given bit-vector. - - The node [t1] must have a bit-vector sort. - + The node [t1] must have a bit-vector sort. def_API('mk_zero_ext', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_zero_ext : context -> int -> ast -> ast @@ -2447,9 +2004,7 @@ external mk_zero_ext : context -> int -> ast -> ast (** Summary: \[ [ mk_repeat c i t1 ] \] Repeat the given bit-vector up length {e i }. - - The node [t1] must have a bit-vector sort. - + The node [t1] must have a bit-vector sort. def_API('mk_repeat', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_repeat : context -> int -> ast -> ast @@ -2458,16 +2013,12 @@ external mk_repeat : context -> int -> ast -> ast (** Summary: \[ [ mk_bvshl c t1 t2 ] \] Shift left. - It is equivalent to multiplication by {e 2^x } where [x] is the value of the third argument. - - NB. The semantics of shift operations varies between environments. This - definition does not necessarily capture directly the semantics of the + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the programming language or assembly architecture you are modeling. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvshl', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvshl : context -> ast -> ast -> ast @@ -2476,16 +2027,12 @@ external mk_bvshl : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvlshr c t1 t2 ] \] Logical shift right. - It is equivalent to unsigned int division by {e 2^x } where [x] is the value of the third argument. - - NB. The semantics of shift operations varies between environments. This - definition does not necessarily capture directly the semantics of the + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the programming language or assembly architecture you are modeling. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvlshr', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvlshr : context -> ast -> ast -> ast @@ -2494,17 +2041,13 @@ external mk_bvlshr : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvashr c t1 t2 ] \] Arithmetic shift right. - It is like logical shift right except that the most significant bits of the result always copy the most significant bit of the second argument. - - The semantics of shift operations varies between environments. This - definition does not necessarily capture directly the semantics of the + The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the programming language or assembly architecture you are modeling. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvashr', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvashr : context -> ast -> ast -> ast @@ -2513,9 +2056,7 @@ external mk_bvashr : context -> ast -> ast -> ast (** Summary: \[ [ mk_rotate_left c i t1 ] \] Rotate bits of [t1] to the left [i] times. - - The node [t1] must have a bit-vector sort. - + The node [t1] must have a bit-vector sort. def_API('mk_rotate_left', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_rotate_left : context -> int -> ast -> ast @@ -2524,9 +2065,7 @@ external mk_rotate_left : context -> int -> ast -> ast (** Summary: \[ [ mk_rotate_right c i t1 ] \] Rotate bits of [t1] to the right [i] times. - - The node [t1] must have a bit-vector sort. - + The node [t1] must have a bit-vector sort. def_API('mk_rotate_right', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_rotate_right : context -> int -> ast -> ast @@ -2535,9 +2074,7 @@ external mk_rotate_right : context -> int -> ast -> ast (** Summary: \[ [ mk_ext_rotate_left c t1 t2 ] \] Rotate bits of [t1] to the left [t2] times. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_ext_rotate_left', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_ext_rotate_left : context -> ast -> ast -> ast @@ -2546,9 +2083,7 @@ external mk_ext_rotate_left : context -> ast -> ast -> ast (** Summary: \[ [ mk_ext_rotate_right c t1 t2 ] \] Rotate bits of [t1] to the right [t2] times. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_ext_rotate_right', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_ext_rotate_right : context -> ast -> ast -> ast @@ -2557,13 +2092,10 @@ external mk_ext_rotate_right : context -> ast -> ast -> ast (** Summary: \[ [ mk_int2bv c n t1 ] \] Create an [n] bit bit-vector from the integer argument [t1]. - - NB. This function is essentially treated as uninterpreted. + NB. This function is essentially treated as uninterpreted. So you cannot expect Z3 to precisely reflect the semantics of this function when solving constraints with this function. - - The node [t1] must have integer sort. - + The node [t1] must have integer sort. def_API('mk_int2bv', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_int2bv : context -> int -> ast -> ast @@ -2572,17 +2104,14 @@ external mk_int2bv : context -> int -> ast -> ast (** Summary: \[ [ mk_bv2int c t1 is_signed ] \] Create an integer from the bit-vector argument [t1]. - If [is_signed] is false, then the bit-vector [t1] is treated as unsigned int. + If [is_signed] is false, then the bit-vector [t1] is treated as unsigned int. So the result is non-negative and in the range {e [0..2^N-1] }, where N are the number of bits in [t1]. If [is_signed] is true, [t1] is treated as a signed bit-vector. - - This function is essentially treated as uninterpreted. + This function is essentially treated as uninterpreted. So you cannot expect Z3 to precisely reflect the semantics of this function when solving constraints with this function. - - The node [t1] must have a bit-vector sort. - + The node [t1] must have a bit-vector sort. def_API('mk_bv2int', AST, (_in(CONTEXT), _in(AST), _in(BOOL))) *) external mk_bv2int : context -> ast -> bool -> ast @@ -2592,9 +2121,7 @@ external mk_bv2int : context -> ast -> bool -> ast Summary: \[ [ mk_bvadd_no_overflow c t1 t2 is_signed ] \] Create a predicate that checks that the bit-wise addition of [t1] and [t2] does not overflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvadd_no_overflow', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(BOOL))) *) external mk_bvadd_no_overflow : context -> ast -> ast -> bool -> ast @@ -2604,9 +2131,7 @@ external mk_bvadd_no_overflow : context -> ast -> ast -> bool -> ast Summary: \[ [ mk_bvadd_no_underflow c t1 t2 ] \] Create a predicate that checks that the bit-wise signed addition of [t1] and [t2] does not underflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvadd_no_underflow', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvadd_no_underflow : context -> ast -> ast -> ast @@ -2616,9 +2141,7 @@ external mk_bvadd_no_underflow : context -> ast -> ast -> ast Summary: \[ [ mk_bvsub_no_overflow c t1 t2 ] \] Create a predicate that checks that the bit-wise signed subtraction of [t1] and [t2] does not overflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsub_no_overflow', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsub_no_overflow : context -> ast -> ast -> ast @@ -2628,9 +2151,7 @@ external mk_bvsub_no_overflow : context -> ast -> ast -> ast Summary: \[ [ mk_bvsub_no_underflow c t1 t2 is_signed ] \] Create a predicate that checks that the bit-wise subtraction of [t1] and [t2] does not underflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsub_no_underflow', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(BOOL))) *) external mk_bvsub_no_underflow : context -> ast -> ast -> bool -> ast @@ -2638,11 +2159,9 @@ external mk_bvsub_no_underflow : context -> ast -> ast -> bool -> ast (** Summary: \[ [ mk_bvsdiv_no_overflow c t1 t2 ] \] - Create a predicate that checks that the bit-wise signed division + Create a predicate that checks that the bit-wise signed division of [t1] and [t2] does not overflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsdiv_no_overflow', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsdiv_no_overflow : context -> ast -> ast -> ast @@ -2650,11 +2169,9 @@ external mk_bvsdiv_no_overflow : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvneg_no_overflow c t1 ] \] - Check that bit-wise negation does not overflow when + Check that bit-wise negation does not overflow when [t1] is interpreted as a signed bit-vector. - The node [t1] must have bit-vector sort. - def_API('mk_bvneg_no_overflow', AST, (_in(CONTEXT), _in(AST))) *) external mk_bvneg_no_overflow : context -> ast -> ast @@ -2664,9 +2181,7 @@ external mk_bvneg_no_overflow : context -> ast -> ast Summary: \[ [ mk_bvmul_no_overflow c t1 t2 is_signed ] \] Create a predicate that checks that the bit-wise multiplication of [t1] and [t2] does not overflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvmul_no_overflow', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(BOOL))) *) external mk_bvmul_no_overflow : context -> ast -> ast -> bool -> ast @@ -2676,9 +2191,7 @@ external mk_bvmul_no_overflow : context -> ast -> ast -> bool -> ast Summary: \[ [ mk_bvmul_no_underflow c t1 t2 ] \] Create a predicate that checks that the bit-wise signed multiplication of [t1] and [t2] does not underflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvmul_no_underflow', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvmul_no_underflow : context -> ast -> ast -> ast @@ -2690,15 +2203,12 @@ external mk_bvmul_no_underflow : context -> ast -> ast -> ast (** Summary: \[ [ mk_select c a i ] \] Array read. - The argument [a] is the array and [i] is the index of the array that gets read. - - The node [a] must have an array sort {e [domain -> range] }, + The argument [a] is the array and [i] is the index of the array that gets read. + The node [a] must have an array sort {e [domain -> range] }, and [i] must have the sort [domain]. The sort of the result is [range]. - - {b See also}: {!mk_array_sort} - {b See also}: {!mk_store} - def_API('mk_select', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_select : context -> ast -> ast -> ast @@ -2707,18 +2217,15 @@ external mk_select : context -> ast -> ast -> ast (** Summary: \[ [ mk_store c a i v ] \] Array update. - The node [a] must have an array sort {e [domain -> range] }, [i] must have sort [domain], [v] must have sort range. The sort of the result is {e [domain -> range] }. The semantics of this function is given by the theory of arrays described in the SMT-LIB - standard. See http: + standard. See http://smtlib.org for more details. The result of this function is an array that is equal to [a] (with respect to [select)] - on all indices except for [i], where it maps to [v] (and the [select] of [a] with + on all indices except for [i], where it maps to [v] (and the [select] of [a] with respect to [i] may be a different value). - - {b See also}: {!mk_array_sort} - {b See also}: {!mk_select} - def_API('mk_store', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(AST))) *) external mk_store : context -> ast -> ast -> ast -> ast @@ -2726,14 +2233,11 @@ external mk_store : context -> ast -> ast -> ast -> ast (** Summary: Create the constant array. - - The resulting term is an array, such that a [select] on an arbitrary index + The resulting term is an array, such that a [select] on an arbitrary index produces the value [v]. - @param c logical context. @param domain domain sort for the array. @param v value that the array maps to. - def_API('mk_const_array', AST, (_in(CONTEXT), _in(SORT), _in(AST))) *) external mk_const_array : context -> sort -> ast -> ast @@ -2742,15 +2246,12 @@ external mk_const_array : context -> sort -> ast -> ast (** Summary: \[ [ mk_map f n args ] \] map f on the the argument arrays. - The [n] nodes [args] must be of array sorts {e [domain_i -> range_i] }. - The function declaration [f] must have type {e range_1 .. range_n -> range }. + The function declaration [f] must have type {e range_1 .. range_n -> range }. [v] must have sort range. The sort of the result is {e [domain_i -> range] }. - - {b See also}: {!mk_array_sort} - {b See also}: {!mk_store} - {b See also}: {!mk_select} - def_API('mk_map', AST, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT), _in_array(2, AST))) *) external mk_map : context -> func_decl -> int -> ast -> ast @@ -2758,12 +2259,10 @@ external mk_map : context -> func_decl -> int -> ast -> ast (** Summary: Access the array default value. - Produces the default range value, for arrays that can be represented as + Produces the default range value, for arrays that can be represented as finite maps with a default range value. - @param c logical context. @param array array value whose default range value is accessed. - def_API('mk_array_default', AST, (_in(CONTEXT), _in(AST))) *) external mk_array_default : context -> ast -> ast @@ -2774,7 +2273,6 @@ external mk_array_default : context -> ast -> ast *) (** Summary: Create Set type. - def_API('mk_set_sort', SORT, (_in(CONTEXT), _in(SORT))) *) external mk_set_sort : context -> sort -> sort @@ -2782,7 +2280,6 @@ external mk_set_sort : context -> sort -> sort (** Summary: Create the empty set. - def_API('mk_empty_set', AST, (_in(CONTEXT), _in(SORT))) *) external mk_empty_set : context -> sort -> ast @@ -2790,7 +2287,6 @@ external mk_empty_set : context -> sort -> ast (** Summary: Create the full set. - def_API('mk_full_set', AST, (_in(CONTEXT), _in(SORT))) *) external mk_full_set : context -> sort -> ast @@ -2798,9 +2294,7 @@ external mk_full_set : context -> sort -> ast (** Summary: Add an element to a set. - The first argument must be a set, the second an element. - def_API('mk_set_add', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_set_add : context -> ast -> ast -> ast @@ -2808,9 +2302,7 @@ external mk_set_add : context -> ast -> ast -> ast (** Summary: Remove an element to a set. - The first argument must be a set, the second an element. - def_API('mk_set_del', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_set_del : context -> ast -> ast -> ast @@ -2818,7 +2310,6 @@ external mk_set_del : context -> ast -> ast -> ast (** Summary: Take the union of a list of sets. - def_API('mk_set_union', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_set_union : context -> ast array -> ast @@ -2826,7 +2317,6 @@ external mk_set_union : context -> ast array -> ast (** Summary: Take the intersection of a list of sets. - def_API('mk_set_intersect', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_set_intersect : context -> ast array -> ast @@ -2834,7 +2324,6 @@ external mk_set_intersect : context -> ast array -> ast (** Summary: Take the set difference between two sets. - def_API('mk_set_difference', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_set_difference : context -> ast -> ast -> ast @@ -2842,7 +2331,6 @@ external mk_set_difference : context -> ast -> ast -> ast (** Summary: Take the complement of a set. - def_API('mk_set_complement', AST, (_in(CONTEXT), _in(AST))) *) external mk_set_complement : context -> ast -> ast @@ -2850,9 +2338,7 @@ external mk_set_complement : context -> ast -> ast (** Summary: Check for set membership. - The first argument should be an element type of the set. - def_API('mk_set_member', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_set_member : context -> ast -> ast -> ast @@ -2860,7 +2346,6 @@ external mk_set_member : context -> ast -> ast -> ast (** Summary: Check for subsetness of sets. - def_API('mk_set_subset', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_set_subset : context -> ast -> ast -> ast @@ -2874,32 +2359,27 @@ external mk_set_subset : context -> ast -> ast -> ast Summary: \[ [ numeral_refined ] \] is the refined view of a numeral . *) type numeral_refined = - | Numeral_int of int * sort - | Numeral_int64 of int64 * sort - | Numeral_large of string * sort + | Numeral_int of int * sort + | Numeral_int64 of int64 * sort + | Numeral_large of string * sort | Numeral_rational of numeral_refined * numeral_refined (** Summary: \[ [ embed_numeral c nr ] \] constructs the numeral described by [nr]. - - {b See also}: {!numeral_refine} *) val embed_numeral: context -> numeral_refined -> ast (** - {4 {L Redundant low-level API}} + {4 {L Redundant low-level API}} *) (** - Summary: Create a numeral of a given sort. - + Summary: Create a numeral of a given sort. @param c logical context. @param numeral A string representing the numeral value in decimal notation. If the given sort is a real, then the numeral can be a rational, that is, a string of the form {e [num]* / [num]* }. - @param ty The sort of the numeral. In the current implementation, the given sort can be an int, real, finite-domain, or bit-vectors of arbitrary size. - + @param ty The sort of the numeral. In the current implementation, the given sort can be an int, real, finite-domain, or bit-vectors of arbitrary size. - {b See also}: {!mk_int} - - def_API('mk_numeral', AST, (_in(CONTEXT), _in(STRING), _in(SORT))) *) external mk_numeral : context -> string -> sort -> ast @@ -2907,43 +2387,32 @@ external mk_numeral : context -> string -> sort -> ast (** Summary: Create a real from a fraction. - @param c logical context. @param num numerator of rational. @param den denomerator of rational. - - {b Precondition}: den != 0 - - {b See also}: {!mk_numeral} - {b See also}: {!mk_int} - - def_API('mk_real', AST, (_in(CONTEXT), _in(INT), _in(INT))) *) external mk_real : context -> int -> int -> ast = "camlidl_z3_Z3_mk_real" (** - Summary: Create a numeral of an int, bit-vector, or finite-domain sort. - + Summary: Create a numeral of an int, bit-vector, or finite-domain sort. This function can be use to create numerals that fit in a machine integer. It is slightly faster than {!mk_numeral} since it is not necessary to parse a string. - - {b See also}: {!mk_numeral} - def_API('mk_int', AST, (_in(CONTEXT), _in(INT), _in(SORT))) *) external mk_int : context -> int -> sort -> ast = "camlidl_z3_Z3_mk_int" (** - Summary: Create a numeral of a int, bit-vector, or finite-domain sort. - + Summary: Create a numeral of a int, bit-vector, or finite-domain sort. This function can be use to create numerals that fit in a machine long long integer. It is slightly faster than {!mk_numeral} since it is not necessary to parse a string. - - {b See also}: {!mk_numeral} - def_API('mk_int64', AST, (_in(CONTEXT), _in(INT64), _in(SORT))) *) external mk_int64 : context -> int64 -> sort -> ast @@ -2954,22 +2423,17 @@ external mk_int64 : context -> int64 -> sort -> ast *) (** Summary: Create a pattern for quantifier instantiation. - Z3 uses pattern matching to instantiate quantifiers. If a pattern is not provided for a quantifier, then Z3 will automatically compute a set of patterns for it. However, for optimal performance, the user should provide the patterns. - Patterns comprise a list of terms. The list should be - non-empty. If the list comprises of more than one term, it is + non-empty. If the list comprises of more than one term, it is a called a multi-pattern. - In general, one can pass in a list of (multi-)patterns in the quantifier constructor. - - {b See also}: {!mk_forall} - {b See also}: {!mk_exists} - def_API('mk_pattern', PATTERN, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_pattern : context -> ast array -> pattern @@ -2977,12 +2441,10 @@ external mk_pattern : context -> ast array -> pattern (** Summary: Create a bound variable. - Bound variables are indexed by de-Bruijn indices. It is perhaps easiest to explain the meaning of de-Bruijn indices by indicating the compilation process from non-de-Bruijn formulas to de-Bruijn format. - - {v + {v abs(forall (x1) phi) = forall (x1) abs1(phi, x1, 0) abs(forall (x1, x2) phi) = abs(forall (x1) abs(forall (x2) phi)) abs1(x, x, n) = b_n @@ -2990,18 +2452,14 @@ external mk_pattern : context -> ast array -> pattern abs1(f(t1,...,tn), x, n) = f(abs1(t1,x,n), ..., abs1(tn,x,n)) abs1(forall (x1) phi, x, n) = forall (x1) (abs1(phi, x, n+1)) v} - The last line is significant: the index of a bound variable is different depending on the scope in which it appears. The deeper x appears, the higher is its index. - @param c logical context @param index de-Bruijn index @param ty sort of the bound variable - - {b See also}: {!mk_forall} - {b See also}: {!mk_exists} - def_API('mk_bound', AST, (_in(CONTEXT), _in(UINT), _in(SORT))) *) external mk_bound : context -> int -> sort -> ast @@ -3010,21 +2468,17 @@ external mk_bound : context -> int -> sort -> ast (** Summary: Create a forall formula. It takes an expression [body] that contains bound variables of the same sorts as the sorts listed in the array [sorts]. The bound variables are de-Bruijn indices created - using {!mk_bound}. The array [decl_names] contains the names that the quantified formula uses for the + using {!mk_bound}. The array [decl_names] contains the names that the quantified formula uses for the bound variables. Z3 applies the convention that the last element in the [decl_names] and [sorts] array refers to the variable with index 0, the second to last element of [decl_names] and [sorts] refers to the variable with index 1, etc. - - [mk_forall c w p t n b] creates a forall formula, where [w] is the weight, [p] is an array of patterns, [t] is an array with the sorts of the bound variables, [n] is an array with the 'names' of the bound variables, and [b] is the body of the quantifier. Quantifiers are associated with weights indicating the importance of using the quantifier during - instantiation. - - + instantiation. @param c logical context. @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. @param num_patterns number of patterns. @@ -3033,11 +2487,9 @@ external mk_bound : context -> int -> sort -> ast @param sorts the sorts of the bound variables. @param decl_names names of the bound variables @param body the body of the quantifier. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_bound} - {b See also}: {!mk_exists} - def_API('mk_forall', AST, (_in(CONTEXT), _in(UINT), _in(UINT), _in_array(2, PATTERN), _in(UINT), _in_array(4, SORT), _in_array(4, SYMBOL), _in(AST))) *) external mk_forall : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast @@ -3045,21 +2497,18 @@ external mk_forall : context -> int -> pattern array -> sort array -> symbol arr (** Summary: Create an exists formula. Similar to {!mk_forall}. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_bound} - {b See also}: {!mk_forall} - {b See also}: {!mk_quantifier} - def_API('mk_exists', AST, (_in(CONTEXT), _in(UINT), _in(UINT), _in_array(2, PATTERN), _in(UINT), _in_array(4, SORT), _in_array(4, SYMBOL), _in(AST))) *) external mk_exists : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast = "camlidl_z3_Z3_mk_exists_bytecode" "camlidl_z3_Z3_mk_exists" (** - Summary: Create a quantifier - universal or existential, with pattern hints. + Summary: Create a quantifier - universal or existential, with pattern hints. See the documentation for {!mk_forall} for an explanation of the parameters. - @param c logical context. @param is_forall flag to indicate if this is a universal or existential quantifier. @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. @@ -3069,12 +2518,10 @@ external mk_exists : context -> int -> pattern array -> sort array -> symbol arr @param sorts array of sorts of the bound variables. @param decl_names names of the bound variables. @param body the body of the quantifier. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_bound} - {b See also}: {!mk_forall} - {b See also}: {!mk_exists} - def_API('mk_quantifier', AST, (_in(CONTEXT), _in(BOOL), _in(UINT), _in(UINT), _in_array(3, PATTERN), _in(UINT), _in_array(5, SORT), _in_array(5, SYMBOL), _in(AST))) *) external mk_quantifier : context -> bool -> int -> pattern array -> sort array -> symbol array -> ast -> ast @@ -3082,7 +2529,6 @@ external mk_quantifier : context -> bool -> int -> pattern array -> sort array - (** Summary: Create a quantifier - universal or existential, with pattern hints, no patterns, and attributes - @param c logical context. @param is_forall flag to indicate if this is a universal or existential quantifier. @param quantifier_id identifier to identify quantifier @@ -3096,12 +2542,10 @@ external mk_quantifier : context -> bool -> int -> pattern array -> sort array - @param sorts array of sorts of the bound variables. @param decl_names names of the bound variables. @param body the body of the quantifier. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_bound} - {b See also}: {!mk_forall} - {b See also}: {!mk_exists} - def_API('mk_quantifier_ex', AST, (_in(CONTEXT), _in(BOOL), _in(UINT), _in(SYMBOL), _in(SYMBOL), _in(UINT), _in_array(5, PATTERN), _in(UINT), _in_array(7, AST), _in(UINT), _in_array(9, SORT), _in_array(9, SYMBOL), _in(AST))) *) external mk_quantifier_ex : context -> bool -> int -> symbol -> symbol -> pattern array -> ast array -> sort array -> symbol array -> ast -> ast @@ -3110,19 +2554,16 @@ external mk_quantifier_ex : context -> bool -> int -> symbol -> symbol -> patter (** Summary: Create a universal quantifier using a list of constants that will form the set of bound variables. - @param c logical context. - @param weight quantifiers are associated with weights indicating the importance of using + @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. @param num_bound number of constants to be abstracted into bound variables. @param bound array of constants to be abstracted into bound variables. @param num_patterns number of patterns. @param patterns array containing the patterns created using {!mk_pattern}. @param body the body of the quantifier. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_exists_const} - def_API('mk_forall_const', AST, (_in(CONTEXT), _in(UINT), _in(UINT), _in_array(2, APP), _in(UINT), _in_array(4, PATTERN), _in(AST))) *) external mk_forall_const : context -> int -> app array -> pattern array -> ast -> ast @@ -3130,42 +2571,36 @@ external mk_forall_const : context -> int -> app array -> pattern array -> ast - (** Summary: Similar to {!mk_forall_const}. - Summary: Create an existential quantifier using a list of constants that will form the set of bound variables. - @param c logical context. - @param weight quantifiers are associated with weights indicating the importance of using + @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. @param num_bound number of constants to be abstracted into bound variables. @param bound array of constants to be abstracted into bound variables. @param num_patterns number of patterns. @param patterns array containing the patterns created using {!mk_pattern}. @param body the body of the quantifier. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_forall_const} - def_API('mk_exists_const', AST, (_in(CONTEXT), _in(UINT), _in(UINT), _in_array(2, APP), _in(UINT), _in_array(4, PATTERN), _in(AST))) *) external mk_exists_const : context -> int -> app array -> pattern array -> ast -> ast = "camlidl_z3_Z3_mk_exists_const" (** - Summary: Create a universal or existential + Summary: Create a universal or existential quantifier using a list of constants that will form the set of bound variables. - def_API('mk_quantifier_const', AST, (_in(CONTEXT), _in(BOOL), _in(UINT), _in(UINT), _in_array(3, APP), _in(UINT), _in_array(5, PATTERN), _in(AST))) *) external mk_quantifier_const : context -> bool -> int -> app array -> pattern array -> ast -> ast = "camlidl_z3_Z3_mk_quantifier_const_bytecode" "camlidl_z3_Z3_mk_quantifier_const" (** - Summary: Create a universal or existential + Summary: Create a universal or existential quantifier using a list of constants that will form the set of bound variables. - def_API('mk_quantifier_const_ex', AST, (_in(CONTEXT), _in(BOOL), _in(UINT), _in(SYMBOL), _in(SYMBOL), _in(UINT), _in_array(5, APP), _in(UINT), _in_array(7, PATTERN), _in(UINT), _in_array(9, AST), _in(AST))) *) external mk_quantifier_const_ex : context -> bool -> int -> symbol -> symbol -> app array -> pattern array -> ast array -> ast -> ast @@ -3175,7 +2610,7 @@ external mk_quantifier_const_ex : context -> bool -> int -> symbol -> symbol -> {2 {L Accessors}} *) (** - {3 {L Symbols}} + {3 {L Symbols}} *) (** @@ -3184,13 +2619,12 @@ external mk_quantifier_const_ex : context -> bool -> int -> symbol -> symbol -> val symbol_refine: context -> symbol -> symbol_refined (** - {4 {L Redundant low-level API}} + {4 {L Redundant low-level API}} *) (** Summary: Return [INT_SYMBOL] if the symbol was constructed using {!mk_int_symbol}, and [STRING_SYMBOL] if the symbol was constructed using {!mk_string_symbol}. - def_API('get_symbol_kind', UINT, (_in(CONTEXT), _in(SYMBOL))) *) external get_symbol_kind : context -> symbol -> symbol_kind @@ -3198,12 +2632,9 @@ external get_symbol_kind : context -> symbol -> symbol_kind (** Summary: \[ [ get_symbol_int c s ] \] - Return the symbol int value. - + Return the symbol int value. - {b Precondition}: get_symbol_kind s == INT_SYMBOL - - {b See also}: {!mk_int_symbol} - def_API('get_symbol_int', INT, (_in(CONTEXT), _in(SYMBOL))) *) external get_symbol_int : context -> symbol -> int @@ -3211,23 +2642,16 @@ external get_symbol_int : context -> symbol -> int (** Summary: \[ [ get_symbol_string c s ] \] - Return the symbol name. - + Return the symbol name. - {b Precondition}: get_symbol_string s == STRING_SYMBOL - - - - - - {b See also}: {!mk_string_symbol} - def_API('get_symbol_string', STRING, (_in(CONTEXT), _in(SYMBOL))) *) external get_symbol_string : context -> symbol -> string = "camlidl_z3_Z3_get_symbol_string" (** - {3 {L Sorts}} + {3 {L Sorts}} *) (** @@ -3236,8 +2660,7 @@ external get_symbol_string : context -> symbol -> string val sort_refine: context -> sort -> sort_refined (** - Summary: Return the sort name as a symbol. - + Summary: Return the sort name as a symbol. def_API('get_sort_name', SYMBOL, (_in(CONTEXT), _in(SORT))) *) external get_sort_name : context -> sort -> symbol @@ -3245,20 +2668,18 @@ external get_sort_name : context -> sort -> symbol (** Summary: Return a unique identifier for [s]. - - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. - + - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. def_API('get_sort_id', UINT, (_in(CONTEXT), _in(SORT))) *) external get_sort_id : context -> sort -> int = "camlidl_z3_Z3_get_sort_id" (** - {4 {L Redundant low-level API}} + {4 {L Redundant low-level API}} *) (** - Summary: Convert a [sort] into [ast]. - - {b Remarks}: [sort_to_ast c s] can be replaced by [(s :> ast)]. - + Summary: Convert a [sort] into [ast]. + - {b Remarks}: [sort_to_ast c s] can be replaced by [(s :> ast)]. def_API('sort_to_ast', AST, (_in(CONTEXT), _in(SORT))) *) external sort_to_ast : context -> sort -> ast @@ -3266,8 +2687,7 @@ external sort_to_ast : context -> sort -> ast (** Summary: compare sorts. - - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. - + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. def_API('is_eq_sort', BOOL, (_in(CONTEXT), _in(SORT), _in(SORT))) *) external is_eq_sort : context -> sort -> sort -> bool @@ -3275,9 +2695,7 @@ external is_eq_sort : context -> sort -> sort -> bool (** Summary: Return the sort kind (e.g., array, tuple, int, bool, etc). - - {b See also}: {!sort_kind} - def_API('get_sort_kind', UINT, (_in(CONTEXT), _in(SORT))) *) external get_sort_kind : context -> sort -> sort_kind @@ -3285,23 +2703,18 @@ external get_sort_kind : context -> sort -> sort_kind (** Summary: \[ [ get_bv_sort_size c t ] \] - Return the size of the given bit-vector sort. - + Return the size of the given bit-vector sort. - {b Precondition}: get_sort_kind c t == BV_SORT - - {b See also}: {!mk_bv_sort} - {b See also}: {!get_sort_kind} - def_API('get_bv_sort_size', UINT, (_in(CONTEXT), _in(SORT))) *) external get_bv_sort_size : context -> sort -> int = "camlidl_z3_Z3_get_bv_sort_size" (** - - Summary: Return the size of the sort in [r]. Return [None] if the call failed. + Summary: Return the size of the sort in [r]. Return [None] if the call failed. That is, get_sort_kind(s) == FINITE_DOMAIN_SORT - def_API('get_finite_domain_sort_size', BOOL, (_in(CONTEXT), _in(SORT), _out(UINT64))) *) external get_finite_domain_sort_size : context -> sort -> int64 option @@ -3310,26 +2723,20 @@ external get_finite_domain_sort_size : context -> sort -> int64 option (** Summary: \[ [ get_array_sort_domain c t ] \] Return the domain of the given array sort. - - {b Precondition}: get_sort_kind c t == ARRAY_SORT - - {b See also}: {!mk_array_sort} - {b See also}: {!get_sort_kind} - def_API('get_array_sort_domain', SORT, (_in(CONTEXT), _in(SORT))) *) external get_array_sort_domain : context -> sort -> sort = "camlidl_z3_Z3_get_array_sort_domain" (** - Summary: \[ [ get_array_sort_range c t ] \] - Return the range of the given array sort. - + Summary: \[ [ get_array_sort_range c t ] \] + Return the range of the given array sort. - {b Precondition}: get_sort_kind c t == ARRAY_SORT - - {b See also}: {!mk_array_sort} - {b See also}: {!get_sort_kind} - def_API('get_array_sort_range', SORT, (_in(CONTEXT), _in(SORT))) *) external get_array_sort_range : context -> sort -> sort @@ -3338,13 +2745,10 @@ external get_array_sort_range : context -> sort -> sort (** Summary: \[ [ get_tuple_sort_mk_decl c t ] \] Return the constructor declaration of the given tuple - sort. - + sort. - {b Precondition}: get_sort_kind c t == DATATYPE_SORT - - {b See also}: {!mk_tuple_sort} - {b See also}: {!get_sort_kind} - def_API('get_tuple_sort_mk_decl', FUNC_DECL, (_in(CONTEXT), _in(SORT))) *) external get_tuple_sort_mk_decl : context -> sort -> func_decl @@ -3352,13 +2756,10 @@ external get_tuple_sort_mk_decl : context -> sort -> func_decl (** Summary: \[ [ get_tuple_sort_num_fields c t ] \] - Return the number of fields of the given tuple sort. - + Return the number of fields of the given tuple sort. - {b Precondition}: get_sort_kind c t == DATATYPE_SORT - - {b See also}: {!mk_tuple_sort} - {b See also}: {!get_sort_kind} - def_API('get_tuple_sort_num_fields', UINT, (_in(CONTEXT), _in(SORT))) *) external get_tuple_sort_num_fields : context -> sort -> int @@ -3367,14 +2768,11 @@ external get_tuple_sort_num_fields : context -> sort -> int (** Summary: \[ [ get_tuple_sort_field_decl c t i ] \] Return the i-th field declaration (i.e., projection function declaration) - of the given tuple sort. - + of the given tuple sort. - {b Precondition}: get_sort_kind t == DATATYPE_SORT - {b Precondition}: i < get_tuple_sort_num_fields c t - - {b See also}: {!mk_tuple_sort} - {b See also}: {!get_sort_kind} - def_API('get_tuple_sort_field_decl', FUNC_DECL, (_in(CONTEXT), _in(SORT), _in(UINT))) *) external get_tuple_sort_field_decl : context -> sort -> int -> func_decl @@ -3382,13 +2780,10 @@ external get_tuple_sort_field_decl : context -> sort -> int -> func_decl (** Summary: Return number of constructors for datatype. - - {b Precondition}: get_sort_kind t == DATATYPE_SORT - - {b See also}: {!get_datatype_sort_constructor} - {b See also}: {!get_datatype_sort_recognizer} - {b See also}: {!get_datatype_sort_constructor_accessor} - def_API('get_datatype_sort_num_constructors', UINT, (_in(CONTEXT), _in(SORT))) *) external get_datatype_sort_num_constructors : context -> sort -> int @@ -3396,14 +2791,11 @@ external get_datatype_sort_num_constructors : context -> sort -> int (** Summary: Return idx'th constructor. - - {b Precondition}: get_sort_kind t == DATATYPE_SORT - {b Precondition}: idx < get_datatype_sort_num_constructors c t - - {b See also}: {!get_datatype_sort_num_constructors} - {b See also}: {!get_datatype_sort_recognizer} - {b See also}: {!get_datatype_sort_constructor_accessor} - def_API('get_datatype_sort_constructor', FUNC_DECL, (_in(CONTEXT), _in(SORT), _in(UINT))) *) external get_datatype_sort_constructor : context -> sort -> int -> func_decl @@ -3411,14 +2803,11 @@ external get_datatype_sort_constructor : context -> sort -> int -> func_decl (** Summary: Return idx'th recognizer. - - {b Precondition}: get_sort_kind t == DATATYPE_SORT - {b Precondition}: idx < get_datatype_sort_num_constructors c t - - {b See also}: {!get_datatype_sort_num_constructors} - {b See also}: {!get_datatype_sort_constructor} - {b See also}: {!get_datatype_sort_constructor_accessor} - def_API('get_datatype_sort_recognizer', FUNC_DECL, (_in(CONTEXT), _in(SORT), _in(UINT))) *) external get_datatype_sort_recognizer : context -> sort -> int -> func_decl @@ -3426,15 +2815,12 @@ external get_datatype_sort_recognizer : context -> sort -> int -> func_decl (** Summary: Return idx_a'th accessor for the idx_c'th constructor. - - {b Precondition}: get_sort_kind t == DATATYPE_SORT - {b Precondition}: idx_c < get_datatype_sort_num_constructors c t - {b Precondition}: idx_a < get_domain_size c get_datatype_sort_constructor c idx_c - - {b See also}: {!get_datatype_sort_num_constructors} - {b See also}: {!get_datatype_sort_constructor} - {b See also}: {!get_datatype_sort_recognizer} - def_API('get_datatype_sort_constructor_accessor', FUNC_DECL, (_in(CONTEXT), _in(SORT), _in(UINT), _in(UINT))) *) external get_datatype_sort_constructor_accessor : context -> sort -> int -> int -> func_decl @@ -3442,11 +2828,8 @@ external get_datatype_sort_constructor_accessor : context -> sort -> int -> int (** Summary: Return arity of relation. - - {b Precondition}: get_sort_kind s == RELATION_SORT - - {b See also}: {!get_relation_column} - def_API('get_relation_arity', UINT, (_in(CONTEXT), _in(SORT))) *) external get_relation_arity : context -> sort -> int @@ -3454,24 +2837,20 @@ external get_relation_arity : context -> sort -> int (** Summary: Return sort at i'th column of relation sort. - - {b Precondition}: get_sort_kind c s == RELATION_SORT - {b Precondition}: col < get_relation_arity c s - - {b See also}: {!get_relation_arity} - def_API('get_relation_column', SORT, (_in(CONTEXT), _in(SORT), _in(UINT))) *) external get_relation_column : context -> sort -> int -> sort = "camlidl_z3_Z3_get_relation_column" (** - {3 {L Function Declarations}} + {3 {L Function Declarations}} *) (** - Summary: Convert a [func_decl] into [ast]. - - {b Remarks}: [func_decl_to_ast c f] can be replaced by [(f :> ast)]. - + Summary: Convert a [func_decl] into [ast]. + - {b Remarks}: [func_decl_to_ast c f] can be replaced by [(f :> ast)]. def_API('func_decl_to_ast', AST, (_in(CONTEXT), _in(FUNC_DECL))) *) external func_decl_to_ast : context -> func_decl -> ast @@ -3479,8 +2858,7 @@ external func_decl_to_ast : context -> func_decl -> ast (** Summary: compare terms. - - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. - + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. def_API('is_eq_func_decl', BOOL, (_in(CONTEXT), _in(FUNC_DECL), _in(FUNC_DECL))) *) external is_eq_func_decl : context -> func_decl -> func_decl -> bool @@ -3488,16 +2866,14 @@ external is_eq_func_decl : context -> func_decl -> func_decl -> bool (** Summary: Return a unique identifier for [f]. - - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. - + - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. def_API('get_func_decl_id', UINT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_func_decl_id : context -> func_decl -> int = "camlidl_z3_Z3_get_func_decl_id" (** - Summary: Return the constant declaration name as a symbol. - + Summary: Return the constant declaration name as a symbol. def_API('get_decl_name', SYMBOL, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_decl_name : context -> func_decl -> symbol @@ -3505,7 +2881,6 @@ external get_decl_name : context -> func_decl -> symbol (** Summary: Return declaration kind corresponding to declaration. - def_API('get_decl_kind', UINT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_decl_kind : context -> func_decl -> decl_kind @@ -3513,9 +2888,7 @@ external get_decl_kind : context -> func_decl -> decl_kind (** Summary: Return the number of parameters of the given declaration. - - {b See also}: {!get_arity} - def_API('get_domain_size', UINT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_domain_size : context -> func_decl -> int @@ -3523,9 +2896,7 @@ external get_domain_size : context -> func_decl -> int (** Summary: Alias for [get_domain_size]. - - {b See also}: {!get_domain_size} - def_API('get_arity', UINT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_arity : context -> func_decl -> int @@ -3534,11 +2905,8 @@ external get_arity : context -> func_decl -> int (** Summary: \[ [ get_domain c d i ] \] Return the sort of the i-th parameter of the given function declaration. - - {b Precondition}: i < get_domain_size d - - {b See also}: {!get_domain_size} - def_API('get_domain', SORT, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_domain : context -> func_decl -> int -> sort @@ -3547,7 +2915,6 @@ external get_domain : context -> func_decl -> int -> sort (** Summary: \[ [ get_domains c d ] \] is the array of parameters of [d]. - - {b See also}: {!get_domain_size} - {b See also}: {!get_domain} *) @@ -3555,11 +2922,9 @@ val get_domains: context -> func_decl -> sort array (** Summary: \[ [ get_range c d ] \] - Return the range of the given declaration. - + Return the range of the given declaration. If [d] is a constant (i.e., has zero arguments), then this function returns the sort of the constant. - def_API('get_range', SORT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_range : context -> func_decl -> sort @@ -3567,7 +2932,6 @@ external get_range : context -> func_decl -> sort (** Summary: Return the number of parameters associated with a declaration. - def_API('get_decl_num_parameters', UINT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_decl_num_parameters : context -> func_decl -> int @@ -3575,11 +2939,9 @@ external get_decl_num_parameters : context -> func_decl -> int (** Summary: Return the parameter type associated with a declaration. - @param c the context @param d the function declaration @param idx is the index of the named parameter it should be between 0 and the number of parameters. - def_API('get_decl_parameter_kind', UINT, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_parameter_kind : context -> func_decl -> int -> parameter_kind @@ -3587,9 +2949,7 @@ external get_decl_parameter_kind : context -> func_decl -> int -> parameter_kind (** Summary: Return the integer value associated with an integer parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_INT - def_API('get_decl_int_parameter', INT, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_int_parameter : context -> func_decl -> int -> int @@ -3597,9 +2957,7 @@ external get_decl_int_parameter : context -> func_decl -> int -> int (** Summary: Return the double value associated with an double parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_DOUBLE - def_API('get_decl_double_parameter', DOUBLE, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_double_parameter : context -> func_decl -> int -> float @@ -3607,9 +2965,7 @@ external get_decl_double_parameter : context -> func_decl -> int -> float (** Summary: Return the double value associated with an double parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_SYMBOL - def_API('get_decl_symbol_parameter', SYMBOL, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_symbol_parameter : context -> func_decl -> int -> symbol @@ -3617,9 +2973,7 @@ external get_decl_symbol_parameter : context -> func_decl -> int -> symbol (** Summary: Return the sort value associated with a sort parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_SORT - def_API('get_decl_sort_parameter', SORT, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_sort_parameter : context -> func_decl -> int -> sort @@ -3627,9 +2981,7 @@ external get_decl_sort_parameter : context -> func_decl -> int -> sort (** Summary: Return the expresson value associated with an expression parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_AST - def_API('get_decl_ast_parameter', AST, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_ast_parameter : context -> func_decl -> int -> ast @@ -3637,9 +2989,7 @@ external get_decl_ast_parameter : context -> func_decl -> int -> ast (** Summary: Return the expresson value associated with an expression parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_FUNC_DECL - def_API('get_decl_func_decl_parameter', FUNC_DECL, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_func_decl_parameter : context -> func_decl -> int -> func_decl @@ -3647,21 +2997,18 @@ external get_decl_func_decl_parameter : context -> func_decl -> int -> func_decl (** Summary: Return the rational value, as a string, associated with a rational parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_RATIONAL - def_API('get_decl_rational_parameter', STRING, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_rational_parameter : context -> func_decl -> int -> string = "camlidl_z3_Z3_get_decl_rational_parameter" (** - {3 {L Applications}} + {3 {L Applications}} *) (** - Summary: Convert a [app] into [ast]. - - {b Remarks}: [app_to_ast c a] can be replaced by [(a :> ast)]. - + Summary: Convert a [app] into [ast]. + - {b Remarks}: [app_to_ast c a] can be replaced by [(a :> ast)]. def_API('app_to_ast', AST, (_in(CONTEXT), _in(APP))) *) external app_to_ast : context -> app -> ast @@ -3669,7 +3016,6 @@ external app_to_ast : context -> app -> ast (** Summary: Return the declaration of a constant or function application. - def_API('get_app_decl', FUNC_DECL, (_in(CONTEXT), _in(APP))) *) external get_app_decl : context -> app -> func_decl @@ -3679,7 +3025,6 @@ external get_app_decl : context -> app -> func_decl Summary: \[ [ get_app_num_args c a ] \] Return the number of argument of an application. If [t] is an constant, then the number of arguments is 0. - def_API('get_app_num_args', UINT, (_in(CONTEXT), _in(APP))) *) external get_app_num_args : context -> app -> int @@ -3688,9 +3033,7 @@ external get_app_num_args : context -> app -> int (** Summary: \[ [ get_app_arg c a i ] \] Return the i-th argument of the given application. - - {b Precondition}: i < get_num_args c a - def_API('get_app_arg', AST, (_in(CONTEXT), _in(APP), _in(UINT))) *) external get_app_arg : context -> app -> int -> ast @@ -3699,44 +3042,37 @@ external get_app_arg : context -> app -> int -> ast (** Summary: \[ [ get_app_args c a ] \] is the array of arguments of an application. If [t] is a constant, then the array is empty. - - {b See also}: {!get_app_num_args} - {b See also}: {!get_app_arg} *) val get_app_args: context -> app -> ast array (** - {3 {L Terms}} + {3 {L Terms}} *) (** Summary: \[ [ binder_type ] \] is a universal or existential quantifier. - - {b See also}: {!term_refined} *) type binder_type = Forall | Exists - (** Summary: \[ [ term_refined ] \] is the refinement of a {!ast} . - - {b See also}: {!term_refine} *) type term_refined = - | Term_numeral of numeral_refined - | Term_app of decl_kind * func_decl * ast array + | Term_numeral of numeral_refined + | Term_app of decl_kind * func_decl * ast array | Term_quantifier of binder_type * int * ast array array * (symbol * sort) array * ast - | Term_var of int * sort + | Term_var of int * sort (** Summary: \[ [ mk_term c tr ] \] constructs the term described by [tr]. - - {b Precondition}: [tr] is not of form - {b See also}: {!term_refine} *) (* val mk_term: context -> term_refined -> ast *) - - (** Summary: \[ [ term_refine c a ] \] is the refined view of [a]. *) @@ -3744,8 +3080,7 @@ val term_refine : context -> ast -> term_refined (** Summary: compare terms. - - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. - + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. def_API('is_eq_ast', BOOL, (_in(CONTEXT), _in(AST), _in(AST))) *) external is_eq_ast : context -> ast -> ast -> bool @@ -3753,8 +3088,7 @@ external is_eq_ast : context -> ast -> ast -> bool (** Summary: Return a unique identifier for [t]. - - {b Remarks}: Implicitly used by [Pervasives.compare] for values of type [ast], [app], [sort], [func_decl], and [pattern]. - + - {b Remarks}: Implicitly used by [Pervasives.compare] for values of type [ast], [app], [sort], [func_decl], and [pattern]. def_API('get_ast_id', UINT, (_in(CONTEXT), _in(AST))) *) external get_ast_id : context -> ast -> int @@ -3762,8 +3096,7 @@ external get_ast_id : context -> ast -> int (** Summary: Return a hash code for the given AST. - - {b Remarks}: Implicitly used by [Hashtbl.hash] for values of type [ast], [app], [sort], [func_decl], and [pattern]. - + - {b Remarks}: Implicitly used by [Hashtbl.hash] for values of type [ast], [app], [sort], [func_decl], and [pattern]. def_API('get_ast_hash', UINT, (_in(CONTEXT), _in(AST))) *) external get_ast_hash : context -> ast -> int @@ -3771,9 +3104,7 @@ external get_ast_hash : context -> ast -> int (** Summary: Return the sort of an AST node. - The AST node must be a constant, application, numeral, bound variable, or quantifier. - def_API('get_sort', SORT, (_in(CONTEXT), _in(AST))) *) external get_sort : context -> ast -> sort @@ -3781,7 +3112,6 @@ external get_sort : context -> ast -> sort (** Summary: Return true if the given expression [t] is well sorted. - def_API('is_well_sorted', BOOL, (_in(CONTEXT), _in(AST))) *) external is_well_sorted : context -> ast -> bool @@ -3789,7 +3119,6 @@ external is_well_sorted : context -> ast -> bool (** Summary: Return L_TRUE if [a] is true, L_FALSE if it is false, and L_UNDEF otherwise. - def_API('get_bool_value', UINT, (_in(CONTEXT), _in(AST))) *) external get_bool_value : context -> ast -> lbool @@ -3797,14 +3126,13 @@ external get_bool_value : context -> ast -> lbool (** Summary: Return the kind of the given AST. - def_API('get_ast_kind', UINT, (_in(CONTEXT), _in(AST))) *) external get_ast_kind : context -> ast -> ast_kind = "camlidl_z3_Z3_get_ast_kind" (** - def_API('is_app', BOOL, (_in(CONTEXT), _in(AST))) + def_API('is_app', BOOL, (_in(CONTEXT), _in(AST))) *) external is_app : context -> ast -> bool = "camlidl_z3_Z3_is_app" @@ -3817,17 +3145,14 @@ external is_numeral_ast : context -> ast -> bool (** Summary: Return true if the give AST is a real algebraic number. - def_API('is_algebraic_number', BOOL, (_in(CONTEXT), _in(AST))) *) external is_algebraic_number : context -> ast -> bool = "camlidl_z3_Z3_is_algebraic_number" (** - Summary: Convert an [ast] into an [APP_AST]. - - - {b Precondition}: {v get_ast_kind c a == [APP_AST] v} - + Summary: Convert an [ast] into an [APP_AST]. + - {b Precondition}: {v get_ast_kind c a == [APP_AST] v} def_API('to_app', APP, (_in(CONTEXT), _in(AST))) *) external to_app : context -> ast -> app @@ -3835,33 +3160,28 @@ external to_app : context -> ast -> app (** Summary: Convert an AST into a FUNC_DECL_AST. This is just type casting. - - - {b Precondition}: {v get_ast_kind c a == FUNC_DECL_AST v} - + - {b Precondition}: {v get_ast_kind c a == FUNC_DECL_AST v} def_API('to_func_decl', FUNC_DECL, (_in(CONTEXT), _in(AST))) *) external to_func_decl : context -> ast -> func_decl = "camlidl_z3_Z3_to_func_decl" (** - {4 {L Numerals}} + {4 {L Numerals}} *) (** Summary: \[ [ numeral_refine c a ] \] is the refined view of [a]. - - {b Precondition}: [get_ast_kind c a = NUMERAL_AST] *) val numeral_refine : context -> ast -> numeral_refined (** - {5 {L Low-level API}} + {5 {L Low-level API}} *) (** Summary: Return numeral value, as a string of a numeric constant term - - {b Precondition}: get_ast_kind c a == NUMERAL_AST - def_API('get_numeral_string', STRING, (_in(CONTEXT), _in(AST))) *) external get_numeral_string : context -> ast -> string @@ -3870,19 +3190,15 @@ external get_numeral_string : context -> ast -> string (** Summary: Return numeral as a string in decimal notation. The result has at most [precision] decimal places. - - {b Precondition}: get_ast_kind c a == NUMERAL_AST || is_algebraic_number c a - - def_API('get_numeral_decimal_string', STRING, (_in(CONTEXT), _in(AST), _in(UINT))) + def_API('get_numeral_decimal_string', STRING, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_numeral_decimal_string : context -> ast -> int -> string = "camlidl_z3_Z3_get_numeral_decimal_string" (** Summary: Return the numerator (as a numeral AST) of a numeral AST of sort Real. - - {b Precondition}: get_ast_kind c a == NUMERAL_AST - def_API('get_numerator', AST, (_in(CONTEXT), _in(AST))) *) external get_numerator : context -> ast -> ast @@ -3890,9 +3206,7 @@ external get_numerator : context -> ast -> ast (** Summary: Return the denominator (as a numeral AST) of a numeral AST of sort Real. - - {b Precondition}: get_ast_kind c a == NUMERAL_AST - def_API('get_denominator', AST, (_in(CONTEXT), _in(AST))) *) external get_denominator : context -> ast -> ast @@ -3900,16 +3214,12 @@ external get_denominator : context -> ast -> ast (** Summary: Return numeral value, as a pair of 64 bit numbers if the representation fits. - @param c logical context. @param a term. @param num numerator. @param den denominator. - Return [TRUE] if the numeral value fits in 64 bit numerals, [FALSE] otherwise. - - {b Precondition}: get_ast_kind a == NUMERAL_AST - def_API('get_numeral_small', BOOL, (_in(CONTEXT), _in(AST), _out(INT64), _out(INT64))) *) external get_numeral_small : context -> ast -> bool * int64 * int64 @@ -3919,11 +3229,8 @@ external get_numeral_small : context -> ast -> bool * int64 * int64 Summary: \[ [ get_numeral_int c v ] \] Similar to {!get_numeral_string}, but only succeeds if the value can fit in a machine int. Return TRUE if the call succeeded. - - {b Precondition}: get_ast_kind c v == NUMERAL_AST - - {b See also}: {!get_numeral_string} - def_API('get_numeral_int', BOOL, (_in(CONTEXT), _in(AST), _out(INT))) *) external get_numeral_int : context -> ast -> bool * int @@ -3933,11 +3240,8 @@ external get_numeral_int : context -> ast -> bool * int Summary: \[ [ get_numeral_int64 c v ] \] Similar to {!get_numeral_string}, but only succeeds if the value can fit in a machine long long int. Return TRUE if the call succeeded. - - {b Precondition}: get_ast_kind c v == NUMERAL_AST - - {b See also}: {!get_numeral_string} - def_API('get_numeral_int64', BOOL, (_in(CONTEXT), _in(AST), _out(INT64))) *) external get_numeral_int64 : context -> ast -> bool * int64 @@ -3947,47 +3251,39 @@ external get_numeral_int64 : context -> ast -> bool * int64 Summary: \[ [ get_numeral_rational_int64 c x y] \] Similar to {!get_numeral_string}, but only succeeds if the value can fit as a rational number as machine long long int. Return TRUE if the call succeeded. - - {b Precondition}: get_ast_kind c v == NUMERAL_AST - - {b See also}: {!get_numeral_string} - def_API('get_numeral_rational_int64', BOOL, (_in(CONTEXT), _in(AST), _out(INT64), _out(INT64))) *) external get_numeral_rational_int64 : context -> ast -> bool * int64 * int64 = "camlidl_z3_Z3_get_numeral_rational_int64" (** - Summary: Return a lower bound for the given real algebraic number. + Summary: Return a lower bound for the given real algebraic number. The interval isolating the number is smaller than 1/10^precision. The result is a numeral AST of sort Real. - - {b Precondition}: is_algebraic_number c a - def_API('get_algebraic_number_lower', AST, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_algebraic_number_lower : context -> ast -> int -> ast = "camlidl_z3_Z3_get_algebraic_number_lower" (** - Summary: Return a upper bound for the given real algebraic number. + Summary: Return a upper bound for the given real algebraic number. The interval isolating the number is smaller than 1/10^precision. The result is a numeral AST of sort Real. - - {b Precondition}: is_algebraic_number c a - def_API('get_algebraic_number_upper', AST, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_algebraic_number_upper : context -> ast -> int -> ast = "camlidl_z3_Z3_get_algebraic_number_upper" (** - {4 {L Patterns}} + {4 {L Patterns}} *) (** - Summary: Convert a pattern into ast. - - {b Remarks}: [pattern_to_ast c p] can be replaced by [(p :> ast)]. - + Summary: Convert a pattern into ast. + - {b Remarks}: [pattern_to_ast c p] can be replaced by [(p :> ast)]. def_API('pattern_to_ast', AST, (_in(CONTEXT), _in(PATTERN))) *) external pattern_to_ast : context -> pattern -> ast @@ -3996,7 +3292,6 @@ external pattern_to_ast : context -> pattern -> ast (** Summary: \[ [ get_pattern_terms c p ] \] is the ast's in pattern. - - {b See also}: {!get_pattern_num_terms} - {b See also}: {!get_pattern} *) @@ -4004,7 +3299,6 @@ val get_pattern_terms: context -> pattern -> ast array;; (** Summary: Return number of terms in pattern. - def_API('get_pattern_num_terms', UINT, (_in(CONTEXT), _in(PATTERN))) *) external get_pattern_num_terms : context -> pattern -> int @@ -4012,20 +3306,17 @@ external get_pattern_num_terms : context -> pattern -> int (** Summary: Return i'th ast in pattern. - def_API('get_pattern', AST, (_in(CONTEXT), _in(PATTERN), _in(UINT))) *) external get_pattern : context -> pattern -> int -> ast = "camlidl_z3_Z3_get_pattern" (** - {4 {L Quantifiers}} + {4 {L Quantifiers}} *) (** Summary: Return index of de-Brujin bound variable. - - {b Precondition}: get_ast_kind a == VAR_AST - def_API('get_index_value', UINT, (_in(CONTEXT), _in(AST))) *) external get_index_value : context -> ast -> int @@ -4033,29 +3324,23 @@ external get_index_value : context -> ast -> int (** Summary: Determine if quantifier is universal. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - - def_API('is_quantifier_forall', BOOL, (_in(CONTEXT), _in(AST))) + def_API('is_quantifier_forall', BOOL, (_in(CONTEXT), _in(AST))) *) external is_quantifier_forall : context -> ast -> bool = "camlidl_z3_Z3_is_quantifier_forall" (** Summary: Obtain weight of quantifier. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - - def_API('get_quantifier_weight', UINT, (_in(CONTEXT), _in(AST))) + def_API('get_quantifier_weight', UINT, (_in(CONTEXT), _in(AST))) *) external get_quantifier_weight : context -> ast -> int = "camlidl_z3_Z3_get_quantifier_weight" (** Summary: Return number of patterns used in quantifier. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_num_patterns', UINT, (_in(CONTEXT), _in(AST))) *) external get_quantifier_num_patterns : context -> ast -> int @@ -4063,9 +3348,7 @@ external get_quantifier_num_patterns : context -> ast -> int (** Summary: Return i'th pattern. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_pattern_ast', PATTERN, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_quantifier_pattern_ast : context -> ast -> int -> pattern @@ -4073,9 +3356,7 @@ external get_quantifier_pattern_ast : context -> ast -> int -> pattern (** Summary: Return number of no_patterns used in quantifier. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_num_no_patterns', UINT, (_in(CONTEXT), _in(AST))) *) external get_quantifier_num_no_patterns : context -> ast -> int @@ -4083,9 +3364,7 @@ external get_quantifier_num_no_patterns : context -> ast -> int (** Summary: Return i'th no_pattern. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_no_pattern_ast', AST, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_quantifier_no_pattern_ast : context -> ast -> int -> ast @@ -4093,9 +3372,7 @@ external get_quantifier_no_pattern_ast : context -> ast -> int -> ast (** Summary: Return number of bound variables of quantifier. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_num_bound', UINT, (_in(CONTEXT), _in(AST))) *) external get_quantifier_num_bound : context -> ast -> int @@ -4103,9 +3380,7 @@ external get_quantifier_num_bound : context -> ast -> int (** Summary: Return symbol of the i'th bound variable. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_bound_name', SYMBOL, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_quantifier_bound_name : context -> ast -> int -> symbol @@ -4113,9 +3388,7 @@ external get_quantifier_bound_name : context -> ast -> int -> symbol (** Summary: Return sort of the i'th bound variable. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_bound_sort', SORT, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_quantifier_bound_sort : context -> ast -> int -> sort @@ -4123,22 +3396,18 @@ external get_quantifier_bound_sort : context -> ast -> int -> sort (** Summary: Return body of quantifier. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_body', AST, (_in(CONTEXT), _in(AST))) *) external get_quantifier_body : context -> ast -> ast = "camlidl_z3_Z3_get_quantifier_body" (** - {3 {L Simplification}} + {3 {L Simplification}} *) (** Summary: Interface to simplifier. - Provides an interface to the AST simplifier used by Z3. - def_API('simplify', AST, (_in(CONTEXT), _in(AST))) *) external simplify : context -> ast -> ast @@ -4146,11 +3415,9 @@ external simplify : context -> ast -> ast (** Summary: Interface to simplifier. - Provides an interface to the AST simplifier used by Z3. - This procedure is similar to {!simplify}, but the behavior of the simplifier + This procedure is similar to {!simplify}, but the behavior of the simplifier can be configured using the given parameter set. - def_API('simplify_ex', AST, (_in(CONTEXT), _in(AST), _in(PARAMS))) *) external simplify_ex : context -> ast -> params -> ast @@ -4158,7 +3425,6 @@ external simplify_ex : context -> ast -> params -> ast (** Summary: Return a string describing all available parameters. - def_API('simplify_get_help', STRING, (_in(CONTEXT),)) *) external simplify_get_help : context -> string @@ -4166,7 +3432,6 @@ external simplify_get_help : context -> string (** Summary: Return the parameter description set for the simplify procedure. - def_API('simplify_get_param_descrs', PARAM_DESCRS, (_in(CONTEXT),)) *) external simplify_get_param_descrs : context -> param_descrs @@ -4177,10 +3442,9 @@ external simplify_get_param_descrs : context -> param_descrs *) (** Summary: Update the arguments of term [a] using the arguments [args]. - The number of arguments [num_args] should coincide + The number of arguments [num_args] should coincide with the number of arguments to [a]. If [a] is a quantifier, then num_args has to be 1. - def_API('update_term', AST, (_in(CONTEXT), _in(AST), _in(UINT), _in_array(2, AST))) *) external update_term : context -> ast -> ast array -> ast @@ -4190,7 +3454,6 @@ external update_term : context -> ast -> ast array -> ast Summary: Substitute every occurrence of {e from[i] } in [a] with {e to[i] }, for [i] smaller than [num_exprs]. The result is the new AST. The arrays [from] and [to] must have size [num_exprs]. For every [i] smaller than [num_exprs], we must have that sort of {e from[i] } must be equal to sort of {e to[i] }. - def_API('substitute', AST, (_in(CONTEXT), _in(AST), _in(UINT), _in_array(2, AST), _in_array(2, AST))) *) external substitute : context -> ast -> ast array -> ast array -> ast @@ -4199,7 +3462,6 @@ external substitute : context -> ast -> ast array -> ast array -> ast (** Summary: Substitute the free variables in [a] with the expressions in [to]. For every [i] smaller than [num_exprs], the variable with de-Bruijn index [i] is replaced with term {e to[i] }. - def_API('substitute_vars', AST, (_in(CONTEXT), _in(AST), _in(UINT), _in_array(2, AST))) *) external substitute_vars : context -> ast -> ast array -> ast @@ -4209,7 +3471,6 @@ external substitute_vars : context -> ast -> ast array -> ast Summary: Translate/Copy the AST [a] from context [source] to context [target]. AST [a] must have been created using context [source]. - {b Precondition}: source != target - def_API('translate', AST, (_in(CONTEXT), _in(AST), _in(CONTEXT))) *) external translate : context -> ast -> context -> ast @@ -4232,45 +3493,36 @@ type model_refined = { } -(** +(** Summary: [model_refine c m] is the refined model of [m]. *) val model_refine : context -> model -> model_refined (** Summary: \[ [ model_eval c m t ] \] - Evaluate the AST node [t] in the given model. - - Return [None] if the term was not successfully evaluated. - + Evaluate the AST node [t] in the given model. + Return [None] if the term was not successfully evaluated. If [model_completion] is TRUE, then Z3 will assign an interpretation for any constant or function that does not have an interpretation in [m]. These constants and functions were essentially don't cares. - The evaluation may fail for the following reasons: - - [t] contains a quantifier. - - the model [m] is partial, that is, it doesn't have a complete interpretation for uninterpreted functions. That is, the option {e MODEL_PARTIAL=true } was used. - - [t] is type incorrect. - def_API('model_eval', BOOL, (_in(CONTEXT), _in(MODEL), _in(AST), _in(BOOL), _out(AST))) *) external model_eval : context -> model -> ast -> bool -> ast option = "camlidl_z3_Z3_model_eval" (** - {4 {L Low-level API}} + {4 {L Low-level API}} *) (** Summary: Return the interpretation (i.e., assignment) of constant [a] in the model [m]. - Return [None], - if the model does not assign an interpretation for [a]. + Return [None], + if the model does not assign an interpretation for [a]. That should be interpreted as: the value of [a] does not matter. - - {b Precondition}: get_arity c a == 0 - def_API('model_get_const_interp', AST, (_in(CONTEXT), _in(MODEL), _in(FUNC_DECL))) *) external model_get_const_interp : context -> model -> func_decl -> ast option @@ -4278,15 +3530,10 @@ external model_get_const_interp : context -> model -> func_decl -> ast option (** Summary: Return the interpretation of the function [f] in the model [m]. - Return [None], - if the model does not assign an interpretation for [f]. + Return [None], + if the model does not assign an interpretation for [f]. That should be interpreted as: the [f] does not matter. - - {b Precondition}: get_arity c f > 0 - - - - def_API('model_get_func_interp', FUNC_INTERP, (_in(CONTEXT), _in(MODEL), _in(FUNC_DECL))) *) external model_get_func_interp : context -> model -> func_decl -> func_interp option @@ -4294,9 +3541,7 @@ external model_get_func_interp : context -> model -> func_decl -> func_interp op (** Summary: Return the number of constants assigned by the given model. - - {b See also}: {!model_get_const_decl} - def_API('model_get_num_consts', UINT, (_in(CONTEXT), _in(MODEL))) *) external model_get_num_consts : context -> model -> int @@ -4304,12 +3549,9 @@ external model_get_num_consts : context -> model -> int (** Summary: \[ [ model_get_const_decl c m i ] \] - Return the i-th constant in the given model. - + Return the i-th constant in the given model. - {b Precondition}: i < model_get_num_consts c m - - {b See also}: {!model_eval} - def_API('model_get_const_decl', FUNC_DECL, (_in(CONTEXT), _in(MODEL), _in(UINT))) *) external model_get_const_decl : context -> model -> int -> func_decl @@ -4317,10 +3559,8 @@ external model_get_const_decl : context -> model -> int -> func_decl (** Summary: Return the number of function interpretations in the given model. - A function interpretation is represented as a finite map and an 'else' value. Each entry in the finite map represents the value of a function given a set of arguments. - def_API('model_get_num_funcs', UINT, (_in(CONTEXT), _in(MODEL))) *) external model_get_num_funcs : context -> model -> int @@ -4329,11 +3569,8 @@ external model_get_num_funcs : context -> model -> int (** Summary: \[ [ model_get_func_decl c m i ] \] Return the declaration of the i-th function in the given model. - - {b Precondition}: i < model_get_num_funcs c m - - {b See also}: {!model_get_num_funcs} - def_API('model_get_func_decl', FUNC_DECL, (_in(CONTEXT), _in(MODEL), _in(UINT))) *) external model_get_func_decl : context -> model -> int -> func_decl @@ -4341,14 +3578,11 @@ external model_get_func_decl : context -> model -> int -> func_decl (** Summary: Return the number of uninterpreted sorts that [m] assigs an interpretation to. - Z3 also provides an intepretation for uninterpreted sorts used in a formua. The interpretation for a sort [s] is a finite set of distinct values. We say this finite set is the "universe" of [s]. - - {b See also}: {!model_get_sort} - {b See also}: {!model_get_sort_universe} - def_API('model_get_num_sorts', UINT, (_in(CONTEXT), _in(MODEL))) *) external model_get_num_sorts : context -> model -> int @@ -4356,12 +3590,9 @@ external model_get_num_sorts : context -> model -> int (** Summary: Return a uninterpreted sort that [m] assigns an interpretation. - - {b Precondition}: i < model_get_num_sorts c m - - {b See also}: {!model_get_num_sorts} - {b See also}: {!model_get_sort_universe} - def_API('model_get_sort', SORT, (_in(CONTEXT), _in(MODEL), _in(UINT))) *) external model_get_sort : context -> model -> int -> sort @@ -4369,10 +3600,8 @@ external model_get_sort : context -> model -> int -> sort (** Summary: Return the finite set of distinct values that represent the interpretation for sort [s]. - - {b See also}: {!model_get_num_sorts} - {b See also}: {!model_get_sort} - def_API('model_get_sort_universe', AST_VECTOR, (_in(CONTEXT), _in(MODEL), _in(SORT))) *) external model_get_sort_universe : context -> model -> sort -> ast_vector @@ -4382,11 +3611,8 @@ external model_get_sort_universe : context -> model -> sort -> ast_vector Summary: The {e (_ as-array f) } AST node is a construct for assigning interpretations for arrays in Z3. It is the array such that forall indices [i] we have that {e (select (_ as-array f) i) } is equal to {e (f i) }. This procedure returns TRUE if the [a] is an [as-array] AST node. - - Z3 current solvers have minimal support for [as_array] nodes. - + Z3 current solvers have minimal support for [as_array] nodes. - {b See also}: {!get_as_array_func_decl} - def_API('is_as_array', BOOL, (_in(CONTEXT), _in(AST))) *) external is_as_array : context -> ast -> bool @@ -4394,9 +3620,7 @@ external is_as_array : context -> ast -> bool (** Summary: Return the function declaration [f] associated with a {e (_ as_array f) } node. - - {b See also}: {!is_as_array} - def_API('get_as_array_func_decl', FUNC_DECL, (_in(CONTEXT), _in(AST))) *) external get_as_array_func_decl : context -> ast -> func_decl @@ -4404,11 +3628,9 @@ external get_as_array_func_decl : context -> ast -> func_decl (** Summary: Return the number of entries in the given function interpretation. - A function interpretation is represented as a finite map and an 'else' value. Each entry in the finite map represents the value of a function given a set of arguments. This procedure return the number of element in the finite map of [f]. - def_API('func_interp_get_num_entries', UINT, (_in(CONTEXT), _in(FUNC_INTERP))) *) external func_interp_get_num_entries : context -> func_interp -> int @@ -4417,11 +3639,8 @@ external func_interp_get_num_entries : context -> func_interp -> int (** Summary: Return a "point" of the given function intepretation. It represents the value of [f] in a particular point. - - {b Precondition}: i < func_interp_get_num_entries c f - - {b See also}: {!func_interp_get_num_entries} - def_API('func_interp_get_entry', FUNC_ENTRY, (_in(CONTEXT), _in(FUNC_INTERP), _in(UINT))) *) external func_interp_get_entry : context -> func_interp -> int -> func_entry @@ -4429,10 +3648,8 @@ external func_interp_get_entry : context -> func_interp -> int -> func_entry (** Summary: Return the 'else' value of the given function interpretation. - A function interpretation is represented as a finite map and an 'else' value. This procedure returns the 'else' value. - def_API('func_interp_get_else', AST, (_in(CONTEXT), _in(FUNC_INTERP))) *) external func_interp_get_else : context -> func_interp -> ast @@ -4440,20 +3657,16 @@ external func_interp_get_else : context -> func_interp -> ast (** Summary: Return the arity (number of arguments) of the given function interpretation. - def_API('func_interp_get_arity', UINT, (_in(CONTEXT), _in(FUNC_INTERP))) *) external func_interp_get_arity : context -> func_interp -> int = "camlidl_z3_Z3_func_interp_get_arity" (** - Summary: Return the value of this point. - + Summary: Return the value of this point. A func_entry object represents an element in the finite map used to encode a function interpretation. - - {b See also}: {!func_interp_get_entry} - def_API('func_entry_get_value', AST, (_in(CONTEXT), _in(FUNC_ENTRY))) *) external func_entry_get_value : context -> func_entry -> ast @@ -4461,9 +3674,7 @@ external func_entry_get_value : context -> func_entry -> ast (** Summary: Return the number of arguments in a func_entry object. - - {b See also}: {!func_interp_get_entry} - def_API('func_entry_get_num_args', UINT, (_in(CONTEXT), _in(FUNC_ENTRY))) *) external func_entry_get_num_args : context -> func_entry -> int @@ -4471,11 +3682,8 @@ external func_entry_get_num_args : context -> func_entry -> int (** Summary: Return an argument of a func_entry object. - - {b Precondition}: i < func_entry_get_num_args c e - - {b See also}: {!func_interp_get_entry} - def_API('func_entry_get_arg', AST, (_in(CONTEXT), _in(FUNC_ENTRY), _in(UINT))) *) external func_entry_get_arg : context -> func_entry -> int -> ast @@ -4486,7 +3694,6 @@ external func_entry_get_arg : context -> func_entry -> int -> ast *) (** Summary: Log interaction to a file. - extra_API('open_log', INT, (_in(STRING),)) *) external open_log : string -> bool @@ -4494,11 +3701,9 @@ external open_log : string -> bool (** Summary: Append user-defined string to interaction log. - The interaction log is opened using open_log. It contains the formulas that are checked using Z3. You can use this command to append comments, for instance. - extra_API('append_log', VOID, (_in(STRING),)) *) external append_log : string -> unit @@ -4506,7 +3711,6 @@ external append_log : string -> unit (** Summary: Close interaction log. - extra_API('close_log', VOID, ()) *) external close_log : unit -> unit @@ -4514,10 +3718,8 @@ external close_log : unit -> unit (** Summary: Enable/disable printing warning messages to the console. - Warnings are printed after passing [true], warning messages are - suppressed after calling this method with [false]. - + suppressed after calling this method with [false]. def_API('toggle_warning_messages', VOID, (_in(BOOL),)) *) external toggle_warning_messages : bool -> unit @@ -4528,19 +3730,16 @@ external toggle_warning_messages : bool -> unit *) (** Summary: Select mode for the format used for pretty-printing AST nodes. - The default mode for pretty printing AST nodes is to produce - SMT-LIB style output where common subexpressions are printed + SMT-LIB style output where common subexpressions are printed at each occurrence. The mode is called PRINT_SMTLIB_FULL. - To print shared common subexpressions only once, + To print shared common subexpressions only once, use the PRINT_LOW_LEVEL mode. To print in way that conforms to SMT-LIB standards and uses let expressions to share common sub-expressions use PRINT_SMTLIB_COMPLIANT. - - {b See also}: {!ast_to_string} - {b See also}: {!pattern_to_string} - {b See also}: {!func_decl_to_string} - def_API('set_ast_print_mode', VOID, (_in(CONTEXT), _in(PRINT_MODE))) *) external set_ast_print_mode : context -> ast_print_mode -> unit @@ -4548,13 +3747,8 @@ external set_ast_print_mode : context -> ast_print_mode -> unit (** Summary: Convert the given AST node into a string. - - - - - {b See also}: {!pattern_to_string} - {b See also}: {!sort_to_string} - def_API('ast_to_string', STRING, (_in(CONTEXT), _in(AST))) *) external ast_to_string : context -> ast -> string @@ -4580,11 +3774,6 @@ external func_decl_to_string : context -> func_decl -> string (** Summary: Convert the given model into a string. - - - - - def_API('model_to_string', STRING, (_in(CONTEXT), _in(MODEL))) *) external model_to_string : context -> model -> string @@ -4592,20 +3781,14 @@ external model_to_string : context -> model -> string (** Summary: Convert the given benchmark into SMT-LIB formatted string. - - - - - @param c - context. @param name - name of benchmark. The argument is optional. - @param logic - the benchmark logic. + @param logic - the benchmark logic. @param status - the status string (sat, unsat, or unknown) @param attributes - other attributes, such as source, difficulty or category. @param num_assumptions - number of assumptions. @param assumptions - auxiliary assumptions. @param formula - formula to be checked for consistency in conjunction with assumptions. - def_API('benchmark_to_smtlib_string', STRING, (_in(CONTEXT), _in(STRING), _in(STRING), _in(STRING), _in(STRING), _in(UINT), _in_array(5, AST), _in(AST))) *) external benchmark_to_smtlib_string : context -> string -> string -> string -> string -> ast array -> ast -> string @@ -4616,11 +3799,9 @@ external benchmark_to_smtlib_string : context -> string -> string -> string -> s *) (** Summary: \[ [ parse_smtlib2_string c str ] \] - Parse the given string using the SMT-LIB2 parser. - + Parse the given string using the SMT-LIB2 parser. It returns a formula comprising of the conjunction of assertions in the scope (up to push/pop) at the end of the string. - def_API('parse_smtlib2_string', AST, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _in(UINT), _in_array(5, SYMBOL), _in_array(5, FUNC_DECL))) *) external parse_smtlib2_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast @@ -4628,7 +3809,6 @@ external parse_smtlib2_string : context -> string -> symbol array -> sort array (** Summary: Similar to {!parse_smtlib2_string}, but reads the benchmark from a file. - def_API('parse_smtlib2_file', AST, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _in(UINT), _in_array(5, SYMBOL), _in_array(5, FUNC_DECL))) *) external parse_smtlib2_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast @@ -4637,57 +3817,45 @@ external parse_smtlib2_file : context -> string -> symbol array -> sort array -> (** Summary: \[ [ parse_smtlib_string_x c str sort_names sorts decl_names decls ] \] - - Parse the given string using the SMT-LIB parser. - - The symbol table of the parser can be initialized using the given sorts and declarations. + Parse the given string using the SMT-LIB parser. + The symbol table of the parser can be initialized using the given sorts and declarations. The symbols in the arrays [sort_names] and [decl_names] don't need to match the names of the sorts and declarations in the arrays [sorts] and [decls]. This is an useful feature since we can use arbitrary names to reference sorts and declarations defined using the API. - - {b See also}: {!parse_smtlib_file_x} *) val parse_smtlib_string_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) - (** Summary: Similar to {!parse_smtlib_string_x}, but reads the benchmark from a file. - - {b See also}: {!parse_smtlib_string_x} *) val parse_smtlib_file_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) - (** Summary: \[ [ parse_smtlib_string_formula c ... ] \] calls [(parse_smtlib_string c ...)] and returns the single formula produced. - - {b See also}: {!parse_smtlib_file_formula} - {b See also}: {!parse_smtlib_string_x} *) val parse_smtlib_string_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast - (** Summary: \[ [ parse_smtlib_file_formula c ... ] \] calls [(parse_smtlib_file c ...)] and returns the single formula produced. - - {b See also}: {!parse_smtlib_string_formula} - {b See also}: {!parse_smtlib_file_x} *) val parse_smtlib_file_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast (** - {4 {L Low-level API}} + {4 {L Low-level API}} *) (** Summary: \[ [ parse_smtlib_string c str sort_names sorts decl_names decls ] \] - Parse the given string using the SMT-LIB parser. - - The symbol table of the parser can be initialized using the given sorts and declarations. + Parse the given string using the SMT-LIB parser. + The symbol table of the parser can be initialized using the given sorts and declarations. The symbols in the arrays [sort_names] and [decl_names] don't need to match the names of the sorts and declarations in the arrays [sorts] and [decls]. This is an useful feature since we can use arbitrary names to reference sorts and declarations defined using the C API. - The formulas, assumptions and declarations defined in [str] can be extracted using the functions: - {!get_smtlib_num_formulas}, {!get_smtlib_formula}, {!get_smtlib_num_assumptions}, {!get_smtlib_assumption}, + {!get_smtlib_num_formulas}, {!get_smtlib_formula}, {!get_smtlib_num_assumptions}, {!get_smtlib_assumption}, {!get_smtlib_num_decls}, and {!get_smtlib_decl}. - def_API('parse_smtlib_string', VOID, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _in(UINT), _in_array(5, SYMBOL), _in_array(5, FUNC_DECL))) *) external parse_smtlib_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit @@ -4695,7 +3863,6 @@ external parse_smtlib_string : context -> string -> symbol array -> sort array - (** Summary: Similar to {!parse_smtlib_string}, but reads the benchmark from a file. - def_API('parse_smtlib_file', VOID, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _in(UINT), _in_array(5, SYMBOL), _in_array(5, FUNC_DECL))) *) external parse_smtlib_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit @@ -4703,7 +3870,6 @@ external parse_smtlib_file : context -> string -> symbol array -> sort array -> (** Summary: Return the number of SMTLIB formulas parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. - def_API('get_smtlib_num_formulas', UINT, (_in(CONTEXT), )) *) external get_smtlib_num_formulas : context -> int @@ -4712,9 +3878,7 @@ external get_smtlib_num_formulas : context -> int (** Summary: \[ [ get_smtlib_formula c i ] \] Return the i-th formula parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. - - {b Precondition}: i < get_smtlib_num_formulas c - def_API('get_smtlib_formula', AST, (_in(CONTEXT), _in(UINT))) *) external get_smtlib_formula : context -> int -> ast @@ -4722,7 +3886,6 @@ external get_smtlib_formula : context -> int -> ast (** Summary: Return the number of SMTLIB assumptions parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. - def_API('get_smtlib_num_assumptions', UINT, (_in(CONTEXT), )) *) external get_smtlib_num_assumptions : context -> int @@ -4731,9 +3894,7 @@ external get_smtlib_num_assumptions : context -> int (** Summary: \[ [ get_smtlib_assumption c i ] \] Return the i-th assumption parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. - - {b Precondition}: i < get_smtlib_num_assumptions c - def_API('get_smtlib_assumption', AST, (_in(CONTEXT), _in(UINT))) *) external get_smtlib_assumption : context -> int -> ast @@ -4741,7 +3902,6 @@ external get_smtlib_assumption : context -> int -> ast (** Summary: Return the number of declarations parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. - def_API('get_smtlib_num_decls', UINT, (_in(CONTEXT), )) *) external get_smtlib_num_decls : context -> int @@ -4750,9 +3910,7 @@ external get_smtlib_num_decls : context -> int (** Summary: \[ [ get_smtlib_decl c i ] \] Return the i-th declaration parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. - - {b Precondition}: i < get_smtlib_num_decls c - def_API('get_smtlib_decl', FUNC_DECL, (_in(CONTEXT), _in(UINT))) *) external get_smtlib_decl : context -> int -> func_decl @@ -4760,7 +3918,6 @@ external get_smtlib_decl : context -> int -> func_decl (** Summary: Return the number of sorts parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. - def_API('get_smtlib_num_sorts', UINT, (_in(CONTEXT), )) *) external get_smtlib_num_sorts : context -> int @@ -4769,9 +3926,7 @@ external get_smtlib_num_sorts : context -> int (** Summary: \[ [ get_smtlib_sort c i ] \] Return the i-th sort parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. - - {b Precondition}: i < get_smtlib_num_sorts c - def_API('get_smtlib_sort', SORT, (_in(CONTEXT), _in(UINT))) *) external get_smtlib_sort : context -> int -> sort @@ -4781,38 +3936,17 @@ external get_smtlib_sort : context -> int -> sort (** Summary: \[ [ get_smtlib_error c ] \] Retrieve that last error message information generated from parsing. - def_API('get_smtlib_error', STRING, (_in(CONTEXT), )) *) external get_smtlib_error : context -> string = "camlidl_z3_Z3_get_smtlib_error" *) -(** - Summary: \[ [ parse_z3_string c str ] \] - Parse the given string using the Z3 native parser. - - Return the conjunction of asserts made in the input. - - def_API('parse_z3_string', AST, (_in(CONTEXT), _in(STRING))) -*) -external parse_z3_string : context -> string -> ast - = "camlidl_z3_Z3_parse_z3_string" - -(** - Summary: Similar to {!parse_z3_string}, but reads the benchmark from a file. - - def_API('parse_z3_file', AST, (_in(CONTEXT), _in(STRING))) -*) -external parse_z3_file : context -> string -> ast - = "camlidl_z3_Z3_parse_z3_file" - (** {2 {L Error Handling}} *) (** Summary: Set an error. - def_API('set_error', VOID, (_in(CONTEXT), _in(ERROR_CODE))) *) external set_error : context -> error_code -> unit @@ -4821,7 +3955,6 @@ external set_error : context -> error_code -> unit (* (** Summary: Return a string describing the given error code. - def_API('get_error_msg_ex', STRING, (_in(CONTEXT), _in(ERROR_CODE))) *) external get_error_msg_ex : context -> error_code -> string @@ -4831,7 +3964,7 @@ external get_error_msg_ex : context -> error_code -> string (** Summary: Return a string describing the given error code. -*) +*) val get_error_msg: context -> error_code -> string (** @@ -4839,21 +3972,32 @@ val get_error_msg: context -> error_code -> string *) (** Summary: Return Z3 version number information. - def_API('get_version', VOID, (_out(UINT), _out(UINT), _out(UINT), _out(UINT))) *) external get_version : unit -> int * int * int * int = "camlidl_z3_Z3_get_version" +(** + Summary: Enable tracing messages tagged as [tag] when Z3 is compiled in debug mode. + It is a NOOP otherwise + def_API('enable_trace', VOID, (_in(STRING),)) +*) +external enable_trace : string -> unit + = "camlidl_z3_Z3_enable_trace" + +(** + Summary: Disable tracing messages tagged as [tag] when Z3 is compiled in debug mode. + It is a NOOP otherwise + def_API('disable_trace', VOID, (_in(STRING),)) +*) +external disable_trace : string -> unit + = "camlidl_z3_Z3_disable_trace" + (** {2 {L Fixedpoint facilities}} *) (** - Summary: Create a new fixedpoint context. - - - - + Summary: Create a new fixedpoint context. def_API('mk_fixedpoint', FIXEDPOINT, (_in(CONTEXT), )) *) external mk_fixedpoint : context -> fixedpoint @@ -4862,33 +4006,27 @@ external mk_fixedpoint : context -> fixedpoint (** Summary: Add a universal Horn clause as a named rule. The [horn_rule] should be of the form: - - {v + {v horn_rule ::= (forall (bound-vars) horn_rule) - | (=> atoms horn_rule) - | atom + | (=> atoms horn_rule) + | atom v} - def_API('fixedpoint_add_rule', VOID, (_in(CONTEXT), _in(FIXEDPOINT), _in(AST), _in(SYMBOL))) *) external fixedpoint_add_rule : context -> fixedpoint -> ast -> symbol -> unit = "camlidl_z3_Z3_fixedpoint_add_rule" (** - Summary: Add a Database fact. - + Summary: Add a Database fact. @param c - context @param d - fixed point context @param r - relation signature for the row. - @param num_args - number of columns for the given row. + @param num_args - number of columns for the given row. @param args - array of the row elements. - - The number of arguments [num_args] should be equal to the number + The number of arguments [num_args] should be equal to the number of sorts in the domain of [r]. Each sort in the domain should be an integral (bit-vector, Boolean or or finite domain sort). - - The call has the same effect as adding a rule where is applied to the arguments. - + The call has the same effect as adding a rule where [r] is applied to the arguments. def_API('fixedpoint_add_fact', VOID, (_in(CONTEXT), _in(FIXEDPOINT), _in(FUNC_DECL), _in(UINT), _in_array(3, UINT))) *) external fixedpoint_add_fact : context -> fixedpoint -> func_decl -> int array -> unit @@ -4896,10 +4034,8 @@ external fixedpoint_add_fact : context -> fixedpoint -> func_decl -> int array - (** Summary: Assert a constraint to the fixedpoint context. - The constraints are used as background axioms when the fixedpoint engine uses the PDR mode. They are ignored for standard Datalog mode. - def_API('fixedpoint_assert', VOID, (_in(CONTEXT), _in(FIXEDPOINT), _in(AST))) *) external fixedpoint_assert : context -> fixedpoint -> ast -> unit @@ -4907,17 +4043,14 @@ external fixedpoint_assert : context -> fixedpoint -> ast -> unit (** Summary: Pose a query against the asserted rules. - - {v + {v query ::= (exists (bound-vars) query) - | literals + | literals v} - - query returns + query returns - L_FALSE if the query is unsatisfiable. - L_TRUE if the query is satisfiable. Obtain the answer by calling {!fixedpoint_get_answer}. - L_UNDEF if the query was interrupted, timed out or otherwise failed. - def_API('fixedpoint_query', INT, (_in(CONTEXT), _in(FIXEDPOINT), _in(AST))) *) external fixedpoint_query : context -> fixedpoint -> ast -> lbool @@ -4925,14 +4058,11 @@ external fixedpoint_query : context -> fixedpoint -> ast -> lbool (** Summary: Pose multiple queries against the asserted rules. - The queries are encoded as relations (function declarations). - - query returns + query returns - L_FALSE if the query is unsatisfiable. - L_TRUE if the query is satisfiable. Obtain the answer by calling {!fixedpoint_get_answer}. - L_UNDEF if the query was interrupted, timed out or otherwise failed. - def_API('fixedpoint_query_relations', INT, (_in(CONTEXT), _in(FIXEDPOINT), _in(UINT), _in_array(2, FUNC_DECL))) *) external fixedpoint_query_relations : context -> fixedpoint -> func_decl array -> lbool @@ -4940,14 +4070,10 @@ external fixedpoint_query_relations : context -> fixedpoint -> func_decl array - (** Summary: Retrieve a formula that encodes satisfying answers to the query. - - When used in Datalog mode, the returned answer is a disjunction of conjuncts. Each conjunct encodes values of the bound variables of the query that are satisfied. In PDR mode, the returned answer is a single conjunction. - The previous call to fixedpoint_query must have returned L_TRUE. - def_API('fixedpoint_get_answer', AST, (_in(CONTEXT), _in(FIXEDPOINT))) *) external fixedpoint_get_answer : context -> fixedpoint -> ast @@ -4955,18 +4081,15 @@ external fixedpoint_get_answer : context -> fixedpoint -> ast (** Summary: Retrieve a string that describes the last status returned by {!fixedpoint_query}. - Use this method when {!fixedpoint_query} returns L_UNDEF. - def_API('fixedpoint_get_reason_unknown', STRING, (_in(CONTEXT), _in(FIXEDPOINT) )) *) external fixedpoint_get_reason_unknown : context -> fixedpoint -> string = "camlidl_z3_Z3_fixedpoint_get_reason_unknown" (** - Summary: Update a named rule. + Summary: Update a named rule. A rule with the same name must have been previously created. - def_API('fixedpoint_update_rule', VOID, (_in(CONTEXT), _in(FIXEDPOINT), _in(AST), _in(SYMBOL))) *) external fixedpoint_update_rule : context -> fixedpoint -> ast -> symbol -> unit @@ -4974,11 +4097,9 @@ external fixedpoint_update_rule : context -> fixedpoint -> ast -> symbol -> unit (** Summary: Query the PDR engine for the maximal levels properties are known about predicate. - - This call retrieves the maximal number of relevant unfoldings + This call retrieves the maximal number of relevant unfoldings of [pred] with respect to the current exploration state. Note: this functionality is PDR specific. - def_API('fixedpoint_get_num_levels', UINT, (_in(CONTEXT), _in(FIXEDPOINT), _in(FUNC_DECL))) *) external fixedpoint_get_num_levels : context -> fixedpoint -> func_decl -> int @@ -4989,9 +4110,7 @@ external fixedpoint_get_num_levels : context -> fixedpoint -> func_decl -> int Return just the delta that is known at [level]. To obtain the full set of properties of [pred] one should query at [level+1] , [level+2] etc, and include [level=-1]. - Note: this functionality is PDR specific. - def_API('fixedpoint_get_cover_delta', AST, (_in(CONTEXT), _in(FIXEDPOINT), _in(INT), _in(FUNC_DECL))) *) external fixedpoint_get_cover_delta : context -> fixedpoint -> int -> func_decl -> ast @@ -4999,14 +4118,11 @@ external fixedpoint_get_cover_delta : context -> fixedpoint -> int -> func_decl (** Summary: Add property about the predicate [pred]. - Add a property of predicate [pred] at [level]. + Add a property of predicate [pred] at [level]. It gets pushed forward when possible. - Note: level = -1 is treated as the fixedpoint. So passing -1 for the [level] means that the property is true of the fixed-point unfolding with respect to [pred]. - Note: this functionality is PDR specific. - def_API('fixedpoint_add_cover', VOID, (_in(CONTEXT), _in(FIXEDPOINT), _in(INT), _in(FUNC_DECL), _in(AST))) *) external fixedpoint_add_cover : context -> fixedpoint -> int -> func_decl -> ast -> unit @@ -5014,7 +4130,6 @@ external fixedpoint_add_cover : context -> fixedpoint -> int -> func_decl -> ast (** Summary: Retrieve statistics information from the last call to {!fixedpoint_query}. - def_API('fixedpoint_get_statistics', STATS, (_in(CONTEXT), _in(FIXEDPOINT))) *) external fixedpoint_get_statistics : context -> fixedpoint -> stats @@ -5025,7 +4140,6 @@ external fixedpoint_get_statistics : context -> fixedpoint -> stats Fixedpoint defined relations have least-fixedpoint semantics. For example, the relation is empty if it does not occur in a head or a fact. - def_API('fixedpoint_register_relation', VOID, (_in(CONTEXT), _in(FIXEDPOINT), _in(FUNC_DECL))) *) external fixedpoint_register_relation : context -> fixedpoint -> func_decl -> unit @@ -5033,29 +4147,30 @@ external fixedpoint_register_relation : context -> fixedpoint -> func_decl -> un (** Summary: Configure the predicate representation. - It sets the predicate to use a set of domains given by the list of symbols. The domains given by the list of symbols must belong to a set of built-in domains. - def_API('fixedpoint_set_predicate_representation', VOID, (_in(CONTEXT), _in(FIXEDPOINT), _in(FUNC_DECL), _in(UINT), _in_array(3, SYMBOL))) *) external fixedpoint_set_predicate_representation : context -> fixedpoint -> func_decl -> symbol array -> unit = "camlidl_z3_Z3_fixedpoint_set_predicate_representation" (** - Summary: Simplify rules into a set of new rules that are returned. - The simplification routines apply inlining, quantifier elimination, and other - algebraic simplifications. - - def_API('fixedpoint_simplify_rules', AST_VECTOR, (_in(CONTEXT), _in(FIXEDPOINT), _in(UINT), _in_array(2,AST), _in(UINT), _in_array(4,FUNC_DECL))) + Summary: Retrieve set of rules from fixedpoint context. + def_API('fixedpoint_get_rules', AST_VECTOR, (_in(CONTEXT),_in(FIXEDPOINT))) *) -external fixedpoint_simplify_rules : context -> fixedpoint -> ast array -> func_decl array -> ast_vector - = "camlidl_z3_Z3_fixedpoint_simplify_rules" +external fixedpoint_get_rules : context -> fixedpoint -> ast_vector + = "camlidl_z3_Z3_fixedpoint_get_rules" (** - Summary: Set parameters on fixedpoint context. + Summary: Retrieve set of background assertions from fixedpoint context. + def_API('fixedpoint_get_assertions', AST_VECTOR, (_in(CONTEXT),_in(FIXEDPOINT))) +*) +external fixedpoint_get_assertions : context -> fixedpoint -> ast_vector + = "camlidl_z3_Z3_fixedpoint_get_assertions" +(** + Summary: Set parameters on fixedpoint context. def_API('fixedpoint_set_params', VOID, (_in(CONTEXT), _in(FIXEDPOINT), _in(PARAMS))) *) external fixedpoint_set_params : context -> fixedpoint -> params -> unit @@ -5063,7 +4178,6 @@ external fixedpoint_set_params : context -> fixedpoint -> params -> unit (** Summary: Return a string describing all fixedpoint available parameters. - def_API('fixedpoint_get_help', STRING, (_in(CONTEXT), _in(FIXEDPOINT))) *) external fixedpoint_get_help : context -> fixedpoint -> string @@ -5071,7 +4185,6 @@ external fixedpoint_get_help : context -> fixedpoint -> string (** Summary: Return the parameter description set for the given fixedpoint object. - def_API('fixedpoint_get_param_descrs', PARAM_DESCRS, (_in(CONTEXT), _in(FIXEDPOINT))) *) external fixedpoint_get_param_descrs : context -> fixedpoint -> param_descrs @@ -5083,20 +4196,40 @@ external fixedpoint_get_param_descrs : context -> fixedpoint -> param_descrs @param f - fixedpoint context. @param num_queries - number of additional queries to print. @param queries - additional queries. - def_API('fixedpoint_to_string', STRING, (_in(CONTEXT), _in(FIXEDPOINT), _in(UINT), _in_array(2, AST))) *) external fixedpoint_to_string : context -> fixedpoint -> ast array -> string = "camlidl_z3_Z3_fixedpoint_to_string" +(** + Summary: Parse an SMT-LIB2 string with fixedpoint rules. + Add the rules to the current fixedpoint context. + Return the set of queries in the file. + @param c - context. + @param f - fixedpoint context. + @param s - string containing SMT2 specification. + def_API('fixedpoint_from_string', AST_VECTOR, (_in(CONTEXT), _in(FIXEDPOINT), _in(STRING))) +*) +external fixedpoint_from_string : context -> fixedpoint -> string -> ast_vector + = "camlidl_z3_Z3_fixedpoint_from_string" + +(** + Summary: Parse an SMT-LIB2 file with fixedpoint rules. + Add the rules to the current fixedpoint context. + Return the set of queries in the file. + @param c - context. + @param f - fixedpoint context. + @param s - string containing SMT2 specification. + def_API('fixedpoint_from_file', AST_VECTOR, (_in(CONTEXT), _in(FIXEDPOINT), _in(STRING))) +*) +external fixedpoint_from_file : context -> fixedpoint -> string -> ast_vector + = "camlidl_z3_Z3_fixedpoint_from_file" + (** Summary: Create a backtracking point. - The fixedpoint solver contains a set of rules, added facts and assertions. The set of rules, facts and assertions are restored upon calling {!fixedpoint_pop}. - - {b See also}: {!fixedpoint_pop} - def_API('fixedpoint_push', VOID, (_in(CONTEXT), _in(FIXEDPOINT))) *) external fixedpoint_push : context -> fixedpoint -> unit @@ -5104,11 +4237,8 @@ external fixedpoint_push : context -> fixedpoint -> unit (** Summary: Backtrack one backtracking point. - - {b See also}: {!fixedpoint_push} - - {b Precondition}: The number of calls to pop cannot exceed calls to push. - def_API('fixedpoint_pop', VOID, (_in(CONTEXT), _in(FIXEDPOINT))) *) external fixedpoint_pop : context -> fixedpoint -> unit @@ -5119,10 +4249,6 @@ external fixedpoint_pop : context -> fixedpoint -> unit *) (** Summary: Return an empty AST vector. - - - - def_API('mk_ast_vector', AST_VECTOR, (_in(CONTEXT),)) *) external mk_ast_vector : context -> ast_vector @@ -5130,7 +4256,6 @@ external mk_ast_vector : context -> ast_vector (** Summary: Return the size of the given AST vector. - def_API('ast_vector_size', UINT, (_in(CONTEXT), _in(AST_VECTOR))) *) external ast_vector_size : context -> ast_vector -> int @@ -5138,27 +4263,22 @@ external ast_vector_size : context -> ast_vector -> int (** Summary: Return the AST at position [i] in the AST vector [v]. - - {b Precondition}: i < ast_vector_size c v - def_API('ast_vector_get', AST, (_in(CONTEXT), _in(AST_VECTOR), _in(UINT))) *) external ast_vector_get : context -> ast_vector -> int -> ast = "camlidl_z3_Z3_ast_vector_get" (** - Summary: Update position [i] of the AST vector [v] with the AST [a]. - + Summary: Update position [i] of the AST vector [v] with the AST [a]. - {b Precondition}: i < ast_vector_size c v - def_API('ast_vector_set', VOID, (_in(CONTEXT), _in(AST_VECTOR), _in(UINT), _in(AST))) *) external ast_vector_set : context -> ast_vector -> int -> ast -> unit = "camlidl_z3_Z3_ast_vector_set" (** - Summary: Resize the AST vector [v]. - + Summary: Resize the AST vector [v]. def_API('ast_vector_resize', VOID, (_in(CONTEXT), _in(AST_VECTOR), _in(UINT))) *) external ast_vector_resize : context -> ast_vector -> int -> unit @@ -5166,7 +4286,6 @@ external ast_vector_resize : context -> ast_vector -> int -> unit (** Summary: Add the AST [a] in the end of the AST vector [v]. The size of [v] is increased by one. - def_API('ast_vector_push', VOID, (_in(CONTEXT), _in(AST_VECTOR), _in(AST))) *) external ast_vector_push : context -> ast_vector -> ast -> unit @@ -5174,7 +4293,6 @@ external ast_vector_push : context -> ast_vector -> ast -> unit (** Summary: Translate the AST vector [v] from context [s] into an AST vector in context [t]. - def_API('ast_vector_translate', AST_VECTOR, (_in(CONTEXT), _in(AST_VECTOR), _in(CONTEXT))) *) external ast_vector_translate : context -> ast_vector -> context -> ast_vector @@ -5182,7 +4300,6 @@ external ast_vector_translate : context -> ast_vector -> context -> ast_vector (** Summary: Convert AST vector into a string. - def_API('ast_vector_to_string', STRING, (_in(CONTEXT), _in(AST_VECTOR))) *) external ast_vector_to_string : context -> ast_vector -> string @@ -5193,10 +4310,6 @@ external ast_vector_to_string : context -> ast_vector -> string *) (** Summary: Return an empty mapping from AST to AST - - - - def_API('mk_ast_map', AST_MAP, (_in(CONTEXT),) ) *) external mk_ast_map : context -> ast_map @@ -5204,7 +4317,6 @@ external mk_ast_map : context -> ast_map (** Summary: Return true if the map [m] contains the AST key [k]. - def_API('ast_map_contains', BOOL, (_in(CONTEXT), _in(AST_MAP), _in(AST))) *) external ast_map_contains : context -> ast_map -> ast -> bool @@ -5212,9 +4324,7 @@ external ast_map_contains : context -> ast_map -> ast -> bool (** Summary: Return the value associated with the key [k]. - The procedure invokes the error handler if [k] is not in the map. - def_API('ast_map_find', AST, (_in(CONTEXT), _in(AST_MAP), _in(AST))) *) external ast_map_find : context -> ast_map -> ast -> ast @@ -5222,7 +4332,6 @@ external ast_map_find : context -> ast_map -> ast -> ast (** Summary: Store/Replace a new key, value pair in the given map. - def_API('ast_map_insert', VOID, (_in(CONTEXT), _in(AST_MAP), _in(AST), _in(AST))) *) external ast_map_insert : context -> ast_map -> ast -> ast -> unit @@ -5230,7 +4339,6 @@ external ast_map_insert : context -> ast_map -> ast -> ast -> unit (** Summary: Erase a key from the map. - def_API('ast_map_erase', VOID, (_in(CONTEXT), _in(AST_MAP), _in(AST))) *) external ast_map_erase : context -> ast_map -> ast -> unit @@ -5238,7 +4346,6 @@ external ast_map_erase : context -> ast_map -> ast -> unit (** Summary: Remove all keys from the given map. - def_API('ast_map_reset', VOID, (_in(CONTEXT), _in(AST_MAP))) *) external ast_map_reset : context -> ast_map -> unit @@ -5246,7 +4353,6 @@ external ast_map_reset : context -> ast_map -> unit (** Summary: Return the size of the given map. - def_API('ast_map_size', UINT, (_in(CONTEXT), _in(AST_MAP))) *) external ast_map_size : context -> ast_map -> int @@ -5254,7 +4360,6 @@ external ast_map_size : context -> ast_map -> int (** Summary: Return the keys stored in the given map. - def_API('ast_map_keys', AST_VECTOR, (_in(CONTEXT), _in(AST_MAP))) *) external ast_map_keys : context -> ast_map -> ast_vector @@ -5262,7 +4367,6 @@ external ast_map_keys : context -> ast_map -> ast_vector (** Summary: Convert the given map into a string. - def_API('ast_map_to_string', STRING, (_in(CONTEXT), _in(AST_MAP))) *) external ast_map_to_string : context -> ast_map -> string @@ -5275,17 +4379,10 @@ external ast_map_to_string : context -> ast_map -> string Summary: Create a goal (aka problem). A goal is essentially a set of formulas, that can be solved and/or transformed using tactics and solvers. - If models == true, then model generation is enabled for the new goal. - If unsat_cores == true, then unsat core generation is enabled for the new goal. - - If proofs == true, then proof generation is enabled for the new goal. Remark, the + If proofs == true, then proof generation is enabled for the new goal. Remark, the Z3 context c must have been created with proof generation support. - - - - def_API('mk_goal', GOAL, (_in(CONTEXT), _in(BOOL), _in(BOOL), _in(BOOL))) *) external mk_goal : context -> bool -> bool -> bool -> goal @@ -5295,15 +4392,13 @@ external mk_goal : context -> bool -> bool -> bool -> goal Summary: Return the "precision" of the given goal. Goals can be transformed using over and under approximations. A under approximation is applied when the objective is to find a model for a given goal. An over approximation is applied when the objective is to find a proof for a given goal. - def_API('goal_precision', UINT, (_in(CONTEXT), _in(GOAL))) *) external goal_precision : context -> goal -> goal_prec = "camlidl_z3_Z3_goal_precision" (** - Summary: Add a new formula [a] to the given goal. - + Summary: Add a new formula [a] to the given goal. def_API('goal_assert', VOID, (_in(CONTEXT), _in(GOAL), _in(AST))) *) external goal_assert : context -> goal -> ast -> unit @@ -5311,7 +4406,6 @@ external goal_assert : context -> goal -> ast -> unit (** Summary: Return true if the given goal contains the formula [false]. - def_API('goal_inconsistent', BOOL, (_in(CONTEXT), _in(GOAL))) *) external goal_inconsistent : context -> goal -> bool @@ -5319,7 +4413,6 @@ external goal_inconsistent : context -> goal -> bool (** Summary: Return the depth of the given goal. It tracks how many transformations were applied to it. - def_API('goal_depth', UINT, (_in(CONTEXT), _in(GOAL))) *) external goal_depth : context -> goal -> int @@ -5327,7 +4420,6 @@ external goal_depth : context -> goal -> int (** Summary: Erase all formulas from the given goal. - def_API('goal_reset', VOID, (_in(CONTEXT), _in(GOAL))) *) external goal_reset : context -> goal -> unit @@ -5335,7 +4427,6 @@ external goal_reset : context -> goal -> unit (** Summary: Return the number of formulas in the given goal. - def_API('goal_size', UINT, (_in(CONTEXT), _in(GOAL))) *) external goal_size : context -> goal -> int @@ -5343,9 +4434,7 @@ external goal_size : context -> goal -> int (** Summary: Return a formula from the given goal. - - {b Precondition}: idx < goal_size c g - def_API('goal_formula', AST, (_in(CONTEXT), _in(GOAL), _in(UINT))) *) external goal_formula : context -> goal -> int -> ast @@ -5353,7 +4442,6 @@ external goal_formula : context -> goal -> int -> ast (** Summary: Return the number of formulas, subformulas and terms in the given goal. - def_API('goal_num_exprs', UINT, (_in(CONTEXT), _in(GOAL))) *) external goal_num_exprs : context -> goal -> int @@ -5361,7 +4449,6 @@ external goal_num_exprs : context -> goal -> int (** Summary: Return true if the goal is empty, and it is precise or the product of a under approximation. - def_API('goal_is_decided_sat', BOOL, (_in(CONTEXT), _in(GOAL))) *) external goal_is_decided_sat : context -> goal -> bool @@ -5369,7 +4456,6 @@ external goal_is_decided_sat : context -> goal -> bool (** Summary: Return true if the goal contains false, and it is precise or the product of an over approximation. - def_API('goal_is_decided_unsat', BOOL, (_in(CONTEXT), _in(GOAL))) *) external goal_is_decided_unsat : context -> goal -> bool @@ -5377,7 +4463,6 @@ external goal_is_decided_unsat : context -> goal -> bool (** Summary: Copy a goal [g] from the context [source] to a the context [target]. - def_API('goal_translate', GOAL, (_in(CONTEXT), _in(GOAL), _in(CONTEXT))) *) external goal_translate : context -> goal -> context -> goal @@ -5385,7 +4470,6 @@ external goal_translate : context -> goal -> context -> goal (** Summary: Convert a goal into a string. - def_API('goal_to_string', STRING, (_in(CONTEXT), _in(GOAL))) *) external goal_to_string : context -> goal -> string @@ -5398,9 +4482,7 @@ external goal_to_string : context -> goal -> string Summary: Return a tactic associated with the given name. The complete list of tactics may be obtained using the procedures {!get_num_tactics} and {!get_tactic_name}. It may also be obtained using the command {e (help-tactics) } in the SMT 2.0 front-end. - Tactics are the basic building block for creating custom solvers for specific problem domains. - def_API('mk_tactic', TACTIC, (_in(CONTEXT), _in(STRING))) *) external mk_tactic : context -> string -> tactic @@ -5410,10 +4492,8 @@ external mk_tactic : context -> string -> tactic Summary: Return a probe associated with the given name. The complete list of probes may be obtained using the procedures {!get_num_probes} and {!get_probe_name}. It may also be obtained using the command {e (help-tactics) } in the SMT 2.0 front-end. - Probes are used to inspect a goal (aka problem) and collect information that may be used to decide which solver and/or preprocessing step will be used. - def_API('mk_probe', PROBE, (_in(CONTEXT), _in(STRING))) *) external mk_probe : context -> string -> probe @@ -5422,7 +4502,6 @@ external mk_probe : context -> string -> probe (** Summary: Return a tactic that applies [t1] to a given goal and [t2] to every subgoal produced by t1. - def_API('tactic_and_then', TACTIC, (_in(CONTEXT), _in(TACTIC), _in(TACTIC))) *) external tactic_and_then : context -> tactic -> tactic -> tactic @@ -5431,7 +4510,6 @@ external tactic_and_then : context -> tactic -> tactic -> tactic (** Summary: Return a tactic that first applies [t1] to a given goal, if it fails then returns the result of [t2] applied to the given goal. - def_API('tactic_or_else', TACTIC, (_in(CONTEXT), _in(TACTIC), _in(TACTIC))) *) external tactic_or_else : context -> tactic -> tactic -> tactic @@ -5439,7 +4517,6 @@ external tactic_or_else : context -> tactic -> tactic -> tactic (** Summary: Return a tactic that applies the given tactics in parallel. - def_API('tactic_par_or', TACTIC, (_in(CONTEXT), _in(UINT), _in_array(1, TACTIC))) *) external tactic_par_or : context -> tactic array -> tactic @@ -5448,7 +4525,6 @@ external tactic_par_or : context -> tactic array -> tactic (** Summary: Return a tactic that applies [t1] to a given goal and then [t2] to every subgoal produced by t1. The subgoals are processed in parallel. - def_API('tactic_par_and_then', TACTIC, (_in(CONTEXT), _in(TACTIC), _in(TACTIC))) *) external tactic_par_and_then : context -> tactic -> tactic -> tactic @@ -5457,7 +4533,6 @@ external tactic_par_and_then : context -> tactic -> tactic -> tactic (** Summary: Return a tactic that applies [t] to a given goal for [ms] milliseconds. If [t] does not terminate in [ms] milliseconds, then it fails. - def_API('tactic_try_for', TACTIC, (_in(CONTEXT), _in(TACTIC), _in(UINT))) *) external tactic_try_for : context -> tactic -> int -> tactic @@ -5466,7 +4541,6 @@ external tactic_try_for : context -> tactic -> int -> tactic (** Summary: Return a tactic that applies [t] to a given goal is the probe [p] evaluates to true. If [p] evaluates to false, then the new tactic behaves like the skip tactic. - def_API('tactic_when', TACTIC, (_in(CONTEXT), _in(PROBE), _in(TACTIC))) *) external tactic_when : context -> probe -> tactic -> tactic @@ -5475,7 +4549,6 @@ external tactic_when : context -> probe -> tactic -> tactic (** Summary: Return a tactic that applies [t1] to a given goal if the probe [p] evaluates to true, and [t2] if [p] evaluates to false. - def_API('tactic_cond', TACTIC, (_in(CONTEXT), _in(PROBE), _in(TACTIC), _in(TACTIC))) *) external tactic_cond : context -> probe -> tactic -> tactic -> tactic @@ -5484,7 +4557,6 @@ external tactic_cond : context -> probe -> tactic -> tactic -> tactic (** Summary: Return a tactic that keeps applying [t] until the goal is not modified anymore or the maximum number of iterations [max] is reached. - def_API('tactic_repeat', TACTIC, (_in(CONTEXT), _in(TACTIC), _in(UINT))) *) external tactic_repeat : context -> tactic -> int -> tactic @@ -5492,7 +4564,6 @@ external tactic_repeat : context -> tactic -> int -> tactic (** Summary: Return a tactic that just return the given goal. - def_API('tactic_skip', TACTIC, (_in(CONTEXT),)) *) external tactic_skip : context -> tactic @@ -5500,7 +4571,6 @@ external tactic_skip : context -> tactic (** Summary: Return a tactic that always fails. - def_API('tactic_fail', TACTIC, (_in(CONTEXT),)) *) external tactic_fail : context -> tactic @@ -5508,7 +4578,6 @@ external tactic_fail : context -> tactic (** Summary: Return a tactic that fails if the probe [p] evaluates to false. - def_API('tactic_fail_if', TACTIC, (_in(CONTEXT), _in(PROBE))) *) external tactic_fail_if : context -> probe -> tactic @@ -5517,7 +4586,6 @@ external tactic_fail_if : context -> probe -> tactic (** Summary: Return a tactic that fails if the goal is not trivially satisfiable (i.e., empty) or trivially unsatisfiable (i.e., contains false). - def_API('tactic_fail_if_not_decided', TACTIC, (_in(CONTEXT),)) *) external tactic_fail_if_not_decided : context -> tactic @@ -5525,7 +4593,6 @@ external tactic_fail_if_not_decided : context -> tactic (** Summary: Return a tactic that applies [t] using the given set of parameters. - def_API('tactic_using_params', TACTIC, (_in(CONTEXT), _in(TACTIC), _in(PARAMS))) *) external tactic_using_params : context -> tactic -> params -> tactic @@ -5533,7 +4600,6 @@ external tactic_using_params : context -> tactic -> params -> tactic (** Summary: Return a probe that always evaluates to val. - def_API('probe_const', PROBE, (_in(CONTEXT), _in(DOUBLE))) *) external probe_const : context -> float -> probe @@ -5541,9 +4607,7 @@ external probe_const : context -> float -> probe (** Summary: Return a probe that evaluates to "true" when the value returned by [p1] is less than the value returned by [p2]. - - {b Remarks}: For probes, "true" is any value different from 0.0. - def_API('probe_lt', PROBE, (_in(CONTEXT), _in(PROBE), _in(PROBE))) *) external probe_lt : context -> probe -> probe -> probe @@ -5551,9 +4615,7 @@ external probe_lt : context -> probe -> probe -> probe (** Summary: Return a probe that evaluates to "true" when the value returned by [p1] is greater than the value returned by [p2]. - - {b Remarks}: For probes, "true" is any value different from 0.0. - def_API('probe_gt', PROBE, (_in(CONTEXT), _in(PROBE), _in(PROBE))) *) external probe_gt : context -> probe -> probe -> probe @@ -5561,9 +4623,7 @@ external probe_gt : context -> probe -> probe -> probe (** Summary: Return a probe that evaluates to "true" when the value returned by [p1] is less than or equal to the value returned by [p2]. - - {b Remarks}: For probes, "true" is any value different from 0.0. - def_API('probe_le', PROBE, (_in(CONTEXT), _in(PROBE), _in(PROBE))) *) external probe_le : context -> probe -> probe -> probe @@ -5571,19 +4631,15 @@ external probe_le : context -> probe -> probe -> probe (** Summary: Return a probe that evaluates to "true" when the value returned by [p1] is greater than or equal to the value returned by [p2]. - - {b Remarks}: For probes, "true" is any value different from 0.0. - - def_API('probe_ge', PROBE, (_in(CONTEXT), _in(PROBE), _in(PROBE))) + def_API('probe_ge', PROBE, (_in(CONTEXT), _in(PROBE), _in(PROBE))) *) external probe_ge : context -> probe -> probe -> probe = "camlidl_z3_Z3_probe_ge" (** Summary: Return a probe that evaluates to "true" when the value returned by [p1] is equal to the value returned by [p2]. - - {b Remarks}: For probes, "true" is any value different from 0.0. - def_API('probe_eq', PROBE, (_in(CONTEXT), _in(PROBE), _in(PROBE))) *) external probe_eq : context -> probe -> probe -> probe @@ -5591,9 +4647,7 @@ external probe_eq : context -> probe -> probe -> probe (** Summary: Return a probe that evaluates to "true" when [p1] and [p2] evaluates to true. - - {b Remarks}: For probes, "true" is any value different from 0.0. - def_API('probe_and', PROBE, (_in(CONTEXT), _in(PROBE), _in(PROBE))) *) external probe_and : context -> probe -> probe -> probe @@ -5601,9 +4655,7 @@ external probe_and : context -> probe -> probe -> probe (** Summary: Return a probe that evaluates to "true" when [p1] or [p2] evaluates to true. - - {b Remarks}: For probes, "true" is any value different from 0.0. - def_API('probe_or', PROBE, (_in(CONTEXT), _in(PROBE), _in(PROBE))) *) external probe_or : context -> probe -> probe -> probe @@ -5611,9 +4663,7 @@ external probe_or : context -> probe -> probe -> probe (** Summary: Return a probe that evaluates to "true" when [p] does not evaluate to true. - - {b Remarks}: For probes, "true" is any value different from 0.0. - def_API('probe_not', PROBE, (_in(CONTEXT), _in(PROBE))) *) external probe_not : context -> probe -> probe @@ -5621,7 +4671,6 @@ external probe_not : context -> probe -> probe (** Summary: Return the number of builtin tactics available in Z3. - def_API('get_num_tactics', UINT, (_in(CONTEXT),)) *) external get_num_tactics : context -> int @@ -5629,9 +4678,7 @@ external get_num_tactics : context -> int (** Summary: Return the name of the idx tactic. - - {b Precondition}: i < get_num_tactics c - def_API('get_tactic_name', STRING, (_in(CONTEXT), _in(UINT))) *) external get_tactic_name : context -> int -> string @@ -5639,7 +4686,6 @@ external get_tactic_name : context -> int -> string (** Summary: Return the number of builtin probes available in Z3. - def_API('get_num_probes', UINT, (_in(CONTEXT),)) *) external get_num_probes : context -> int @@ -5647,9 +4693,7 @@ external get_num_probes : context -> int (** Summary: Return the name of the i probe. - - {b Precondition}: i < get_num_probes c - def_API('get_probe_name', STRING, (_in(CONTEXT), _in(UINT))) *) external get_probe_name : context -> int -> string @@ -5657,7 +4701,6 @@ external get_probe_name : context -> int -> string (** Summary: Return a string containing a description of parameters accepted by the given tactic. - def_API('tactic_get_help', STRING, (_in(CONTEXT), _in(TACTIC))) *) external tactic_get_help : context -> tactic -> string @@ -5665,7 +4708,6 @@ external tactic_get_help : context -> tactic -> string (** Summary: Return the parameter description set for the given tactic object. - def_API('tactic_get_param_descrs', PARAM_DESCRS, (_in(CONTEXT), _in(TACTIC))) *) external tactic_get_param_descrs : context -> tactic -> param_descrs @@ -5673,7 +4715,6 @@ external tactic_get_param_descrs : context -> tactic -> param_descrs (** Summary: Return a string containing a description of the tactic with the given name. - def_API('tactic_get_descr', STRING, (_in(CONTEXT), _in(STRING))) *) external tactic_get_descr : context -> string -> string @@ -5681,7 +4722,6 @@ external tactic_get_descr : context -> string -> string (** Summary: Return a string containing a description of the probe with the given name. - def_API('probe_get_descr', STRING, (_in(CONTEXT), _in(STRING))) *) external probe_get_descr : context -> string -> string @@ -5690,7 +4730,6 @@ external probe_get_descr : context -> string -> string (** Summary: Execute the probe over the goal. The probe always produce a double value. "Boolean" probes return 0.0 for false, and a value different from 0.0 for true. - def_API('probe_apply', DOUBLE, (_in(CONTEXT), _in(PROBE), _in(GOAL))) *) external probe_apply : context -> probe -> goal -> float @@ -5698,7 +4737,6 @@ external probe_apply : context -> probe -> goal -> float (** Summary: Apply tactic [t] to the goal [g]. - def_API('tactic_apply', APPLY_RESULT, (_in(CONTEXT), _in(TACTIC), _in(GOAL))) *) external tactic_apply : context -> tactic -> goal -> apply_result @@ -5706,7 +4744,6 @@ external tactic_apply : context -> tactic -> goal -> apply_result (** Summary: Apply tactic [t] to the goal [g] using the parameter set [p]. - def_API('tactic_apply_ex', APPLY_RESULT, (_in(CONTEXT), _in(TACTIC), _in(GOAL), _in(PARAMS))) *) external tactic_apply_ex : context -> tactic -> goal -> params -> apply_result @@ -5714,7 +4751,6 @@ external tactic_apply_ex : context -> tactic -> goal -> params -> apply_result (** Summary: Convert the [apply_result] object returned by {!tactic_apply} into a string. - def_API('apply_result_to_string', STRING, (_in(CONTEXT), _in(APPLY_RESULT))) *) external apply_result_to_string : context -> apply_result -> string @@ -5722,7 +4758,6 @@ external apply_result_to_string : context -> apply_result -> string (** Summary: Return the number of subgoals in the [apply_result] object returned by {!tactic_apply}. - def_API('apply_result_get_num_subgoals', UINT, (_in(CONTEXT), _in(APPLY_RESULT))) *) external apply_result_get_num_subgoals : context -> apply_result -> int @@ -5730,9 +4765,7 @@ external apply_result_get_num_subgoals : context -> apply_result -> int (** Summary: Return one of the subgoals in the [apply_result] object returned by {!tactic_apply}. - - {b Precondition}: i < apply_result_get_num_subgoals c r - def_API('apply_result_get_subgoal', GOAL, (_in(CONTEXT), _in(APPLY_RESULT), _in(UINT))) *) external apply_result_get_subgoal : context -> apply_result -> int -> goal @@ -5741,7 +4774,6 @@ external apply_result_get_subgoal : context -> apply_result -> int -> goal (** Summary: Convert a model for the subgoal [apply_result_get_subgoal(c], r, i) into a model for the original goal [g]. Where [g] is the goal used to create [r] using [tactic_apply(c], t, g). - def_API('apply_result_convert_model', MODEL, (_in(CONTEXT), _in(APPLY_RESULT), _in(UINT), _in(MODEL))) *) external apply_result_convert_model : context -> apply_result -> int -> model -> model @@ -5753,11 +4785,7 @@ external apply_result_convert_model : context -> apply_result -> int -> model -> (** Summary: Create a new (incremental) solver. This solver also uses a set of builtin tactics for handling the first check-sat command, and - check-sat commands that take more than a given number of milliseconds to be solved. - - - - + check-sat commands that take more than a given number of milliseconds to be solved. def_API('mk_solver', SOLVER, (_in(CONTEXT),)) *) external mk_solver : context -> solver @@ -5765,7 +4793,6 @@ external mk_solver : context -> solver (** Summary: Create a new (incremental) solver. - def_API('mk_simple_solver', SOLVER, (_in(CONTEXT),)) *) external mk_simple_solver : context -> solver @@ -5774,10 +4801,6 @@ external mk_simple_solver : context -> solver (** Summary: Create a new solver customized for the given logic. It behaves like {!mk_solver} if the logic is unknown or unsupported. - - - - def_API('mk_solver_for_logic', SOLVER, (_in(CONTEXT), _in(SYMBOL))) *) external mk_solver_for_logic : context -> symbol -> solver @@ -5787,7 +4810,6 @@ external mk_solver_for_logic : context -> symbol -> solver Summary: Create a new solver that is implemented using the given tactic. The solver supports the commands {!solver_push} and {!solver_pop}, but it will always solve each {!solver_check} from scratch. - def_API('mk_solver_from_tactic', SOLVER, (_in(CONTEXT), _in(TACTIC))) *) external mk_solver_from_tactic : context -> tactic -> solver @@ -5795,7 +4817,6 @@ external mk_solver_from_tactic : context -> tactic -> solver (** Summary: Return a string describing all solver available parameters. - def_API('solver_get_help', STRING, (_in(CONTEXT), _in(SOLVER))) *) external solver_get_help : context -> solver -> string @@ -5803,7 +4824,6 @@ external solver_get_help : context -> solver -> string (** Summary: Return the parameter description set for the given solver object. - def_API('solver_get_param_descrs', PARAM_DESCRS, (_in(CONTEXT), _in(SOLVER))) *) external solver_get_param_descrs : context -> solver -> param_descrs @@ -5811,7 +4831,6 @@ external solver_get_param_descrs : context -> solver -> param_descrs (** Summary: Set the given solver using the given parameters. - def_API('solver_set_params', VOID, (_in(CONTEXT), _in(SOLVER), _in(PARAMS))) *) external solver_set_params : context -> solver -> params -> unit @@ -5819,11 +4838,8 @@ external solver_set_params : context -> solver -> params -> unit (** Summary: Create a backtracking point. - - The solver contains a stack of assertions. - + The solver contains a stack of assertions. - {b See also}: {!solver_pop} - def_API('solver_push', VOID, (_in(CONTEXT), _in(SOLVER))) *) external solver_push : context -> solver -> unit @@ -5831,11 +4847,8 @@ external solver_push : context -> solver -> unit (** Summary: Backtrack [n] backtracking points. - - {b See also}: {!solver_push} - - {b Precondition}: n <= solver_get_num_scopes c s - def_API('solver_pop', VOID, (_in(CONTEXT), _in(SOLVER), _in(UINT))) *) external solver_pop : context -> solver -> int -> unit @@ -5843,7 +4856,6 @@ external solver_pop : context -> solver -> int -> unit (** Summary: Remove all assertions from the solver. - def_API('solver_reset', VOID, (_in(CONTEXT), _in(SOLVER))) *) external solver_reset : context -> solver -> unit @@ -5851,10 +4863,8 @@ external solver_reset : context -> solver -> unit (** Summary: Return the number of backtracking points. - - {b See also}: {!solver_push} - {b See also}: {!solver_pop} - def_API('solver_get_num_scopes', UINT, (_in(CONTEXT), _in(SOLVER))) *) external solver_get_num_scopes : context -> solver -> int @@ -5862,34 +4872,42 @@ external solver_get_num_scopes : context -> solver -> int (** Summary: Assert a constraint into the solver. - The functions {!solver_check} and {!solver_check_assumptions} should be used to check whether the logical context is consistent or not. - def_API('solver_assert', VOID, (_in(CONTEXT), _in(SOLVER), _in(AST))) *) external solver_assert : context -> solver -> ast -> unit = "camlidl_z3_Z3_solver_assert" +(** + Summary: Assert a constraint [a] into the solver, and track it (in the unsat) core using + the Boolean constant [p]. + This API is an alternative to {!solver_check_assumptions} for extracting unsat cores. + Both APIs can be used in the same solver. The unsat core will contain a combination + of the Boolean variables provided using solver_assert_and_track and the Boolean literals + provided using {!solver_check_assumptions}. + - {b Precondition}: [a] must be a Boolean expression + - {b Precondition}: [p] must be a Boolean constant aka variable. + def_API('solver_assert_and_track', VOID, (_in(CONTEXT), _in(SOLVER), _in(AST), _in(AST))) +*) +external solver_assert_and_track : context -> solver -> ast -> ast -> unit + = "camlidl_z3_Z3_solver_assert_and_track" + (** Summary: Return the set of asserted formulas as a goal object. - - def_API('solver_get_assertions', AST_VECTOR, (_in(CONTEXT), _in(SOLVER))) + def_API('solver_get_assertions', AST_VECTOR, (_in(CONTEXT), _in(SOLVER))) *) external solver_get_assertions : context -> solver -> ast_vector = "camlidl_z3_Z3_solver_get_assertions" (** Summary: Check whether the assertions in a given solver are consistent or not. - The function {!solver_get_model} retrieves a model if the assertions are not unsatisfiable (i.e., the result is not \c L_FALSE) and model construction is enabled. - The function {!solver_get_proof} retrieves a proof if proof - generation was enabled when the context was created, and the + generation was enabled when the context was created, and the assertions are unsatisfiable (i.e., the result is [L_FALSE)]. - def_API('solver_check', INT, (_in(CONTEXT), _in(SOLVER))) *) external solver_check : context -> solver -> lbool @@ -5898,12 +4916,9 @@ external solver_check : context -> solver -> lbool (** Summary: Check whether the assertions in the given solver and optional assumptions are consistent or not. - - The function {!solver_get_unsat_core} retrieves the subset of the + The function {!solver_get_unsat_core} retrieves the subset of the assumptions used in the unsatisfiability proof produced by Z3. - - {b See also}: {!solver_check} - def_API('solver_check_assumptions', INT, (_in(CONTEXT), _in(SOLVER), _in(UINT), _in_array(2, AST))) *) external solver_check_assumptions : context -> solver -> ast array -> lbool @@ -5911,10 +4926,8 @@ external solver_check_assumptions : context -> solver -> ast array -> lbool (** Summary: Retrieve the model for the last {!solver_check} or {!solver_check_assumptions} - - The error handler is invoked if a model is not available because + The error handler is invoked if a model is not available because the commands above were not invoked for the given solver, or if the result was [L_FALSE]. - def_API('solver_get_model', MODEL, (_in(CONTEXT), _in(SOLVER))) *) external solver_get_model : context -> solver -> model @@ -5922,11 +4935,9 @@ external solver_get_model : context -> solver -> model (** Summary: Retrieve the proof for the last {!solver_check} or {!solver_check_assumptions} - The error handler is invoked if proof generation is not enabled, or if the commands above were not invoked for the given solver, or if the result was different from [L_FALSE]. - def_API('solver_get_proof', AST, (_in(CONTEXT), _in(SOLVER))) *) external solver_get_proof : context -> solver -> ast @@ -5935,7 +4946,6 @@ external solver_get_proof : context -> solver -> ast (** Summary: Retrieve the unsat core for the last {!solver_check_assumptions} The unsat core is a subset of the assumptions [a]. - def_API('solver_get_unsat_core', AST_VECTOR, (_in(CONTEXT), _in(SOLVER))) *) external solver_get_unsat_core : context -> solver -> ast_vector @@ -5944,7 +4954,6 @@ external solver_get_unsat_core : context -> solver -> ast_vector (** Summary: Return a brief justification for an "unknown" result (i.e., L_UNDEF) for the commands {!solver_check} and {!solver_check_assumptions} - def_API('solver_get_reason_unknown', STRING, (_in(CONTEXT), _in(SOLVER))) *) external solver_get_reason_unknown : context -> solver -> string @@ -5952,9 +4961,6 @@ external solver_get_reason_unknown : context -> solver -> string (** Summary: Return statistics for the given solver. - - - def_API('solver_get_statistics', STATS, (_in(CONTEXT), _in(SOLVER))) *) external solver_get_statistics : context -> solver -> stats @@ -5962,7 +4968,6 @@ external solver_get_statistics : context -> solver -> stats (** Summary: Convert a solver into a string. - def_API('solver_to_string', STRING, (_in(CONTEXT), _in(SOLVER))) *) external solver_to_string : context -> solver -> string @@ -5976,25 +4981,23 @@ type stat_datum = Stat_int of int | Stat_float of float type stats_refined = (string, stat_datum) Hashtbl.t -(** +(** Summary: [stats_refine c s] is the refined stats of [s]. *) val stats_refine : context -> stats -> stats_refined (** Summary: Convert a statistics into a string. - def_API('stats_to_string', STRING, (_in(CONTEXT), _in(STATS))) *) external stats_to_string : context -> stats -> string = "camlidl_z3_Z3_stats_to_string" (** - {4 {L Low-level API}} + {4 {L Low-level API}} *) (** Summary: Return the number of statistical data in [s]. - def_API('stats_size', UINT, (_in(CONTEXT), _in(STATS))) *) external stats_size : context -> stats -> int @@ -6002,9 +5005,7 @@ external stats_size : context -> stats -> int (** Summary: Return the key (a string) for a particular statistical data. - - {b Precondition}: idx < stats_size c s - def_API('stats_get_key', STRING, (_in(CONTEXT), _in(STATS), _in(UINT))) *) external stats_get_key : context -> stats -> int -> string @@ -6012,9 +5013,7 @@ external stats_get_key : context -> stats -> int -> string (** Summary: Return TRUE if the given statistical data is a unsigned int integer. - - {b Precondition}: idx < stats_size c s - def_API('stats_is_uint', BOOL, (_in(CONTEXT), _in(STATS), _in(UINT))) *) external stats_is_uint : context -> stats -> int -> bool @@ -6022,9 +5021,7 @@ external stats_is_uint : context -> stats -> int -> bool (** Summary: Return TRUE if the given statistical data is a double. - - {b Precondition}: idx < stats_size c s - def_API('stats_is_double', BOOL, (_in(CONTEXT), _in(STATS), _in(UINT))) *) external stats_is_double : context -> stats -> int -> bool @@ -6032,9 +5029,7 @@ external stats_is_double : context -> stats -> int -> bool (** Summary: Return the unsigned int value of the given statistical data. - - {b Precondition}: idx < stats_size c s && stats_is_uint c s - def_API('stats_get_uint_value', UINT, (_in(CONTEXT), _in(STATS), _in(UINT))) *) external stats_get_uint_value : context -> stats -> int -> int @@ -6042,25 +5037,22 @@ external stats_get_uint_value : context -> stats -> int -> int (** Summary: Return the double value of the given statistical data. - - {b Precondition}: idx < stats_size c s && stats_is_double c s - def_API('stats_get_double_value', DOUBLE, (_in(CONTEXT), _in(STATS), _in(UINT))) *) external stats_get_double_value : context -> stats -> int -> float = "camlidl_z3_Z3_stats_get_double_value" -(** - {2 {L Legacy V3 API}} -*) - +(** + {2 {L Legacy V3 API}} +*) module V3 : sig -(** - {2 {L Legacy V3 API}} -*) +(** + {2 {L Legacy V3 API}} +*) -(* File generated from z3.idl *) +(* File generated from z3V3.idl *) type symbol and literals @@ -6296,24 +5288,17 @@ and ast_print_mode = (** - - *) (** {2 {L Types}} - - - Most of the types in the API are abstract. - - + Most of the types in the API are abstract. - [context]: manager of all other Z3 objects, global configuration options, etc. - - [symbol]: Lisp-like symbol used to name types, constants, and functions. A symbol can be created using string or integers. + - [symbol]: Lisp-like symbol used to name types, constants, and functions. A symbol can be created using string or integers. - [ast]: abstract syntax tree node. That is, the data-structure used in Z3 to represent terms, formulas and types. - [sort]: kind of AST used to represent types. - [func_decl]: kind of AST used to represent function symbols. - [app]: kind of AST used to represent function applications. - [pattern]: kind of AST used to represent pattern and multi-patterns used to guide quantifier instantiation. - - [params]: parameter set used to configure many components such as: simplifiers, tactics, solvers, etc. - [model]: model for the constraints asserted into the logical context. - [func_interp]: interpretation of a function in a model. @@ -6329,23 +5314,21 @@ and ast_print_mode = - [stats]: statistical data for a solver. *) (** - {!lbool} + {!lbool} Lifted Boolean type: [false], [undefined], [true]. *) (** - {!symbol_kind} + {!symbol_kind} The different kinds of symbol. In Z3, a symbol can be represented using integers and strings (See {!get_symbol_kind}). - - {b See also}: {!mk_int_symbol} - {b See also}: {!mk_string_symbol} *) (** - {!parameter_kind} + {!parameter_kind} The different kinds of parameters that can be associated with function symbols. - {b See also}: {!get_decl_num_parameters} - {b See also}: {!get_decl_parameter_kind} - - PARAMETER_INT is used for integer parameters. - PARAMETER_DOUBLE is used for double parameters. - PARAMETER_RATIONAL is used for parameters that are rational numbers. @@ -6355,23 +5338,23 @@ and ast_print_mode = - PARAMETER_FUNC_DECL is used for function declaration parameters. *) (** - {!sort_kind} + {!sort_kind} The different kinds of Z3 types (See {!get_sort_kind}). *) (** - {!ast_kind} + {!ast_kind} The different kinds of Z3 AST (abstract syntax trees). That is, terms, formulas and types. - - APP_AST: constant and applications - - NUMERAL_AST: numeral constants - - VAR_AST: bound variables - - QUANTIFIER_AST: quantifiers - - SORT_AST: sort - - FUNC_DECL_AST: function declaration - - UNKNOWN_AST: internal + - APP_AST: constant and applications + - NUMERAL_AST: numeral constants + - VAR_AST: bound variables + - QUANTIFIER_AST: quantifiers + - SORT_AST: sort + - FUNC_DECL_AST: function declaration + - UNKNOWN_AST: internal *) (** - {!decl_kind} + {!decl_kind} The different kinds of interpreted function kinds. - OP_TRUE The constant true. @@ -6436,9 +5419,9 @@ and ast_print_mode = - OP_POWER Power operator x^y. - OP_STORE Array store. It satisfies select(store(a,i,v),j) = if i = j then v else select(a,j). - Array store takes at least 3 arguments. + Array store takes at least 3 arguments. - - OP_SELECT Array select. + - OP_SELECT Array select. - OP_CONST_ARRAY The constant array. For example, select(const(v),i) = v holds for every v and i. The function is unary. @@ -6473,7 +5456,7 @@ and ast_print_mode = - OP_BSUB Binary subtraction. - OP_BMUL Binary multiplication. - + - OP_BSDIV Binary signed division. - OP_BUDIV Binary unsigned int division. @@ -6493,16 +5476,16 @@ and ast_print_mode = - OP_BUREM0 Unary function. burem(x,0) is congruent to burem0(x). - OP_BSMOD0 Unary function. bsmod(x,0) is congruent to bsmod0(x). - + - OP_ULEQ Unsigned bit-vector <= - Binary relation. - - OP_SLEQ Signed bit-vector <= - Binary relation. + - OP_SLEQ Signed bit-vector <= - Binary relation. - - OP_UGEQ Unsigned bit-vector >= - Binary relation. + - OP_UGEQ Unsigned bit-vector >= - Binary relation. - - OP_SGEQ Signed bit-vector >= - Binary relation. + - OP_SGEQ Signed bit-vector >= - Binary relation. - - OP_ULT Unsigned bit-vector < - Binary relation. + - OP_ULT Unsigned bit-vector < - Binary relation. - OP_SLT Signed bit-vector < - Binary relation. @@ -6562,7 +5545,7 @@ and ast_print_mode = is not supported by the decision procedures. Only the most rudimentary simplification rules are applied to this function. - - OP_CARRY Compute the carry bit in a full-adder. + - OP_CARRY Compute the carry bit in a full-adder. The meaning is given by the equivalence (carry l1 l2 l3) <=> (or (and l1 l2) (and l1 l3) (and l2 l3))) @@ -6575,7 +5558,7 @@ and ast_print_mode = - OP_PR_TRUE: Proof for the expression 'true'. - OP_PR_ASSERTED: Proof for a fact asserted by the user. - + - OP_PR_GOAL: Proof for a fact (tagged as goal) asserted by the user. - OP_PR_MODUS_PONENS: Given a proof for p and a proof for (implies p q), produces a proof for q. @@ -6587,7 +5570,7 @@ and ast_print_mode = The second antecedents may also be a proof for (iff p q). - OP_PR_REFLEXIVITY: A proof for (R t t), where R is a reflexive relation. This proof object has no antecedents. - The only reflexive relations that are used are + The only reflexive relations that are used are equivalence modulo namings, equality and equivalence. That is, R is either '~', '=' or 'iff'. @@ -6607,7 +5590,7 @@ and ast_print_mode = } - OP_PR_TRANSITIVITY_STAR: Condensed transitivity proof. This proof object is only used if the parameter PROOF_MODE is 1. - It combines several symmetry and transitivity proofs. + It combines several symmetry and transitivity proofs. Example: {e @@ -6620,7 +5603,7 @@ and ast_print_mode = Assuming that this proof object is a proof for (R s t), then a proof checker must check if it is possible to prove (R s t) - using the antecedents, symmetry and transitivity. That is, + using the antecedents, symmetry and transitivity. That is, if there is a path from s to t, if we view every antecedent (R a b) as an edge between a and b. @@ -6638,8 +5621,8 @@ and ast_print_mode = T1: (~ p q) [quant-intro T1]: (~ (forall (x) p) (forall (x) q)) - - - OP_PR_DISTRIBUTIVITY: Distributivity proof object. + + - OP_PR_DISTRIBUTIVITY: Distributivity proof object. Given that f (= or) distributes over g (= and), produces a proof for (= (f a (g c d)) @@ -6653,11 +5636,11 @@ and ast_print_mode = where each f and g can have arbitrary number of arguments. This proof object has no antecedents. - Remark. This rule is used by the CNF conversion pass and + Remark. This rule is used by the CNF conversion pass and instantiated by f = or, and g = and. - + - OP_PR_AND_ELIM: Given a proof for (and l_1 ... l_n), produces a proof for l_i - + {e T1: (and l_1 ... l_n) [and-elim T1]: l_i @@ -6673,10 +5656,10 @@ and ast_print_mode = The head function symbol of t is interpreted. This proof object has no antecedents. - The conclusion of a rewrite rule is either an equality (= t s), + The conclusion of a rewrite rule is either an equality (= t s), an equivalence (iff t s), or equi-satisfiability (~ t s). Remark: if f is bool, then = is iff. - + Examples: {e @@ -6698,22 +5681,22 @@ and ast_print_mode = - OP_PR_PULL_QUANT: A proof for (iff (f (forall (x) q(x)) r) (forall (x) (f (q x) r))). This proof object has no antecedents. - OP_PR_PULL_QUANT_STAR: A proof for (iff P Q) where Q is in prenex normal form. - This proof object is only used if the parameter PROOF_MODE is 1. + This proof object is only used if the parameter PROOF_MODE is 1. This proof object has no antecedents. - + - OP_PR_PUSH_QUANT: A proof for: {e (iff (forall (x_1 ... x_m) (and p_1[x_1 ... x_m] ... p_n[x_1 ... x_m])) (and (forall (x_1 ... x_m) p_1[x_1 ... x_m]) - ... + ... (forall (x_1 ... x_m) p_n[x_1 ... x_m]))) } This proof object has no antecedents. - - OP_PR_ELIM_UNUSED_VARS: + - OP_PR_ELIM_UNUSED_VARS: A proof for (iff (forall (x_1 ... x_n y_1 ... y_m) p[x_1 ... x_n]) - (forall (x_1 ... x_n) p[x_1 ... x_n])) + (forall (x_1 ... x_n) p[x_1 ... x_n])) It is used to justify the elimination of unused variables. This proof object has no antecedents. @@ -6723,14 +5706,14 @@ and ast_print_mode = if x does not occur in t. This proof object has no antecedents. - + Several variables can be eliminated simultaneously. - OP_PR_QUANT_INST: A proof of (or (not (forall (x) (P x))) (P a)) - OP_PR_HYPOTHESIS: Mark a hypothesis in a natural deduction style proof. - - OP_PR_LEMMA: + - OP_PR_LEMMA: {e T1: false @@ -6740,16 +5723,16 @@ and ast_print_mode = It converts the proof in a proof for (or (not l_1) ... (not l_n)), when T1 contains the hypotheses: l_1, ..., l_n. - - OP_PR_UNIT_RESOLUTION: + - OP_PR_UNIT_RESOLUTION: {e - T1: (or l_1 ... l_n l_1' ... l_m') - T2: (not l_1) + T1: (or l_1 ... l_n l_1' ... l_m') + T2: (not l_1) ... - T(n+1): (not l_n) + T(n+1): (not l_n) [unit-resolution T1 ... T(n+1)]: (or l_1' ... l_m') } - - OP_PR_IFF_TRUE: + - OP_PR_IFF_TRUE: {e T1: p [iff-true T1]: (iff p true) @@ -6764,14 +5747,14 @@ and ast_print_mode = - OP_PR_COMMUTATIVITY: [comm]: (= (f a b) (f b a)) - + f is a commutative operator. This proof object has no antecedents. Remark: if f is bool, then = is iff. - + - OP_PR_DEF_AXIOM: Proof object used to justify Tseitin's like axioms: - + {e (or (not (and p q)) p) (or (not (and p q)) q) @@ -6800,7 +5783,7 @@ and ast_print_mode = You can recover the propositional tautologies by unfolding the Boolean connectives in the axioms a small bounded number of steps (=3). - + - OP_PR_DEF_INTRO: Introduces a name for a formula/term. Suppose e is an expression with free variables x, and def-intro introduces the name n(x). The possible cases are: @@ -6816,17 +5799,17 @@ and ast_print_mode = [def-intro]: (and (or (not cond) (= n th)) (or cond (= n el))) Otherwise: - [def-intro]: (= n e) + [def-intro]: (= n e) - - OP_PR_APPLY_DEF: + - OP_PR_APPLY_DEF: [apply-def T1]: F ~ n F is 'equivalent' to n, given that T1 is a proof that n is a name for F. - + - OP_PR_IFF_OEQ: T1: (iff p q) [iff~ T1]: (~ p q) - + - OP_PR_NNF_POS: Proof for a (positive) NNF step. Example: {e T1: (not s_1) ~ r_1 @@ -6841,7 +5824,7 @@ and ast_print_mode = The quantifier is retained (unless the bound variables are eliminated). Example {e - T1: q ~ q_new + T1: q ~ q_new [nnf-pos T1]: (~ (forall (x T) q) (forall (x T) q_new)) } (b) When recursively creating NNF over Boolean formulas, where the top-level @@ -6850,7 +5833,7 @@ and ast_print_mode = NNF_NEG furthermore handles the case where negation is pushed over Boolean connectives 'and' and 'or'. - + - OP_PR_NFF_NEG: Proof for a (negative) NNF step. Examples: {e T1: (not s_1) ~ r_1 @@ -6871,24 +5854,24 @@ and ast_print_mode = (and (or r_1 r_2) (or r_1' r_2'))) } - OP_PR_NNF_STAR: A proof for (~ P Q) where Q is in negation normal form. - - This proof object is only used if the parameter PROOF_MODE is 1. - + + This proof object is only used if the parameter PROOF_MODE is 1. + This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. - OP_PR_CNF_STAR: A proof for (~ P Q) where Q is in conjunctive normal form. - This proof object is only used if the parameter PROOF_MODE is 1. - This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. + This proof object is only used if the parameter PROOF_MODE is 1. + This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO. + + - OP_PR_SKOLEMIZE: Proof for: - - OP_PR_SKOLEMIZE: Proof for: - {e [sk]: (~ (not (forall x (p x y))) (not (p (sk y) y))) [sk]: (~ (exists x (p x y)) (p (sk y) y)) } This proof object has no antecedents. - + - OP_PR_MODUS_PONENS_OEQ: Modus ponens style rule for equi-satisfiability. {e T1: p @@ -6901,9 +5884,9 @@ and ast_print_mode = The theory lemma function comes with one or more parameters. The first parameter indicates the name of the theory. For the theory of arithmetic, additional parameters provide hints for - checking the theory lemma. + checking the theory lemma. The hints for arithmetic are: - + - farkas - followed by rational coefficients. Multiply the coefficients to the inequalities in the lemma, add the (negated) inequalities and obtain a contradiction. @@ -6934,7 +5917,7 @@ and ast_print_mode = {e (=> (and ln+1 ln+2 .. ln+m) (or l0 l1 .. ln-1)) } - In other words we use the following (Prolog style) convention for Horn + In other words we use the following (Prolog style) convention for Horn implications: The head of a Horn implication is position 0, the first conjunct in the body of an implication is position 1 @@ -6957,16 +5940,16 @@ and ast_print_mode = - OP_RA_STORE: Insert a record into a relation. - The function takes [n+1] arguments, where the first argument is the relation and the remaining [n] elements + The function takes [n+1] arguments, where the first argument is the relation and the remaining [n] elements correspond to the [n] columns of the relation. - - OP_RA_EMPTY: Creates the empty relation. - + - OP_RA_EMPTY: Creates the empty relation. + - OP_RA_IS_EMPTY: Tests if the relation is empty. - OP_RA_JOIN: Create the relational join. - - OP_RA_UNION: Create the union or convex hull of two relations. + - OP_RA_UNION: Create the union or convex hull of two relations. The function takes two arguments. - OP_RA_WIDEN: Widen two relations. @@ -6976,7 +5959,7 @@ and ast_print_mode = The function takes one argument. - OP_RA_FILTER: Filter (restrict) a relation with respect to a predicate. - The first argument is a relation. + The first argument is a relation. The second argument is a predicate with free de-Brujin indices corresponding to the columns of the relation. So the first column in the relation has index 0. @@ -6991,23 +5974,23 @@ and ast_print_mode = target are elements in x in pos, such that there is no y in neg that agrees with x on the columns c1, d1, .., cN, dN. - - - OP_RA_RENAME: rename columns in the relation. + + - OP_RA_RENAME: rename columns in the relation. The function takes one argument. The parameters contain the renaming as a cycle. - + - OP_RA_COMPLEMENT: Complement the relation. - OP_RA_SELECT: Check if a record is an element of the relation. The function takes [n+1] arguments, where the first argument is a relation, and the remaining [n] arguments correspond to a record. - - OP_RA_CLONE: Create a fresh copy (clone) of a relation. + - OP_RA_CLONE: Create a fresh copy (clone) of a relation. The function is logically the identity, but in the context of a register machine allows - for [OP_RA_UNION] + for [OP_RA_UNION] to perform destructive updates to the first argument. - + - OP_FD_LT: A less than predicate over the finite domain FINITE_DOMAIN_SORT. @@ -7027,10 +6010,10 @@ and ast_print_mode = - OP_UNINTERPRETED: kind used for uninterpreted symbols. *) (** - {!param_kind} + {!param_kind} The different kinds of parameters that can be associated with parameter sets. - (see {!mk_params}). + (see {!mk_params}). - PK_UINT integer parameters. - PK_BOOL boolean parameters. @@ -7041,77 +6024,128 @@ and ast_print_mode = - PK_INVALID invalid parameter. *) (** - {!search_failure} + {!search_failure} The different kinds of search failure types. - - NO_FAILURE: The last search was successful - - UNKNOWN: Undocumented failure reason - - TIMEOUT: Timeout - - MEMOUT_WATERMAK: Search hit a memory high-watermak limit - - CANCELED: External cancel flag was set - - NUM_CONFLICTS: Maximum number of conflicts was reached - - THEORY: Theory is incomplete - - QUANTIFIERS: Logical context contains universal quantifiers + - NO_FAILURE: The last search was successful + - UNKNOWN: Undocumented failure reason + - TIMEOUT: Timeout + - MEMOUT_WATERMAK: Search hit a memory high-watermak limit + - CANCELED: External cancel flag was set + - NUM_CONFLICTS: Maximum number of conflicts was reached + - THEORY: Theory is incomplete + - QUANTIFIERS: Logical context contains universal quantifiers *) (** - {!ast_print_mode} + {!ast_print_mode} Z3 pretty printing modes (See {!set_ast_print_mode}). - - PRINT_SMTLIB_FULL: Print AST nodes in SMTLIB verbose format. - - PRINT_LOW_LEVEL: Print AST nodes using a low-level format. + - PRINT_SMTLIB_FULL: Print AST nodes in SMTLIB verbose format. + - PRINT_LOW_LEVEL: Print AST nodes using a low-level format. - PRINT_SMTLIB_COMPLIANT: Print AST nodes in SMTLIB 1.x compliant format. - PRINT_SMTLIB2_COMPLIANT: Print AST nodes in SMTLIB 2.x compliant format. *) (** Definitions for update_api.py - - def_Type('CONFIG', 'config', 'Config') - def_Type('CONTEXT', 'context', 'ContextObj') - def_Type('AST', 'ast', 'Ast') - def_Type('APP', 'app', 'Ast') - def_Type('SORT', 'sort', 'Sort') - def_Type('FUNC_DECL', 'func_decl', 'FuncDecl') - def_Type('PATTERN', 'pattern', 'Pattern') - def_Type('MODEL', 'model', 'Model') - def_Type('LITERALS', 'literals', 'Literals') - def_Type('CONSTRUCTOR', 'constructor', 'Constructor') + def_Type('CONFIG', 'config', 'Config') + def_Type('CONTEXT', 'context', 'ContextObj') + def_Type('AST', 'ast', 'Ast') + def_Type('APP', 'app', 'Ast') + def_Type('SORT', 'sort', 'Sort') + def_Type('FUNC_DECL', 'func_decl', 'FuncDecl') + def_Type('PATTERN', 'pattern', 'Pattern') + def_Type('MODEL', 'model', 'Model') + def_Type('LITERALS', 'literals', 'Literals') + def_Type('CONSTRUCTOR', 'constructor', 'Constructor') def_Type('CONSTRUCTOR_LIST', 'constructor_list', 'ConstructorList') - def_Type('THEORY', 'theory', 'ctypes.c_void_p') - def_Type('THEORY_DATA', 'theory_data', 'ctypes.c_void_p') - def_Type('SOLVER', 'solver', 'SolverObj') - def_Type('GOAL', 'goal', 'GoalObj') - def_Type('TACTIC', 'tactic', 'TacticObj') - def_Type('PARAMS', 'params', 'Params') - def_Type('PROBE', 'probe', 'ProbeObj') - def_Type('STATS', 'stats', 'StatsObj') - def_Type('AST_VECTOR', 'ast_vector', 'AstVectorObj') - def_Type('AST_MAP', 'ast_map', 'AstMapObj') - def_Type('APPLY_RESULT', 'apply_result', 'ApplyResultObj') - def_Type('FUNC_INTERP', 'func_interp', 'FuncInterpObj') - def_Type('FUNC_ENTRY', 'func_entry', 'FuncEntryObj') - def_Type('FIXEDPOINT', 'fixedpoint', 'FixedpointObj') - def_Type('PARAM_DESCRS', 'param_descrs', 'ParamDescrs') + def_Type('THEORY', 'theory', 'ctypes.c_void_p') + def_Type('THEORY_DATA', 'theory_data', 'ctypes.c_void_p') + def_Type('SOLVER', 'solver', 'SolverObj') + def_Type('GOAL', 'goal', 'GoalObj') + def_Type('TACTIC', 'tactic', 'TacticObj') + def_Type('PARAMS', 'params', 'Params') + def_Type('PROBE', 'probe', 'ProbeObj') + def_Type('STATS', 'stats', 'StatsObj') + def_Type('AST_VECTOR', 'ast_vector', 'AstVectorObj') + def_Type('AST_MAP', 'ast_map', 'AstMapObj') + def_Type('APPLY_RESULT', 'apply_result', 'ApplyResultObj') + def_Type('FUNC_INTERP', 'func_interp', 'FuncInterpObj') + def_Type('FUNC_ENTRY', 'func_entry', 'FuncEntryObj') + def_Type('FIXEDPOINT', 'fixedpoint', 'FixedpointObj') + def_Type('PARAM_DESCRS', 'param_descrs', 'ParamDescrs') *) +(** + {2 {L Configuration}} +*) +(** + Summary: Set a global (or module) parameter. + This setting is shared by all Z3 contexts. + When a Z3 module is initialized it will use the value of these parameters + when params objects are not provided. + The name of parameter can be composed of characters [a-z][A-Z], digits [0-9], '-' and '_'. + The character '.' is a delimiter (more later). + The parameter names are case-insensitive. The character '-' should be viewed as an "alias" for '_'. + Thus, the following parameter names are considered equivalent: "pp.decimal-precision" and "PP.DECIMAL_PRECISION". + This function can be used to set parameters for a specific Z3 module. + This can be done by using .. + For example: + global_param_set('pp.decimal', 'true') + will set the parameter "decimal" in the module "pp" to true. + def_API('global_param_set', VOID, (_in(STRING), _in(STRING))) +*) +external global_param_set : string -> string -> unit + = "camlidl_z3V3_Z3_global_param_set" + +(** + Summary: Restore the value of all global (and module) parameters. + This command will not affect already created objects (such as tactics and solvers). + - {b See also}: {!global_param_set} + def_API('global_param_reset_all', VOID, ()) +*) +external global_param_reset_all : unit -> unit + = "camlidl_z3V3_Z3_global_param_reset_all" + +(** + Summary: Get a global (or module) parameter. + Returns [None] + if the parameter value does not exist. + - {b See also}: {!global_param_set} + The caller must invoke {!global_param_del_value} to delete the value returned at [param_value]. + - {b Remarks}: This function cannot be invoked simultaneously from different threads without synchronization. + The result string stored in param_value is stored in shared location. + def_API('global_param_get', BOOL, (_in(STRING), _out(STRING))) +*) +external global_param_get : string -> string option + = "camlidl_z3V3_Z3_global_param_get" + (** {2 {L Create configuration}} *) (** - Summary: Create a configuration. - - Configurations are created in order to assign parameters prior to creating - contexts for Z3 interaction. For example, if the users wishes to use model + Summary: Create a configuration object for the Z3 context object. + Configurations are created in order to assign parameters prior to creating + contexts for Z3 interaction. For example, if the users wishes to use proof generation, then call: - - [set_param_value cfg "MODEL" "true"] - + [set_param_value cfg "proof" "true"] - {b Remarks}: Consider using {!mk_context_x} instead of using explicit configuration objects. The function {!mk_context_x} receives an array of string pairs. This array represents the - configuration options. - + configuration options. + - {b Remarks}: In previous versions of Z3, the [config] was used to store + global and module configurations. Now, we should use [global_param_set]. + The following parameters can be set: + - proof (Boolean) Enable proof generation + - debug_ref_count (Boolean) Enable debug support for ast reference counting + - trace (Boolean) Tracing support for VCC + - trace_file_name (String) Trace out file for VCC traces + - timeout (unsigned) default timeout (in milliseconds) used for solvers + - well_sorted_check type checker + - auto_config use heuristics to automatically select solver and configure it + - model model generation for solvers, this parameter can be overwritten when creating a solver + - model_validate validate models produced by solvers + - unsat_core unsat-core generation for solvers, this parameter can be overwritten when creating a solver - {b See also}: {!set_param_value} - {b See also}: {!del_config} - def_API('mk_config', CONFIG, ()) *) external mk_config : unit -> config @@ -7119,9 +6153,7 @@ external mk_config : unit -> config (** Summary: Delete the given configuration object. - - {b See also}: {!mk_config} - def_API('del_config', VOID, (_in(CONFIG),)) *) external del_config : config -> unit @@ -7129,15 +6161,8 @@ external del_config : config -> unit (** Summary: Set a configuration parameter. - - The list of all configuration parameters can be obtained using the Z3 executable: - - {v - z3.exe -ini? - v} - + The following parameters can be set for - {b See also}: {!mk_config} - def_API('set_param_value', VOID, (_in(CONFIG), _in(STRING), _in(STRING))) *) external set_param_value : config -> string -> string -> unit @@ -7147,16 +6172,10 @@ external set_param_value : config -> string -> string -> unit {2 {L Create context}} *) (** - Summary: Create a context using the given configuration. - + Summary: Create a context using the given configuration. After a context is created, the configuration cannot be changed, although some parameters can be changed using {!update_param_value}. All main interaction with Z3 happens in the context of a [context]. - - - - - def_API('mk_context', CONTEXT, (_in(CONFIG),)) *) external mk_context : config -> context @@ -7164,44 +6183,23 @@ external mk_context : config -> context (** Summary: Delete the given logical context. - - {b See also}: {!mk_context} - def_API('del_context', VOID, (_in(CONTEXT),)) *) external del_context : context -> unit = "camlidl_z3V3_Z3_del_context" (** - Summary: Update a mutable configuration parameter. - - The list of all configuration parameters can be obtained using the Z3 executable: - - {v - z3.exe -ini? - v} - - Only a few configuration parameters are mutable once the context is created. - The error handler is invoked when trying to modify an immutable parameter. - - - - {b See also}: {!mk_context } - + Summary: Set a value of a context parameter. + - {b See also}: {!global_param_set} def_API('update_param_value', VOID, (_in(CONTEXT), _in(STRING), _in(STRING))) *) external update_param_value : context -> string -> string -> unit = "camlidl_z3V3_Z3_update_param_value" (** - Summary: Get a configuration parameter. - - Returns [None] - if the parameter value does not exist. - - - - - {b See also}: {!mk_context } - + Summary: Return the value of a context parameter. + - {b See also}: {!global_param_get} def_API('get_param_value', BOOL, (_in(CONTEXT), _in(STRING), _out(STRING))) *) external get_param_value : context -> string -> string option @@ -7211,18 +6209,14 @@ external get_param_value : context -> string -> string option {2 {L Symbols}} *) (** - {4 {L Redundant low-level API}} + {4 {L Redundant low-level API}} *) (** Summary: Create a Z3 symbol using an integer. - Symbols are used to name several term and type constructors. - NB. Not all integers can be passed to this function. The legal range of unsigned int integers is 0 to 2^30-1. - - {b See also}: {!mk_string_symbol} - def_API('mk_int_symbol', SYMBOL, (_in(CONTEXT), _in(INT))) *) external mk_int_symbol : context -> int -> symbol @@ -7230,11 +6224,8 @@ external mk_int_symbol : context -> int -> symbol (** Summary: Create a Z3 symbol using a C string. - Symbols are used to name several term and type constructors. - - {b See also}: {!mk_int_symbol} - def_API('mk_string_symbol', SYMBOL, (_in(CONTEXT), _in(STRING))) *) external mk_string_symbol : context -> string -> symbol @@ -7244,23 +6235,19 @@ external mk_string_symbol : context -> string -> symbol {2 {L Sorts}} *) (** - {4 {L Redundant low-level API}} + {4 {L Redundant low-level API}} *) (** Summary: Create a free (uninterpreted) type using the given name (symbol). - Two free types are considered the same iff the have the same name. - def_API('mk_uninterpreted_sort', SORT, (_in(CONTEXT), _in(SYMBOL))) *) external mk_uninterpreted_sort : context -> symbol -> sort = "camlidl_z3V3_Z3_mk_uninterpreted_sort" (** - Summary: Create the Boolean type. - + Summary: Create the Boolean type. This type is used to create propositional variables and predicates. - def_API('mk_bool_sort', SORT, (_in(CONTEXT), )) *) external mk_bool_sort : context -> sort @@ -7268,24 +6255,19 @@ external mk_bool_sort : context -> sort (** Summary: Create the integer type. - This type is not the int type found in programming languages. A machine integer can be represented using bit-vectors. The function {!mk_bv_sort} creates a bit-vector type. - - {b See also}: {!mk_bv_sort} - def_API('mk_int_sort', SORT, (_in(CONTEXT), )) *) external mk_int_sort : context -> sort = "camlidl_z3V3_Z3_mk_int_sort" (** - Summary: Create the real type. - + Summary: Create the real type. This type is not a floating point number. Z3 does not have support for floating point numbers yet. - def_API('mk_real_sort', SORT, (_in(CONTEXT), )) *) external mk_real_sort : context -> sort @@ -7293,11 +6275,8 @@ external mk_real_sort : context -> sort (** Summary: Create a bit-vector type of the given size. - This type can also be seen as a machine integer. - - {b Remarks}: The size of the bitvector type must be greater than zero. - def_API('mk_bv_sort', SORT, (_in(CONTEXT), _in(UINT))) *) external mk_bv_sort : context -> int -> sort @@ -7305,27 +6284,21 @@ external mk_bv_sort : context -> int -> sort (** Summary: Create a named finite domain sort. - - To create constants that belong to the finite domain, + To create constants that belong to the finite domain, use the APIs for creating numerals and pass a numeric constant together with the sort returned by this call. - - - {b See also}: {!get_finite_domain_sort_size.} - + - {b See also}: {!get_finite_domain_sort_size} def_API('mk_finite_domain_sort', SORT, (_in(CONTEXT), _in(SYMBOL), _in(UINT64))) *) external mk_finite_domain_sort : context -> symbol -> int64 -> sort = "camlidl_z3V3_Z3_mk_finite_domain_sort" (** - Summary: Create an array type. - + Summary: Create an array type. We usually represent the array type as: {e [domain -> range] }. Arrays are usually used to model the heap/memory in software verification. - - {b See also}: {!mk_select} - {b See also}: {!mk_store} - def_API('mk_array_sort', SORT, (_in(CONTEXT), _in(SORT), _in(SORT))) *) external mk_array_sort : context -> sort -> sort -> sort @@ -7333,14 +6306,8 @@ external mk_array_sort : context -> sort -> sort -> sort (** Summary: Create a tuple type. - [mk_tuple_sort c name field_names field_sorts] creates a tuple with a constructor named [name], a [n] fields, where [n] is the size of the arrays [field_names] and [field_sorts]. - - - - - @param c logical context @param mk_tuple_name name of the constructor function associated with the tuple type. @param num_fields number of fields in the tuple type. @@ -7348,7 +6315,6 @@ external mk_array_sort : context -> sort -> sort -> sort @param field_sorts type of the tuple fields. @param mk_tuple_decl output parameter that will contain the constructor declaration. @param proj_decl output parameter that will contain the projection function declarations. This field must be a buffer of size [num_fields] allocated by the user. - def_API('mk_tuple_sort', SORT, (_in(CONTEXT), _in(SYMBOL), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _out(FUNC_DECL), _out_array(2, FUNC_DECL))) *) external mk_tuple_sort : context -> symbol -> symbol array -> sort array -> sort * func_decl * func_decl array @@ -7356,28 +6322,20 @@ external mk_tuple_sort : context -> symbol -> symbol array -> sort array -> sort (** Summary: Create a enumeration sort. - - [mk_enumeration_sort c enums] creates an enumeration sort with enumeration names [enums], + [mk_enumeration_sort c enums] creates an enumeration sort with enumeration names [enums], it also returns [n] predicates, where [n] is the number of [enums] corresponding to testing whether an element is one of the enumerants. - - - - - @param c logical context @param name name of the enumeration sort. @param n number of elemenets in enumeration sort. @param enum_names names of the enumerated elements. @param enum_consts constants corresponding to the enumerated elements. @param enum_testers predicates testing if terms of the enumeration sort correspond to an enumeration. - - For example, if this function is called with three symbols A, B, C and the name S, then - [s] is a sort whose name is S, and the function returns three terms corresponding to A, B, C in + For example, if this function is called with three symbols A, B, C and the name S, then + [s] is a sort whose name is S, and the function returns three terms corresponding to A, B, C in [enum_consts]. The array [enum_testers] has three predicates of type {e (s -> Bool) }. The first predicate (corresponding to A) is true when applied to A, and false otherwise. Similarly for the other predicates. - def_API('mk_enumeration_sort', SORT, (_in(CONTEXT), _in(SYMBOL), _in(UINT), _in_array(2, SYMBOL), _out_array(2, FUNC_DECL), _out_array(2, FUNC_DECL))) *) external mk_enumeration_sort : context -> symbol -> symbol array -> sort * func_decl array * func_decl array @@ -7385,13 +6343,7 @@ external mk_enumeration_sort : context -> symbol -> symbol array -> sort * func_ (** Summary: Create a list sort - [mk_list_sort c name elem_sort] creates a list sort of [name], over elements of sort [elem_sort]. - - - - - @param c logical context @param name name of the list sort. @param elem_sort sort of list elements. @@ -7401,7 +6353,6 @@ external mk_enumeration_sort : context -> symbol -> symbol array -> sort * func_ @param is_cons_decl cons cell test. @param head_decl list head. @param tail_decl list tail. - def_API('mk_list_sort', SORT, (_in(CONTEXT), _in(SYMBOL), _in(SORT), _out(FUNC_DECL), _out(FUNC_DECL), _out(FUNC_DECL), _out(FUNC_DECL), _out(FUNC_DECL), _out(FUNC_DECL))) *) external mk_list_sort : context -> symbol -> sort -> sort * func_decl * func_decl * func_decl * func_decl * func_decl * func_decl @@ -7409,44 +6360,38 @@ external mk_list_sort : context -> symbol -> sort -> sort * func_decl * func_dec (** Summary: Create a constructor. - @param c logical context. @param name constructor name. @param recognizer name of recognizer function. @param num_fields number of fields in constructor. @param field_names names of the constructor fields. - @param sorts field sorts, [None] + @param sorts field sorts, [None] if the field sort refers to a recursive sort. @param sort_refs reference to datatype sort that is an argument to the constructor; if the corresponding - sort reference is [None], - then the value in sort_refs should be an index referring to - one of the recursive datatypes that is declared. - + sort reference is [None], + then the value in sort_refs should be an index referring to + one of the recursive datatypes that is declared. def_API('mk_constructor', CONSTRUCTOR, (_in(CONTEXT), _in(SYMBOL), _in(SYMBOL), _in(UINT), _in_array(3, SYMBOL), _in_array(3, SORT), _in_array(3, UINT))) *) external mk_constructor : context -> symbol -> symbol -> symbol array -> sort array -> int array -> constructor - = "camlidl_z3_Z3_mk_constructor_bytecode" "camlidl_z3V3_Z3_mk_constructor" + = "camlidl_z3V3_Z3_mk_constructor_bytecode" "camlidl_z3V3_Z3_mk_constructor" (** Summary: Reclaim memory allocated to constructor. - @param c logical context. @param constr constructor. - def_API('del_constructor', VOID, (_in(CONTEXT), _in(CONSTRUCTOR))) *) external del_constructor : context -> constructor -> unit = "camlidl_z3V3_Z3_del_constructor" (** - Summary: Create datatype, such as lists, trees, records, enumerations or unions of records. + Summary: Create datatype, such as lists, trees, records, enumerations or unions of records. The datatype may be recursive. Return the datatype sort. - @param c logical context. - @param name name of datatype. + @param name name of datatype. @param num_constructors number of constructors passed in. @param constructors array of constructor containers. - def_API('mk_datatype', SORT, (_in(CONTEXT), _in(SYMBOL), _in(UINT), _inout_array(2, CONSTRUCTOR))) *) external mk_datatype : context -> symbol -> constructor array -> sort * constructor array @@ -7454,11 +6399,9 @@ external mk_datatype : context -> symbol -> constructor array -> sort * construc (** Summary: Create list of constructors. - @param c logical context. @param num_constructors number of constructors in list. @param constructors list of constructors. - def_API('mk_constructor_list', CONSTRUCTOR_LIST, (_in(CONTEXT), _in(UINT), _in_array(1, CONSTRUCTOR))) *) external mk_constructor_list : context -> constructor array -> constructor_list @@ -7466,12 +6409,9 @@ external mk_constructor_list : context -> constructor array -> constructor_list (** Summary: Reclaim memory allocated for constructor list. - Each constructor inside the constructor list must be independently reclaimed using {!del_constructor}. - @param c logical context. @param clist constructor list container. - def_API('del_constructor_list', VOID, (_in(CONTEXT), _in(CONSTRUCTOR_LIST))) *) external del_constructor_list : context -> constructor_list -> unit @@ -7479,28 +6419,24 @@ external del_constructor_list : context -> constructor_list -> unit (** Summary: Create mutually recursive datatypes. - @param c logical context. @param num_sorts number of datatype sorts. @param sort_names names of datatype sorts. - @param sorts array of datattype sorts. + @param sorts array of datatype sorts. @param constructor_lists list of constructors, one list per sort. - def_API('mk_datatypes', VOID, (_in(CONTEXT), _in(UINT), _in_array(1, SYMBOL), _out_array(1, SORT), _inout_array(1, CONSTRUCTOR_LIST))) *) external mk_datatypes : context -> symbol array -> constructor_list array -> sort array * constructor_list array = "camlidl_z3V3_Z3_mk_datatypes" (** - Summary: Query constructor for declared functions. - + Summary: Query constructor for declared functions. @param c logical context. @param constr constructor container. The container must have been passed in to a {!mk_datatype} call. @param num_fields number of accessor fields in the constructor. @param constructor constructor function declaration. @param tester constructor test function declaration. @param accessors array of accessor function declarations. - def_API('query_constructor', VOID, (_in(CONTEXT), _in(CONSTRUCTOR), _in(UINT), _out(FUNC_DECL), _out(FUNC_DECL), _out_array(2, FUNC_DECL))) *) external query_constructor : context -> constructor -> int -> func_decl * func_decl * func_decl array @@ -7511,22 +6447,17 @@ external query_constructor : context -> constructor -> int -> func_decl * func_d *) (** Summary: Declare a constant or function. - [mk_func_decl c n d r] creates a function with name [n], domain [d], and range [r]. - The arity of the function is the size of the array [d]. - + The arity of the function is the size of the array [d]. @param c logical context. @param s name of the constant or function. @param domain_size number of arguments. It is 0 when declaring a constant. @param domain array containing the sort of each argument. The array must contain domain_size elements. It is 0 when declaring a constant. @param range sort of the constant or the return sort of the function. - After declaring a constant or function, the function {!mk_app} can be used to create a constant or function application. - - {b See also}: {!mk_app} - def_API('mk_func_decl', FUNC_DECL, (_in(CONTEXT), _in(SYMBOL), _in(UINT), _in_array(2, SORT), _in(SORT))) *) external mk_func_decl : context -> symbol -> sort array -> sort -> func_decl @@ -7534,9 +6465,7 @@ external mk_func_decl : context -> symbol -> sort array -> sort -> func_decl (** Summary: Create a constant or function application. - - {b See also}: {!mk_func_decl} - def_API('mk_app', AST, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT), _in_array(2, AST))) *) external mk_app : context -> func_decl -> ast array -> ast @@ -7544,18 +6473,9 @@ external mk_app : context -> func_decl -> ast array -> ast (** Summary: Declare and create a constant. - - - - - - - - [mk_const c s t] is a shorthand for [mk_app c (mk_func_decl c s [||] t) [||]] - + [mk_const c s t] is a shorthand for [mk_app c (mk_func_decl c s [||] t) [||]] - {b See also}: {!mk_func_decl} - {b See also}: {!mk_app} - def_API('mk_const', AST, (_in(CONTEXT), _in(SYMBOL), _in(SORT))) *) external mk_const : context -> symbol -> sort -> ast @@ -7563,14 +6483,8 @@ external mk_const : context -> symbol -> sort -> ast (** Summary: Declare a fresh constant or function. - Z3 will generate an unique name for this function declaration. - - - - - {b See also}: {!mk_func_decl} - def_API('mk_fresh_func_decl', FUNC_DECL, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SORT), _in(SORT))) *) external mk_fresh_func_decl : context -> string -> sort array -> sort -> func_decl @@ -7578,17 +6492,9 @@ external mk_fresh_func_decl : context -> string -> sort array -> sort -> func_de (** Summary: Declare and create a fresh constant. - - - - - [mk_fresh_const c p t] is a shorthand for [mk_app c (mk_fresh_func_decl c p [||] t) [||]]. - - - + [mk_fresh_const c p t] is a shorthand for [mk_app c (mk_fresh_func_decl c p [||] t) [||]]. - {b See also}: {!mk_func_decl} - {b See also}: {!mk_app} - def_API('mk_fresh_const', AST, (_in(CONTEXT), _in(STRING), _in(SORT))) *) external mk_fresh_const : context -> string -> sort -> ast @@ -7599,7 +6505,6 @@ external mk_fresh_const : context -> string -> sort -> ast *) (** Summary: Create an AST node representing [true]. - def_API('mk_true', AST, (_in(CONTEXT), )) *) external mk_true : context -> ast @@ -7607,7 +6512,6 @@ external mk_true : context -> ast (** Summary: Create an AST node representing [false]. - def_API('mk_false', AST, (_in(CONTEXT), )) *) external mk_false : context -> ast @@ -7616,51 +6520,40 @@ external mk_false : context -> ast (** Summary: \[ [ mk_eq c l r ] \] Create an AST node representing {e l = r }. - - The nodes [l] and [r] must have the same type. - + The nodes [l] and [r] must have the same type. def_API('mk_eq', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_eq : context -> ast -> ast -> ast = "camlidl_z3V3_Z3_mk_eq" (** - Summary: \[ [mk_distinct c [| t_1; ...; t_n |]] \] Create an AST node represeting a distinct construct. It is used for declaring - the arguments t_i pairwise distinct. - + the arguments t_i pairwise distinct. The [distinct] construct is used for declaring the arguments pairwise distinct. That is, {e Forall 0 <= i < j < num_args. not args[i] = args[j] }. - All arguments must have the same sort. - - {b Remarks}: The number of arguments of a distinct construct must be greater than one. - def_API('mk_distinct', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_distinct : context -> ast array -> ast = "camlidl_z3V3_Z3_mk_distinct" (** - Summary: \[ [ mk_not c a ] \] + Summary: \[ [ mk_not c a ] \] Create an AST node representing {e not(a) }. - The node [a] must have Boolean sort. - def_API('mk_not', AST, (_in(CONTEXT), _in(AST))) *) external mk_not : context -> ast -> ast = "camlidl_z3V3_Z3_mk_not" (** - Summary: \[ [ mk_ite c t1 t2 t2 ] \] + Summary: \[ [ mk_ite c t1 t2 t2 ] \] Create an AST node representing an if-then-else: {e ite(t1, t2, t3) }. - The node [t1] must have Boolean sort, [t2] and [t3] must have the same sort. The sort of the new node is equal to the sort of [t2] and [t3]. - def_API('mk_ite', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(AST))) *) external mk_ite : context -> ast -> ast -> ast -> ast @@ -7669,9 +6562,7 @@ external mk_ite : context -> ast -> ast -> ast -> ast (** Summary: \[ [ mk_iff c t1 t2 ] \] Create an AST node representing {e t1 iff t2 }. - The nodes [t1] and [t2] must have Boolean sort. - def_API('mk_iff', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_iff : context -> ast -> ast -> ast @@ -7680,9 +6571,7 @@ external mk_iff : context -> ast -> ast -> ast (** Summary: \[ [ mk_implies c t1 t2 ] \] Create an AST node representing {e t1 implies t2 }. - The nodes [t1] and [t2] must have Boolean sort. - def_API('mk_implies', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_implies : context -> ast -> ast -> ast @@ -7691,37 +6580,25 @@ external mk_implies : context -> ast -> ast -> ast (** Summary: \[ [ mk_xor c t1 t2 ] \] Create an AST node representing {e t1 xor t2 }. - The nodes [t1] and [t2] must have Boolean sort. - def_API('mk_xor', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_xor : context -> ast -> ast -> ast = "camlidl_z3V3_Z3_mk_xor" (** - - Summary: \[ [mk_and c [| t_1; ...; t_n |]] \] Create the conjunction: {e t_1 and ... and t_n}. - - + Summary: \[ [mk_and c [| t_1; ...; t_n |]] \] Create the conjunction: {e t_1 and ... and t_n}. All arguments must have Boolean sort. - - {b Remarks}: The number of arguments must be greater than zero. - def_API('mk_and', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_and : context -> ast array -> ast = "camlidl_z3V3_Z3_mk_and" (** - - Summary: \[ [mk_or c [| t_1; ...; t_n |]] \] Create the disjunction: {e t_1 or ... or t_n}. - - + Summary: \[ [mk_or c [| t_1; ...; t_n |]] \] Create the disjunction: {e t_1 or ... or t_n}. All arguments must have Boolean sort. - - {b Remarks}: The number of arguments must be greater than zero. - def_API('mk_or', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_or : context -> ast array -> ast @@ -7731,110 +6608,78 @@ external mk_or : context -> ast array -> ast {2 {L Arithmetic: Integers and Reals}} *) (** - - Summary: \[ [mk_add c [| t_1; ...; t_n |]] \] Create the term: {e t_1 + ... + t_n}. - - + Summary: \[ [mk_add c [| t_1; ...; t_n |]] \] Create the term: {e t_1 + ... + t_n}. All arguments must have int or real sort. - - {b Remarks}: The number of arguments must be greater than zero. - def_API('mk_add', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_add : context -> ast array -> ast = "camlidl_z3V3_Z3_mk_add" (** - - Summary: \[ [mk_mul c [| t_1; ...; t_n |]] \] Create the term: {e t_1 * ... * t_n}. - - + Summary: \[ [mk_mul c [| t_1; ...; t_n |]] \] Create the term: {e t_1 * ... * t_n}. All arguments must have int or real sort. - - {b Remarks}: Z3 has limited support for non-linear arithmetic. - {b Remarks}: The number of arguments must be greater than zero. - def_API('mk_mul', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_mul : context -> ast array -> ast = "camlidl_z3V3_Z3_mk_mul" (** - - Summary: \[ [mk_sub c [| t_1; ...; t_n |]] \] Create the term: {e t_1 - ... - t_n}. - - + Summary: \[ [mk_sub c [| t_1; ...; t_n |]] \] Create the term: {e t_1 - ... - t_n}. All arguments must have int or real sort. - - {b Remarks}: The number of arguments must be greater than zero. - def_API('mk_sub', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_sub : context -> ast array -> ast = "camlidl_z3V3_Z3_mk_sub" (** - - Summary: \[ [mk_unary_minus c arg] \] Create the term: {e - arg}. - + Summary: \[ [mk_unary_minus c arg] \] Create the term: {e - arg}. The arguments must have int or real type. - def_API('mk_unary_minus', AST, (_in(CONTEXT), _in(AST))) *) external mk_unary_minus : context -> ast -> ast = "camlidl_z3V3_Z3_mk_unary_minus" (** - - Summary: \[ [mk_div c t_1 t_2] \] Create the term: {e t_1 div t_2}. - + Summary: \[ [mk_div c t_1 t_2] \] Create the term: {e t_1 div t_2}. The arguments must either both have int type or both have real type. If the arguments have int type, then the result type is an int type, otherwise the the result type is real. - def_API('mk_div', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_div : context -> ast -> ast -> ast = "camlidl_z3V3_Z3_mk_div" (** - - Summary: \[ [mk_mod c t_1 t_2] \] Create the term: {e t_1 mod t_2}. - + Summary: \[ [mk_mod c t_1 t_2] \] Create the term: {e t_1 mod t_2}. The arguments must have int type. - def_API('mk_mod', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_mod : context -> ast -> ast -> ast = "camlidl_z3V3_Z3_mk_mod" (** - - Summary: \[ [mk_rem c t_1 t_2] \] Create the term: {e t_1 rem t_2}. - + Summary: \[ [mk_rem c t_1 t_2] \] Create the term: {e t_1 rem t_2}. The arguments must have int type. - def_API('mk_rem', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_rem : context -> ast -> ast -> ast = "camlidl_z3V3_Z3_mk_rem" (** - - The arguments must have int or real type. - def_API('mk_power', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_power : context -> ast -> ast -> ast = "camlidl_z3V3_Z3_mk_power" (** - Summary: \[ [ mk_lt c t1 t2 ] \] + Summary: \[ [ mk_lt c t1 t2 ] \] Create less than. - The nodes [t1] and [t2] must have the same sort, and must be int or real. - def_API('mk_lt', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_lt : context -> ast -> ast -> ast @@ -7843,9 +6688,7 @@ external mk_lt : context -> ast -> ast -> ast (** Summary: \[ [ mk_le c t1 t2 ] \] Create less than or equal to. - The nodes [t1] and [t2] must have the same sort, and must be int or real. - def_API('mk_le', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_le : context -> ast -> ast -> ast @@ -7854,9 +6697,7 @@ external mk_le : context -> ast -> ast -> ast (** Summary: \[ [ mk_gt c t1 t2 ] \] Create greater than. - The nodes [t1] and [t2] must have the same sort, and must be int or real. - def_API('mk_gt', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_gt : context -> ast -> ast -> ast @@ -7865,9 +6706,7 @@ external mk_gt : context -> ast -> ast -> ast (** Summary: \[ [ mk_ge c t1 t2 ] \] Create greater than or equal to. - The nodes [t1] and [t2] must have the same sort, and must be int or real. - def_API('mk_ge', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_ge : context -> ast -> ast -> ast @@ -7876,19 +6715,14 @@ external mk_ge : context -> ast -> ast -> ast (** Summary: \[ [ mk_int2real c t1 ] \] Coerce an integer to a real. - There is also a converse operation exposed. It follows the semantics prescribed by the SMT-LIB standard. - - You can take the floor of a real by + You can take the floor of a real by creating an auxiliary integer constant [k] and - and asserting {e mk_int2real(k) <= t1 < mk_int2real(k)+1 }. - + and asserting {e mk_int2real(k) <= t1 < mk_int2real(k)+1 }. The node [t1] must have sort integer. - - {b See also}: {!mk_real2int} - {b See also}: {!mk_is_int} - def_API('mk_int2real', AST, (_in(CONTEXT), _in(AST))) *) external mk_int2real : context -> ast -> ast @@ -7897,13 +6731,10 @@ external mk_int2real : context -> ast -> ast (** Summary: \[ [ mk_real2int c t1 ] \] Coerce a real to an integer. - The semantics of this function follows the SMT-LIB standard for the function to_int - - {b See also}: {!mk_int2real} - {b See also}: {!mk_is_int} - def_API('mk_real2int', AST, (_in(CONTEXT), _in(AST))) *) external mk_real2int : context -> ast -> ast @@ -7912,10 +6743,8 @@ external mk_real2int : context -> ast -> ast (** Summary: \[ [ mk_is_int c t1 ] \] Check if a real number is an integer. - - {b See also}: {!mk_int2real} - {b See also}: {!mk_real2int} - def_API('mk_is_int', AST, (_in(CONTEXT), _in(AST))) *) external mk_is_int : context -> ast -> ast @@ -7927,9 +6756,7 @@ external mk_is_int : context -> ast -> ast (** Summary: \[ [ mk_bvnot c t1 ] \] Bitwise negation. - The node [t1] must have a bit-vector sort. - def_API('mk_bvnot', AST, (_in(CONTEXT), _in(AST))) *) external mk_bvnot : context -> ast -> ast @@ -7938,9 +6765,7 @@ external mk_bvnot : context -> ast -> ast (** Summary: \[ [ mk_bvredand c t1 ] \] Take conjunction of bits in vector, return vector of length 1. - The node [t1] must have a bit-vector sort. - def_API('mk_bvredand', AST, (_in(CONTEXT), _in(AST))) *) external mk_bvredand : context -> ast -> ast @@ -7949,9 +6774,7 @@ external mk_bvredand : context -> ast -> ast (** Summary: \[ [ mk_bvredor c t1 ] \] Take disjunction of bits in vector, return vector of length 1. - The node [t1] must have a bit-vector sort. - def_API('mk_bvredor', AST, (_in(CONTEXT), _in(AST))) *) external mk_bvredor : context -> ast -> ast @@ -7960,9 +6783,7 @@ external mk_bvredor : context -> ast -> ast (** Summary: \[ [ mk_bvand c t1 t2 ] \] Bitwise and. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvand', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvand : context -> ast -> ast -> ast @@ -7971,9 +6792,7 @@ external mk_bvand : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvor c t1 t2 ] \] Bitwise or. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvor', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvor : context -> ast -> ast -> ast @@ -7982,9 +6801,7 @@ external mk_bvor : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvxor c t1 t2 ] \] Bitwise exclusive-or. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvxor', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvxor : context -> ast -> ast -> ast @@ -7992,10 +6809,8 @@ external mk_bvxor : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvnand c t1 t2 ] \] - Bitwise nand. - + Bitwise nand. The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvnand', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvnand : context -> ast -> ast -> ast @@ -8003,10 +6818,8 @@ external mk_bvnand : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvnor c t1 t2 ] \] - Bitwise nor. - + Bitwise nor. The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvnor', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvnor : context -> ast -> ast -> ast @@ -8014,10 +6827,8 @@ external mk_bvnor : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvxnor c t1 t2 ] \] - Bitwise xnor. - + Bitwise xnor. The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvxnor', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvxnor : context -> ast -> ast -> ast @@ -8026,9 +6837,7 @@ external mk_bvxnor : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvneg c t1 ] \] Standard two's complement unary minus. - The node [t1] must have bit-vector sort. - def_API('mk_bvneg', AST, (_in(CONTEXT), _in(AST))) *) external mk_bvneg : context -> ast -> ast @@ -8037,9 +6846,7 @@ external mk_bvneg : context -> ast -> ast (** Summary: \[ [ mk_bvadd c t1 t2 ] \] Standard two's complement addition. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvadd', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvadd : context -> ast -> ast -> ast @@ -8048,9 +6855,7 @@ external mk_bvadd : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsub c t1 t2 ] \] Standard two's complement subtraction. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsub', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsub : context -> ast -> ast -> ast @@ -8059,9 +6864,7 @@ external mk_bvsub : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvmul c t1 t2 ] \] Standard two's complement multiplication. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvmul', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvmul : context -> ast -> ast -> ast @@ -8069,14 +6872,11 @@ external mk_bvmul : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvudiv c t1 t2 ] \] - Unsigned division. - + Unsigned division. It is defined as the [floor] of {e t1/t2 } if [t2] is different from zero. If {e t2 } is zero, then the result is undefined. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvudiv', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvudiv : context -> ast -> ast -> ast @@ -8085,17 +6885,11 @@ external mk_bvudiv : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsdiv c t1 t2 ] \] Two's complement signed division. - It is defined in the following way: - - The [floor] of {e t1/t2 } if [t2] is different from zero, and {e t1*t2 >= 0 }. - - The [ceiling] of {e t1/t2 } if [t2] is different from zero, and {e t1*t2 < 0 }. - If {e t2 } is zero, then the result is undefined. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsdiv', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsdiv : context -> ast -> ast -> ast @@ -8104,13 +6898,9 @@ external mk_bvsdiv : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvurem c t1 t2 ] \] Unsigned remainder. - It is defined as {e t1 - (t1 /u t2) * t2 }, where {e /u } represents unsigned int division. - If {e t2 } is zero, then the result is undefined. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvurem', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvurem : context -> ast -> ast -> ast @@ -8119,16 +6909,11 @@ external mk_bvurem : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsrem c t1 t2 ] \] Two's complement signed remainder (sign follows dividend). - It is defined as {e t1 - (t1 /s t2) * t2 }, where {e /s } represents signed division. The most significant bit (sign) of the result is equal to the most significant bit of [t1]. - If {e t2 } is zero, then the result is undefined. - The nodes [t1] and [t2] must have the same bit-vector sort. - - {b See also}: {!mk_bvsmod} - def_API('mk_bvsrem', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsrem : context -> ast -> ast -> ast @@ -8137,13 +6922,9 @@ external mk_bvsrem : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsmod c t1 t2 ] \] Two's complement signed remainder (sign follows divisor). - If {e t2 } is zero, then the result is undefined. - The nodes [t1] and [t2] must have the same bit-vector sort. - - {b See also}: {!mk_bvsrem} - def_API('mk_bvsmod', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsmod : context -> ast -> ast -> ast @@ -8152,9 +6933,7 @@ external mk_bvsmod : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvult c t1 t2 ] \] Unsigned less than. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvult', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvult : context -> ast -> ast -> ast @@ -8163,17 +6942,14 @@ external mk_bvult : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvslt c t1 t2 ] \] Two's complement signed less than. - It abbreviates: - {v + {v (or (and (= (extract[|m-1|:|m-1|] t1) bit1) (= (extract[|m-1|:|m-1|] t2) bit0)) (and (= (extract[|m-1|:|m-1|] t1) (extract[|m-1|:|m-1|] t2)) (bvult t1 t2))) v} - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvslt', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvslt : context -> ast -> ast -> ast @@ -8182,9 +6958,7 @@ external mk_bvslt : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvule c t1 t2 ] \] Unsigned less than or equal to. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvule', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvule : context -> ast -> ast -> ast @@ -8193,9 +6967,7 @@ external mk_bvule : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsle c t1 t2 ] \] Two's complement signed less than or equal to. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsle', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsle : context -> ast -> ast -> ast @@ -8204,9 +6976,7 @@ external mk_bvsle : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvuge c t1 t2 ] \] Unsigned greater than or equal to. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvuge', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvuge : context -> ast -> ast -> ast @@ -8215,9 +6985,7 @@ external mk_bvuge : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsge c t1 t2 ] \] Two's complement signed greater than or equal to. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsge', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsge : context -> ast -> ast -> ast @@ -8226,9 +6994,7 @@ external mk_bvsge : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvugt c t1 t2 ] \] Unsigned greater than. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvugt', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvugt : context -> ast -> ast -> ast @@ -8237,9 +7003,7 @@ external mk_bvugt : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvsgt c t1 t2 ] \] Two's complement signed greater than. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsgt', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsgt : context -> ast -> ast -> ast @@ -8248,12 +7012,9 @@ external mk_bvsgt : context -> ast -> ast -> ast (** Summary: \[ [ mk_concat c t1 t2 ] \] Concatenate the given bit-vectors. - The nodes [t1] and [t2] must have (possibly different) bit-vector sorts - The result is a bit-vector of size {e n1+n2 }, where [n1] ([n2)] is the size of [t1] ([t2)]. - def_API('mk_concat', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_concat : context -> ast -> ast -> ast @@ -8264,9 +7025,7 @@ external mk_concat : context -> ast -> ast -> ast Extract the bits [high] down to [low] from a bitvector of size [m] to yield a new bitvector of size [n], where {e n = high - low + 1 }. - The node [t1] must have a bit-vector sort. - def_API('mk_extract', AST, (_in(CONTEXT), _in(UINT), _in(UINT), _in(AST))) *) external mk_extract : context -> int -> int -> ast -> ast @@ -8277,9 +7036,7 @@ external mk_extract : context -> int -> int -> ast -> ast Sign-extend of the given bit-vector to the (signed) equivalent bitvector of size {e m+i }, where [m] is the size of the given bit-vector. - The node [t1] must have a bit-vector sort. - def_API('mk_sign_ext', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_sign_ext : context -> int -> ast -> ast @@ -8287,12 +7044,10 @@ external mk_sign_ext : context -> int -> ast -> ast (** Summary: \[ [ mk_zero_ext c i t1 ] \] - Extend the given bit-vector with zeros to the (unsigned int) equivalent + Extend the given bit-vector with zeros to the (unsigned) equivalent bitvector of size {e m+i }, where [m] is the size of the given bit-vector. - - The node [t1] must have a bit-vector sort. - + The node [t1] must have a bit-vector sort. def_API('mk_zero_ext', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_zero_ext : context -> int -> ast -> ast @@ -8301,9 +7056,7 @@ external mk_zero_ext : context -> int -> ast -> ast (** Summary: \[ [ mk_repeat c i t1 ] \] Repeat the given bit-vector up length {e i }. - - The node [t1] must have a bit-vector sort. - + The node [t1] must have a bit-vector sort. def_API('mk_repeat', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_repeat : context -> int -> ast -> ast @@ -8312,16 +7065,12 @@ external mk_repeat : context -> int -> ast -> ast (** Summary: \[ [ mk_bvshl c t1 t2 ] \] Shift left. - It is equivalent to multiplication by {e 2^x } where [x] is the value of the third argument. - - NB. The semantics of shift operations varies between environments. This - definition does not necessarily capture directly the semantics of the + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the programming language or assembly architecture you are modeling. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvshl', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvshl : context -> ast -> ast -> ast @@ -8330,16 +7079,12 @@ external mk_bvshl : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvlshr c t1 t2 ] \] Logical shift right. - It is equivalent to unsigned int division by {e 2^x } where [x] is the value of the third argument. - - NB. The semantics of shift operations varies between environments. This - definition does not necessarily capture directly the semantics of the + NB. The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the programming language or assembly architecture you are modeling. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvlshr', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvlshr : context -> ast -> ast -> ast @@ -8348,17 +7093,13 @@ external mk_bvlshr : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvashr c t1 t2 ] \] Arithmetic shift right. - It is like logical shift right except that the most significant bits of the result always copy the most significant bit of the second argument. - - The semantics of shift operations varies between environments. This - definition does not necessarily capture directly the semantics of the + The semantics of shift operations varies between environments. This + definition does not necessarily capture directly the semantics of the programming language or assembly architecture you are modeling. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvashr', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvashr : context -> ast -> ast -> ast @@ -8367,9 +7108,7 @@ external mk_bvashr : context -> ast -> ast -> ast (** Summary: \[ [ mk_rotate_left c i t1 ] \] Rotate bits of [t1] to the left [i] times. - - The node [t1] must have a bit-vector sort. - + The node [t1] must have a bit-vector sort. def_API('mk_rotate_left', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_rotate_left : context -> int -> ast -> ast @@ -8378,9 +7117,7 @@ external mk_rotate_left : context -> int -> ast -> ast (** Summary: \[ [ mk_rotate_right c i t1 ] \] Rotate bits of [t1] to the right [i] times. - - The node [t1] must have a bit-vector sort. - + The node [t1] must have a bit-vector sort. def_API('mk_rotate_right', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_rotate_right : context -> int -> ast -> ast @@ -8389,9 +7126,7 @@ external mk_rotate_right : context -> int -> ast -> ast (** Summary: \[ [ mk_ext_rotate_left c t1 t2 ] \] Rotate bits of [t1] to the left [t2] times. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_ext_rotate_left', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_ext_rotate_left : context -> ast -> ast -> ast @@ -8400,9 +7135,7 @@ external mk_ext_rotate_left : context -> ast -> ast -> ast (** Summary: \[ [ mk_ext_rotate_right c t1 t2 ] \] Rotate bits of [t1] to the right [t2] times. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_ext_rotate_right', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_ext_rotate_right : context -> ast -> ast -> ast @@ -8411,13 +7144,10 @@ external mk_ext_rotate_right : context -> ast -> ast -> ast (** Summary: \[ [ mk_int2bv c n t1 ] \] Create an [n] bit bit-vector from the integer argument [t1]. - - NB. This function is essentially treated as uninterpreted. + NB. This function is essentially treated as uninterpreted. So you cannot expect Z3 to precisely reflect the semantics of this function when solving constraints with this function. - - The node [t1] must have integer sort. - + The node [t1] must have integer sort. def_API('mk_int2bv', AST, (_in(CONTEXT), _in(UINT), _in(AST))) *) external mk_int2bv : context -> int -> ast -> ast @@ -8426,17 +7156,14 @@ external mk_int2bv : context -> int -> ast -> ast (** Summary: \[ [ mk_bv2int c t1 is_signed ] \] Create an integer from the bit-vector argument [t1]. - If [is_signed] is false, then the bit-vector [t1] is treated as unsigned int. + If [is_signed] is false, then the bit-vector [t1] is treated as unsigned int. So the result is non-negative and in the range {e [0..2^N-1] }, where N are the number of bits in [t1]. If [is_signed] is true, [t1] is treated as a signed bit-vector. - - This function is essentially treated as uninterpreted. + This function is essentially treated as uninterpreted. So you cannot expect Z3 to precisely reflect the semantics of this function when solving constraints with this function. - - The node [t1] must have a bit-vector sort. - + The node [t1] must have a bit-vector sort. def_API('mk_bv2int', AST, (_in(CONTEXT), _in(AST), _in(BOOL))) *) external mk_bv2int : context -> ast -> bool -> ast @@ -8446,9 +7173,7 @@ external mk_bv2int : context -> ast -> bool -> ast Summary: \[ [ mk_bvadd_no_overflow c t1 t2 is_signed ] \] Create a predicate that checks that the bit-wise addition of [t1] and [t2] does not overflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvadd_no_overflow', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(BOOL))) *) external mk_bvadd_no_overflow : context -> ast -> ast -> bool -> ast @@ -8458,9 +7183,7 @@ external mk_bvadd_no_overflow : context -> ast -> ast -> bool -> ast Summary: \[ [ mk_bvadd_no_underflow c t1 t2 ] \] Create a predicate that checks that the bit-wise signed addition of [t1] and [t2] does not underflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvadd_no_underflow', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvadd_no_underflow : context -> ast -> ast -> ast @@ -8470,9 +7193,7 @@ external mk_bvadd_no_underflow : context -> ast -> ast -> ast Summary: \[ [ mk_bvsub_no_overflow c t1 t2 ] \] Create a predicate that checks that the bit-wise signed subtraction of [t1] and [t2] does not overflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsub_no_overflow', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsub_no_overflow : context -> ast -> ast -> ast @@ -8482,9 +7203,7 @@ external mk_bvsub_no_overflow : context -> ast -> ast -> ast Summary: \[ [ mk_bvsub_no_underflow c t1 t2 is_signed ] \] Create a predicate that checks that the bit-wise subtraction of [t1] and [t2] does not underflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsub_no_underflow', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(BOOL))) *) external mk_bvsub_no_underflow : context -> ast -> ast -> bool -> ast @@ -8492,11 +7211,9 @@ external mk_bvsub_no_underflow : context -> ast -> ast -> bool -> ast (** Summary: \[ [ mk_bvsdiv_no_overflow c t1 t2 ] \] - Create a predicate that checks that the bit-wise signed division + Create a predicate that checks that the bit-wise signed division of [t1] and [t2] does not overflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvsdiv_no_overflow', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvsdiv_no_overflow : context -> ast -> ast -> ast @@ -8504,11 +7221,9 @@ external mk_bvsdiv_no_overflow : context -> ast -> ast -> ast (** Summary: \[ [ mk_bvneg_no_overflow c t1 ] \] - Check that bit-wise negation does not overflow when + Check that bit-wise negation does not overflow when [t1] is interpreted as a signed bit-vector. - The node [t1] must have bit-vector sort. - def_API('mk_bvneg_no_overflow', AST, (_in(CONTEXT), _in(AST))) *) external mk_bvneg_no_overflow : context -> ast -> ast @@ -8518,9 +7233,7 @@ external mk_bvneg_no_overflow : context -> ast -> ast Summary: \[ [ mk_bvmul_no_overflow c t1 t2 is_signed ] \] Create a predicate that checks that the bit-wise multiplication of [t1] and [t2] does not overflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvmul_no_overflow', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(BOOL))) *) external mk_bvmul_no_overflow : context -> ast -> ast -> bool -> ast @@ -8530,9 +7243,7 @@ external mk_bvmul_no_overflow : context -> ast -> ast -> bool -> ast Summary: \[ [ mk_bvmul_no_underflow c t1 t2 ] \] Create a predicate that checks that the bit-wise signed multiplication of [t1] and [t2] does not underflow. - The nodes [t1] and [t2] must have the same bit-vector sort. - def_API('mk_bvmul_no_underflow', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_bvmul_no_underflow : context -> ast -> ast -> ast @@ -8544,15 +7255,12 @@ external mk_bvmul_no_underflow : context -> ast -> ast -> ast (** Summary: \[ [ mk_select c a i ] \] Array read. - The argument [a] is the array and [i] is the index of the array that gets read. - - The node [a] must have an array sort {e [domain -> range] }, + The argument [a] is the array and [i] is the index of the array that gets read. + The node [a] must have an array sort {e [domain -> range] }, and [i] must have the sort [domain]. The sort of the result is [range]. - - {b See also}: {!mk_array_sort} - {b See also}: {!mk_store} - def_API('mk_select', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_select : context -> ast -> ast -> ast @@ -8561,18 +7269,15 @@ external mk_select : context -> ast -> ast -> ast (** Summary: \[ [ mk_store c a i v ] \] Array update. - The node [a] must have an array sort {e [domain -> range] }, [i] must have sort [domain], [v] must have sort range. The sort of the result is {e [domain -> range] }. The semantics of this function is given by the theory of arrays described in the SMT-LIB - standard. See http: + standard. See http://smtlib.org for more details. The result of this function is an array that is equal to [a] (with respect to [select)] - on all indices except for [i], where it maps to [v] (and the [select] of [a] with + on all indices except for [i], where it maps to [v] (and the [select] of [a] with respect to [i] may be a different value). - - {b See also}: {!mk_array_sort} - {b See also}: {!mk_select} - def_API('mk_store', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(AST))) *) external mk_store : context -> ast -> ast -> ast -> ast @@ -8580,14 +7285,11 @@ external mk_store : context -> ast -> ast -> ast -> ast (** Summary: Create the constant array. - - The resulting term is an array, such that a [select] on an arbitrary index + The resulting term is an array, such that a [select] on an arbitrary index produces the value [v]. - @param c logical context. @param domain domain sort for the array. @param v value that the array maps to. - def_API('mk_const_array', AST, (_in(CONTEXT), _in(SORT), _in(AST))) *) external mk_const_array : context -> sort -> ast -> ast @@ -8596,15 +7298,12 @@ external mk_const_array : context -> sort -> ast -> ast (** Summary: \[ [ mk_map f n args ] \] map f on the the argument arrays. - The [n] nodes [args] must be of array sorts {e [domain_i -> range_i] }. - The function declaration [f] must have type {e range_1 .. range_n -> range }. + The function declaration [f] must have type {e range_1 .. range_n -> range }. [v] must have sort range. The sort of the result is {e [domain_i -> range] }. - - {b See also}: {!mk_array_sort} - {b See also}: {!mk_store} - {b See also}: {!mk_select} - def_API('mk_map', AST, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT), _in_array(2, AST))) *) external mk_map : context -> func_decl -> int -> ast -> ast @@ -8612,12 +7311,10 @@ external mk_map : context -> func_decl -> int -> ast -> ast (** Summary: Access the array default value. - Produces the default range value, for arrays that can be represented as + Produces the default range value, for arrays that can be represented as finite maps with a default range value. - @param c logical context. @param array array value whose default range value is accessed. - def_API('mk_array_default', AST, (_in(CONTEXT), _in(AST))) *) external mk_array_default : context -> ast -> ast @@ -8628,7 +7325,6 @@ external mk_array_default : context -> ast -> ast *) (** Summary: Create Set type. - def_API('mk_set_sort', SORT, (_in(CONTEXT), _in(SORT))) *) external mk_set_sort : context -> sort -> sort @@ -8636,7 +7332,6 @@ external mk_set_sort : context -> sort -> sort (** Summary: Create the empty set. - def_API('mk_empty_set', AST, (_in(CONTEXT), _in(SORT))) *) external mk_empty_set : context -> sort -> ast @@ -8644,7 +7339,6 @@ external mk_empty_set : context -> sort -> ast (** Summary: Create the full set. - def_API('mk_full_set', AST, (_in(CONTEXT), _in(SORT))) *) external mk_full_set : context -> sort -> ast @@ -8652,9 +7346,7 @@ external mk_full_set : context -> sort -> ast (** Summary: Add an element to a set. - The first argument must be a set, the second an element. - def_API('mk_set_add', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_set_add : context -> ast -> ast -> ast @@ -8662,9 +7354,7 @@ external mk_set_add : context -> ast -> ast -> ast (** Summary: Remove an element to a set. - The first argument must be a set, the second an element. - def_API('mk_set_del', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_set_del : context -> ast -> ast -> ast @@ -8672,7 +7362,6 @@ external mk_set_del : context -> ast -> ast -> ast (** Summary: Take the union of a list of sets. - def_API('mk_set_union', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_set_union : context -> ast array -> ast @@ -8680,7 +7369,6 @@ external mk_set_union : context -> ast array -> ast (** Summary: Take the intersection of a list of sets. - def_API('mk_set_intersect', AST, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_set_intersect : context -> ast array -> ast @@ -8688,7 +7376,6 @@ external mk_set_intersect : context -> ast array -> ast (** Summary: Take the set difference between two sets. - def_API('mk_set_difference', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_set_difference : context -> ast -> ast -> ast @@ -8696,7 +7383,6 @@ external mk_set_difference : context -> ast -> ast -> ast (** Summary: Take the complement of a set. - def_API('mk_set_complement', AST, (_in(CONTEXT), _in(AST))) *) external mk_set_complement : context -> ast -> ast @@ -8704,9 +7390,7 @@ external mk_set_complement : context -> ast -> ast (** Summary: Check for set membership. - The first argument should be an element type of the set. - def_API('mk_set_member', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_set_member : context -> ast -> ast -> ast @@ -8714,7 +7398,6 @@ external mk_set_member : context -> ast -> ast -> ast (** Summary: Check for subsetness of sets. - def_API('mk_set_subset', AST, (_in(CONTEXT), _in(AST), _in(AST))) *) external mk_set_subset : context -> ast -> ast -> ast @@ -8724,18 +7407,14 @@ external mk_set_subset : context -> ast -> ast -> ast {2 {L Numerals}} *) (** - {4 {L Redundant low-level API}} + {4 {L Redundant low-level API}} *) (** - Summary: Create a numeral of a given sort. - + Summary: Create a numeral of a given sort. @param c logical context. @param numeral A string representing the numeral value in decimal notation. If the given sort is a real, then the numeral can be a rational, that is, a string of the form {e [num]* / [num]* }. - @param ty The sort of the numeral. In the current implementation, the given sort can be an int, real, finite-domain, or bit-vectors of arbitrary size. - + @param ty The sort of the numeral. In the current implementation, the given sort can be an int, real, finite-domain, or bit-vectors of arbitrary size. - {b See also}: {!mk_int} - - def_API('mk_numeral', AST, (_in(CONTEXT), _in(STRING), _in(SORT))) *) external mk_numeral : context -> string -> sort -> ast @@ -8743,43 +7422,32 @@ external mk_numeral : context -> string -> sort -> ast (** Summary: Create a real from a fraction. - @param c logical context. @param num numerator of rational. @param den denomerator of rational. - - {b Precondition}: den != 0 - - {b See also}: {!mk_numeral} - {b See also}: {!mk_int} - - def_API('mk_real', AST, (_in(CONTEXT), _in(INT), _in(INT))) *) external mk_real : context -> int -> int -> ast = "camlidl_z3V3_Z3_mk_real" (** - Summary: Create a numeral of an int, bit-vector, or finite-domain sort. - + Summary: Create a numeral of an int, bit-vector, or finite-domain sort. This function can be use to create numerals that fit in a machine integer. It is slightly faster than {!mk_numeral} since it is not necessary to parse a string. - - {b See also}: {!mk_numeral} - def_API('mk_int', AST, (_in(CONTEXT), _in(INT), _in(SORT))) *) external mk_int : context -> int -> sort -> ast = "camlidl_z3V3_Z3_mk_int" (** - Summary: Create a numeral of a int, bit-vector, or finite-domain sort. - + Summary: Create a numeral of a int, bit-vector, or finite-domain sort. This function can be use to create numerals that fit in a machine long long integer. It is slightly faster than {!mk_numeral} since it is not necessary to parse a string. - - {b See also}: {!mk_numeral} - def_API('mk_int64', AST, (_in(CONTEXT), _in(INT64), _in(SORT))) *) external mk_int64 : context -> int64 -> sort -> ast @@ -8790,22 +7458,17 @@ external mk_int64 : context -> int64 -> sort -> ast *) (** Summary: Create a pattern for quantifier instantiation. - Z3 uses pattern matching to instantiate quantifiers. If a pattern is not provided for a quantifier, then Z3 will automatically compute a set of patterns for it. However, for optimal performance, the user should provide the patterns. - Patterns comprise a list of terms. The list should be - non-empty. If the list comprises of more than one term, it is + non-empty. If the list comprises of more than one term, it is a called a multi-pattern. - In general, one can pass in a list of (multi-)patterns in the quantifier constructor. - - {b See also}: {!mk_forall} - {b See also}: {!mk_exists} - def_API('mk_pattern', PATTERN, (_in(CONTEXT), _in(UINT), _in_array(1, AST))) *) external mk_pattern : context -> ast array -> pattern @@ -8813,12 +7476,10 @@ external mk_pattern : context -> ast array -> pattern (** Summary: Create a bound variable. - Bound variables are indexed by de-Bruijn indices. It is perhaps easiest to explain the meaning of de-Bruijn indices by indicating the compilation process from non-de-Bruijn formulas to de-Bruijn format. - - {v + {v abs(forall (x1) phi) = forall (x1) abs1(phi, x1, 0) abs(forall (x1, x2) phi) = abs(forall (x1) abs(forall (x2) phi)) abs1(x, x, n) = b_n @@ -8826,18 +7487,14 @@ external mk_pattern : context -> ast array -> pattern abs1(f(t1,...,tn), x, n) = f(abs1(t1,x,n), ..., abs1(tn,x,n)) abs1(forall (x1) phi, x, n) = forall (x1) (abs1(phi, x, n+1)) v} - The last line is significant: the index of a bound variable is different depending on the scope in which it appears. The deeper x appears, the higher is its index. - @param c logical context @param index de-Bruijn index @param ty sort of the bound variable - - {b See also}: {!mk_forall} - {b See also}: {!mk_exists} - def_API('mk_bound', AST, (_in(CONTEXT), _in(UINT), _in(SORT))) *) external mk_bound : context -> int -> sort -> ast @@ -8846,21 +7503,17 @@ external mk_bound : context -> int -> sort -> ast (** Summary: Create a forall formula. It takes an expression [body] that contains bound variables of the same sorts as the sorts listed in the array [sorts]. The bound variables are de-Bruijn indices created - using {!mk_bound}. The array [decl_names] contains the names that the quantified formula uses for the + using {!mk_bound}. The array [decl_names] contains the names that the quantified formula uses for the bound variables. Z3 applies the convention that the last element in the [decl_names] and [sorts] array refers to the variable with index 0, the second to last element of [decl_names] and [sorts] refers to the variable with index 1, etc. - - [mk_forall c w p t n b] creates a forall formula, where [w] is the weight, [p] is an array of patterns, [t] is an array with the sorts of the bound variables, [n] is an array with the 'names' of the bound variables, and [b] is the body of the quantifier. Quantifiers are associated with weights indicating the importance of using the quantifier during - instantiation. - - + instantiation. @param c logical context. @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. @param num_patterns number of patterns. @@ -8869,33 +7522,28 @@ external mk_bound : context -> int -> sort -> ast @param sorts the sorts of the bound variables. @param decl_names names of the bound variables @param body the body of the quantifier. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_bound} - {b See also}: {!mk_exists} - def_API('mk_forall', AST, (_in(CONTEXT), _in(UINT), _in(UINT), _in_array(2, PATTERN), _in(UINT), _in_array(4, SORT), _in_array(4, SYMBOL), _in(AST))) *) external mk_forall : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast - = "camlidl_z3_Z3_mk_forall_bytecode" "camlidl_z3V3_Z3_mk_forall" + = "camlidl_z3V3_Z3_mk_forall_bytecode" "camlidl_z3V3_Z3_mk_forall" (** Summary: Create an exists formula. Similar to {!mk_forall}. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_bound} - {b See also}: {!mk_forall} - {b See also}: {!mk_quantifier} - def_API('mk_exists', AST, (_in(CONTEXT), _in(UINT), _in(UINT), _in_array(2, PATTERN), _in(UINT), _in_array(4, SORT), _in_array(4, SYMBOL), _in(AST))) *) external mk_exists : context -> int -> pattern array -> sort array -> symbol array -> ast -> ast - = "camlidl_z3_Z3_mk_exists_bytecode" "camlidl_z3V3_Z3_mk_exists" + = "camlidl_z3V3_Z3_mk_exists_bytecode" "camlidl_z3V3_Z3_mk_exists" (** - Summary: Create a quantifier - universal or existential, with pattern hints. + Summary: Create a quantifier - universal or existential, with pattern hints. See the documentation for {!mk_forall} for an explanation of the parameters. - @param c logical context. @param is_forall flag to indicate if this is a universal or existential quantifier. @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. @@ -8905,20 +7553,17 @@ external mk_exists : context -> int -> pattern array -> sort array -> symbol arr @param sorts array of sorts of the bound variables. @param decl_names names of the bound variables. @param body the body of the quantifier. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_bound} - {b See also}: {!mk_forall} - {b See also}: {!mk_exists} - def_API('mk_quantifier', AST, (_in(CONTEXT), _in(BOOL), _in(UINT), _in(UINT), _in_array(3, PATTERN), _in(UINT), _in_array(5, SORT), _in_array(5, SYMBOL), _in(AST))) *) external mk_quantifier : context -> bool -> int -> pattern array -> sort array -> symbol array -> ast -> ast - = "camlidl_z3_Z3_mk_quantifier_bytecode" "camlidl_z3V3_Z3_mk_quantifier" + = "camlidl_z3V3_Z3_mk_quantifier_bytecode" "camlidl_z3V3_Z3_mk_quantifier" (** Summary: Create a quantifier - universal or existential, with pattern hints, no patterns, and attributes - @param c logical context. @param is_forall flag to indicate if this is a universal or existential quantifier. @param quantifier_id identifier to identify quantifier @@ -8932,33 +7577,28 @@ external mk_quantifier : context -> bool -> int -> pattern array -> sort array - @param sorts array of sorts of the bound variables. @param decl_names names of the bound variables. @param body the body of the quantifier. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_bound} - {b See also}: {!mk_forall} - {b See also}: {!mk_exists} - def_API('mk_quantifier_ex', AST, (_in(CONTEXT), _in(BOOL), _in(UINT), _in(SYMBOL), _in(SYMBOL), _in(UINT), _in_array(5, PATTERN), _in(UINT), _in_array(7, AST), _in(UINT), _in_array(9, SORT), _in_array(9, SYMBOL), _in(AST))) *) external mk_quantifier_ex : context -> bool -> int -> symbol -> symbol -> pattern array -> ast array -> sort array -> symbol array -> ast -> ast - = "camlidl_z3_Z3_mk_quantifier_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_ex" + = "camlidl_z3V3_Z3_mk_quantifier_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_ex" (** Summary: Create a universal quantifier using a list of constants that will form the set of bound variables. - @param c logical context. - @param weight quantifiers are associated with weights indicating the importance of using + @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. @param num_bound number of constants to be abstracted into bound variables. @param bound array of constants to be abstracted into bound variables. @param num_patterns number of patterns. @param patterns array containing the patterns created using {!mk_pattern}. @param body the body of the quantifier. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_exists_const} - def_API('mk_forall_const', AST, (_in(CONTEXT), _in(UINT), _in(UINT), _in_array(2, APP), _in(UINT), _in_array(4, PATTERN), _in(AST))) *) external mk_forall_const : context -> int -> app array -> pattern array -> ast -> ast @@ -8966,61 +7606,54 @@ external mk_forall_const : context -> int -> app array -> pattern array -> ast - (** Summary: Similar to {!mk_forall_const}. - Summary: Create an existential quantifier using a list of constants that will form the set of bound variables. - @param c logical context. - @param weight quantifiers are associated with weights indicating the importance of using + @param weight quantifiers are associated with weights indicating the importance of using the quantifier during instantiation. By default, pass the weight 0. @param num_bound number of constants to be abstracted into bound variables. @param bound array of constants to be abstracted into bound variables. @param num_patterns number of patterns. @param patterns array containing the patterns created using {!mk_pattern}. @param body the body of the quantifier. - - {b See also}: {!mk_pattern} - {b See also}: {!mk_forall_const} - def_API('mk_exists_const', AST, (_in(CONTEXT), _in(UINT), _in(UINT), _in_array(2, APP), _in(UINT), _in_array(4, PATTERN), _in(AST))) *) external mk_exists_const : context -> int -> app array -> pattern array -> ast -> ast = "camlidl_z3V3_Z3_mk_exists_const" (** - Summary: Create a universal or existential + Summary: Create a universal or existential quantifier using a list of constants that will form the set of bound variables. - def_API('mk_quantifier_const', AST, (_in(CONTEXT), _in(BOOL), _in(UINT), _in(UINT), _in_array(3, APP), _in(UINT), _in_array(5, PATTERN), _in(AST))) *) external mk_quantifier_const : context -> bool -> int -> app array -> pattern array -> ast -> ast - = "camlidl_z3_Z3_mk_quantifier_const_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const" + = "camlidl_z3V3_Z3_mk_quantifier_const_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const" (** - Summary: Create a universal or existential + Summary: Create a universal or existential quantifier using a list of constants that will form the set of bound variables. - def_API('mk_quantifier_const_ex', AST, (_in(CONTEXT), _in(BOOL), _in(UINT), _in(SYMBOL), _in(SYMBOL), _in(UINT), _in_array(5, APP), _in(UINT), _in_array(7, PATTERN), _in(UINT), _in_array(9, AST), _in(AST))) *) external mk_quantifier_const_ex : context -> bool -> int -> symbol -> symbol -> app array -> pattern array -> ast array -> ast -> ast - = "camlidl_z3_Z3_mk_quantifier_const_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const_ex" + = "camlidl_z3V3_Z3_mk_quantifier_const_ex_bytecode" "camlidl_z3V3_Z3_mk_quantifier_const_ex" (** {2 {L Accessors}} *) (** - {3 {L Symbols}} + {3 {L Symbols}} *) (** - {4 {L Redundant low-level API}} + {4 {L Redundant low-level API}} *) (** Summary: Return [INT_SYMBOL] if the symbol was constructed using {!mk_int_symbol}, and [STRING_SYMBOL] if the symbol was constructed using {!mk_string_symbol}. - def_API('get_symbol_kind', UINT, (_in(CONTEXT), _in(SYMBOL))) *) external get_symbol_kind : context -> symbol -> symbol_kind @@ -9028,12 +7661,9 @@ external get_symbol_kind : context -> symbol -> symbol_kind (** Summary: \[ [ get_symbol_int c s ] \] - Return the symbol int value. - + Return the symbol int value. - {b Precondition}: get_symbol_kind s == INT_SYMBOL - - {b See also}: {!mk_int_symbol} - def_API('get_symbol_int', INT, (_in(CONTEXT), _in(SYMBOL))) *) external get_symbol_int : context -> symbol -> int @@ -9041,27 +7671,19 @@ external get_symbol_int : context -> symbol -> int (** Summary: \[ [ get_symbol_string c s ] \] - Return the symbol name. - + Return the symbol name. - {b Precondition}: get_symbol_string s == STRING_SYMBOL - - - - - - {b See also}: {!mk_string_symbol} - def_API('get_symbol_string', STRING, (_in(CONTEXT), _in(SYMBOL))) *) external get_symbol_string : context -> symbol -> string = "camlidl_z3V3_Z3_get_symbol_string" (** - {3 {L Sorts}} + {3 {L Sorts}} *) (** - Summary: Return the sort name as a symbol. - + Summary: Return the sort name as a symbol. def_API('get_sort_name', SYMBOL, (_in(CONTEXT), _in(SORT))) *) external get_sort_name : context -> sort -> symbol @@ -9069,20 +7691,18 @@ external get_sort_name : context -> sort -> symbol (** Summary: Return a unique identifier for [s]. - - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. - + - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. def_API('get_sort_id', UINT, (_in(CONTEXT), _in(SORT))) *) external get_sort_id : context -> sort -> int = "camlidl_z3V3_Z3_get_sort_id" (** - {4 {L Redundant low-level API}} + {4 {L Redundant low-level API}} *) (** - Summary: Convert a [sort] into [ast]. - - {b Remarks}: [sort_to_ast c s] can be replaced by [(s :> ast)]. - + Summary: Convert a [sort] into [ast]. + - {b Remarks}: [sort_to_ast c s] can be replaced by [(s :> ast)]. def_API('sort_to_ast', AST, (_in(CONTEXT), _in(SORT))) *) external sort_to_ast : context -> sort -> ast @@ -9090,8 +7710,7 @@ external sort_to_ast : context -> sort -> ast (** Summary: compare sorts. - - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. - + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. def_API('is_eq_sort', BOOL, (_in(CONTEXT), _in(SORT), _in(SORT))) *) external is_eq_sort : context -> sort -> sort -> bool @@ -9099,9 +7718,7 @@ external is_eq_sort : context -> sort -> sort -> bool (** Summary: Return the sort kind (e.g., array, tuple, int, bool, etc). - - {b See also}: {!sort_kind} - def_API('get_sort_kind', UINT, (_in(CONTEXT), _in(SORT))) *) external get_sort_kind : context -> sort -> sort_kind @@ -9109,23 +7726,18 @@ external get_sort_kind : context -> sort -> sort_kind (** Summary: \[ [ get_bv_sort_size c t ] \] - Return the size of the given bit-vector sort. - + Return the size of the given bit-vector sort. - {b Precondition}: get_sort_kind c t == BV_SORT - - {b See also}: {!mk_bv_sort} - {b See also}: {!get_sort_kind} - def_API('get_bv_sort_size', UINT, (_in(CONTEXT), _in(SORT))) *) external get_bv_sort_size : context -> sort -> int = "camlidl_z3V3_Z3_get_bv_sort_size" (** - - Summary: Return the size of the sort in [r]. Return [None] if the call failed. + Summary: Return the size of the sort in [r]. Return [None] if the call failed. That is, get_sort_kind(s) == FINITE_DOMAIN_SORT - def_API('get_finite_domain_sort_size', BOOL, (_in(CONTEXT), _in(SORT), _out(UINT64))) *) external get_finite_domain_sort_size : context -> sort -> int64 option @@ -9134,26 +7746,20 @@ external get_finite_domain_sort_size : context -> sort -> int64 option (** Summary: \[ [ get_array_sort_domain c t ] \] Return the domain of the given array sort. - - {b Precondition}: get_sort_kind c t == ARRAY_SORT - - {b See also}: {!mk_array_sort} - {b See also}: {!get_sort_kind} - def_API('get_array_sort_domain', SORT, (_in(CONTEXT), _in(SORT))) *) external get_array_sort_domain : context -> sort -> sort = "camlidl_z3V3_Z3_get_array_sort_domain" (** - Summary: \[ [ get_array_sort_range c t ] \] - Return the range of the given array sort. - + Summary: \[ [ get_array_sort_range c t ] \] + Return the range of the given array sort. - {b Precondition}: get_sort_kind c t == ARRAY_SORT - - {b See also}: {!mk_array_sort} - {b See also}: {!get_sort_kind} - def_API('get_array_sort_range', SORT, (_in(CONTEXT), _in(SORT))) *) external get_array_sort_range : context -> sort -> sort @@ -9162,13 +7768,10 @@ external get_array_sort_range : context -> sort -> sort (** Summary: \[ [ get_tuple_sort_mk_decl c t ] \] Return the constructor declaration of the given tuple - sort. - + sort. - {b Precondition}: get_sort_kind c t == DATATYPE_SORT - - {b See also}: {!mk_tuple_sort} - {b See also}: {!get_sort_kind} - def_API('get_tuple_sort_mk_decl', FUNC_DECL, (_in(CONTEXT), _in(SORT))) *) external get_tuple_sort_mk_decl : context -> sort -> func_decl @@ -9176,13 +7779,10 @@ external get_tuple_sort_mk_decl : context -> sort -> func_decl (** Summary: \[ [ get_tuple_sort_num_fields c t ] \] - Return the number of fields of the given tuple sort. - + Return the number of fields of the given tuple sort. - {b Precondition}: get_sort_kind c t == DATATYPE_SORT - - {b See also}: {!mk_tuple_sort} - {b See also}: {!get_sort_kind} - def_API('get_tuple_sort_num_fields', UINT, (_in(CONTEXT), _in(SORT))) *) external get_tuple_sort_num_fields : context -> sort -> int @@ -9191,14 +7791,11 @@ external get_tuple_sort_num_fields : context -> sort -> int (** Summary: \[ [ get_tuple_sort_field_decl c t i ] \] Return the i-th field declaration (i.e., projection function declaration) - of the given tuple sort. - + of the given tuple sort. - {b Precondition}: get_sort_kind t == DATATYPE_SORT - {b Precondition}: i < get_tuple_sort_num_fields c t - - {b See also}: {!mk_tuple_sort} - {b See also}: {!get_sort_kind} - def_API('get_tuple_sort_field_decl', FUNC_DECL, (_in(CONTEXT), _in(SORT), _in(UINT))) *) external get_tuple_sort_field_decl : context -> sort -> int -> func_decl @@ -9206,13 +7803,10 @@ external get_tuple_sort_field_decl : context -> sort -> int -> func_decl (** Summary: Return number of constructors for datatype. - - {b Precondition}: get_sort_kind t == DATATYPE_SORT - - {b See also}: {!get_datatype_sort_constructor} - {b See also}: {!get_datatype_sort_recognizer} - {b See also}: {!get_datatype_sort_constructor_accessor} - def_API('get_datatype_sort_num_constructors', UINT, (_in(CONTEXT), _in(SORT))) *) external get_datatype_sort_num_constructors : context -> sort -> int @@ -9220,14 +7814,11 @@ external get_datatype_sort_num_constructors : context -> sort -> int (** Summary: Return idx'th constructor. - - {b Precondition}: get_sort_kind t == DATATYPE_SORT - {b Precondition}: idx < get_datatype_sort_num_constructors c t - - {b See also}: {!get_datatype_sort_num_constructors} - {b See also}: {!get_datatype_sort_recognizer} - {b See also}: {!get_datatype_sort_constructor_accessor} - def_API('get_datatype_sort_constructor', FUNC_DECL, (_in(CONTEXT), _in(SORT), _in(UINT))) *) external get_datatype_sort_constructor : context -> sort -> int -> func_decl @@ -9235,14 +7826,11 @@ external get_datatype_sort_constructor : context -> sort -> int -> func_decl (** Summary: Return idx'th recognizer. - - {b Precondition}: get_sort_kind t == DATATYPE_SORT - {b Precondition}: idx < get_datatype_sort_num_constructors c t - - {b See also}: {!get_datatype_sort_num_constructors} - {b See also}: {!get_datatype_sort_constructor} - {b See also}: {!get_datatype_sort_constructor_accessor} - def_API('get_datatype_sort_recognizer', FUNC_DECL, (_in(CONTEXT), _in(SORT), _in(UINT))) *) external get_datatype_sort_recognizer : context -> sort -> int -> func_decl @@ -9250,15 +7838,12 @@ external get_datatype_sort_recognizer : context -> sort -> int -> func_decl (** Summary: Return idx_a'th accessor for the idx_c'th constructor. - - {b Precondition}: get_sort_kind t == DATATYPE_SORT - {b Precondition}: idx_c < get_datatype_sort_num_constructors c t - {b Precondition}: idx_a < get_domain_size c get_datatype_sort_constructor c idx_c - - {b See also}: {!get_datatype_sort_num_constructors} - {b See also}: {!get_datatype_sort_constructor} - {b See also}: {!get_datatype_sort_recognizer} - def_API('get_datatype_sort_constructor_accessor', FUNC_DECL, (_in(CONTEXT), _in(SORT), _in(UINT), _in(UINT))) *) external get_datatype_sort_constructor_accessor : context -> sort -> int -> int -> func_decl @@ -9266,11 +7851,8 @@ external get_datatype_sort_constructor_accessor : context -> sort -> int -> int (** Summary: Return arity of relation. - - {b Precondition}: get_sort_kind s == RELATION_SORT - - {b See also}: {!get_relation_column} - def_API('get_relation_arity', UINT, (_in(CONTEXT), _in(SORT))) *) external get_relation_arity : context -> sort -> int @@ -9278,24 +7860,20 @@ external get_relation_arity : context -> sort -> int (** Summary: Return sort at i'th column of relation sort. - - {b Precondition}: get_sort_kind c s == RELATION_SORT - {b Precondition}: col < get_relation_arity c s - - {b See also}: {!get_relation_arity} - def_API('get_relation_column', SORT, (_in(CONTEXT), _in(SORT), _in(UINT))) *) external get_relation_column : context -> sort -> int -> sort = "camlidl_z3V3_Z3_get_relation_column" (** - {3 {L Function Declarations}} + {3 {L Function Declarations}} *) (** - Summary: Convert a [func_decl] into [ast]. - - {b Remarks}: [func_decl_to_ast c f] can be replaced by [(f :> ast)]. - + Summary: Convert a [func_decl] into [ast]. + - {b Remarks}: [func_decl_to_ast c f] can be replaced by [(f :> ast)]. def_API('func_decl_to_ast', AST, (_in(CONTEXT), _in(FUNC_DECL))) *) external func_decl_to_ast : context -> func_decl -> ast @@ -9303,8 +7881,7 @@ external func_decl_to_ast : context -> func_decl -> ast (** Summary: compare terms. - - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. - + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. def_API('is_eq_func_decl', BOOL, (_in(CONTEXT), _in(FUNC_DECL), _in(FUNC_DECL))) *) external is_eq_func_decl : context -> func_decl -> func_decl -> bool @@ -9312,16 +7889,14 @@ external is_eq_func_decl : context -> func_decl -> func_decl -> bool (** Summary: Return a unique identifier for [f]. - - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. - + - {b Remarks}: Implicitly used by [Pervasives.( = )] and [Pervasives.compare]. def_API('get_func_decl_id', UINT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_func_decl_id : context -> func_decl -> int = "camlidl_z3V3_Z3_get_func_decl_id" (** - Summary: Return the constant declaration name as a symbol. - + Summary: Return the constant declaration name as a symbol. def_API('get_decl_name', SYMBOL, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_decl_name : context -> func_decl -> symbol @@ -9329,7 +7904,6 @@ external get_decl_name : context -> func_decl -> symbol (** Summary: Return declaration kind corresponding to declaration. - def_API('get_decl_kind', UINT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_decl_kind : context -> func_decl -> decl_kind @@ -9337,9 +7911,7 @@ external get_decl_kind : context -> func_decl -> decl_kind (** Summary: Return the number of parameters of the given declaration. - - {b See also}: {!get_arity} - def_API('get_domain_size', UINT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_domain_size : context -> func_decl -> int @@ -9347,9 +7919,7 @@ external get_domain_size : context -> func_decl -> int (** Summary: Alias for [get_domain_size]. - - {b See also}: {!get_domain_size} - def_API('get_arity', UINT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_arity : context -> func_decl -> int @@ -9358,11 +7928,8 @@ external get_arity : context -> func_decl -> int (** Summary: \[ [ get_domain c d i ] \] Return the sort of the i-th parameter of the given function declaration. - - {b Precondition}: i < get_domain_size d - - {b See also}: {!get_domain_size} - def_API('get_domain', SORT, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_domain : context -> func_decl -> int -> sort @@ -9370,11 +7937,9 @@ external get_domain : context -> func_decl -> int -> sort (** Summary: \[ [ get_range c d ] \] - Return the range of the given declaration. - + Return the range of the given declaration. If [d] is a constant (i.e., has zero arguments), then this function returns the sort of the constant. - def_API('get_range', SORT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_range : context -> func_decl -> sort @@ -9382,7 +7947,6 @@ external get_range : context -> func_decl -> sort (** Summary: Return the number of parameters associated with a declaration. - def_API('get_decl_num_parameters', UINT, (_in(CONTEXT), _in(FUNC_DECL))) *) external get_decl_num_parameters : context -> func_decl -> int @@ -9390,11 +7954,9 @@ external get_decl_num_parameters : context -> func_decl -> int (** Summary: Return the parameter type associated with a declaration. - @param c the context @param d the function declaration @param idx is the index of the named parameter it should be between 0 and the number of parameters. - def_API('get_decl_parameter_kind', UINT, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_parameter_kind : context -> func_decl -> int -> parameter_kind @@ -9402,9 +7964,7 @@ external get_decl_parameter_kind : context -> func_decl -> int -> parameter_kind (** Summary: Return the integer value associated with an integer parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_INT - def_API('get_decl_int_parameter', INT, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_int_parameter : context -> func_decl -> int -> int @@ -9412,9 +7972,7 @@ external get_decl_int_parameter : context -> func_decl -> int -> int (** Summary: Return the double value associated with an double parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_DOUBLE - def_API('get_decl_double_parameter', DOUBLE, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_double_parameter : context -> func_decl -> int -> float @@ -9422,9 +7980,7 @@ external get_decl_double_parameter : context -> func_decl -> int -> float (** Summary: Return the double value associated with an double parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_SYMBOL - def_API('get_decl_symbol_parameter', SYMBOL, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_symbol_parameter : context -> func_decl -> int -> symbol @@ -9432,9 +7988,7 @@ external get_decl_symbol_parameter : context -> func_decl -> int -> symbol (** Summary: Return the sort value associated with a sort parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_SORT - def_API('get_decl_sort_parameter', SORT, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_sort_parameter : context -> func_decl -> int -> sort @@ -9442,9 +7996,7 @@ external get_decl_sort_parameter : context -> func_decl -> int -> sort (** Summary: Return the expresson value associated with an expression parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_AST - def_API('get_decl_ast_parameter', AST, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_ast_parameter : context -> func_decl -> int -> ast @@ -9452,9 +8004,7 @@ external get_decl_ast_parameter : context -> func_decl -> int -> ast (** Summary: Return the expresson value associated with an expression parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_FUNC_DECL - def_API('get_decl_func_decl_parameter', FUNC_DECL, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_func_decl_parameter : context -> func_decl -> int -> func_decl @@ -9462,21 +8012,18 @@ external get_decl_func_decl_parameter : context -> func_decl -> int -> func_decl (** Summary: Return the rational value, as a string, associated with a rational parameter. - - {b Precondition}: get_decl_parameter_kind c d idx == PARAMETER_RATIONAL - def_API('get_decl_rational_parameter', STRING, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT))) *) external get_decl_rational_parameter : context -> func_decl -> int -> string = "camlidl_z3V3_Z3_get_decl_rational_parameter" (** - {3 {L Applications}} + {3 {L Applications}} *) (** - Summary: Convert a [app] into [ast]. - - {b Remarks}: [app_to_ast c a] can be replaced by [(a :> ast)]. - + Summary: Convert a [app] into [ast]. + - {b Remarks}: [app_to_ast c a] can be replaced by [(a :> ast)]. def_API('app_to_ast', AST, (_in(CONTEXT), _in(APP))) *) external app_to_ast : context -> app -> ast @@ -9484,7 +8031,6 @@ external app_to_ast : context -> app -> ast (** Summary: Return the declaration of a constant or function application. - def_API('get_app_decl', FUNC_DECL, (_in(CONTEXT), _in(APP))) *) external get_app_decl : context -> app -> func_decl @@ -9494,7 +8040,6 @@ external get_app_decl : context -> app -> func_decl Summary: \[ [ get_app_num_args c a ] \] Return the number of argument of an application. If [t] is an constant, then the number of arguments is 0. - def_API('get_app_num_args', UINT, (_in(CONTEXT), _in(APP))) *) external get_app_num_args : context -> app -> int @@ -9503,21 +8048,18 @@ external get_app_num_args : context -> app -> int (** Summary: \[ [ get_app_arg c a i ] \] Return the i-th argument of the given application. - - {b Precondition}: i < get_num_args c a - def_API('get_app_arg', AST, (_in(CONTEXT), _in(APP), _in(UINT))) *) external get_app_arg : context -> app -> int -> ast = "camlidl_z3V3_Z3_get_app_arg" (** - {3 {L Terms}} + {3 {L Terms}} *) (** Summary: compare terms. - - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. - + - {b Remarks}: [Pervasives.( = )] or [Pervasives.compare] can also be used. def_API('is_eq_ast', BOOL, (_in(CONTEXT), _in(AST), _in(AST))) *) external is_eq_ast : context -> ast -> ast -> bool @@ -9525,8 +8067,7 @@ external is_eq_ast : context -> ast -> ast -> bool (** Summary: Return a unique identifier for [t]. - - {b Remarks}: Implicitly used by [Pervasives.compare] for values of type [ast], [app], [sort], [func_decl], and [pattern]. - + - {b Remarks}: Implicitly used by [Pervasives.compare] for values of type [ast], [app], [sort], [func_decl], and [pattern]. def_API('get_ast_id', UINT, (_in(CONTEXT), _in(AST))) *) external get_ast_id : context -> ast -> int @@ -9534,8 +8075,7 @@ external get_ast_id : context -> ast -> int (** Summary: Return a hash code for the given AST. - - {b Remarks}: Implicitly used by [Hashtbl.hash] for values of type [ast], [app], [sort], [func_decl], and [pattern]. - + - {b Remarks}: Implicitly used by [Hashtbl.hash] for values of type [ast], [app], [sort], [func_decl], and [pattern]. def_API('get_ast_hash', UINT, (_in(CONTEXT), _in(AST))) *) external get_ast_hash : context -> ast -> int @@ -9543,9 +8083,7 @@ external get_ast_hash : context -> ast -> int (** Summary: Return the sort of an AST node. - The AST node must be a constant, application, numeral, bound variable, or quantifier. - def_API('get_sort', SORT, (_in(CONTEXT), _in(AST))) *) external get_sort : context -> ast -> sort @@ -9553,7 +8091,6 @@ external get_sort : context -> ast -> sort (** Summary: Return true if the given expression [t] is well sorted. - def_API('is_well_sorted', BOOL, (_in(CONTEXT), _in(AST))) *) external is_well_sorted : context -> ast -> bool @@ -9561,7 +8098,6 @@ external is_well_sorted : context -> ast -> bool (** Summary: Return L_TRUE if [a] is true, L_FALSE if it is false, and L_UNDEF otherwise. - def_API('get_bool_value', UINT, (_in(CONTEXT), _in(AST))) *) external get_bool_value : context -> ast -> lbool @@ -9569,14 +8105,13 @@ external get_bool_value : context -> ast -> lbool (** Summary: Return the kind of the given AST. - def_API('get_ast_kind', UINT, (_in(CONTEXT), _in(AST))) *) external get_ast_kind : context -> ast -> ast_kind = "camlidl_z3V3_Z3_get_ast_kind" (** - def_API('is_app', BOOL, (_in(CONTEXT), _in(AST))) + def_API('is_app', BOOL, (_in(CONTEXT), _in(AST))) *) external is_app : context -> ast -> bool = "camlidl_z3V3_Z3_is_app" @@ -9589,17 +8124,14 @@ external is_numeral_ast : context -> ast -> bool (** Summary: Return true if the give AST is a real algebraic number. - def_API('is_algebraic_number', BOOL, (_in(CONTEXT), _in(AST))) *) external is_algebraic_number : context -> ast -> bool = "camlidl_z3V3_Z3_is_algebraic_number" (** - Summary: Convert an [ast] into an [APP_AST]. - - - {b Precondition}: {v get_ast_kind c a == [APP_AST] v} - + Summary: Convert an [ast] into an [APP_AST]. + - {b Precondition}: {v get_ast_kind c a == [APP_AST] v} def_API('to_app', APP, (_in(CONTEXT), _in(AST))) *) external to_app : context -> ast -> app @@ -9607,25 +8139,21 @@ external to_app : context -> ast -> app (** Summary: Convert an AST into a FUNC_DECL_AST. This is just type casting. - - - {b Precondition}: {v get_ast_kind c a == FUNC_DECL_AST v} - + - {b Precondition}: {v get_ast_kind c a == FUNC_DECL_AST v} def_API('to_func_decl', FUNC_DECL, (_in(CONTEXT), _in(AST))) *) external to_func_decl : context -> ast -> func_decl = "camlidl_z3V3_Z3_to_func_decl" (** - {4 {L Numerals}} + {4 {L Numerals}} *) (** - {5 {L Low-level API}} + {5 {L Low-level API}} *) (** Summary: Return numeral value, as a string of a numeric constant term - - {b Precondition}: get_ast_kind c a == NUMERAL_AST - def_API('get_numeral_string', STRING, (_in(CONTEXT), _in(AST))) *) external get_numeral_string : context -> ast -> string @@ -9634,19 +8162,15 @@ external get_numeral_string : context -> ast -> string (** Summary: Return numeral as a string in decimal notation. The result has at most [precision] decimal places. - - {b Precondition}: get_ast_kind c a == NUMERAL_AST || is_algebraic_number c a - - def_API('get_numeral_decimal_string', STRING, (_in(CONTEXT), _in(AST), _in(UINT))) + def_API('get_numeral_decimal_string', STRING, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_numeral_decimal_string : context -> ast -> int -> string = "camlidl_z3V3_Z3_get_numeral_decimal_string" (** Summary: Return the numerator (as a numeral AST) of a numeral AST of sort Real. - - {b Precondition}: get_ast_kind c a == NUMERAL_AST - def_API('get_numerator', AST, (_in(CONTEXT), _in(AST))) *) external get_numerator : context -> ast -> ast @@ -9654,9 +8178,7 @@ external get_numerator : context -> ast -> ast (** Summary: Return the denominator (as a numeral AST) of a numeral AST of sort Real. - - {b Precondition}: get_ast_kind c a == NUMERAL_AST - def_API('get_denominator', AST, (_in(CONTEXT), _in(AST))) *) external get_denominator : context -> ast -> ast @@ -9664,16 +8186,12 @@ external get_denominator : context -> ast -> ast (** Summary: Return numeral value, as a pair of 64 bit numbers if the representation fits. - @param c logical context. @param a term. @param num numerator. @param den denominator. - Return [TRUE] if the numeral value fits in 64 bit numerals, [FALSE] otherwise. - - {b Precondition}: get_ast_kind a == NUMERAL_AST - def_API('get_numeral_small', BOOL, (_in(CONTEXT), _in(AST), _out(INT64), _out(INT64))) *) external get_numeral_small : context -> ast -> bool * int64 * int64 @@ -9683,11 +8201,8 @@ external get_numeral_small : context -> ast -> bool * int64 * int64 Summary: \[ [ get_numeral_int c v ] \] Similar to {!get_numeral_string}, but only succeeds if the value can fit in a machine int. Return TRUE if the call succeeded. - - {b Precondition}: get_ast_kind c v == NUMERAL_AST - - {b See also}: {!get_numeral_string} - def_API('get_numeral_int', BOOL, (_in(CONTEXT), _in(AST), _out(INT))) *) external get_numeral_int : context -> ast -> bool * int @@ -9697,11 +8212,8 @@ external get_numeral_int : context -> ast -> bool * int Summary: \[ [ get_numeral_int64 c v ] \] Similar to {!get_numeral_string}, but only succeeds if the value can fit in a machine long long int. Return TRUE if the call succeeded. - - {b Precondition}: get_ast_kind c v == NUMERAL_AST - - {b See also}: {!get_numeral_string} - def_API('get_numeral_int64', BOOL, (_in(CONTEXT), _in(AST), _out(INT64))) *) external get_numeral_int64 : context -> ast -> bool * int64 @@ -9711,47 +8223,39 @@ external get_numeral_int64 : context -> ast -> bool * int64 Summary: \[ [ get_numeral_rational_int64 c x y] \] Similar to {!get_numeral_string}, but only succeeds if the value can fit as a rational number as machine long long int. Return TRUE if the call succeeded. - - {b Precondition}: get_ast_kind c v == NUMERAL_AST - - {b See also}: {!get_numeral_string} - def_API('get_numeral_rational_int64', BOOL, (_in(CONTEXT), _in(AST), _out(INT64), _out(INT64))) *) external get_numeral_rational_int64 : context -> ast -> bool * int64 * int64 = "camlidl_z3V3_Z3_get_numeral_rational_int64" (** - Summary: Return a lower bound for the given real algebraic number. + Summary: Return a lower bound for the given real algebraic number. The interval isolating the number is smaller than 1/10^precision. The result is a numeral AST of sort Real. - - {b Precondition}: is_algebraic_number c a - def_API('get_algebraic_number_lower', AST, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_algebraic_number_lower : context -> ast -> int -> ast = "camlidl_z3V3_Z3_get_algebraic_number_lower" (** - Summary: Return a upper bound for the given real algebraic number. + Summary: Return a upper bound for the given real algebraic number. The interval isolating the number is smaller than 1/10^precision. The result is a numeral AST of sort Real. - - {b Precondition}: is_algebraic_number c a - def_API('get_algebraic_number_upper', AST, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_algebraic_number_upper : context -> ast -> int -> ast = "camlidl_z3V3_Z3_get_algebraic_number_upper" (** - {4 {L Patterns}} + {4 {L Patterns}} *) (** - Summary: Convert a pattern into ast. - - {b Remarks}: [pattern_to_ast c p] can be replaced by [(p :> ast)]. - + Summary: Convert a pattern into ast. + - {b Remarks}: [pattern_to_ast c p] can be replaced by [(p :> ast)]. def_API('pattern_to_ast', AST, (_in(CONTEXT), _in(PATTERN))) *) external pattern_to_ast : context -> pattern -> ast @@ -9759,7 +8263,6 @@ external pattern_to_ast : context -> pattern -> ast (** Summary: Return number of terms in pattern. - def_API('get_pattern_num_terms', UINT, (_in(CONTEXT), _in(PATTERN))) *) external get_pattern_num_terms : context -> pattern -> int @@ -9767,20 +8270,17 @@ external get_pattern_num_terms : context -> pattern -> int (** Summary: Return i'th ast in pattern. - def_API('get_pattern', AST, (_in(CONTEXT), _in(PATTERN), _in(UINT))) *) external get_pattern : context -> pattern -> int -> ast = "camlidl_z3V3_Z3_get_pattern" (** - {4 {L Quantifiers}} + {4 {L Quantifiers}} *) (** Summary: Return index of de-Brujin bound variable. - - {b Precondition}: get_ast_kind a == VAR_AST - def_API('get_index_value', UINT, (_in(CONTEXT), _in(AST))) *) external get_index_value : context -> ast -> int @@ -9788,29 +8288,23 @@ external get_index_value : context -> ast -> int (** Summary: Determine if quantifier is universal. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - - def_API('is_quantifier_forall', BOOL, (_in(CONTEXT), _in(AST))) + def_API('is_quantifier_forall', BOOL, (_in(CONTEXT), _in(AST))) *) external is_quantifier_forall : context -> ast -> bool = "camlidl_z3V3_Z3_is_quantifier_forall" (** Summary: Obtain weight of quantifier. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - - def_API('get_quantifier_weight', UINT, (_in(CONTEXT), _in(AST))) + def_API('get_quantifier_weight', UINT, (_in(CONTEXT), _in(AST))) *) external get_quantifier_weight : context -> ast -> int = "camlidl_z3V3_Z3_get_quantifier_weight" (** Summary: Return number of patterns used in quantifier. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_num_patterns', UINT, (_in(CONTEXT), _in(AST))) *) external get_quantifier_num_patterns : context -> ast -> int @@ -9818,9 +8312,7 @@ external get_quantifier_num_patterns : context -> ast -> int (** Summary: Return i'th pattern. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_pattern_ast', PATTERN, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_quantifier_pattern_ast : context -> ast -> int -> pattern @@ -9828,9 +8320,7 @@ external get_quantifier_pattern_ast : context -> ast -> int -> pattern (** Summary: Return number of no_patterns used in quantifier. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_num_no_patterns', UINT, (_in(CONTEXT), _in(AST))) *) external get_quantifier_num_no_patterns : context -> ast -> int @@ -9838,9 +8328,7 @@ external get_quantifier_num_no_patterns : context -> ast -> int (** Summary: Return i'th no_pattern. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_no_pattern_ast', AST, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_quantifier_no_pattern_ast : context -> ast -> int -> ast @@ -9848,9 +8336,7 @@ external get_quantifier_no_pattern_ast : context -> ast -> int -> ast (** Summary: Return number of bound variables of quantifier. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_num_bound', UINT, (_in(CONTEXT), _in(AST))) *) external get_quantifier_num_bound : context -> ast -> int @@ -9858,9 +8344,7 @@ external get_quantifier_num_bound : context -> ast -> int (** Summary: Return symbol of the i'th bound variable. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_bound_name', SYMBOL, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_quantifier_bound_name : context -> ast -> int -> symbol @@ -9868,9 +8352,7 @@ external get_quantifier_bound_name : context -> ast -> int -> symbol (** Summary: Return sort of the i'th bound variable. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_bound_sort', SORT, (_in(CONTEXT), _in(AST), _in(UINT))) *) external get_quantifier_bound_sort : context -> ast -> int -> sort @@ -9878,22 +8360,18 @@ external get_quantifier_bound_sort : context -> ast -> int -> sort (** Summary: Return body of quantifier. - - {b Precondition}: get_ast_kind a == QUANTIFIER_AST - def_API('get_quantifier_body', AST, (_in(CONTEXT), _in(AST))) *) external get_quantifier_body : context -> ast -> ast = "camlidl_z3V3_Z3_get_quantifier_body" (** - {3 {L Simplification}} + {3 {L Simplification}} *) (** Summary: Interface to simplifier. - Provides an interface to the AST simplifier used by Z3. - def_API('simplify', AST, (_in(CONTEXT), _in(AST))) *) external simplify : context -> ast -> ast @@ -9904,10 +8382,9 @@ external simplify : context -> ast -> ast *) (** Summary: Update the arguments of term [a] using the arguments [args]. - The number of arguments [num_args] should coincide + The number of arguments [num_args] should coincide with the number of arguments to [a]. If [a] is a quantifier, then num_args has to be 1. - def_API('update_term', AST, (_in(CONTEXT), _in(AST), _in(UINT), _in_array(2, AST))) *) external update_term : context -> ast -> ast array -> ast @@ -9917,7 +8394,6 @@ external update_term : context -> ast -> ast array -> ast Summary: Substitute every occurrence of {e from[i] } in [a] with {e to[i] }, for [i] smaller than [num_exprs]. The result is the new AST. The arrays [from] and [to] must have size [num_exprs]. For every [i] smaller than [num_exprs], we must have that sort of {e from[i] } must be equal to sort of {e to[i] }. - def_API('substitute', AST, (_in(CONTEXT), _in(AST), _in(UINT), _in_array(2, AST), _in_array(2, AST))) *) external substitute : context -> ast -> ast array -> ast array -> ast @@ -9926,7 +8402,6 @@ external substitute : context -> ast -> ast array -> ast array -> ast (** Summary: Substitute the free variables in [a] with the expressions in [to]. For every [i] smaller than [num_exprs], the variable with de-Bruijn index [i] is replaced with term {e to[i] }. - def_API('substitute_vars', AST, (_in(CONTEXT), _in(AST), _in(UINT), _in_array(2, AST))) *) external substitute_vars : context -> ast -> ast array -> ast @@ -9937,7 +8412,6 @@ external substitute_vars : context -> ast -> ast array -> ast *) (** Summary: Log interaction to a file. - extra_API('open_log', INT, (_in(STRING),)) *) external open_log : string -> bool @@ -9945,11 +8419,9 @@ external open_log : string -> bool (** Summary: Append user-defined string to interaction log. - The interaction log is opened using open_log. It contains the formulas that are checked using Z3. You can use this command to append comments, for instance. - extra_API('append_log', VOID, (_in(STRING),)) *) external append_log : string -> unit @@ -9957,7 +8429,6 @@ external append_log : string -> unit (** Summary: Close interaction log. - extra_API('close_log', VOID, ()) *) external close_log : unit -> unit @@ -9965,10 +8436,8 @@ external close_log : unit -> unit (** Summary: Enable/disable printing warning messages to the console. - Warnings are printed after passing [true], warning messages are - suppressed after calling this method with [false]. - + suppressed after calling this method with [false]. def_API('toggle_warning_messages', VOID, (_in(BOOL),)) *) external toggle_warning_messages : bool -> unit @@ -9979,19 +8448,16 @@ external toggle_warning_messages : bool -> unit *) (** Summary: Select mode for the format used for pretty-printing AST nodes. - The default mode for pretty printing AST nodes is to produce - SMT-LIB style output where common subexpressions are printed + SMT-LIB style output where common subexpressions are printed at each occurrence. The mode is called PRINT_SMTLIB_FULL. - To print shared common subexpressions only once, + To print shared common subexpressions only once, use the PRINT_LOW_LEVEL mode. To print in way that conforms to SMT-LIB standards and uses let expressions to share common sub-expressions use PRINT_SMTLIB_COMPLIANT. - - {b See also}: {!ast_to_string} - {b See also}: {!pattern_to_string} - {b See also}: {!func_decl_to_string} - def_API('set_ast_print_mode', VOID, (_in(CONTEXT), _in(PRINT_MODE))) *) external set_ast_print_mode : context -> ast_print_mode -> unit @@ -9999,13 +8465,8 @@ external set_ast_print_mode : context -> ast_print_mode -> unit (** Summary: Convert the given AST node into a string. - - - - - {b See also}: {!pattern_to_string} - {b See also}: {!sort_to_string} - def_API('ast_to_string', STRING, (_in(CONTEXT), _in(AST))) *) external ast_to_string : context -> ast -> string @@ -10031,11 +8492,6 @@ external func_decl_to_string : context -> func_decl -> string (** Summary: Convert the given model into a string. - - - - - def_API('model_to_string', STRING, (_in(CONTEXT), _in(MODEL))) *) external model_to_string : context -> model -> string @@ -10043,80 +8499,66 @@ external model_to_string : context -> model -> string (** Summary: Convert the given benchmark into SMT-LIB formatted string. - - - - - @param c - context. @param name - name of benchmark. The argument is optional. - @param logic - the benchmark logic. + @param logic - the benchmark logic. @param status - the status string (sat, unsat, or unknown) @param attributes - other attributes, such as source, difficulty or category. @param num_assumptions - number of assumptions. @param assumptions - auxiliary assumptions. @param formula - formula to be checked for consistency in conjunction with assumptions. - def_API('benchmark_to_smtlib_string', STRING, (_in(CONTEXT), _in(STRING), _in(STRING), _in(STRING), _in(STRING), _in(UINT), _in_array(5, AST), _in(AST))) *) external benchmark_to_smtlib_string : context -> string -> string -> string -> string -> ast array -> ast -> string - = "camlidl_z3_Z3_benchmark_to_smtlib_string_bytecode" "camlidl_z3V3_Z3_benchmark_to_smtlib_string" + = "camlidl_z3V3_Z3_benchmark_to_smtlib_string_bytecode" "camlidl_z3V3_Z3_benchmark_to_smtlib_string" (** {2 {L Parser interface}} *) (** Summary: \[ [ parse_smtlib2_string c str ] \] - Parse the given string using the SMT-LIB2 parser. - + Parse the given string using the SMT-LIB2 parser. It returns a formula comprising of the conjunction of assertions in the scope (up to push/pop) at the end of the string. - def_API('parse_smtlib2_string', AST, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _in(UINT), _in_array(5, SYMBOL), _in_array(5, FUNC_DECL))) *) external parse_smtlib2_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast - = "camlidl_z3_Z3_parse_smtlib2_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_string" + = "camlidl_z3V3_Z3_parse_smtlib2_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_string" (** Summary: Similar to {!parse_smtlib2_string}, but reads the benchmark from a file. - def_API('parse_smtlib2_file', AST, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _in(UINT), _in_array(5, SYMBOL), _in_array(5, FUNC_DECL))) *) external parse_smtlib2_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast - = "camlidl_z3_Z3_parse_smtlib2_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_file" + = "camlidl_z3V3_Z3_parse_smtlib2_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib2_file" (** - {4 {L Low-level API}} + {4 {L Low-level API}} *) (** Summary: \[ [ parse_smtlib_string c str sort_names sorts decl_names decls ] \] - Parse the given string using the SMT-LIB parser. - - The symbol table of the parser can be initialized using the given sorts and declarations. + Parse the given string using the SMT-LIB parser. + The symbol table of the parser can be initialized using the given sorts and declarations. The symbols in the arrays [sort_names] and [decl_names] don't need to match the names of the sorts and declarations in the arrays [sorts] and [decls]. This is an useful feature since we can use arbitrary names to reference sorts and declarations defined using the C API. - The formulas, assumptions and declarations defined in [str] can be extracted using the functions: - {!get_smtlib_num_formulas}, {!get_smtlib_formula}, {!get_smtlib_num_assumptions}, {!get_smtlib_assumption}, + {!get_smtlib_num_formulas}, {!get_smtlib_formula}, {!get_smtlib_num_assumptions}, {!get_smtlib_assumption}, {!get_smtlib_num_decls}, and {!get_smtlib_decl}. - def_API('parse_smtlib_string', VOID, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _in(UINT), _in_array(5, SYMBOL), _in_array(5, FUNC_DECL))) *) external parse_smtlib_string : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit - = "camlidl_z3_Z3_parse_smtlib_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib_string" + = "camlidl_z3V3_Z3_parse_smtlib_string_bytecode" "camlidl_z3V3_Z3_parse_smtlib_string" (** Summary: Similar to {!parse_smtlib_string}, but reads the benchmark from a file. - def_API('parse_smtlib_file', VOID, (_in(CONTEXT), _in(STRING), _in(UINT), _in_array(2, SYMBOL), _in_array(2, SORT), _in(UINT), _in_array(5, SYMBOL), _in_array(5, FUNC_DECL))) *) external parse_smtlib_file : context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> unit - = "camlidl_z3_Z3_parse_smtlib_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib_file" + = "camlidl_z3V3_Z3_parse_smtlib_file_bytecode" "camlidl_z3V3_Z3_parse_smtlib_file" (** Summary: Return the number of SMTLIB formulas parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. - def_API('get_smtlib_num_formulas', UINT, (_in(CONTEXT), )) *) external get_smtlib_num_formulas : context -> int @@ -10125,9 +8567,7 @@ external get_smtlib_num_formulas : context -> int (** Summary: \[ [ get_smtlib_formula c i ] \] Return the i-th formula parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. - - {b Precondition}: i < get_smtlib_num_formulas c - def_API('get_smtlib_formula', AST, (_in(CONTEXT), _in(UINT))) *) external get_smtlib_formula : context -> int -> ast @@ -10135,7 +8575,6 @@ external get_smtlib_formula : context -> int -> ast (** Summary: Return the number of SMTLIB assumptions parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. - def_API('get_smtlib_num_assumptions', UINT, (_in(CONTEXT), )) *) external get_smtlib_num_assumptions : context -> int @@ -10144,9 +8583,7 @@ external get_smtlib_num_assumptions : context -> int (** Summary: \[ [ get_smtlib_assumption c i ] \] Return the i-th assumption parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. - - {b Precondition}: i < get_smtlib_num_assumptions c - def_API('get_smtlib_assumption', AST, (_in(CONTEXT), _in(UINT))) *) external get_smtlib_assumption : context -> int -> ast @@ -10154,7 +8591,6 @@ external get_smtlib_assumption : context -> int -> ast (** Summary: Return the number of declarations parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. - def_API('get_smtlib_num_decls', UINT, (_in(CONTEXT), )) *) external get_smtlib_num_decls : context -> int @@ -10163,9 +8599,7 @@ external get_smtlib_num_decls : context -> int (** Summary: \[ [ get_smtlib_decl c i ] \] Return the i-th declaration parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. - - {b Precondition}: i < get_smtlib_num_decls c - def_API('get_smtlib_decl', FUNC_DECL, (_in(CONTEXT), _in(UINT))) *) external get_smtlib_decl : context -> int -> func_decl @@ -10173,7 +8607,6 @@ external get_smtlib_decl : context -> int -> func_decl (** Summary: Return the number of sorts parsed by {!parse_smtlib_string} or {!parse_smtlib_file}. - def_API('get_smtlib_num_sorts', UINT, (_in(CONTEXT), )) *) external get_smtlib_num_sorts : context -> int @@ -10182,9 +8615,7 @@ external get_smtlib_num_sorts : context -> int (** Summary: \[ [ get_smtlib_sort c i ] \] Return the i-th sort parsed by the last call to {!parse_smtlib_string} or {!parse_smtlib_file}. - - {b Precondition}: i < get_smtlib_num_sorts c - def_API('get_smtlib_sort', SORT, (_in(CONTEXT), _in(UINT))) *) external get_smtlib_sort : context -> int -> sort @@ -10193,50 +8624,43 @@ external get_smtlib_sort : context -> int -> sort (** Summary: \[ [ get_smtlib_error c ] \] Retrieve that last error message information generated from parsing. - def_API('get_smtlib_error', STRING, (_in(CONTEXT), )) *) external get_smtlib_error : context -> string = "camlidl_z3V3_Z3_get_smtlib_error" -(** - Summary: \[ [ parse_z3_string c str ] \] - Parse the given string using the Z3 native parser. - - Return the conjunction of asserts made in the input. - - def_API('parse_z3_string', AST, (_in(CONTEXT), _in(STRING))) -*) -external parse_z3_string : context -> string -> ast - = "camlidl_z3_Z3_parse_z3V3_string" - -(** - Summary: Similar to {!parse_z3_string}, but reads the benchmark from a file. - - def_API('parse_z3_file', AST, (_in(CONTEXT), _in(STRING))) -*) -external parse_z3_file : context -> string -> ast - = "camlidl_z3_Z3_parse_z3V3_file" - (** {2 {L Miscellaneous}} *) (** Summary: Return Z3 version number information. - def_API('get_version', VOID, (_out(UINT), _out(UINT), _out(UINT), _out(UINT))) *) external get_version : unit -> int * int * int * int = "camlidl_z3V3_Z3_get_version" (** - Summary: Reset all allocated resources. + Summary: Enable tracing messages tagged as [tag] when Z3 is compiled in debug mode. + It is a NOOP otherwise + def_API('enable_trace', VOID, (_in(STRING),)) +*) +external enable_trace : string -> unit + = "camlidl_z3V3_Z3_enable_trace" - Use this facility on out-of memory errors. +(** + Summary: Disable tracing messages tagged as [tag] when Z3 is compiled in debug mode. + It is a NOOP otherwise + def_API('disable_trace', VOID, (_in(STRING),)) +*) +external disable_trace : string -> unit + = "camlidl_z3V3_Z3_disable_trace" + +(** + Summary: Reset all allocated resources. + Use this facility on out-of memory errors. It allows discharging the previous state and resuming afresh. Any pointers previously returned by the API become invalid. - def_API('reset_memory', VOID, ()) *) external reset_memory : unit -> unit @@ -10277,15 +8701,12 @@ external theory_get_context : theory -> context (** Summary: Assert a theory axiom/lemmas during the search. - - An axiom added at search level [n] will remain in the logical context until - level [n] is backtracked. - + An axiom added at search level [n] will remain in the logical context until + level [n] is backtracked. The callbacks for push ({!set_push_callback}) and pop ({!set_pop_callback}) can be used to track when the search level is increased (i.e., new case-split) and decreased (i.e., case-split is backtracked). - Z3 tracks the theory axioms asserted. So, multiple assertions of the same axiom are ignored. *) @@ -10296,7 +8717,6 @@ external theory_assert_axiom : theory -> ast -> unit Summary: Inform to the logical context that [lhs] and [rhs] have the same interpretation in the model being built by theory [t]. If lhs = rhs is inconsistent with other theories, then the logical context will backtrack. - For more information, see the paper "Model-Based Theory Combination" in the Z3 website. *) external theory_assume_eq : theory -> ast -> ast -> unit @@ -10304,7 +8724,7 @@ external theory_assume_eq : theory -> ast -> ast -> unit (** Summary: Enable/disable the simplification of theory axioms asserted using {!theory_assert_axiom}. - By default, the simplification of theory specific operators is disabled. + By default, the simplification of theory specific operators is disabled. That is, the reduce theory callbacks are not invoked for theory axioms. The default behavior is useful when asserting axioms stating properties of theory operators. *) @@ -10319,12 +8739,11 @@ external theory_get_eqc_root : theory -> ast -> ast (** Summary: Return the next element in the equivalence class containing [n]. - The elements in an equivalence class are organized in a circular list. - You can traverse the list by calling this function multiple times + You can traverse the list by calling this function multiple times using the result from the previous call. This is illustrated in the code snippet below. - {v + {v ast curr = n; do curr = theory_get_eqc_next(theory, curr); @@ -10335,14 +8754,14 @@ external theory_get_eqc_next : theory -> ast -> ast = "camlidl_z3V3_Z3_theory_get_eqc_next" (** - Summary: Return the number of parents of [n] that are operators of the given theory. + Summary: Return the number of parents of [n] that are operators of the given theory. *) external theory_get_num_parents : theory -> ast -> int = "camlidl_z3V3_Z3_theory_get_num_parents" (** - Summary: Return the i-th parent of [n]. - See {!theory_get_num_parents}. + Summary: Return the i-th parent of [n]. + See {!theory_get_num_parents}. *) external theory_get_parent : theory -> ast -> int -> ast = "camlidl_z3V3_Z3_theory_get_parent" @@ -10369,7 +8788,6 @@ external theory_get_num_elems : theory -> int (** Summary: Return the i-th elem of the given theory in the logical context. - - {b See}: {!theory_get_num_elems} *) external theory_get_elem : theory -> int -> ast @@ -10385,7 +8803,6 @@ external theory_get_num_apps : theory -> int (** Summary: Return the i-th application of the given theory in the logical context. - - {b See}: {!theory_get_num_apps} *) external theory_get_app : theory -> int -> ast @@ -10396,11 +8813,9 @@ external theory_get_app : theory -> int -> ast *) (** Summary: Create injective function declaration - @deprecated This method just asserts a (universally quantified) formula that asserts that the new function is injective. It is compatible with the old interface for solving: {!assert_cnstr}, {!check_assumptions}, etc. - def_API('mk_injective_function', FUNC_DECL, (_in(CONTEXT), _in(SYMBOL), _in(UINT), _in_array(2, SORT), _in(SORT))) *) external mk_injective_function : context -> symbol -> sort array -> sort -> func_decl @@ -10414,9 +8829,7 @@ external mk_injective_function : context -> symbol -> sort array -> sort -> func It is incorrect to invoke this function after invoking {!check}, {!check_and_get_model}, {!check_assumptions} and {!push}. Return [TRUE] if the logic was changed successfully, and [FALSE] otherwise. - @deprecated Subsumed by {!mk_solver_for_logic} - def_API('set_logic', VOID, (_in(CONTEXT), _in(STRING))) *) external set_logic : context -> string -> bool @@ -10424,15 +8837,11 @@ external set_logic : context -> string -> bool (** Summary: Create a backtracking point. - - The logical context can be viewed as a stack of contexts. The + The logical context can be viewed as a stack of contexts. The scope level is the number of elements on this stack. The stack of contexts is simulated using trail (undo) stacks. - - {b See also}: {!pop} - @deprecated Subsumed by {!solver_push} - def_API('push', VOID, (_in(CONTEXT),)) *) external push : context -> unit @@ -10440,17 +8849,13 @@ external push : context -> unit (** Summary: Backtrack. - Restores the context from the top of the stack, and pops it off the - stack. Any changes to the logical context (by {!assert_cnstr} or + stack. Any changes to the logical context (by {!assert_cnstr} or other functions) between the matching {!push} and [pop] operators are flushed, and the context is completely restored to what it was right before the {!push}. - - {b See also}: {!push} - @deprecated Subsumed by {!solver_pop} - def_API('pop', VOID, (_in(CONTEXT), _in(UINT))) *) external pop : context -> int -> unit @@ -10458,38 +8863,17 @@ external pop : context -> int -> unit (** Summary: Retrieve the current scope level. - It retrieves the number of scopes that have been pushed, but not yet popped. - - {b See also}: {!push} - {b See also}: {!pop} - @deprecated Subsumed by {!solver_get_num_scopes}. - def_API('get_num_scopes', UINT, (_in(CONTEXT),)) *) external get_num_scopes : context -> int = "camlidl_z3V3_Z3_get_num_scopes" (** - - - - - - - - - - - - - - - - - @deprecated This function has no effect. - + @deprecated This function has no effect. def_API('persist_ast', VOID, (_in(CONTEXT), _in(AST), _in(UINT))) *) external persist_ast : context -> ast -> int -> unit @@ -10497,18 +8881,13 @@ external persist_ast : context -> ast -> int -> unit (** Summary: Assert a constraint into the logical context. - After one assertion, the logical context may become - inconsistent. - + inconsistent. The functions {!check} or {!check_and_get_model} should be used to check whether the logical context is consistent or not. - - {b See also}: {!check} - {b See also}: {!check_and_get_model} - @deprecated Subsumed by {!solver_assert} - def_API('assert_cnstr', VOID, (_in(CONTEXT), _in(AST))) *) external assert_cnstr : context -> ast -> unit @@ -10516,25 +8895,13 @@ external assert_cnstr : context -> ast -> unit (** Summary: Check whether the given logical context is consistent or not. - If the logical context is not unsatisfiable (i.e., the return value is different from [L_FALSE)] and model construction is enabled (see {!mk_config}), - - then a valid model is returned. Otherwise, it is unsafe to use the returned model. - - - - - - + then a valid model is returned. Otherwise, it is unsafe to use the returned model. - {b Remarks}: Model construction must be enabled using configuration parameters (See, {!mk_config}). - - {b See also}: {!check} - - @deprecated Subsumed by {!solver_check} - def_API('check_and_get_model', INT, (_in(CONTEXT), _out(MODEL))) *) external check_and_get_model : context -> lbool * model @@ -10542,13 +8909,9 @@ external check_and_get_model : context -> lbool * model (** Summary: Check whether the given logical context is consistent or not. - The function {!check_and_get_model} should be used when models are needed. - - {b See also}: {!check_and_get_model} - @deprecated Subsumed by {!solver_check} - def_API('check', INT, (_in(CONTEXT),)) *) external check : context -> lbool @@ -10556,40 +8919,23 @@ external check : context -> lbool (** Summary: Check whether the given logical context and optional assumptions is consistent or not. - If the logical context is not unsatisfiable (i.e., the return value is different from [L_FALSE)], - and model construction is enabled (see {!mk_config}), - - then a valid model is returned. Otherwise, it is unsafe to use the returned model. - - - - - + then a valid model is returned. Otherwise, it is unsafe to use the returned model. @param c logical context. @param num_assumptions number of auxiliary assumptions. @param assumptions array of auxiliary assumptions @param m optional pointer to a model. @param proof optional pointer to a proof term. - @param core_size size of unsatisfiable core. - @param core pointer to an array receiving unsatisfiable core. + @param core_size size of unsatisfiable core. + @param core pointer to an array receiving unsatisfiable core. The unsatisfiable core is a subset of the assumptions, so the array has the same size as the assumptions. The [core] array is not populated if [core_size] is set to 0. - - {b Precondition}: assumptions comprises of propositional literals. - In other words, you cannot use compound formulas for assumptions, + In other words, you cannot use compound formulas for assumptions, but should use propositional variables or negations of propositional variables. - - - - - - {b See also}: {!check} - - @deprecated Subsumed by {!solver_check_assumptions} - def_API('check_assumptions', INT, (_in(CONTEXT), _in(UINT), _in_array(1, AST), _out(MODEL), _out(AST), _out(UINT), _out_array2(1, 5, AST))) *) external check_assumptions : context -> ast array -> int -> ast array -> lbool * model * ast * int * ast array @@ -10597,25 +8943,20 @@ external check_assumptions : context -> ast array -> int -> ast array -> lbool * (** Summary: Retrieve congruence class representatives for terms. - The function can be used for relying on Z3 to identify equal terms under the current set of assumptions. The array of terms and array of class identifiers should have the same length. The class identifiers are numerals that are assigned to the same value for their corresponding terms if the current context forces the terms to be - equal. You cannot deduce that terms corresponding to different numerals must be all different, + equal. You cannot deduce that terms corresponding to different numerals must be all different, (especially when using non-convex theories). All implied equalities are returned by this call. This means that two terms map to the same class identifier if and only if the current context implies that they are equal. - A side-effect of the function is a satisfiability check. The function return L_FALSE if the current assertions are not satisfiable. - - {b See also}: {!check_and_get_model} - {b See also}: {!check} - @deprecated Subsumed by solver API - def_API('get_implied_equalities', UINT, (_in(CONTEXT), _in(UINT), _in_array(1, AST), _out_array(1, UINT))) *) external get_implied_equalities : context -> ast array -> lbool * int array @@ -10623,11 +8964,8 @@ external get_implied_equalities : context -> ast array -> lbool * int array (** Summary: Delete a model object. - - {b See also}: {!check_and_get_model} - @deprecated Subsumed by solver API - def_API('del_model', VOID, (_in(CONTEXT), _in(MODEL))) *) external del_model : context -> model -> unit @@ -10638,13 +8976,10 @@ external del_model : context -> model -> unit *) (** Summary: Cancel an ongoing check. - Notifies the current check to abort and return. This method should be called from a different thread than the one performing the check. - @deprecated Use {!interrupt} instead. - def_API('soft_check_cancel', VOID, (_in(CONTEXT), )) *) external soft_check_cancel : context -> unit @@ -10652,12 +8987,9 @@ external soft_check_cancel : context -> unit (** Summary: Retrieve reason for search failure. - - If a call to {!check} or {!check_and_get_model} returns L_UNDEF, + If a call to {!check} or {!check_and_get_model} returns L_UNDEF, use this facility to determine the more detailed cause of search failure. - @deprecated Subsumed by {!solver_get_reason_unknown} - def_API('get_search_failure', UINT, (_in(CONTEXT), )) *) external get_search_failure : context -> search_failure @@ -10668,20 +9000,16 @@ external get_search_failure : context -> search_failure *) (** Summary: Create a labeled formula. - @param c logical context. @param s name of the label. @param is_pos label polarity. @param f formula being labeled. - - A label behaves as an identity function, so the truth value of the - labeled formula is unchanged. Labels are used for identifying + A label behaves as an identity function, so the truth value of the + labeled formula is unchanged. Labels are used for identifying useful sub-formulas when generating counter-examples. - @deprecated Labels are only supported by the old Solver API. This feature is not essential (it can be simulated using auxiliary Boolean variables). It is only available for backward compatibility. - def_API('mk_label', AST, (_in(CONTEXT), _in(SYMBOL), _in(BOOL), _in(AST))) *) external mk_label : context -> symbol -> bool -> ast -> ast @@ -10690,14 +9018,11 @@ external mk_label : context -> symbol -> bool -> ast -> ast (** Summary: Retrieve the set of labels that were relevant in the context of the current satisfied context. - - {b See also}: {!del_literals} - {b See also}: {!get_num_literals} - {b See also}: {!get_label_symbol} - {b See also}: {!get_literal} - @deprecated This procedure is based on the old Solver API. - def_API('get_relevant_labels', LITERALS, (_in(CONTEXT), )) *) external get_relevant_labels : context -> literals @@ -10705,30 +9030,24 @@ external get_relevant_labels : context -> literals (** Summary: Retrieve the set of literals that satisfy the current context. - - {b See also}: {!del_literals} - {b See also}: {!get_num_literals} - {b See also}: {!get_label_symbol} - {b See also}: {!get_literal} - @deprecated This procedure is based on the old Solver API. - def_API('get_relevant_literals', LITERALS, (_in(CONTEXT), )) *) external get_relevant_literals : context -> literals = "camlidl_z3V3_Z3_get_relevant_literals" (** - Summary: Retrieve the set of literals that whose assignment were + Summary: Retrieve the set of literals that whose assignment were guess, but not propagated during the search. - - {b See also}: {!del_literals} - {b See also}: {!get_num_literals} - {b See also}: {!get_label_symbol} - {b See also}: {!get_literal} - @deprecated This procedure is based on the old Solver API. - def_API('get_guessed_literals', LITERALS, (_in(CONTEXT), )) *) external get_guessed_literals : context -> literals @@ -10736,11 +9055,8 @@ external get_guessed_literals : context -> literals (** Summary: Delete a labels context. - - {b See also}: {!get_relevant_labels} - @deprecated This procedure is based on the old Solver API. - def_API('del_literals', VOID, (_in(CONTEXT), _in(LITERALS))) *) external del_literals : context -> literals -> unit @@ -10748,11 +9064,8 @@ external del_literals : context -> literals -> unit (** Summary: Retrieve the number of label symbols that were returned. - - {b See also}: {!get_relevant_labels} - @deprecated This procedure is based on the old Solver API. - def_API('get_num_literals', UINT, (_in(CONTEXT), _in(LITERALS))) *) external get_num_literals : context -> literals -> int @@ -10760,9 +9073,7 @@ external get_num_literals : context -> literals -> int (** Summary: Retrieve label symbol at idx. - @deprecated This procedure is based on the old Solver API. - def_API('get_label_symbol', SYMBOL, (_in(CONTEXT), _in(LITERALS), _in(UINT))) *) external get_label_symbol : context -> literals -> int -> symbol @@ -10770,9 +9081,7 @@ external get_label_symbol : context -> literals -> int -> symbol (** Summary: Retrieve literal expression at idx. - @deprecated This procedure is based on the old Solver API. - def_API('get_literal', AST, (_in(CONTEXT), _in(LITERALS), _in(UINT))) *) external get_literal : context -> literals -> int -> ast @@ -10780,13 +9089,9 @@ external get_literal : context -> literals -> int -> ast (** Summary: Disable label. - The disabled label is not going to be used when blocking the subsequent search. - - {b See also}: {!block_literals} - @deprecated This procedure is based on the old Solver API. - def_API('disable_literal', VOID, (_in(CONTEXT), _in(LITERALS), _in(UINT))) *) external disable_literal : context -> literals -> int -> unit @@ -10794,9 +9099,7 @@ external disable_literal : context -> literals -> int -> unit (** Summary: Block subsequent checks using the remaining enabled labels. - @deprecated This procedure is based on the old Solver API. - def_API('block_literals', VOID, (_in(CONTEXT), _in(LITERALS))) *) external block_literals : context -> literals -> unit @@ -10807,13 +9110,9 @@ external block_literals : context -> literals -> unit *) (** Summary: Return the number of constants assigned by the given model. - - - {b Remarks}: Consider using {!get_model_constants}. - + - {b Remarks}: Consider using {!get_model_constants}. - {b See also}: {!get_model_constant} - @deprecated use {!model_get_num_consts} - def_API('get_model_num_constants', UINT, (_in(CONTEXT), _in(MODEL))) *) external get_model_num_constants : context -> model -> int @@ -10821,14 +9120,10 @@ external get_model_num_constants : context -> model -> int (** Summary: \[ [ get_model_constant c m i ] \] - Return the i-th constant in the given model. - - - {b Remarks}: Consider using {!get_model_constants}. - + Return the i-th constant in the given model. + - {b Remarks}: Consider using {!get_model_constants}. - {b Precondition}: i < get_model_num_constants c m - @deprecated use {!model_get_const_decl} - def_API('get_model_constant', FUNC_DECL, (_in(CONTEXT), _in(MODEL), _in(UINT))) *) external get_model_constant : context -> model -> int -> func_decl @@ -10836,12 +9131,9 @@ external get_model_constant : context -> model -> int -> func_decl (** Summary: Return the number of function interpretations in the given model. - A function interpretation is represented as a finite map and an 'else' value. Each entry in the finite map represents the value of a function given a set of arguments. - @deprecated use {!model_get_num_funcs} - def_API('get_model_num_funcs', UINT, (_in(CONTEXT), _in(MODEL))) *) external get_model_num_funcs : context -> model -> int @@ -10850,24 +9142,18 @@ external get_model_num_funcs : context -> model -> int (** Summary: \[ [ get_model_func_decl c m i ] \] Return the declaration of the i-th function in the given model. - - {b Precondition}: i < get_model_num_funcs c m - - {b See also}: {!get_model_num_funcs} - @deprecated use {!model_get_func_decl} - def_API('get_model_func_decl', FUNC_DECL, (_in(CONTEXT), _in(MODEL), _in(UINT))) *) external get_model_func_decl : context -> model -> int -> func_decl = "camlidl_z3V3_Z3_get_model_func_decl" (** - Summary: Return the value of the given constant or function + Summary: Return the value of the given constant or function in the given model. - @deprecated Consider using {!model_eval} or {!model_get_func_interp} - def_API('eval_func_decl', BOOL, (_in(CONTEXT), _in(MODEL), _in(FUNC_DECL), _out(AST))) *) external eval_func_decl : context -> model -> func_decl -> bool * ast @@ -10875,17 +9161,14 @@ external eval_func_decl : context -> model -> func_decl -> bool * ast (** Summary: \[ [ is_array_value c v ] \] - Determine whether the term encodes an array value. - A term encodes an array value if it is a nested sequence of + Determine whether the term encodes an array value. + A term encodes an array value if it is a nested sequence of applications of store on top of a constant array. The indices to the stores have to be values (for example, integer constants) so that equality between the indices can be evaluated. Array values are useful for representing interpretations for arrays. - Return the number of entries mapping to non-default values of the array. - @deprecated Use {!is_as_array} - def_API('is_array_value', BOOL, (_in(CONTEXT), _in(MODEL), _in(AST), _out(UINT))) *) external is_array_value : context -> model -> ast -> bool * int @@ -10895,11 +9178,8 @@ external is_array_value : context -> model -> ast -> bool * int Summary: \[ [ get_array_value c v ] \] An array values is represented as a dictionary plus a default (else) value. This function returns the array graph. - - - {b Precondition}: TRUE == is_array_value c v &num_entries - + - {b Precondition}: TRUE == is_array_value c v &num_entries @deprecated Use func_interp objects and {!get_as_array_func_decl} - def_API('get_array_value', VOID, (_in(CONTEXT), _in(MODEL), _in(AST), _in(UINT), _out_array(3, AST), _out_array(3, AST), _out (AST))) *) external get_array_value : context -> model -> ast -> ast array -> ast array -> ast array * ast array * ast @@ -10908,20 +9188,14 @@ external get_array_value : context -> model -> ast -> ast array -> ast array -> (** Summary: \[ [ get_model_func_else c m i ] \] Return the 'else' value of the i-th function interpretation in the given model. - A function interpretation is represented as a finite map and an 'else' value. - - - {b Remarks}: Consider using {!get_model_funcs}. - + - {b Remarks}: Consider using {!get_model_funcs}. - {b Precondition}: i < get_model_num_funcs c m - - {b See also}: {!get_model_num_funcs} - {b See also}: {!get_model_func_num_entries} - {b See also}: {!get_model_func_entry_num_args} - {b See also}: {!get_model_func_entry_arg} - @deprecated Use func_interp objects - def_API('get_model_func_else', AST, (_in(CONTEXT), _in(MODEL), _in(UINT))) *) external get_model_func_else : context -> model -> int -> ast @@ -10930,20 +9204,14 @@ external get_model_func_else : context -> model -> int -> ast (** Summary: \[ [ get_model_func_num_entries c m i ] \] Return the number of entries of the i-th function interpretation in the given model. - A function interpretation is represented as a finite map and an 'else' value. - - - {b Remarks}: Consider using {!get_model_funcs}. - + - {b Remarks}: Consider using {!get_model_funcs}. - {b Precondition}: i < get_model_num_funcs c m - - {b See also}: {!get_model_num_funcs} - {b See also}: {!get_model_func_else} - {b See also}: {!get_model_func_entry_num_args} - {b See also}: {!get_model_func_entry_arg} - @deprecated Use func_interp objects - def_API('get_model_func_num_entries', UINT, (_in(CONTEXT), _in(MODEL), _in(UINT))) *) external get_model_func_num_entries : context -> model -> int -> int @@ -10953,24 +9221,16 @@ external get_model_func_num_entries : context -> model -> int -> int Summary: \[ [ get_model_func_entry_num_args c m i j ] \] Return the number of arguments of the j-th entry of the i-th function interpretation in the given model. - A function interpretation is represented as a finite map and an 'else' value. This function returns the j-th entry of this map. - An entry represents the value of a function given a set of arguments. - - - - {b Remarks}: Consider using {!get_model_funcs}. - + - {b Remarks}: Consider using {!get_model_funcs}. - {b Precondition}: i < get_model_num_funcs c m - {b Precondition}: j < get_model_func_num_entries c m i - - {b See also}: {!get_model_num_funcs} - {b See also}: {!get_model_func_num_entries } - {b See also}: {!get_model_func_entry_arg} - @deprecated Use func_interp objects - def_API('get_model_func_entry_num_args', UINT, (_in(CONTEXT), _in(MODEL), _in(UINT), _in(UINT))) *) external get_model_func_entry_num_args : context -> model -> int -> int -> int @@ -10980,25 +9240,17 @@ external get_model_func_entry_num_args : context -> model -> int -> int -> int Summary: \[ [ get_model_func_entry_arg c m i j k ] \] Return the k-th argument of the j-th entry of the i-th function interpretation in the given model. - A function interpretation is represented as a finite map and an 'else' value. This function returns the j-th entry of this map. - An entry represents the value of a function given a set of arguments. - - - - {b Remarks}: Consider using {!get_model_funcs}. - + - {b Remarks}: Consider using {!get_model_funcs}. - {b Precondition}: i < get_model_num_funcs c m - {b Precondition}: j < get_model_func_num_entries c m i - {b Precondition}: k < get_model_func_entry_num_args c m i j - - {b See also}: {!get_model_num_funcs} - {b See also}: {!get_model_func_num_entries } - {b See also}: {!get_model_func_entry_num_args} - @deprecated Use func_interp objects - def_API('get_model_func_entry_arg', AST, (_in(CONTEXT), _in(MODEL), _in(UINT), _in(UINT), _in(UINT))) *) external get_model_func_entry_arg : context -> model -> int -> int -> int -> ast @@ -11008,23 +9260,15 @@ external get_model_func_entry_arg : context -> model -> int -> int -> int -> ast Summary: \[ [ get_model_func_entry_value c m i j ] \] Return the return value of the j-th entry of the i-th function interpretation in the given model. - A function interpretation is represented as a finite map and an 'else' value. This function returns the j-th entry of this map. - An entry represents the value of a function given a set of arguments. - - - - {b Remarks}: Consider using {!get_model_funcs}. - + - {b Remarks}: Consider using {!get_model_funcs}. - {b Precondition}: i < get_model_num_funcs c m - {b Precondition}: j < get_model_func_num_entries c m i - - {b See also}: {!get_model_num_funcs} - {b See also}: {!get_model_func_num_entries } - @deprecated Use func_interp objects - def_API('get_model_func_entry_value', AST, (_in(CONTEXT), _in(MODEL), _in(UINT), _in(UINT))) *) external get_model_func_entry_value : context -> model -> int -> int -> ast @@ -11032,21 +9276,14 @@ external get_model_func_entry_value : context -> model -> int -> int -> ast (** Summary: \[ [ eval c m t ] \] - Evaluate the AST node [t] in the given model. - - Return a pair: Boolean and value. The Boolean is true if the term was successfully evaluated. - + Evaluate the AST node [t] in the given model. + Return a pair: Boolean and value. The Boolean is true if the term was successfully evaluated. The evaluation may fail for the following reasons: - - [t] contains a quantifier. - - the model [m] is partial, that is, it doesn't have a complete interpretation for uninterpreted functions. That is, the option {e MODEL_PARTIAL=true } was used. - - [t] is type incorrect. - @deprecated Use {!model_eval} - def_API('eval', BOOL, (_in(CONTEXT), _in(MODEL), _in(AST), _out(AST))) *) external eval : context -> model -> ast -> bool * ast @@ -11054,12 +9291,9 @@ external eval : context -> model -> ast -> bool * ast (** Summary: Evaluate declaration given values. - Provides direct way to evaluate declarations without going over terms. - @deprecated Consider using {!model_eval} and {!substitute_vars} - def_API('eval_decl', BOOL, (_in(CONTEXT), _in(MODEL), _in(FUNC_DECL), _in(UINT), _in_array(3, AST), _out(AST))) *) external eval_decl : context -> model -> func_decl -> ast array -> bool * ast @@ -11070,17 +9304,10 @@ external eval_decl : context -> model -> func_decl -> ast array -> bool * ast *) (** Summary: Convert the given logical context into a string. - This function is mainly used for debugging purposes. It displays the internal structure of a logical context. - - - - - - @deprecated This method is obsolete. It just displays the internal representation of + @deprecated This method is obsolete. It just displays the internal representation of the global solver available for backward compatibility reasons. - def_API('context_to_string', STRING, (_in(CONTEXT),)) *) external context_to_string : context -> string @@ -11088,17 +9315,10 @@ external context_to_string : context -> string (** Summary: Return runtime statistics as a string. - This function is mainly used for debugging purposes. It displays statistics of the search activity. - - - - - - @deprecated This method is based on the old solver API. + @deprecated This method is based on the old solver API. Use {!stats_to_string} when using the new solver API. - def_API('statistics_to_string', STRING, (_in(CONTEXT),)) *) external statistics_to_string : context -> string @@ -11106,129 +9326,98 @@ external statistics_to_string : context -> string (** Summary: Extract satisfying assignment from context as a conjunction. - This function can be used for debugging purposes. It returns a conjunction of formulas that are assigned to true in the current context. This conjunction will contain not only the assertions that are set to true under the current assignment, but will also include additional literals - if there has been a call to {!check} or {!check_and_get_model}. - + if there has been a call to {!check} or {!check_and_get_model}. @deprecated This method is based on the old solver API. - def_API('get_context_assignment', AST, (_in(CONTEXT),)) *) external get_context_assignment : context -> ast = "camlidl_z3V3_Z3_get_context_assignment" - (** {2 {L ML Extensions}} *) - (** \[ [ mk_context_x configs] \] is a shorthand for the context with configurations in [configs]. *) val mk_context_x: (string * string) array -> context;; - (** \[ [ get_app_args c a ] \] is the array of arguments of an application. If [t] is a constant, then the array is empty. - - {b See also}: {!get_app_num_args} - {b See also}: {!get_app_arg} *) -val get_app_args: context -> app -> ast array - +val get_app_args: context -> app -> ast array (** \[ [ get_app_args c d ] \] is the array of parameters of [d]. - - {b See also}: {!get_domain_size} - {b See also}: {!get_domain} *) val get_domains: context -> func_decl -> sort array - (** \[ [ get_array_sort c t ] \] is the domain and the range of [t]. - - {b See also}: {!get_array_sort_domain} - {b See also}: {!get_array_sort_range} *) val get_array_sort: context -> sort -> sort * sort - (** \[ [ get_tuple_sort c ty ] \] is the pair [(mk_decl, fields)] where [mk_decl] is the constructor declaration of [ty], and [fields] is the array of fields in [ty]. - - {b See also}: {!get_tuple_sort_mk_decl} - {b See also}: {!get_tuple_sort_num_fields} - {b See also}: {!get_tuple_sort_field_decl} *) val get_tuple_sort: context -> sort -> (func_decl * func_decl array) - (** \[ [ datatype_constructor_refined ] \] is the refinement of a datatype constructor. - It contains the constructor declaration, recognizer, and list of accessor functions. *) -type datatype_constructor_refined = { - constructor : func_decl; - recognizer : func_decl; - accessors : func_decl array +type datatype_constructor_refined = { + constructor : func_decl; + recognizer : func_decl; + accessors : func_decl array } - (** \[ [ get_datatype_sort c ty ] \] is the array of triples [(constructor, recognizer, fields)] where [constructor] is the constructor declaration of [ty], [recognizer] is the recognizer for the [constructor], and [fields] is the array of fields in [ty]. - - {b See also}: {!get_datatype_sort_num_constructors} - {b See also}: {!get_datatype_sort_constructor} - {b See also}: {!get_datatype_sort_recognizer} - {b See also}: {!get_datatype_sort_constructor_accessor} *) - - val get_datatype_sort: context -> sort -> datatype_constructor_refined array - (** \[ [ get_model_constants c m ] \] is the array of constants in the model [m]. - - {b See also}: {!get_model_num_constants} - {b See also}: {!get_model_constant} *) val get_model_constants: context -> model -> func_decl array - - (** \[ [ get_model_func_entry c m i j ] \] is the [j]'th entry in the [i]'th function in the model [m]. - - {b See also}: {!get_model_func_entry_num_args} - {b See also}: {!get_model_func_entry_arg} - {b See also}: {!get_model_func_entry_value} *) val get_model_func_entry: context -> model -> int -> int -> (ast array * ast);; - (** \[ [ get_model_func_entries c m i ] \] is the array of entries in the [i]'th function in the model [m]. - - {b See also}: {!get_model_func_num_entries} - {b See also}: {!get_model_func_entry} *) val get_model_func_entries: context -> model -> int -> (ast array * ast) array;; - (** \[ [ get_model_funcs c m ] \] is the array of functions in the model [m]. Each function is represented by the triple [(decl, entries, else)], where [decl] is the declaration name for the function, [entries] is the array of entries in the function, and [else] is the default (else) value for the function. - - {b See also}: {!get_model_num_funcs} - {b See also}: {!get_model_func_decl} - {b See also}: {!get_model_func_entries} - {b See also}: {!get_model_func_else} *) -val get_model_funcs: context -> model -> +val get_model_funcs: context -> model -> (symbol * - (ast array * ast) array * + (ast array * ast) array * ast) array - (** \[ [ get_smtlib_formulas c ] \] is the array of formulas created by a preceding call to {!parse_smtlib_string} or {!parse_smtlib_file}. - Recommend use {!parse_smtlib_string_x} or {!parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. - - {b See also}: {!parse_smtlib_string_x} - {b See also}: {!parse_smtlib_file_x} - {b See also}: {!parse_smtlib_string} @@ -11237,13 +9426,9 @@ val get_model_funcs: context -> model -> - {b See also}: {!get_smtlib_formula} *) val get_smtlib_formulas: context -> ast array - (** \[ [get_smtlib_assumptions c] \] is the array of assumptions created by a preceding call to {!parse_smtlib_string} or {!parse_smtlib_file}. - Recommend use {!parse_smtlib_string_x} or {!parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. - - - {b See also}: {!parse_smtlib_string_x} - {b See also}: {!parse_smtlib_file_x} - {b See also}: {!parse_smtlib_string} @@ -11252,13 +9437,9 @@ val get_smtlib_formulas: context -> ast array - {b See also}: {!get_smtlib_assumption} *) val get_smtlib_assumptions: context -> ast array - (** \[ [ get_smtlib_decls c ] \] is the array of declarations created by a preceding call to {!parse_smtlib_string} or {!parse_smtlib_file}. - Recommend use {!parse_smtlib_string_x} or {!parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. - - - {b See also}: {!parse_smtlib_string_x} - {b See also}: {!parse_smtlib_file_x} - {b See also}: {!parse_smtlib_string} @@ -11267,13 +9448,9 @@ val get_smtlib_assumptions: context -> ast array - {b See also}: {!get_smtlib_decl} *) val get_smtlib_decls: context -> func_decl array - (** \[ [ get_smtlib_parse_results c ] \] is the triple [(get_smtlib_formulas c, get_smtlib_assumptions c, get_smtlib_decls c)]. - Recommend use {!parse_smtlib_string_x} or {!parse_smtlib_file_x} for functional style interface to the SMT-LIB parser. - - - {b See also}: {!parse_smtlib_string_x} - {b See also}: {!parse_smtlib_file_x} - {b See also}: {!parse_smtlib_string} @@ -11283,52 +9460,38 @@ val get_smtlib_decls: context -> func_decl array - {b See also}: {!get_smtlib_decls} *) val get_smtlib_parse_results: context -> (ast array * ast array * func_decl array) - (** - \[ [ parse_smtlib_string_formula c ... ] \] calls [(parse_smtlib_string c ...)] and returns the single formula produced. - + \[ [ parse_smtlib_string_formula c ... ] \] calls [(parse_smtlib_string c ...)] and returns the single formula produced. Recommended for functional style interface to the SMT-LIB parser. - - {b See also}: {!parse_smtlib_file_formula} - {b See also}: {!parse_smtlib_string_x} *) val parse_smtlib_string_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast - (** - \[ [ parse_smtlib_file_formula c ... ] \] calls [(parse_smtlib_file c ...)] and returns the single formula produced. - + \[ [ parse_smtlib_file_formula c ... ] \] calls [(parse_smtlib_file c ...)] and returns the single formula produced. Recommended for functional style interface to the SMT-LIB parser. - - {b See also}: {!parse_smtlib_file_formula} - {b See also}: {!parse_smtlib_file_x} *) val parse_smtlib_file_formula: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> ast - (** \[ [ parse_smtlib_string_x c ... ] \] is [(parse_smtlib_string c ...; get_smtlib_parse_results c)] - Recommended for functional style interface to the SMT-LIB parser. - - {b See also}: {!parse_smtlib_file_x} - {b See also}: {!parse_smtlib_string} - {b See also}: {!get_smtlib_parse_results} *) val parse_smtlib_string_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) - (** \[ [ parse_smtlib_file_x c ... ] \] is [(parse_smtlib_file c ...; get_smtlib_parse_results c)] - Recommended for functional style interface to the SMT-LIB parser. - - {b See also}: {!parse_smtlib_string_x} - {b See also}: {!parse_smtlib_file} - {b See also}: {!get_smtlib_parse_results} *) val parse_smtlib_file_x: context -> string -> symbol array -> sort array -> symbol array -> func_decl array -> (ast array * ast array * func_decl array) - (** \[ [ symbol_refined ] \] is the refinement of a {!symbol} . - - {b See also}: {!symbol_refine} - {b See also}: {!get_symbol_kind} *) @@ -11336,23 +9499,17 @@ type symbol_refined = | Symbol_int of int | Symbol_string of string | Symbol_unknown;; - (** \[ [ symbol_refine c s ] \] is the refined symbol of [s]. - - - {b See also}: {!symbol_refined} + - {b See also}: {!symbol_refined} - {b See also}: {!get_symbol_kind} *) val symbol_refine: context -> symbol -> symbol_refined;; - (** \[ [ sort_refined ] \] is the refinement of a {!sort} . - - {b See also}: {!sort_refine} - {b See also}: {!get_sort_kind} *) - - type sort_refined = | Sort_uninterpreted of symbol | Sort_bool @@ -11364,122 +9521,91 @@ type sort_refined = | Sort_relation | Sort_finite_domain | Sort_unknown of symbol - (** \[ [ sort_refine c t ] \] is the refined sort of [t]. - - - {b See also}: {!sort_refined} + - {b See also}: {!sort_refined} - {b See also}: {!get_sort_kind} *) val sort_refine: context -> sort -> sort_refined;; - (** \[ [ binder_type ] \] is a universal or existential quantifier. - - {b See also}: {!term_refined} *) -type binder_type = | Forall | Exists - +type binder_type = | Forall | Exists (** \[ [ numeral_refined ] \] is the refinement of a numeral . - Numerals whose fractional representation can be fit with 64 bit integers are treated as small. - *) -type numeral_refined = - | Numeral_small of int64 * int64 - | Numeral_large of string - +type numeral_refined = + | Numeral_small of int64 * int64 + | Numeral_large of string (** \[ [ term_refined ] \] is the refinement of a {!ast} . - - {b See also}: {!term_refine} *) -type term_refined = - | Term_app of decl_kind * func_decl * ast array +type term_refined = + | Term_app of decl_kind * func_decl * ast array | Term_quantifier of binder_type * int * ast array array * (symbol * sort) array * ast - | Term_numeral of numeral_refined * sort - | Term_var of int * sort - + | Term_numeral of numeral_refined * sort + | Term_var of int * sort (** \[ [ term_refine c a ] \] is the refined term of [a]. - - - {b See also}: {!term_refined} + - {b See also}: {!term_refined} *) val term_refine : context -> ast -> term_refined - -(** +(** \[ [mk_theory c name ] \] create a custom theory. - *) val mk_theory : context -> string -> theory - (** \[ [set_delete_callback th cb] \] set callback when theory gets deleted. *) val set_delete_callback : theory -> (unit -> unit) -> unit - (** \[ [set_reduce_app_callback th cb] \] set callback for simplifying theory terms. *) val set_reduce_app_callback : theory -> (func_decl -> ast array -> ast option) -> unit - (** \[ [set_reduce_eq_callback th cb] \] set callback for simplifying equalities over theory terms. *) val set_reduce_eq_callback : theory -> (ast -> ast -> ast option) -> unit - (** \[ [set_reduce_distinct_callback th cb] \] set callback for simplifying disequalities over theory terms. *) val set_reduce_distinct_callback : theory -> (ast array -> ast option) -> unit - (** \[ [set_new_app_callback th cb] \] set callback for registering new application. *) val set_new_app_callback : theory -> (ast -> unit) -> unit - (** \[ [set_new_elem_callback th cb] \] set callback for registering new element. - - - {b See also}: the help for the corresponding C API function. + - {b See also}: the help for the corresponding C API function. *) val set_new_elem_callback : theory -> (ast -> unit) -> unit - (** \[ [set_init_search_callback th cb] \] set callback when Z3 starts searching for a satisfying assignment. *) val set_init_search_callback : theory -> (unit -> unit) -> unit - (** \[ [set_push_callback th cb] \] set callback for a logical context push. *) val set_push_callback : theory -> (unit -> unit) -> unit - (** \[ [set_pop_callback th cb] \] set callback for a logical context pop. *) val set_pop_callback : theory -> (unit -> unit) -> unit - (** \[ [set_restart_callback th cb] \] set callback for search restart. *) val set_restart_callback : theory -> (unit -> unit) -> unit - val set_reset_callback : theory -> (unit -> unit) -> unit - val set_final_check_callback : theory -> (unit -> bool) -> unit - val set_new_eq_callback : theory -> (ast -> ast -> unit) -> unit - val set_new_diseq_callback : theory -> (ast -> ast -> unit) -> unit - val set_new_assignment_callback : theory -> (ast -> bool -> unit) -> unit - val set_new_relevant_callback : theory -> (ast -> unit) -> unit - end diff --git a/src/api/ml/z3_stubs.c b/src/api/ml/z3_stubs.c index 0f32cb20e..0cf20fb2e 100644 --- a/src/api/ml/z3_stubs.c +++ b/src/api/ml/z3_stubs.c @@ -18,16 +18,13 @@ #define xstr(s) str(s) #define str(s) #s -#pragma warning(disable:4090) void check_error_code (Z3_context c); - Z3_context last_ctx; - + // caml_final_register is the implementation of Gc.finalize value caml_final_register (value f, value v); - void register_finalizer(value** closure, char* name, Z3_context ctx, value v) { if (*closure == NULL) { @@ -39,7 +36,6 @@ Z3_context last_ctx; } caml_final_register(**closure, v); } - value c2ml_Z3_context (Z3_context* c) { static value* finalize_Z3_context_closure = NULL; @@ -50,13 +46,11 @@ Z3_context last_ctx; (Z3_context) *c, v); return v; } - void ml2c_Z3_context (value v, Z3_context* c) { *c = (Z3_context) Field(v, 0); last_ctx = *c; } - value finalize_Z3_context (value v) { Z3_context c; @@ -87,17 +81,15 @@ typedef struct _Z3_ast_context { Z3_ast ast; Z3_context ctx; } Z3_ast_context; - void ml2c_Z3_ast (value v, Z3_ast* c) { *c = ((Z3_ast_context*) Data_custom_val(v))->ast; } - static int compare_Z3_ast (value v1, value v2) { Z3_ast_context* ac1; Z3_ast_context* ac2; - unsigned int id1, id2; + unsigned id1, id2; ac1 = Data_custom_val(v1); ac2 = Data_custom_val(v2); id1 = Z3_get_ast_id(ac1->ctx, ac1->ast); @@ -106,11 +98,10 @@ static int compare_Z3_ast (value v1, value v2) check_error_code(ac2->ctx); return id2 - id1; } - static intnat hash_Z3_ast (value v) { Z3_ast_context* ac; - unsigned int hash; + unsigned hash; ac = Data_custom_val(v); hash = Z3_get_ast_hash(ac->ctx, ac->ast); check_error_code(ac->ctx); @@ -126,7 +117,6 @@ static intnat hash_Z3_ast (value v) check_error_code(ac->ctx); return Val_unit; } - static struct custom_operations cops_Z3_ast = { NULL, custom_finalize_default, @@ -135,7 +125,6 @@ static intnat hash_Z3_ast (value v) custom_serialize_default, custom_deserialize_default }; - value c2ml_Z3_ast (Z3_ast* c) { static value* finalize_Z3_ast_closure = NULL; @@ -156,7 +145,7 @@ static intnat hash_Z3_ast (value v) #define camlidl_c2ml_z3_Z3_ast(c,ctx) c2ml_Z3_ast(c) -#define DEFINE_SUBAST_OPS(T) void ml2c_ ## T (value v, T * a) { ml2c_Z3_ast(v, (Z3_ast*) a); } value c2ml_ ## T (T * a) { return c2ml_Z3_ast((Z3_ast*) a); } +#define DEFINE_SUBAST_OPS(T) void ml2c_ ## T (value v, T * a) { ml2c_Z3_ast(v, (Z3_ast*) a); } value c2ml_ ## T (T * a) { return c2ml_Z3_ast((Z3_ast*) a); } DEFINE_SUBAST_OPS(Z3_sort) #define camlidl_ml2c_z3_Z3_sort(v,c,ctx) ml2c_Z3_sort(v,c) @@ -177,7 +166,7 @@ DEFINE_SUBAST_OPS(Z3_pattern) #define camlidl_c2ml_z3_Z3_pattern(c,ctx) c2ml_Z3_pattern(c) -#define DEFINE_RC_OPS(T) value c2ml_ ## T (T * c) { static value* finalize_ ## T ## _closure = NULL; value v; check_error_code(last_ctx); v = caml_alloc_small(2, Abstract_tag); Field(v, 0) = (value) *c; Field(v, 1) = (value) last_ctx; register_finalizer(&finalize_ ## T ## _closure, xstr(finalize_ ## T), (Z3_context) *c, v); T ## _inc_ref(last_ctx, *c); return v; } void ml2c_ ## T (value v, T * c) { *c = (T) Field(v, 0); } value finalize_ ## T (value v) { Z3_context c; c = (Z3_context) Field(v, 1); T ## _dec_ref(c, (T) Field(v, 0)); check_error_code(c); return Val_unit; } + #define DEFINE_RC_OPS(T) value c2ml_ ## T (T * c) { static value* finalize_ ## T ## _closure = NULL; value v; check_error_code(last_ctx); v = caml_alloc_small(2, Abstract_tag); Field(v, 0) = (value) *c; Field(v, 1) = (value) last_ctx; register_finalizer(&finalize_ ## T ## _closure, xstr(finalize_ ## T), (Z3_context) *c, v); T ## _inc_ref(last_ctx, *c); return v; } void ml2c_ ## T (value v, T * c) { *c = (T) Field(v, 0); } value finalize_ ## T (value v) { Z3_context c; c = (Z3_context) Field(v, 1); T ## _dec_ref(c, (T) Field(v, 0)); check_error_code(c); return Val_unit; } DEFINE_RC_OPS(Z3_params) #define camlidl_ml2c_z3_Z3_params(v,c,ctx) ml2c_Z3_params(v,c) @@ -248,7 +237,7 @@ DEFINE_RC_OPS(Z3_stats) #define camlidl_c2ml_z3_Z3_stats(c,ctx) c2ml_Z3_stats(c) -#define DEFINE_OPT_OPS(T) void ml2c_ ## T ## _opt (value v, T* c) { struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; if (v != Val_int(0)) { camlidl_ml2c_z3_ ## T(Field(v, 0), c, _ctx); } else { *c = NULL; } } value c2ml_ ## T ## _opt (T* c) { struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; value v; value a; if (*c) { a = camlidl_c2ml_z3_ ## T(c, _ctx); Begin_root(a) v = caml_alloc_small(1, 0); Field(v, 0) = a; End_roots(); } else { v = Val_int(0); } return v; } +#define DEFINE_OPT_OPS(T) void ml2c_ ## T ## _opt (value v, T* c) { struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; if (v != Val_int(0)) { camlidl_ml2c_z3_ ## T(Field(v, 0), c, _ctx); } else { *c = NULL; } } value c2ml_ ## T ## _opt (T* c) { struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; value v; value a; if (*c) { a = camlidl_c2ml_z3_ ## T(c, _ctx); Begin_root(a) v = caml_alloc_small(1, 0); Field(v, 0) = a; End_roots(); } else { v = Val_int(0); } return v; } DEFINE_OPT_OPS(Z3_ast) #define camlidl_ml2c_z3_Z3_ast_opt(v,c,ctx) ml2c_Z3_ast_opt(v,c) @@ -682,9 +671,12 @@ value _v1; } +/* All contexts share the same handler */ +static value caml_z3_error_handler = 0; + + value camlidl_c2ml_z3_Z3_error_code(Z3_error_code * _c2, camlidl_ctx _ctx); - - +/* Error checking routine that raises OCaml Error exceptions */ void check_error_code (Z3_context c) { static struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; @@ -703,8 +695,7 @@ void check_error_code (Z3_context c) caml_raise_with_args(*exn_tag, 2, ctx_err); } } - - +/* Disable default error handler, all error checking is done by check_error_code */ void* error_handler_static = NULL; int camlidl_transl_table_z3_enum_11[4] = { @@ -743,9 +734,7 @@ value caml_z3_mk_context(value key_val_list) Z3_context _res; struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; - cfg = Z3_mk_config(); - while (key_val_list != Val_emptylist) { item = Field(key_val_list, 0); @@ -756,7 +745,6 @@ value caml_z3_mk_context(value key_val_list) Z3_set_param_value(cfg, ckey, cval); key_val_list = Field(key_val_list, 1); } - _res = Z3_mk_context_rc(cfg); Z3_del_config(cfg); _vres = camlidl_c2ml_z3_Z3_context(&_res, _ctx); @@ -1238,7 +1226,7 @@ value camlidl_z3_Z3_mk_finite_domain_sort( { Z3_context c; /*in*/ Z3_symbol name; /*in*/ - __int64 size; /*in*/ + unsigned long long size; /*in*/ Z3_sort _res; value _vres; @@ -4286,7 +4274,7 @@ value camlidl_z3_Z3_mk_int64( value _v_ty) { Z3_context c; /*in*/ - __int64 v; /*in*/ + long long v; /*in*/ Z3_sort ty; /*in*/ Z3_ast _res; value _vres; @@ -5105,8 +5093,8 @@ value camlidl_z3_Z3_get_finite_domain_sort_size( { Z3_context c; /*in*/ Z3_sort s; /*in*/ - __int64 *r; /*out*/ - __int64 _c1; + unsigned long long *r; /*out*/ + unsigned long long _c1; value _v2; value _vres; @@ -6273,13 +6261,13 @@ value camlidl_z3_Z3_get_numeral_small( { Z3_context c; /*in*/ Z3_ast a; /*in*/ - __int64 *num; /*out*/ - __int64 *den; /*out*/ + long long *num; /*out*/ + long long *den; /*out*/ int _res; struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; - __int64 _c1; - __int64 _c2; + long long _c1; + long long _c2; value _vresult; value _vres[3] = { 0, 0, 0, }; @@ -6342,11 +6330,11 @@ value camlidl_z3_Z3_get_numeral_int64( { Z3_context c; /*in*/ Z3_ast v; /*in*/ - __int64 *i; /*out*/ + long long *i; /*out*/ int _res; struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; - __int64 _c1; + long long _c1; value _vresult; value _vres[2] = { 0, 0, }; @@ -6374,13 +6362,13 @@ value camlidl_z3_Z3_get_numeral_rational_int64( { Z3_context c; /*in*/ Z3_ast v; /*in*/ - __int64 *num; /*out*/ - __int64 *den; /*out*/ + long long *num; /*out*/ + long long *den; /*out*/ int _res; struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; - __int64 _c1; - __int64 _c2; + long long _c1; + long long _c2; value _vresult; value _vres[3] = { 0, 0, 0, }; @@ -8170,50 +8158,6 @@ check_error_code(c); return _vres; } -value camlidl_z3_Z3_parse_z3_string( - value _v_c, - value _v_str) -{ - Z3_context c; /*in*/ - Z3_string str; /*in*/ - Z3_ast _res; - value _vres; - - struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; - camlidl_ctx _ctx = &_ctxs; - camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); - camlidl_ml2c_z3_Z3_string(_v_str, &str, _ctx); - _res = Z3_parse_z3_string(c, str); - _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); - camlidl_free(_ctx); - /* begin user-supplied deallocation sequence */ -check_error_code(c); - /* end user-supplied deallocation sequence */ - return _vres; -} - -value camlidl_z3_Z3_parse_z3_file( - value _v_c, - value _v_file_name) -{ - Z3_context c; /*in*/ - Z3_string file_name; /*in*/ - Z3_ast _res; - value _vres; - - struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; - camlidl_ctx _ctx = &_ctxs; - camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); - camlidl_ml2c_z3_Z3_string(_v_file_name, &file_name, _ctx); - _res = Z3_parse_z3_file(c, file_name); - _vres = camlidl_c2ml_z3_Z3_ast(&_res, _ctx); - camlidl_free(_ctx); - /* begin user-supplied deallocation sequence */ -check_error_code(c); - /* end user-supplied deallocation sequence */ - return _vres; -} - value camlidl_z3_Z3_set_error( value _v_c, value _v_e) @@ -8286,6 +8230,30 @@ value camlidl_z3_Z3_get_version(value _unit) return _vresult; } +value camlidl_z3_Z3_enable_trace( + value _v_tag) +{ + Z3_string tag; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_string(_v_tag, &tag, _ctx); + Z3_enable_trace(tag); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3_Z3_disable_trace( + value _v_tag) +{ + Z3_string tag; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_string(_v_tag, &tag, _ctx); + Z3_disable_trace(tag); + camlidl_free(_ctx); + return Val_unit; +} + value camlidl_z3_Z3_mk_fixedpoint( value _v_c) { @@ -8669,46 +8637,42 @@ check_error_code(c); return Val_unit; } -value camlidl_z3_Z3_fixedpoint_simplify_rules( +value camlidl_z3_Z3_fixedpoint_get_rules( value _v_c, - value _v_f, - value _v_rules, - value _v_outputs) + value _v_f) { Z3_context c; /*in*/ Z3_fixedpoint f; /*in*/ - unsigned int num_rules; /*in*/ - Z3_ast *rules; /*in*/ - unsigned int num_outputs; /*in*/ - Z3_func_decl *outputs; /*in*/ Z3_ast_vector _res; - mlsize_t _c1; - mlsize_t _c2; - value _v3; - mlsize_t _c4; - mlsize_t _c5; - value _v6; value _vres; struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); camlidl_ml2c_z3_Z3_fixedpoint(_v_f, &f, _ctx); - _c1 = Wosize_val(_v_rules); - rules = camlidl_malloc(_c1 * sizeof(Z3_ast ), _ctx); - for (_c2 = 0; _c2 < _c1; _c2++) { - _v3 = Field(_v_rules, _c2); - camlidl_ml2c_z3_Z3_ast(_v3, &rules[_c2], _ctx); - } - num_rules = _c1; - _c4 = Wosize_val(_v_outputs); - outputs = camlidl_malloc(_c4 * sizeof(Z3_func_decl ), _ctx); - for (_c5 = 0; _c5 < _c4; _c5++) { - _v6 = Field(_v_outputs, _c5); - camlidl_ml2c_z3_Z3_func_decl(_v6, &outputs[_c5], _ctx); - } - num_outputs = _c4; - _res = Z3_fixedpoint_simplify_rules(c, f, num_rules, rules, num_outputs, outputs); + _res = Z3_fixedpoint_get_rules(c, f); + _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_get_assertions( + value _v_c, + value _v_f) +{ + Z3_context c; /*in*/ + Z3_fixedpoint f; /*in*/ + Z3_ast_vector _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_f, &f, _ctx); + _res = Z3_fixedpoint_get_assertions(c, f); _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); camlidl_free(_ctx); /* begin user-supplied deallocation sequence */ @@ -8817,6 +8781,56 @@ check_error_code(c); return _vres; } +value camlidl_z3_Z3_fixedpoint_from_string( + value _v_c, + value _v_f, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_fixedpoint f; /*in*/ + Z3_string s; /*in*/ + Z3_ast_vector _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_f, &f, _ctx); + camlidl_ml2c_z3_Z3_string(_v_s, &s, _ctx); + _res = Z3_fixedpoint_from_string(c, f, s); + _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + +value camlidl_z3_Z3_fixedpoint_from_file( + value _v_c, + value _v_f, + value _v_s) +{ + Z3_context c; /*in*/ + Z3_fixedpoint f; /*in*/ + Z3_string s; /*in*/ + Z3_ast_vector _res; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_fixedpoint(_v_f, &f, _ctx); + camlidl_ml2c_z3_Z3_string(_v_s, &s, _ctx); + _res = Z3_fixedpoint_from_file(c, f, s); + _vres = camlidl_c2ml_z3_Z3_ast_vector(&_res, _ctx); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return _vres; +} + value camlidl_z3_Z3_fixedpoint_push( value _v_c, value _v_d) @@ -10692,6 +10706,30 @@ check_error_code(c); return Val_unit; } +value camlidl_z3_Z3_solver_assert_and_track( + value _v_c, + value _v_s, + value _v_a, + value _v_p) +{ + Z3_context c; /*in*/ + Z3_solver s; /*in*/ + Z3_ast a; /*in*/ + Z3_ast p; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3_Z3_context(_v_c, &c, _ctx); + camlidl_ml2c_z3_Z3_solver(_v_s, &s, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_a, &a, _ctx); + camlidl_ml2c_z3_Z3_ast(_v_p, &p, _ctx); + Z3_solver_assert_and_track(c, s, a, p); + camlidl_free(_ctx); + /* begin user-supplied deallocation sequence */ +check_error_code(c); + /* end user-supplied deallocation sequence */ + return Val_unit; +} + value camlidl_z3_Z3_solver_get_assertions( value _v_c, value _v_s) @@ -11072,7 +11110,6 @@ check_error_code(c); return _vres; } -void caml_z3_error_handler(Z3_context c, Z3_error_code e) { static char buffer[128]; char * msg = Z3_get_error_msg_ex(c, e); if (strlen(msg) > 100) { failwith("Z3: error message is too big to fit in buffer"); } else { sprintf(buffer, "Z3: %s", msg); failwith(buffer); } } void camlidl_ml2c_z3V3_Z3_symbol(value _v1, Z3_symbol * _c2, camlidl_ctx _ctx) { *_c2 = *((Z3_symbol *) Bp_val(_v1)); @@ -11604,6 +11641,54 @@ value _v1; return _v1; } +value camlidl_z3V3_Z3_global_param_set( + value _v_param_id, + value _v_param_value) +{ + Z3_string param_id; /*in*/ + Z3_string param_value; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_string(_v_param_id, ¶m_id, _ctx); + camlidl_ml2c_z3V3_Z3_string(_v_param_value, ¶m_value, _ctx); + Z3_global_param_set(param_id, param_value); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_global_param_reset_all(value _unit) +{ + Z3_global_param_reset_all(); + return Val_unit; +} + +value camlidl_z3V3_Z3_global_param_get( + value _v_param_id) +{ + Z3_string param_id; /*in*/ + Z3_string *param_value; /*out*/ + Z3_string _c1; + value _v2; + value _vres; + + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_string(_v_param_id, ¶m_id, _ctx); + param_value = &_c1; + Z3_global_param_get(param_id, param_value); + if (param_value == NULL) { + _vres = Val_int(0); + } else { + _v2 = camlidl_c2ml_z3V3_Z3_string(&*param_value, _ctx); + Begin_root(_v2) + _vres = camlidl_alloc_small(1, 0); + Field(_vres, 0) = _v2; + End_roots(); + } + camlidl_free(_ctx); + return _vres; +} + value camlidl_z3V3_Z3_mk_config(value _unit) { Z3_config _res; @@ -11661,7 +11746,7 @@ value camlidl_z3V3_Z3_mk_context( _vres = camlidl_c2ml_z3V3_Z3_context(&_res, _ctx); camlidl_free(_ctx); /* begin user-supplied deallocation sequence */ -Z3_set_error_handler(_res, caml_z3_error_handler); +Z3_set_error_handler(_res, (void*)caml_z3_error_handler); /* end user-supplied deallocation sequence */ return _vres; } @@ -11857,7 +11942,7 @@ value camlidl_z3V3_Z3_mk_finite_domain_sort( { Z3_context c; /*in*/ Z3_symbol name; /*in*/ - __int64 size; /*in*/ + unsigned long long size; /*in*/ Z3_sort _res; value _vres; @@ -14575,7 +14660,7 @@ value camlidl_z3V3_Z3_mk_int64( value _v_ty) { Z3_context c; /*in*/ - __int64 v; /*in*/ + long long v; /*in*/ Z3_sort ty; /*in*/ Z3_ast _res; value _vres; @@ -15334,8 +15419,8 @@ value camlidl_z3V3_Z3_get_finite_domain_sort_size( { Z3_context c; /*in*/ Z3_sort s; /*in*/ - __int64 *r; /*out*/ - __int64 _c1; + unsigned long long *r; /*out*/ + unsigned long long _c1; value _v2; value _vres; @@ -16352,13 +16437,13 @@ value camlidl_z3V3_Z3_get_numeral_small( { Z3_context c; /*in*/ Z3_ast a; /*in*/ - __int64 *num; /*out*/ - __int64 *den; /*out*/ + long long *num; /*out*/ + long long *den; /*out*/ int _res; struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; - __int64 _c1; - __int64 _c2; + long long _c1; + long long _c2; value _vresult; value _vres[3] = { 0, 0, 0, }; @@ -16415,11 +16500,11 @@ value camlidl_z3V3_Z3_get_numeral_int64( { Z3_context c; /*in*/ Z3_ast v; /*in*/ - __int64 *i; /*out*/ + long long *i; /*out*/ int _res; struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; - __int64 _c1; + long long _c1; value _vresult; value _vres[2] = { 0, 0, }; @@ -16444,13 +16529,13 @@ value camlidl_z3V3_Z3_get_numeral_rational_int64( { Z3_context c; /*in*/ Z3_ast v; /*in*/ - __int64 *num; /*out*/ - __int64 *den; /*out*/ + long long *num; /*out*/ + long long *den; /*out*/ int _res; struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; camlidl_ctx _ctx = &_ctxs; - __int64 _c1; - __int64 _c2; + long long _c1; + long long _c2; value _vresult; value _vres[3] = { 0, 0, 0, }; @@ -17570,44 +17655,6 @@ value camlidl_z3V3_Z3_get_smtlib_error( return _vres; } -value camlidl_z3_Z3_parse_z3V3_string( - value _v_c, - value _v_str) -{ - Z3_context c; /*in*/ - Z3_string str; /*in*/ - Z3_ast _res; - value _vres; - - struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; - camlidl_ctx _ctx = &_ctxs; - camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); - camlidl_ml2c_z3V3_Z3_string(_v_str, &str, _ctx); - _res = Z3_parse_z3_string(c, str); - _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); - camlidl_free(_ctx); - return _vres; -} - -value camlidl_z3_Z3_parse_z3V3_file( - value _v_c, - value _v_file_name) -{ - Z3_context c; /*in*/ - Z3_string file_name; /*in*/ - Z3_ast _res; - value _vres; - - struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; - camlidl_ctx _ctx = &_ctxs; - camlidl_ml2c_z3V3_Z3_context(_v_c, &c, _ctx); - camlidl_ml2c_z3V3_Z3_string(_v_file_name, &file_name, _ctx); - _res = Z3_parse_z3_file(c, file_name); - _vres = camlidl_c2ml_z3V3_Z3_ast(&_res, _ctx); - camlidl_free(_ctx); - return _vres; -} - value camlidl_z3V3_Z3_get_version(value _unit) { unsigned int *major; /*out*/ @@ -17640,6 +17687,30 @@ value camlidl_z3V3_Z3_get_version(value _unit) return _vresult; } +value camlidl_z3V3_Z3_enable_trace( + value _v_tag) +{ + Z3_string tag; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_string(_v_tag, &tag, _ctx); + Z3_enable_trace(tag); + camlidl_free(_ctx); + return Val_unit; +} + +value camlidl_z3V3_Z3_disable_trace( + value _v_tag) +{ + Z3_string tag; /*in*/ + struct camlidl_ctx_struct _ctxs = { CAMLIDL_TRANSIENT, NULL }; + camlidl_ctx _ctx = &_ctxs; + camlidl_ml2c_z3V3_Z3_string(_v_tag, &tag, _ctx); + Z3_disable_trace(tag); + camlidl_free(_ctx); + return Val_unit; +} + value camlidl_z3V3_Z3_reset_memory(value _unit) { Z3_reset_memory();