Module Prop


module Prop: sig  end

Translations to/from ICSAT propositions



type t =
| True
| False
| Var of Name.t
| Atom of Atom.t
| Disj of t list
| Iff of t * t
| Ite of t * t * t
| Neg of t
| Let of Name.t * t * t

val pp : t Pretty.printer
Parameters:
fmt : Format.formatter
?? : t
val occurs : Name.t -> t -> bool
Parameters:
x : Name.t
?? : t
val mk_true : t
val mk_false : t
val mk_var : Name.t -> t
Parameters:
n : Name.t
val mk_poslit : Atom.t -> t
Parameters:
?? : Atom.t
val mk_neglit : Atom.t -> t
Parameters:
a : Atom.t
val mk_disj : t list -> t
Parameters:
pl : t list
val mk_iff : t -> t -> t
Parameters:
p : t
q : t
val mk_ite : t -> t -> t -> t
Parameters:
p : t
q : t
r : t
val mk_neg : t -> t
Parameters:
p : t
val mk_conj : t list -> t
Parameters:
pl : t list
val mk_let : Name.t -> t -> t -> t
Parameters:
x : Name.t
p : t
q : t
val apply : (Name.t * t) list -> t -> t
Parameters:
rho : (Name.t * t) list
q : t


Translations to/from ICSAT propositions



type prop = int
val icsat_initialize : unit -> unit
val icsat_finalize : unit -> unit
val icsat_mk_true : unit -> prop
val icsat_mk_false : unit -> prop
val icsat_mk_var : string -> prop
val icsat_mk_atom : int -> int -> prop
val icsat_mk_or : prop list -> prop
val icsat_mk_and : prop list -> prop
val icsat_mk_iff : prop -> prop -> prop
val icsat_mk_implies : prop -> prop -> prop
val icsat_mk_xor : prop -> prop -> prop
val icsat_mk_not : prop -> prop
val icsat_mk_ite : prop -> prop -> prop -> prop
val icsat_is_true : prop -> bool
val icsat_is_false : prop -> bool
val icsat_is_not : prop -> bool
val icsat_is_or : prop -> bool
val icsat_is_iff : prop -> bool
val icsat_is_ite : prop -> bool
val icsat_is_var : prop -> bool
val icsat_is_atom : prop -> bool
val icsat_d_var : prop -> string
val icsat_d_atom : prop -> int
val icsat_d_not : prop -> prop
val icsat_num_arguments : prop -> int
val icsat_get_argument : prop -> int -> prop
val icsat_get_assignment : int -> int
val icsat_print_statistics : unit -> unit

Parameter settings for SAT solver

val set_verbose : bool -> unit
val set_remove_subsumed_clauses : bool -> unit
val set_validate_counter_example : bool -> unit
val set_polarity_optimization : bool -> unit
val set_clause_relevance : int -> unit
val set_cleanup_period : int -> unit
val set_num_refinements : int -> unit

Translating to and from propositions

module Atomtbl: sig  end
module Inttbl: sig  end
module Nametbl: sig  end
val id : Inttbl.key Pervasives.ref
val atomtbl : Inttbl.key Atomtbl.t
val inttbl : Atomtbl.key Inttbl.t
val idtbl : prop Atomtbl.t
val vartbl : prop Nametbl.t
val atom_to_id : Atomtbl.key -> Inttbl.key
Parameters:
a : Atomtbl.key
val id_to_atom : Inttbl.key -> Atomtbl.key
Parameters:
i : Inttbl.key
val atom_to_icsat_id : Atomtbl.key -> prop
Parameters:
a : Atomtbl.key
val var_to_icsat_id : Nametbl.key -> prop
Parameters:
x : Nametbl.key
val to_prop : t -> prop
Parameters:
p : t
val of_prop : prop -> t
Parameters:
p : prop
val d_disj : prop -> prop list
Parameters:
p : prop


Lists


val is_nil : 'a list -> bool
Parameters:
?? : 'a list
val head : 'a list -> 'a
val tail : 'a list -> 'a list
val length : 'a list -> int


Atoms


val is_connected : Inttbl.key -> Inttbl.key -> bool
Parameters:
i : Inttbl.key
j : Inttbl.key
val atom_pp : Inttbl.key -> unit
Parameters:
i : Inttbl.key


Stack


val stack : (Context.t * Atomtbl.key list) Stack.t
val initial : (Context.t * Atomtbl.key list) Pervasives.ref
val stack_reset : unit -> unit
Parameters:
() : unit
val dup : unit -> unit
Parameters:
() : unit
val push : Context.t * Atomtbl.key list -> unit
Parameters:
(s,al) : Context.t * Atomtbl.key list
val pop : unit -> unit
Parameters:
() : unit
val top : unit -> Context.t
Parameters:
() : unit
val stackpp : unit -> unit
Parameters:
() : unit
val add : Inttbl.key -> int
Parameters:
i : Inttbl.key

Scratch state

val scratch : Context.t Pervasives.ref
val reset_scratch_context : unit -> unit
Parameters:
() : unit
val add_scratch_context : Inttbl.key -> int
Parameters:
i : Inttbl.key

Calling external SAT solver

val icsat_sat : prop -> bool
val init : Context.t -> unit
Parameters:
s : Context.t
val finalize : unit -> unit
Parameters:
() : unit
val statistics : bool Pervasives.ref
module Assignment: sig  end
val sat : Context.t -> t -> (Assignment.t * Context.t) option
Parameters:
s : Context.t
p : t
val debug : unit -> unit
Parameters:
() : unit
val assignment : unit -> Assignment.t
Parameters:
() : unit