# add support for more theories, just list them here in the same order
# you would to the LFSC proof-checker binary.
#
-CORE_PLFS = sat.plf smt.plf th_base.plf th_arrays.plf
+CORE_PLFS = sat.plf smt.plf th_base.plf th_arrays.plf th_bv.plf th_bv_bitblast.plf
noinst_LTLIBRARIES = libsignatures.la
--- /dev/null
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;; Rewrite rules
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; t rewrites to t'
+(declare rw_term
+ (! s sort
+ (! t (term s)
+ (! t' (term s)
+ type))))
+
+(declare rw_formula
+ (! f formula
+ (! f' formula
+ type)))
+
+
+(declare apply_rw_formula
+ (! f formula
+ (! f' formula
+ (! rw (rw_formula f f')
+ (! fh (th_holds f)
+ (th_holds f'))))))
+
+
+;; Identity rewrite rules
+(declare rw_term_id
+ (! s sort
+ (! t (term s)
+ (rw_term s t t))))
+
+(declare rw_term_trans
+ (! s sort
+ (! t1 (term s)
+ (! t2 (term s)
+ (! t3 (term s)
+ (! rw12 (rw_term _ t1 t2)
+ (! rw23 (rw_term _ t2 t3)
+ (rw_term s t1 t3))))))))
+
+;; rw_symmetry
+
+(declare rw_formula_trans
+ (! f1 formula
+ (! f2 formula
+ (! f3 formula
+ (! rw1 (rw_formula f1 f2)
+ (! rw2 (rw_formula f2 f3)
+ (rw_formula f1 f3)))))))
+
+
+(declare rw_op1_id
+ (! s sort
+ (! a (term s)
+ (! a' (term s)
+ (! rw (rw_term _ a a')
+ (! op term_op1
+ (rw_term _ (op _ a) (op _ a'))))))))
+
+(declare rw_op2_id
+ (! s sort
+ (! a (term s)
+ (! a' (term s)
+ (! b (term s)
+ (! b' (term s)
+ (! rw (rw_term _ a a')
+ (! rw (rw_term _ b b')
+ (! op term_op2
+ (rw_term _ (op _ a b) (op _ a' b')))))))))))
+
+(declare rw_pred1_id
+ (! s sort
+ (! a (term s)
+ (! a' (term s)
+ (! rw (rw_term _ a a')
+ (! op op_pred1
+ (rw_formula (op _ a) (op _ a'))))))))
+
+(declare rw_pred2_id
+ (! s sort
+ (! a (term s)
+ (! a' (term s)
+ (! b (term s)
+ (! b' (term s)
+ (! rw (rw_term _ a a')
+ (! rw (rw_term _ b b')
+ (! op op_pred2
+ (rw_formula (op _ a b) (op _ a' b')))))))))))
+
+(declare rw_eq_id
+ (! s sort
+ (! a (term s)
+ (! a' (term s)
+ (! b (term s)
+ (! b' (term s)
+ (! rw (rw_term _ a a')
+ (! rw (rw_term _ b b')
+ (rw_formula (= s a b) (= s a' b'))))))))))
+
+(declare rw_formula_op1_id
+ (! f formula
+ (! f' formula
+ (! frw (rw_formula f f')
+ (! op formula_op1
+ (rw_formula (op f) (op f')))))))
+
+(declare rw_formula_op2_id
+ (! f1 formula
+ (! f1' formula
+ (! f2 formula
+ (! f2' formula
+ (! frw1 (rw_formula f1 f1')
+ (! frw2 (rw_formula f2 f2')
+ (! op formula_op2
+ (rw_formula (op f1 f2) (op f1' f2'))))))))))
+
+
+(apply_rw_formula
+ (! f formula
+ (! f' formula
+ (! r (rw_formula f f')
+ (! h (th_holds f)
+ (th_holds f'))))))
\ No newline at end of file
-; AJR : proof used for testing memory use of theory lemmas
-
(check
(% s sort
(% a (term s)
; -------------------- declaration of input formula -----------------------------------
(% A1 (th_holds (= s a b))
-(% A2 (th_holds (= s b a))
-(% A3 (th_holds (not (= s a a)))
+(% A2 (th_holds (= s b c))
+(% A3 (th_holds (not (= s a c)))
; ------------------- specify that the following is a proof of the empty clause -----------------
; ---------- use atoms (a1, a2, a3) to map theory literals to boolean literals (v1, v2, v3) ------
(decl_atom (= s a b) (\ v1 (\ a1
-(decl_atom (= s b a) (\ v2 (\ a2
-(decl_atom (= s a a) (\ v3 (\ a3
+(decl_atom (= s b c) (\ v2 (\ a2
+(decl_atom (= s a c) (\ v3 (\ a3
; --------------------------- proof of theory lemma ---------------------------------------------
(satlem _ _ (ast _ _ _ a1 (\ l1 (ast _ _ _ a2 (\ l2 (asf _ _ _ a3 (\ l3 (clausify_false (contra _ (trans _ _ _ _ l1 l2) l3)))))))) (\ CT1
-(satlem _ _ (ast _ _ _ a1 (\ l1 (ast _ _ _ a2 (\ l2 (asf _ _ _ a3 (\ l3 (clausify_false (contra _ (trans _ _ _ _ l1 l2) l3)))))))) (\ CT2
-(satlem _ _ (ast _ _ _ a1 (\ l1 (ast _ _ _ a2 (\ l2 (asf _ _ _ a3 (\ l3 (clausify_false (contra _ (trans _ _ _ _ l1 l2) l3)))))))) (\ CT3
-;...add copies here...
; -------------------- clausification of input formulas -----------------------------------------
(\ x x))
-)))))))))))))))))))))))))))))
-))
+)))))))))))))))))))))))))))
-; a = b ^ a = 00000 ^ b = 11111 is UNSAT
+; (a = b) ^ (a = b & 00000) ^ (b = 11111) is UNSAT
(check
(% a var_bv
(% b var_bv
-(% f1 (th_holds (= BitVec (a_var_bv a) (a_var_bv b)))
-(% f2 (th_holds (= BitVec (a_var_bv a) (a_bv (bvc b0 (bvc b0 (bvc b0 (bvc b0 (bvc b0 bvn))))))))
-(% f3 (th_holds (= BitVec (a_var_bv b) (a_bv (bvc b1 (bvc b1 (bvc b1 (bvc b1 (bvc b1 bvn))))))))
+(% f1 (th_holds (= (BitVec 4) (a_var_bv _ a) (a_var_bv _ b)))
+(% f2 (th_holds (= (BitVec 4) (a_var_bv _ a) (bvand 4 (a_var_bv 4 b) (a_bv _ (bvc b0 (bvc b0 (bvc b0 (bvc b0 (bvc b0 bvn)))))))))
+(% f3 (th_holds (= (BitVec 4) (a_var_bv _ b) (a_bv _ (bvc b1 (bvc b1 (bvc b1 (bvc b1 (bvc b1 bvn))))))))
(: (holds cln)
-(decl_bv_atom_var 5 a (\ ba1
-(decl_bv_atom_var 5 b (\ ba2
-(decl_bv_atom_const _ (bvc b0 (bvc b0 (bvc b0 (bvc b0 (bvc b0 bvn))))) (\ c (\ ba3
-(decl_bv_atom_const _ (bvc b1 (bvc b1 (bvc b1 (bvc b1 (bvc b1 bvn))))) (\ d (\ ba4
+;; (decl_bv_term_var 5 a (\ ba1
+;; (decl_bv_term_var 5 b (\ ba2
+;; (decl_bv_term_const _ (bvc b0 (bvc b0 (bvc b0 (bvc b0 (bvc b0 bvn))))) (\ c (\ ba3
+;; (decl_bv_term_const _ (bvc b1 (bvc b1 (bvc b1 (bvc b1 (bvc b1 bvn))))) (\ d (\ ba4
-(decl_atom (bblast a 4) (\ v1 (\ a1
-(decl_atom (bblast b 4) (\ v2 (\ a2
+(decl_atom (bitof a 4) (\ v1 (\ a1
+(decl_atom (bitof b 4) (\ v2 (\ a2
; bitblasting terms
-(th_let_pf _ (bv_bbl_var _ _ _ ba1) (\ bt1
-(th_let_pf _ (bv_bbl_var _ _ _ ba2) (\ bt2
-(th_let_pf _ (bv_bbl_const _ _ _ _ ba3) (\ bt3
-(th_let_pf _ (bv_bbl_const _ _ _ _ ba4) (\ bt4
+(decl_bblast _ _ _ (bv_bbl_var 4 a _ ) (\ bt1
+(decl_bblast _ _ _ (bv_bbl_var 4 b _ ) (\ bt2
+(decl_bblast _ _ _ (bv_bbl_const 4 _ (bvc b0 (bvc b0 (bvc b0 (bvc b0 bvn))))) (\ bt3
+(decl_bblast _ _ _ (bv_bbl_const 4 _ (bvc b1 (bvc b1 (bvc b1 (bvc b1 bvn))))) (\ bt4
+(decl_bblast _ _ _ (bv_bbl_bvand 4 _ _ _ _ _ bt1 bt3) (\ bt5
; bitblasting formulas
-(th_let_pf _ (bv_bbl_eq _ _ _ _ _ bt1 bt2) (\ bf1
-(th_let_pf _ (bv_bbl_eq _ _ _ _ _ bt1 bt3) (\ bf2
-(th_let_pf _ (bv_bbl_eq _ _ _ _ _ bt2 bt4) (\ bf3
+(th_let_pf _ (bv_bbl_eq _ _ _ _ _ _ bt1 bt2) (\ bf1
+(th_let_pf _ (bv_bbl_bvult _ _ _ _ _ _ bt1 bt5) (\ bf2
+(th_let_pf _ (bv_bbl_eq _ _ _ _ _ _ bt2 bt4) (\ bf3
; CNFication
; a.4 V ~b.4
(asf _ _ _ a1 (\ l1
(ast _ _ _ a2 (\ l2
(clausify_false
- (contra _ (impl_elim _ _ l2 (iff_elim_2 _ _ (and_elim_1 _ _ (impl_elim _ _ f1 bf1)))) l1) ; notice at the intermost we impl_elim, which converts from atom to bit-blasting representation
+ trust
))))) (\ C2
; ~a.4
(satlem _ _
(ast _ _ _ a1 (\ l1
(clausify_false
- (impl_elim _ _ l1 (iff_elim_1 _ _ (and_elim_1 _ _ (impl_elim _ _ f2 bf2))))
+ trust
))) (\ C3
; b.4
(satlem _ _
(asf _ _ _ a2 (\ l2
(clausify_false
- (contra _ (impl_elim _ _ truth (iff_elim_2 _ _ (and_elim_1 _ _ (impl_elim _ _ f3 bf3)))) l2)
+ trust
))) (\ C6
(satlem_simplify _ _ _
(R _ _ (R _ _ C6 C2 v2) C3 v1) (\ x x))
-)))))))))))))))))))))))))))))))))))))))))))
\ No newline at end of file
+)))))))))))))))))))))))))))))))))))))))))))))
--- /dev/null
+(check
+(% x var_bv
+(% y var_bv
+(% a var_bv
+(% A0 (th_holds true)
+(% A1 (th_holds
+ (= (BitVec 1) (a_var_bv 1 x)
+ (bvnot 1 (bvxnor 1 (bvxor 1 (a_var_bv 1 a) (a_bv 1 (bvc b1 bvn)))
+ (bvxor 1 (a_var_bv 1 a) (a_bv 1 (bvc b0 bvn))) ))))
+(: (th_holds
+ (= (BitVec 1) (a_var_bv 1 x)
+ (bvxor 1 (bvnot 1 (a_var_bv 1 a)) (a_var_bv 1 a))))
+
+;; print rewritten assertions
+
+(@ ones (a_bv 1 (bvc b1 bvn))
+(@ zero (a_bv 1 (bvc b0 bvn))
+(@ xorone (bvxor 1 (a_var_bv 1 a) ones)
+(@ xorzero (bvxor 1 (a_var_bv 1 a) zero)
+(@ t1 (bvxor 1 xorone xorzero)
+(@ t2 (bvxnor 1 xorone xorzero)
+(@ t3 (bvnot 1 t2)
+(@ t4 (bvnot 1 t1)
+(@ t5 (bvxor 1 (bvnot 1 (a_var_bv 1 a)) (a_var_bv 1 a))
+;; adding identity rewrite proofs
+(@ xor_onerw (rw_term_id 1 xorone)
+(@ xor_zerorw (rw_term_id 1 xorzero)
+(@ rw1 (xnor_elim 1 _ _ _ _ xor_onerw xor_zerorw) ;; bvxnor t1 t2 -> bvnot (bvxor t1 t2)
+(@ rw2 (xor_zero 1 _ _ _ _ (rw_term_id 1 (a_var_bv 1 a)) (rw_term_id 1 zero))
+(@ rw3 (xor_one 1 _ _ _ _ (rw_term_id 1 (a_var_bv 1 a)) (rw_term_id 1 ones))
+(@ rw4 (rw_bvop2_id 1 _ _ _ _ rw3 rw2 bvxor) ;; bvxor t1 t2 -> bvxor t1' t2'
+(@ rw5 (rw_bvop1_id 1 _ _ rw4 bvnot) ;; bvnot (bvxor t1 t2) -> bvnot (bvxor t1' t2')
+(@ rw6 (rw_term_trans 1 _ _ _ rw1 rw5) ;; bvxnor t1 t2 -> bvnot (bvxor t1' t2')
+(@ rw7 (rw_bvop1_id 1 _ _ rw6 bvnot) ;; (bvnot (bvxnor t1 t2)) ->(bvnot (bvnot (bvxor t1' t2')))
+(@ rw8 (not_idemp 1 _ _ (rw_term_id 1 t5)) ;; (bvnot (bvnot (bvxor t1' t2'))) -> bvxor t1' t2'
+(@ rw9 (rw_term_trans 1 _ _ _ rw7 rw8) ;; (bvnot (bvxnor t1 t2)) -> (bvxor t1' t2')
+(@ rw10 (rw_term_id 1 (a_var_bv 1 x))
+(@ rw11 (rw_eq_id 1 _ _ _ _ rw10 rw9) ;; x = t1 => x = t'
+(apply_rw_formula _ _ rw11 A1)
+
+)))))))))))))))))))))))))))))
\ No newline at end of file
; constructs for general clauses for R, Q, satlem
-(declare concat (! c1 clause (! c2 clause clause)))
+(declare concat_cl (! c1 clause (! c2 clause clause)))
(declare clr (! l lit (! c clause clause)))
; code to check resolutions
(match m
(tt (do (ifmarked4 v v (markvar4 v)) c'))
(ff (do (ifmarked4 v (markvar4 v) v) (markvar2 v) (clc l c')))))))))
- ((concat c1 c2) (append (simplify_clause c1) (simplify_clause c2)))
+ ((concat_cl c1 c2) (append (simplify_clause c1) (simplify_clause c2)))
((clr l c1)
(match l
; set mark 1 to indicate we should remove v, and fail if
(! u1 (holds c1)
(! u2 (holds c2)
(! n var
- (holds (concat (clr (pos n) c1)
+ (holds (concat_cl (clr (pos n) c1)
(clr (neg n) c2)))))))))
(declare Q (! c1 clause (! c2 clause
(! u1 (holds c1)
(! u2 (holds c2)
(! n var
- (holds (concat (clr (neg n) c1)
+ (holds (concat_cl (clr (neg n) c1)
(clr (pos n) c2)))))))))
(declare satlem_simplify
;
; (check
; (% v1 var
-; (% u1 (holds (concat (clr (neg v1) (clr (pos v1) (clc (pos v1) (clr (pos v1) (clc (pos v1) (clc (neg v1) cln))))))
+; (% u1 (holds (concat_cl (clr (neg v1) (clr (pos v1) (clc (pos v1) (clr (pos v1) (clc (pos v1) (clc (neg v1) cln))))))
; (clc (pos v1) (clc (pos v1) cln))))
; (satlem _ _ _ u1 (\ x x))))))
;(check
; (% v1 var
-; (% u1 (holds (clr (neg v1) (concat (clc (neg v1) cln)
+; (% u1 (holds (clr (neg v1) (concat_cl (clc (neg v1) cln)
; (clr (neg v1) (clc (neg v1) cln)))))
; (satlem _ _ _ u1 (\ x x))))))
; standard logic definitions
(declare true formula)
(declare false formula)
-(declare not (! f formula formula))
-(declare and (! f1 formula (! f2 formula formula)))
-(declare or (! f1 formula (! f2 formula formula)))
-(declare impl (! f1 formula (! f2 formula formula)))
-(declare iff (! f1 formula (! f2 formula formula)))
-(declare xor (! f1 formula (! f2 formula formula)))
-(declare ifte (! b formula (! f1 formula (! f2 formula formula))))
+
+(define formula_op1
+ (! f formula
+ formula))
+
+(define formula_op2
+ (! f1 formula
+ (! f2 formula
+ formula)))
+
+(define formula_op3
+ (! f1 formula
+ (! f2 formula
+ (! f3 formula
+ formula))))
+
+(declare not formula_op1)
+(declare and formula_op2)
+(declare or formula_op2)
+(declare impl formula_op2)
+(declare iff formula_op2)
+(declare xor formula_op2)
+(declare ifte formula_op3)
; terms
(declare sort type)
(declare Bool sort) ; the special sort for predicates
(declare p_app (! x (term Bool) formula)) ; propositional application of term
+; boolean terms
+(declare t_true (term Bool))
+(declare t_false (term Bool))
+(declare t_t_neq_f
+ (th_holds (not (= Bool t_true t_false))))
+(declare pred_eq_t
+ (! x (term Bool)
+ (! u (th_holds (p_app x))
+ (th_holds (= Bool x t_true)))))
+(declare pred_eq_f
+ (! x (term Bool)
+ (! u (th_holds (not (p_app x)))
+ (th_holds (= Bool x t_false)))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; binding between an LF var and an (atomic) formula
+
(declare atom (! v var (! p formula type)))
+; binding between two LF vars
+(declare bvatom (! sat_v var (! bv_v var type)))
+
(declare decl_atom
(! f formula
(! u (! v var
(holds cln)))
(holds cln))))
+;; declare atom enhanced with mapping
+;; between SAT prop variable and BVSAT prop variable
+(declare decl_bvatom
+ (! f formula
+ (! u (! v var
+ (! bv_v var
+ (! a (atom v f)
+ (! bva (atom bv_v f)
+ (! vbv (bvatom v bv_v)
+ (holds cln))))))
+ (holds cln))))
+
+
; clausify a formula directly
(declare clausify_form
(! f formula
(! u2 (! v (th_holds f) (holds cln))
(holds cln)))))
-
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Natural deduction rules : used for CNF
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; for eager bit-blasting
+(declare iff_symm
+ (! f formula
+ (th_holds (iff f f))))
+
;; contradiction
(! u (! o (th_holds (not f))
(holds C))
(holds (clc (pos v) C))))))))
-
+;; Bitvector lemma constructors to assume
+;; the unit clause containing the assumptions
+;; it also requires the mapping between bv_v and v
+;; The resolution proof proving false will use bv_v as the definition clauses use bv_v
+;; but the Problem clauses in the main SAT solver will use v so the learned clause is in terms of v
+(declare bv_asf
+ (! v var
+ (! bv_v var
+ (! f formula
+ (! C clause
+ (! r (atom v f) ;; passed in
+ (! x (bvatom v bv_v) ; establishes the equivalence of v to bv_
+ (! u (! o (holds (clc (neg bv_v) cln)) ;; l binding to be used in proof
+ (holds C))
+ (holds (clc (pos v) C))))))))))
+
+(declare bv_ast
+ (! v var
+ (! bv_v var
+ (! f formula
+ (! C clause
+ (! r (atom v f) ; this is specified
+ (! x (bvatom v bv_v) ; establishes the equivalence of v to bv_v
+ (! u (! o (holds (clc (pos bv_v) cln))
+ (holds C))
+ (holds (clc (neg v) C))))))))))
;; Example:
; Theory of Arrays
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-; depdends on : th_base.plf
+; depends on : th_base.plf
; sorts
+;;;; TEMPORARY:
+
+(declare trust-bad (th_holds false))
+
+; helper stuff
+(program mpz_sub ((x mpz) (y mpz)) mpz
+ (mp_add x (mp_mul (~1) y)))
+
+(program mp_ispos ((x mpz)) formula
+ (mp_ifneg x false true))
+
+(program mpz_eq ((x mpz) (y mpz)) formula
+ (mp_ifzero (mpz_sub x y) true false))
+
+(program mpz_lt ((x mpz) (y mpz)) formula
+ (mp_ifneg (mpz_sub x y) true false))
+
+(program mpz_lte ((x mpz) (y mpz)) formula
+ (mp_ifneg (mpz_sub x y) true (mpz_eq x y)))
+
+(program mpz_ ((x mpz) (y mpz)) formula
+ (mp_ifzero (mpz_sub x y) true false))
+
+
; "bitvec" is a term of type "sort"
-(declare BitVec sort)
+; (declare BitVec sort)
+(declare BitVec (!n mpz sort))
; bit type
(declare bit type)
(declare b0 bit)
(declare b1 bit)
-; bit vector type
+; bit vector type used for constants
(declare bv type)
(declare bvn bv)
(declare bvc (! b bit (! v bv bv)))
-; a bv constant term
-(declare a_bv (! v bv (term BitVec)))
; calculate the length of a bitvector
-(program bv_len ((v bv)) mpz
- (match v
- (bvn 0)
- ((bvc b v') (mp_add (bv_len v') 1))))
+;; (program bv_len ((v bv)) mpz
+;; (match v
+;; (bvn 0)
+;; ((bvc b v') (mp_add (bv_len v') 1))))
+
+
+; a bv constant term
+(declare a_bv
+ (! n mpz
+ (! v bv
+ (term (BitVec n)))))
+
; a bv variable
(declare var_bv type)
; a bv variable term
-(declare a_var_bv (! v var_bv (term BitVec)))
-
-
-; bit vector operators
-(define bvoper (! x (term BitVec)
- (! y (term BitVec)
- (term BitVec))))
-(declare bvand bvoper)
-(declare bvadd bvoper)
-;....
-
-; all bit-vector terms are mapped with "bv_atom" to:
-; - a simply-typed term of type "var_bv", which is necessary for bit-blasting
-; - a integer size
-(declare bv_atom (! x (term BitVec) (! y var_bv (! n mpz type))))
-
-(declare decl_bv_atom_var (! n mpz ; must be specified
- (! x var_bv
- (! p (! u (bv_atom (a_var_bv x) x n)
- (holds cln))
- (holds cln)))))
-
-(declare decl_bv_atom_const (! n mpz
- (! v bv
- (! s (^ (bv_len v) n)
- (! p (! w var_bv
- (! u (bv_atom (a_bv v) w n)
- (holds cln)))
- (holds cln))))))
-
-
-; other terms here?
-
-
-; bit blasted terms
-(declare bblt type)
-(declare bbltn bblt)
-(declare bbltc (! f formula (! v bblt bblt)))
-
-; (bblast_term x y) means term x corresponds to bit level interpretation y
-(declare bblast_term (! x (term BitVec) (! y bblt formula)))
-
-; a predicate to represent the n^th bit of a bitvector term
-(declare bblast (! x var_bv (! n mpz formula)))
-
-
-; bit blast constant
-(program bblast_const ((v bv) (n mpz)) bblt
- (mp_ifneg n (match v (bvn bbltn)
- (default (fail bblt)))
- (match v ((bvc b v') (bbltc (match b (b0 false) (b1 true)) (bblast_const v' (mp_add n (~ 1)))))
- (default (fail bblt)))))
-
-(declare bv_bbl_const (! n mpz
- (! v bv
- (! x var_bv
- (! f bblt
- (! u (bv_atom (a_bv v) x n)
- (! c (^ (bblast_const v (mp_add n (~ 1))) f)
- (th_holds (bblast_term (a_bv v) f)))))))))
-
-; bit blast variable
-(program bblast_var ((x var_bv) (n mpz)) bblt
- (mp_ifneg n bbltn
- (bbltc (bblast x n) (bblast_var x (mp_add n (~ 1))))))
-
-(declare bv_bbl_var (! n mpz
- (! x var_bv
- (! f bblt
- (! u (bv_atom (a_var_bv x) x n)
- (! c (^ (bblast_var x (mp_add n (~ 1))) f)
- (th_holds (bblast_term (a_var_bv x) f))))))))
-
-; bit blast x = y
-; for x,y of size n, it will return a conjuction (x.{n-1} = y.{n-1} ^ ( ... ^ (x.0 = y.0 ^ true)))
-(program bblast_eq ((x bblt) (y bblt)) formula
- (match x
- (bbltn (match y (bbltn true) (default (fail formula))))
- ((bbltc fx x') (match y
- (bbltn (fail formula))
- ((bbltc fy y') (and (iff fx fy) (bblast_eq x' y')))))))
-
-(declare bv_bbl_eq (! x (term BitVec)
- (! y (term BitVec)
- (! fx bblt
- (! fy bblt
- (! f formula
- (! ux (th_holds (bblast_term x fx))
- (! uy (th_holds (bblast_term y fy))
- (! c (^ (bblast_eq fx fy) f)
- (th_holds (impl (= BitVec x y) f)))))))))))
-
-
-; rewrite rule :
-; x + y = y + x
-(declare bvadd_symm (! x (term BitVec)
- (! y (term BitVec)
- (! x' var_bv
- (! y' var_bv
- (! n mpz
- (! ux (bv_atom x x' n)
- (! uy (bv_atom y y' n)
- (th_holds (= BitVec (bvadd x y) (bvadd y x)))))))))))
-
-
-
-; necessary?
-(program calc_bvand ((a bv) (b bv)) bv
- (match a
- (bvn (match b (bvn bvn) (default (fail bv))))
- ((bvc ba a') (match b
- ((bvc bb b') (bvc (match ba (b0 b0) (b1 bb)) (calc_bvand a' b')))
- (default (fail bv))))))
-
-; rewrite rule (w constants) :
-; a & b = c
-(declare bvand_const (! c bv
- (! a bv
- (! b bv
- (! u (^ (calc_bvand a b) c)
- (th_holds (= BitVec (bvand (a_bv a) (a_bv b)) (a_bv c))))))))
\ No newline at end of file
+(declare a_var_bv
+ (! n mpz
+ (! v var_bv
+ (term (BitVec n)))))
+
+; bit vector binary operators
+(define bvop2
+ (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ (term (BitVec n))))))
+
+(declare bvand bvop2)
+(declare bvor bvop2)
+(declare bvor bvop2)
+(declare bvxor bvop2)
+(declare bvnand bvop2)
+(declare bvnor bvop2)
+(declare bvxnor bvop2)
+(declare bvmul bvop2)
+(declare bvadd bvop2)
+(declare bvsub bvop2)
+(declare bvudiv bvop2)
+(declare bvurem bvop2)
+(declare bvsdiv bvop2)
+(declare bvsrem bvop2)
+(declare bvsmod bvop2)
+(declare bvshl bvop2)
+(declare bvlshr bvop2)
+(declare bvashr bvop2)
+(declare concat bvop2)
+
+; bit vector unary operators
+(define bvop1
+ (! n mpz
+ (! x (term (BitVec n))
+ (term (BitVec n)))))
+
+
+(declare bvneg bvop1)
+(declare bvnot bvop1)
+(declare rotate_left bvop1)
+(declare rotate_right bvop1)
+
+(declare bvcomp
+ (! n mpz
+ (! t1 (term (BitVec n))
+ (! t2 (term (BitVec n))
+ (term (BitVec 1))))))
+
+
+(declare concat
+ (! n mpz
+ (! m mpz
+ (! m' mpz
+ (! t1 (term (BitVec m))
+ (! t2 (term (BitVec m'))
+ (term (BitVec n))))))))
+
+;; side-condition fails in signature only??
+;; (! s (^ (mp_add m m') n)
+
+;; (declare repeat bvopp)
+
+(declare extract
+ (! n mpz
+ (! i mpz
+ (! j mpz
+ (! m mpz
+ (! t2 (term (BitVec m))
+ (term (BitVec n))))))))
+
+(declare zero_extend
+ (! n mpz
+ (! i mpz
+ (! m mpz
+ (! t2 (term (BitVec m))
+ (term (BitVec n)))))))
+
+(declare sign_extend
+ (! n mpz
+ (! i mpz
+ (! m mpz
+ (! t2 (term (BitVec m))
+ (term (BitVec n)))))))
+
+(declare repeat
+ (! n mpz
+ (! i mpz
+ (! m mpz
+ (! t2 (term (BitVec m))
+ (term (BitVec n)))))))
+
+
+
+;; TODO: add checks for valid typing for these operators
+;; (! c1 (^ (mpz_lte i j)
+;; (! c2 (^ (mpz_lt i n) true)
+;; (! c3 (^ (mp_ifneg i false true) true)
+;; (! c4 (^ (mp_ifneg j false true) true)
+;; (! s (^ (mp_add (mpz_sub i j) 1) m)
+
+
+; bit vector predicates
+(define bvpred
+ (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ formula))))
+
+(declare bvult bvpred)
+(declare bvule bvpred)
+(declare bvugt bvpred)
+(declare bvuge bvpred)
+(declare bvslt bvpred)
+(declare bvsle bvpred)
+(declare bvsgt bvpred)
+(declare bvsge bvpred)
+
--- /dev/null
+; bit blasted terms as list of formulas
+(declare bblt type)
+(declare bbltn bblt)
+(declare bbltc (! f formula (! v bblt bblt)))
+
+; calculate the length of a bit-blasted term
+(program bblt_len ((v bblt)) mpz
+ (match v
+ (bbltn 0)
+ ((bbltc b v') (mp_add (bblt_len v') 1))))
+
+
+; (bblast_term x y) means term y corresponds to bit level interpretation x
+(declare bblast_term
+ (! n mpz
+ (! x (term (BitVec n))
+ (! y bblt
+ type))))
+
+; FIXME: for unsupported bit-blast terms
+(declare trust_bblast_term
+ (! n mpz
+ (! x (term (BitVec n))
+ (! y bblt
+ (bblast_term n x y)))))
+
+
+(declare decl_bblast
+ (! n mpz
+ (! b bblt
+ (! t (term (BitVec n))
+ (! bb (bblast_term n t b)
+ (! s (^ (bblt_len b) n)
+ (! u (! v (bblast_term n t b) (holds cln))
+ (holds cln))))))))
+
+
+; a predicate to represent the n^th bit of a bitvector term
+(declare bitof
+ (! x var_bv
+ (! n mpz formula)))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; BITBLASTING RULES
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST CONSTANT
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_const ((v bv) (n mpz)) bblt
+ (mp_ifneg n (match v (bvn bbltn)
+ (default (fail bblt)))
+ (match v ((bvc b v') (bbltc (match b (b0 false) (b1 true)) (bblast_const v' (mp_add n (~ 1)))))
+ (default (fail bblt)))))
+
+(declare bv_bbl_const (! n mpz
+ (! f bblt
+ (! v bv
+ (! c (^ (bblast_const v (mp_add n (~ 1))) f)
+ (bblast_term n (a_bv n v) f))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST VARIABLE
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_var ((x var_bv) (n mpz)) bblt
+ (mp_ifneg n bbltn
+ (bbltc (bitof x n) (bblast_var x (mp_add n (~ 1))))))
+
+(declare bv_bbl_var (! n mpz
+ (! x var_bv
+ (! f bblt
+ (! c (^ (bblast_var x (mp_add n (~ 1))) f)
+ (bblast_term n (a_var_bv n x) f))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST CONCAT
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_concat ((x bblt) (y bblt)) bblt
+ (match x
+ (bbltn (match y ((bbltc by y') (bbltc by (bblast_concat x y')))
+ (bbltn bbltn)))
+ ((bbltc bx x') (bbltc bx (bblast_concat x' y)))))
+
+
+(declare bv_bbl_concat (! n mpz
+ (! m mpz
+ (! m1 mpz
+ (! x (term (BitVec m))
+ (! y (term (BitVec m1))
+ (! xb bblt
+ (! yb bblt
+ (! rb bblt
+ (! xbb (bblast_term m x xb)
+ (! ybb (bblast_term m1 y yb)
+ (! c (^ (bblast_concat xb yb ) rb)
+ (bblast_term n (concat n m m1 x y) rb)))))))))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST EXTRACT
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_extract_rec ((x bblt) (i mpz) (j mpz) (n mpz)) bblt
+ (match x
+ ((bbltc bx x') (mp_ifneg (mpz_sub (mpz_sub j n) 1)
+ (mp_ifneg (mpz_sub (mpz_sub n i) 1)
+ (bbltc bx (bblast_extract_rec x' i j (mpz_sub n 1)))
+ (bblast_extract_rec x' i j (mpz_sub n 1)))
+
+ bbltn))
+ (bbltn bbltn)))
+
+(program bblast_extract ((x bblt) (i mpz) (j mpz) (n mpz)) bblt
+ (bblast_extract_rec x i j (mpz_sub n 1)))
+
+(declare bv_bbl_extract (! n mpz
+ (! i mpz
+ (! j mpz
+ (! m mpz
+ (! x (term (BitVec m))
+ (! xb bblt
+ (! rb bblt
+ (! xbb (bblast_term m x xb)
+ (! c ( ^ (bblast_extract xb i j m) rb)
+ (bblast_term n (extract n i j m x) rb)))))))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST ZERO/SIGN EXTEND
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program extend_rec ((x bblt) (i mpz) (b formula)) bblt
+ (mp_ifneg i x
+ (bbltc b (extend_rec x (mpz_sub i 1) b)))))
+
+(program bblast_zextend ((x bblt) (i mpz)) bblt
+ (extend_rec x (mpz_sub i 1) false))
+
+(declare bv_bbl_zero_extend (! n mpz
+ (! k mpz
+ (! m mpz
+ (! x (term (BitVec m))
+ (! xb bblt
+ (! rb bblt
+ (! xbb (bblast_term m x xb)
+ (! c ( ^ (bblast_zextend xb k m) rb)
+ (bblast_term n (zero_extend n k m x) rb))))))))))
+
+
+(program bblast_sextend ((x bblt) (i mpz)) bblt
+ (match x (bbltn (fail bblt))
+ ((bbltc xb x') (extend_rec x (mpz_sub i 1) xb))))
+
+(declare bv_bbl_sign_extend (! n mpz
+ (! k mpz
+ (! m mpz
+ (! x (term (BitVec m))
+ (! xb bblt
+ (! rb bblt
+ (! xbb (bblast_term m x xb)
+ (! c ( ^ (bblast_sextend xb k m) rb)
+ (bblast_term n (sign_extend n k m x) rb))))))))))
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST BVAND
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_bvand ((x bblt) (y bblt)) bblt
+ (match x
+ (bbltn (match y (bbltn bbltn) (default (fail bblt))))
+ ((bbltc bx x') (match y
+ (bbltn (fail bblt))
+ ((bbltc by y') (bbltc (and bx by) (bblast_bvand x' y')))))))
+
+
+(declare bv_bbl_bvand (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ (! xb bblt
+ (! yb bblt
+ (! rb bblt
+ (! xbb (bblast_term n x xb)
+ (! ybb (bblast_term n y yb)
+ (! c (^ (bblast_bvand xb yb ) rb)
+ (bblast_term n (bvand n x y) rb)))))))))))
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST BVNOT
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_bvnot ((x bblt)) bblt
+ (match x
+ (bbltn bbltn)
+ ((bbltc bx x') (bbltc (not bx) (bblast_bvnot x')))))
+
+
+(declare bv_bbl_bvnot (! n mpz
+ (! x (term (BitVec n))
+ (! xb bblt
+ (! rb bblt
+ (! xbb (bblast_term n x xb)
+ (! c (^ (bblast_bvnot xb ) rb)
+ (bblast_term n (bvnot n x) rb))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST BVOR
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_bvor ((x bblt) (y bblt)) bblt
+ (match x
+ (bbltn (match y (bbltn bbltn) (default (fail bblt))))
+ ((bbltc bx x') (match y
+ (bbltn (fail bblt))
+ ((bbltc by y') (bbltc (or bx by) (bblast_bvor x' y')))))))
+
+
+(declare bv_bbl_bvor (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ (! xb bblt
+ (! yb bblt
+ (! rb bblt
+ (! xbb (bblast_term n x xb)
+ (! ybb (bblast_term n y yb)
+ (! c (^ (bblast_bvor xb yb ) rb)
+ (bblast_term n (bvor n x y) rb)))))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST BVXOR
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_bvxor ((x bblt) (y bblt)) bblt
+ (match x
+ (bbltn (match y (bbltn bbltn) (default (fail bblt))))
+ ((bbltc bx x') (match y
+ (bbltn (fail bblt))
+ ((bbltc by y') (bbltc (xor bx by) (bblast_bvxor x' y')))))))
+
+
+(declare bv_bbl_bvxor (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ (! xb bblt
+ (! yb bblt
+ (! rb bblt
+ (! xbb (bblast_term n x xb)
+ (! ybb (bblast_term n y yb)
+ (! c (^ (bblast_bvxor xb yb ) rb)
+ (bblast_term n (bvxor n x y) rb)))))))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST BVADD
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; return the carry bit after adding x y
+;; FIXME: not the most efficient thing in the world
+(program bblast_bvadd_carry ((a bblt) (b bblt) (carry formula)) formula
+(match a
+ ( bbltn (match b (bbltn carry) (default (fail formula))))
+ ((bbltc ai a') (match b
+ (bbltn (fail formula))
+ ((bbltc bi b') (or (and ai bi) (and (xor ai bi) (bblast_bvadd_carry a' b' carry))))))))
+
+;; ripple carry adder where carry is the initial carry bit
+(program bblast_bvadd ((a bblt) (b bblt) (carry formula)) bblt
+(match a
+ ( bbltn (match b (bbltn bbltn) (default (fail bblt))))
+ ((bbltc ai a') (match b
+ (bbltn (fail bblt))
+ ((bbltc bi b') (bbltc (xor (xor ai bi) (bblast_bvadd_carry a' b' carry))
+ (bblast_bvadd a' b' carry)))))))
+
+
+(declare bv_bbl_bvadd (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ (! xb bblt
+ (! yb bblt
+ (! rb bblt
+ (! xbb (bblast_term n x xb)
+ (! ybb (bblast_term n y yb)
+ (! c (^ (bblast_bvadd xb yb false) rb)
+ (bblast_term n (bvadd n x y) rb)))))))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST BVNEG
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_zero ((n mpz)) bblt
+(mp_ifzero n bbltn
+ (bbltc false (bblast_zero (mp_add n (~1))))))
+
+(program bblast_bvneg ((x bblt) (n mpz)) bblt
+ (bblast_bvadd (bblast_bvnot x) (bblast_zero n) true))
+
+
+(declare bv_bbl_bvneg (! n mpz
+ (! x (term (BitVec n))
+ (! xb bblt
+ (! rb bblt
+ (! xbb (bblast_term n x xb)
+ (! c (^ (bblast_bvneg xb n) rb)
+ (bblast_term n (bvneg n x) rb))))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST BVMUL
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+;; shift add multiplier
+
+(program reverse_help ((x bblt) (acc bblt)) bblt
+(match x
+ (bbltn acc)
+ ((bbltc xi x') (reverse_help x' (bbltc xi acc)))))
+
+
+(program reverseb ((x bblt)) bblt
+ (reverse_help x bbltn))
+
+;; (program concat ((a bblt) (b bblt)) bblt
+;; (match a (bbltn b)
+;; ((bbltc ai a') (bbltc ai (concat a' b)))))
+
+
+(program top_k_bits ((a bblt) (k mpz)) bblt
+ (mp_ifzero k bbltn
+ (match a (bbltn (fail bblt))
+ ((bbltc ai a') (bbltc ai (top_k_bits a' (mpz_sub k 1)))))))
+
+(program bottom_k_bits ((a bblt) (k mpz)) bblt
+ (reverseb (top_k_bits (reverseb a) k)))
+
+;; assumes the least signigicant bit is at the beginning of the list
+(program k_bit ((a bblt) (k mpz)) formula
+(mp_ifneg k (fail formula)
+(match a (bbltn (fail formula))
+ ((bbltc ai a') (mp_ifzero k ai (k_bit a' (mpz_sub k 1)))))))
+
+(program and_with_bit ((a bblt) (bt formula)) bblt
+(match a (bbltn bbltn)
+ ((bbltc ai a') (bbltc (and bt ai) (and_with_bit a' bt)))))
+
+;; a is going to be the current result
+;; carry is going to be false initially
+;; b is the and of a and b[k]
+;; res is going to be bbltn initially
+(program mult_step_k_h ((a bblt) (b bblt) (res bblt) (carry formula) (k mpz)) bblt
+(match a
+ (bbltn (match b (bbltn res) (default (fail bblt))))
+ ((bbltc ai a')
+ (match b (bbltn (fail bblt))
+ ((bbltc bi b')
+ (mp_ifneg (mpz_sub k 1)
+ (let carry_out (or (and ai bi) (and (xor ai bi) carry))
+ (let curr (xor (xor ai bi) carry)
+ (mult_step_k_h a' b' (bbltc curr res) carry_out (mpz_sub k 1))))
+ (mult_step_k_h a' b (bbltc ai res) carry (mpz_sub k 1))
+))))))
+
+;; assumes that a, b and res have already been reversed
+(program mult_step ((a bblt) (b bblt) (res bblt) (n mpz) (k mpz)) bblt
+(let k' (mpz_sub n k )
+(let ak (top_k_bits a k')
+(let b' (and_with_bit ak (k_bit b k))
+ (mp_ifzero (mpz_sub k' 1)
+ (mult_step_k_h res b' bbltn false k)
+ (let res' (mult_step_k_h res b' bbltn false k)
+ (mult_step a b (reverseb res') n (mp_add k 1))))))))
+
+
+(program bblast_bvmul ((a bblt) (b bblt) (n mpz)) bblt
+(let ar (reverseb a) ;; reverse a and b so that we can build the circuit
+(let br (reverseb b) ;; from the least significant bit up
+(let res (and_with_bit ar (k_bit br 0))
+ (mp_ifzero (mpz_sub n 1) ;; if multiplying 1 bit numbers no need to call mult_step
+ res
+ (mult_step ar br res n 1))))))
+
+(declare bv_bbl_bvmul (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ (! xb bblt
+ (! yb bblt
+ (! rb bblt
+ (! xbb (bblast_term n x xb)
+ (! ybb (bblast_term n y yb)
+ (! c (^ (bblast_bvmul xb yb n) rb)
+ (bblast_term n (bvmul n x y) rb)))))))))))
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST EQUALS
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; bit blast x = y
+; for x,y of size n, it will return a conjuction (x.0 = y.0 ^ ( ... ^ (x.{n-1} = y.{n-1})))
+; f is the accumulator formula that builds the equality in the right order
+(program bblast_eq_rec ((x bblt) (y bblt) (f formula)) formula
+ (match x
+ (bbltn (match y (bbltn f) (default (fail formula))))
+ ((bbltc fx x') (match y
+ (bbltn (fail formula))
+ ((bbltc fy y') (bblast_eq_rec x' y' (and (iff fx fy) f)))))
+ (default (fail formula))))
+
+(program bblast_eq ((x bblt) (y bblt)) formula
+ (match x
+ ((bbltc bx x') (match y ((bbltc by y') (bblast_eq_rec x' y' (iff bx by)))
+ (default (fail formula))))
+ (default (fail formula))))
+
+(declare bv_bbl_=
+ (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ (! bx bblt
+ (! by bblt
+ (! f formula
+ (! bbx (bblast_term n x bx)
+ (! bby (bblast_term n y by)
+ (! c (^ (bblast_eq bx by) f)
+ (th_holds (iff (= (BitVec n) x y) f))))))))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST BVULT
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_bvult ((x bblt) (y bblt) (n mpz)) formula
+(match x
+ ( bbltn (fail formula))
+ ((bbltc xi x') (match y
+ (bbltn (fail formula))
+ ((bbltc yi y') (mp_ifzero n
+ (and (not xi) yi)
+ (or (and (iff xi yi) (bblast_bvult x' y' (mp_add n (~1)))) (and (not xi) yi))))))))
+
+(declare bv_bbl_bvult
+ (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ (! bx bblt
+ (! by bblt
+ (! f formula
+ (! bbx (bblast_term n x bx)
+ (! bby (bblast_term n y by)
+ (! c (^ (bblast_bvult bx by (mp_add n (~1))) f)
+ (th_holds (iff (bvult n x y) f))))))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; BITBLAST BVSLT
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(program bblast_bvslt ((x bblt) (y bblt) (n mpz)) formula
+(match x
+ ( bbltn (fail formula))
+ ((bbltc xi x') (match y
+ (bbltn (fail formula))
+ ((bbltc yi y') (mp_ifzero (mpz_sub n 1)
+ (and xi (not yi))
+ (or (and (iff xi yi)
+ (bblast_bvult x' y' (mpz_sub n 2)))
+ (and xi (not yi)))))))))
+
+(declare bv_bbl_bvslt
+ (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ (! bx bblt
+ (! by bblt
+ (! f formula
+ (! bbx (bblast_term n x bx)
+ (! bby (bblast_term n y by)
+ (! c (^ (bblast_bvslt bx by n) f)
+ (th_holds (iff (bvslt n x y) f))))))))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; BITBLASTING CONNECTORS
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+; bit-blasting connections
+
+(declare intro_assump_t
+ (! f formula
+ (! v var
+ (! C clause
+ (! h (th_holds f)
+ (! a (atom v f)
+ (! u (! unit (holds (clc (pos v) cln))
+ (holds C))
+ (holds C))))))))
+
+(declare intro_assump_f
+ (! f formula
+ (! v var
+ (! C clause
+ (! h (th_holds (not f))
+ (! a (atom v f)
+ (! u (! unit (holds (clc (neg v) cln))
+ (holds C))
+ (holds C))))))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; REWRITE RULES
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+; rewrite rule :
+; x + y = y + x
+(declare bvadd_symm
+ (! n mpz
+ (! x (term (BitVec n))
+ (! y (term (BitVec n))
+ (th_holds (= (BitVec n) (bvadd _ x y) (bvadd _ y x)))))))
+
+;; (declare bvcrazy_rewrite
+;; (! n mpz
+;; (! x (term (BitVec n))
+;; (! y (term (BitVec n))
+;; (! xn bv_poly
+;; (! yn bv_poly
+;; (! hxn (bv_normalizes x xn)
+;; (! hyn (bv_normalizes y yn)
+;; (! s (^ (rewrite_scc xn yn) true)
+;; (! u (! x (term (BitVec n)) (holds cln))
+;; (holds cln)))))))))))
+
+;; (th_holds (= (BitVec n) (bvadd x y) (bvadd y x)))))))
+
+
+
+; necessary?
+;; (program calc_bvand ((a bv) (b bv)) bv
+;; (match a
+;; (bvn (match b (bvn bvn) (default (fail bv))))
+;; ((bvc ba a') (match b
+;; ((bvc bb b') (bvc (match ba (b0 b0) (b1 bb)) (calc_bvand a' b')))
+;; (default (fail bv))))))
+
+;; ; rewrite rule (w constants) :
+;; ; a & b = c
+;; (declare bvand_const (! c bv
+;; (! a bv
+;; (! b bv
+;; (! u (^ (calc_bvand a b) c)
+;; (th_holds (= BitVec (bvand (a_bv a) (a_bv b)) (a_bv c))))))))
+
+
+;; making constant bit-vectors
+(program mk_ones ((n mpz)) bv
+ (mp_ifzero n bvn (bvc b1 (mk_ones (mpz_sub n 1)))))
+
+(program mk_zero ((n mpz)) bv
+ (mp_ifzero n bvn (bvc b0 (mk_ones (mpz_sub n 1)))))
+
+
+
+;; (bvxnor a b) => (bvnot (bvxor a b))
+;; (declare bvxnor_elim
+;; (! n mpz
+;; (! a (term (BitVec n))
+;; (! b (term (BitVec n))
+;; (! a' (term (BitVec n))
+;; (! b' (term (BitVec n))
+;; (! rwa (rw_term _ a a')
+;; (! rwb (rw_term _ b b')
+;; (rw_term n (bvxnor _ a b)
+;; (bvnot _ (bvxor _ a' b')))))))))))
+
+
+
+;; ;; (bvxor a 0) => a
+;; (declare bvxor_zero
+;; (! n mpz
+;; (! zero_bits bv
+;; (! sc (^ (mk_zero n) zero_bits)
+;; (! a (term (BitVec n))
+;; (! b (term (BitVec n))
+;; (! a' (term (BitVec n))
+;; (! rwa (rw_term _ a a')
+;; (! rwb (rw_term _ b (a_bv _ zero_bits))
+;; (rw_term _ (bvxor _ a b)
+;; a'))))))))))
+
+;; ;; (bvxor a 11) => (bvnot a)
+;; (declare bvxor_one
+;; (! n mpz
+;; (! one_bits bv
+;; (! sc (^ (mk_ones n) one_bits)
+;; (! a (term (BitVec n))
+;; (! b (term (BitVec n))
+;; (! a' (term (BitVec n))
+;; (! rwa (rw_term _ a a')
+;; (! rwb (rw_term _ b (a_bv _ one_bits))
+;; (rw_term _ (bvxor _ a b)
+;; (bvnot _ a')))))))))))
+
+
+;; ;; (bvnot (bvnot a)) => a
+;; (declare bvnot_idemp
+;; (! n mpz
+;; (! a (term (BitVec n))
+;; (! a' (term (BitVec n))
+;; (! rwa (rw_term _ a a')
+;; (rw_term _ (bvnot _ (bvnot _ a))
+;; a'))))))
+
printer/tptp/tptp_printer.cpp \
proof/proof.h \
proof/sat_proof.h \
- proof/sat_proof.cpp \
+ proof/sat_proof_implementation.h \
proof/cnf_proof.h \
proof/cnf_proof.cpp \
proof/theory_proof.h \
proof/theory_proof.cpp \
+ proof/uf_proof.h \
+ proof/uf_proof.cpp \
+ proof/array_proof.h \
+ proof/bitvector_proof.h \
+ proof/bitvector_proof.cpp \
proof/proof_manager.h \
proof/proof_manager.cpp \
+ proof/proof_utils.h \
+ proof/proof_utils.cpp \
proof/unsat_core.cpp \
proof/unsat_core.h \
prop/registrar.h \
# Options for lazy bit-blasting
-option bitvectorPropagate --bv-propagate bool :default true :read-write :link --bitblast=lazy
+option bitvectorPropagate --bv-propagate bool :default true :read-write
use bit-vector propagation in the bit-blaster
-option bitvectorEqualitySolver --bv-eq-solver bool :default true :read-write :link --bitblast=lazy
+option bitvectorEqualitySolver --bv-eq-solver bool :default true :read-write
use the equality engine for the bit-vector theory (only if --bitblast=lazy)
option bitvectorEqualitySlicer --bv-eq-slicer=MODE CVC4::theory::bv::BvSlicerMode :handler CVC4::options::stringToBvSlicerMode :default CVC4::theory::bv::BITVECTOR_SLICER_OFF :read-write :include "options/bv_bitblast_mode.h" :handler-include "options/options_handler_interface.h" :read-write :link --bv-eq-solver
turn on the slicing equality solver for the bit-vector theory (only if --bitblast=lazy)
-option bitvectorInequalitySolver --bv-inequality-solver bool :default true :read-write :link --bitblast=lazy
+option bitvectorInequalitySolver --bv-inequality-solver bool :default true :read-write
turn on the inequality solver for the bit-vector theory (only if --bitblast=lazy)
-option bitvectorAlgebraicSolver --bv-algebraic-solver bool :default true :read-write :link --bitblast=lazy
+option bitvectorAlgebraicSolver --bv-algebraic-solver bool :default true :read-write
turn on the algebraic solver for the bit-vector theory (only if --bitblast=lazy)
expert-option bitvectorAlgebraicBudget --bv-algebraic-budget unsigned :default 1500 :read-write :link --bv-algebraic-solver
--- /dev/null
+/********************* */
+/*! \file array_proof.h
+ ** \verbatim
+ ** Original author: Liana Hadarean
+ ** Major contributors: none
+ ** Minor contributors (to current version): none
+ ** This file is part of the CVC4 project.
+ ** Copyright (c) 2009-2014 New York University and The University of Iowa
+ ** See the file COPYING in the top-level source directory for licensing
+ ** information.\endverbatim
+ **
+ ** \brief Arrray proof
+ **
+ ** Arrau proof
+ **/
+
+#include "cvc4_private.h"
+
+#ifndef __CVC4__ARRAY__PROOF_H
+#define __CVC4__ARRAY__PROOF_H
+
+#include "expr/expr.h"
+#include "proof/proof_manager.h"
+#include "proof/theory_proof.h"
+#include "theory/arrays/theory_arrays.h"
+
+namespace CVC4 {
+
+namespace theory {
+namespace arrays{
+class TheoryArrays;
+} /* namespace CVC4::theory::arrays */
+} /* namespace CVC4::theory */
+
+class ArrayProof : public TheoryProof {
+ // TODO: whatever goes in this theory
+public:
+ ArrayProof(theory::arrays::TheoryArrays* arrays, TheoryProofEngine* proofEngine)
+ : TheoryProof(arrays, proofEngine)
+ {}
+ virtual void registerTerm(Expr term) {}
+
+ virtual void printTerm(Expr term, std::ostream& os, const LetMap& map) = 0;
+ virtual void printSort(Type type, std::ostream& os) = 0;
+ /**
+ * Print a proof for the theory lemma. Must prove
+ * clause representing lemma to be used in resolution proof.
+ *
+ * @param lemma clausal form of lemma
+ * @param os output stream
+ */
+ virtual void printTheoryLemmaProof(std::vector<Expr>& lemma, std::ostream& os, std::ostream& paren) = 0;
+ /**
+ * Print the variable/sorts declarations for this theory.
+ *
+ * @param os
+ * @param paren
+ */
+ virtual void printDeclarations(std::ostream& os, std::ostream& paren) = 0;
+};
+
+class LFSCArrayProof : public ArrayProof {
+public:
+ LFSCArrayProof(theory::arrays::TheoryArrays* uf, TheoryProofEngine* proofEngine)
+ : ArrayProof(uf, proofEngine)
+ {}
+ // TODO implement
+ virtual void printTerm(Expr term, std::ostream& os, const LetMap& map) {}
+ virtual void printSort(Type type, std::ostream& os) {}
+ virtual void printTheoryLemmaProof(std::vector<Expr>& lemma, std::ostream& os, std::ostream& paren) {}
+ virtual void printDeclarations(std::ostream& os, std::ostream& paren) {}
+
+};
+
+
+}/* CVC4 namespace */
+
+#endif /* __CVC4__ARRAY__PROOF_H */
--- /dev/null
+/********************* */
+/*! \file bitvector_proof.cpp
+** \verbatim
+** Original author: Liana Hadarean
+** Major contributors: none
+** Minor contributors (to current version): none
+** This file is part of the CVC4 project.
+** Copyright (c) 2009-2014 New York University and The University of Iowa
+** See the file COPYING in the top-level source directory for licensing
+** information.\endverbatim
+**
+** \brief [[ Add one-line brief description here ]]
+**
+** [[ Add lengthier description here ]]
+** \todo document this file
+**/
+
+
+#include "proof/bitvector_proof.h"
+#include "options/bv_options.h"
+#include "proof/proof_utils.h"
+#include "proof/sat_proof_implementation.h"
+#include "prop/bvminisat/bvminisat.h"
+#include "theory/bv/bitblaster_template.h"
+#include "theory/bv/theory_bv.h"
+
+using namespace CVC4::theory;
+using namespace CVC4::theory::bv;
+
+namespace CVC4 {
+
+BitVectorProof::BitVectorProof(theory::bv::TheoryBV* bv, TheoryProofEngine* proofEngine)
+ : TheoryProof(bv, proofEngine)
+ , d_declarations()
+ , d_seenBBTerms()
+ , d_bbTerms()
+ , d_bbAtoms()
+ , d_resolutionProof(NULL)
+ , d_cnfProof(NULL)
+ , d_bitblaster(NULL)
+{}
+
+void BitVectorProof::initSatProof(CVC4::BVMinisat::Solver* solver) {
+ Assert (d_resolutionProof == NULL);
+ d_resolutionProof = new LFSCBVSatProof(solver, "bb", true);
+}
+
+void BitVectorProof::initCnfProof(prop::CnfStream* cnfStream,
+ context::Context* cnf) {
+ Assert (d_cnfProof == NULL);
+ d_cnfProof = new LFSCCnfProof(cnfStream, cnf, "bb");
+ Assert (d_resolutionProof != NULL);
+ d_resolutionProof->setCnfProof(d_cnfProof);
+
+ // true and false have to be setup in a special way
+ Node true_node = NodeManager::currentNM()->mkConst<bool>(true);
+ Node false_node = NodeManager::currentNM()->mkConst<bool>(false).notNode();
+
+ d_cnfProof->pushCurrentAssertion(true_node);
+ d_cnfProof->pushCurrentDefinition(true_node);
+ d_cnfProof->registerConvertedClause(d_resolutionProof->getTrueUnit());
+ d_cnfProof->popCurrentAssertion();
+ d_cnfProof->popCurrentDefinition();
+
+ d_cnfProof->pushCurrentAssertion(false_node);
+ d_cnfProof->pushCurrentDefinition(false_node);
+ d_cnfProof->registerConvertedClause(d_resolutionProof->getFalseUnit());
+ d_cnfProof->popCurrentAssertion();
+ d_cnfProof->popCurrentDefinition();
+}
+
+void BitVectorProof::setBitblaster(bv::TBitblaster<Node>* bb) {
+ Assert (d_bitblaster == NULL);
+ d_bitblaster = bb;
+}
+
+BVSatProof* BitVectorProof::getSatProof() {
+ Assert (d_resolutionProof != NULL);
+ return d_resolutionProof;
+}
+
+void BitVectorProof::registerTermBB(Expr term) {
+ if (d_seenBBTerms.find(term) != d_seenBBTerms.end())
+ return;
+
+ d_seenBBTerms.insert(term);
+ d_bbTerms.push_back(term);
+}
+
+void BitVectorProof::registerAtomBB(Expr atom, Expr atom_bb) {
+ Expr def = atom.iffExpr(atom_bb);
+ d_bbAtoms.insert(std::make_pair(atom, def));
+ registerTerm(atom);
+}
+
+void BitVectorProof::registerTerm(Expr term) {
+ d_usedBB.insert(term);
+
+ if (Theory::isLeafOf(term, theory::THEORY_BV) &&
+ !term.isConst()) {
+ d_declarations.insert(term);
+ }
+
+ // don't care about parametric operators for bv?
+ for (unsigned i = 0; i < term.getNumChildren(); ++i) {
+ d_proofEngine->registerTerm(term[i]);
+ }
+}
+
+std::string BitVectorProof::getBBTermName(Expr expr) {
+ std::ostringstream os;
+ os << "bt"<< expr.getId();
+ return os.str();
+}
+
+void BitVectorProof::startBVConflict(CVC4::BVMinisat::Solver::TCRef cr) {
+ d_resolutionProof->startResChain(cr);
+}
+
+void BitVectorProof::startBVConflict(CVC4::BVMinisat::Solver::TLit lit) {
+ d_resolutionProof->startResChain(lit);
+}
+
+void BitVectorProof::endBVConflict(const CVC4::BVMinisat::Solver::TLitVec& confl) {
+ std::vector<Expr> expr_confl;
+ for (int i = 0; i < confl.size(); ++i) {
+ prop::SatLiteral lit = prop::BVMinisatSatSolver::toSatLiteral(confl[i]);
+ Expr atom = d_cnfProof->getAtom(lit.getSatVariable()).toExpr();
+ Expr expr_lit = lit.isNegated() ? atom.notExpr() : atom;
+ expr_confl.push_back(expr_lit);
+ }
+ Expr conflict = utils::mkSortedExpr(kind::OR, expr_confl);
+ Debug("bv-proof") << "Make conflict for " << conflict << std::endl;
+
+ if (d_bbConflictMap.find(conflict) != d_bbConflictMap.end()) {
+ Debug("bv-proof") << "Abort...already conflict for " << conflict << std::endl;
+ // This can only happen when we have eager explanations in the bv solver
+ // if we don't get to propagate p before ~p is already asserted
+ d_resolutionProof->cancelResChain();
+ return;
+ }
+
+ // we don't need to check for uniqueness in the sat solver then
+ ClauseId clause_id = d_resolutionProof->registerAssumptionConflict(confl);
+ d_bbConflictMap[conflict] = clause_id;
+ d_resolutionProof->endResChain(clause_id);
+ Debug("bv-proof") << "BitVectorProof::endBVConflict id"<<clause_id<< " => " << conflict << "\n";
+ d_isAssumptionConflict = false;
+}
+
+void BitVectorProof::finalizeConflicts(std::vector<Expr>& conflicts) {
+ if (options::bitblastMode() == theory::bv::BITBLAST_MODE_EAGER) {
+ Debug("bv-proof") << "Construct full proof." << std::endl;
+ d_resolutionProof->constructProof();
+ return;
+ }
+ for(unsigned i = 0; i < conflicts.size(); ++i) {
+ Expr confl = conflicts[i];
+ Debug("bv-proof") << "Finalize conflict " << confl << std::endl;
+ //Assert (d_bbConflictMap.find(confl) != d_bbConflictMap.end());
+ if(d_bbConflictMap.find(confl) != d_bbConflictMap.end()){
+ ClauseId id = d_bbConflictMap[confl];
+ d_resolutionProof->collectClauses(id);
+ }else{
+ Debug("bv-proof") << "Do not collect clauses for " << confl << std::endl;
+ }
+ }
+}
+
+void LFSCBitVectorProof::printTerm(Expr term, std::ostream& os, const LetMap& map) {
+ Assert (Theory::theoryOf(term) == THEORY_BV);
+
+ // peel off eager bit-blasting trick
+ if (term.getKind() == kind::BITVECTOR_EAGER_ATOM) {
+ d_proofEngine->printBoundTerm(term[0], os, map);
+ return;
+ }
+
+ switch (term.getKind()) {
+ case kind::CONST_BITVECTOR : {
+ printConstant(term, os);
+ return;
+ }
+ case kind::BITVECTOR_AND :
+ case kind::BITVECTOR_OR :
+ case kind::BITVECTOR_XOR :
+ case kind::BITVECTOR_NAND :
+ case kind::BITVECTOR_NOR :
+ case kind::BITVECTOR_XNOR :
+ case kind::BITVECTOR_COMP :
+ case kind::BITVECTOR_MULT :
+ case kind::BITVECTOR_PLUS :
+ case kind::BITVECTOR_SUB :
+ case kind::BITVECTOR_UDIV :
+ case kind::BITVECTOR_UREM :
+ case kind::BITVECTOR_UDIV_TOTAL :
+ case kind::BITVECTOR_UREM_TOTAL :
+ case kind::BITVECTOR_SDIV :
+ case kind::BITVECTOR_SREM :
+ case kind::BITVECTOR_SMOD :
+ case kind::BITVECTOR_SHL :
+ case kind::BITVECTOR_LSHR :
+ case kind::BITVECTOR_ASHR :
+ case kind::BITVECTOR_CONCAT : {
+ printOperatorNary(term, os, map);
+ return;
+ }
+ case kind::BITVECTOR_NEG :
+ case kind::BITVECTOR_NOT :
+ case kind::BITVECTOR_ROTATE_LEFT :
+ case kind::BITVECTOR_ROTATE_RIGHT : {
+ printOperatorUnary(term, os, map);
+ return;
+ }
+ case kind::EQUAL :
+ case kind::BITVECTOR_ULT :
+ case kind::BITVECTOR_ULE :
+ case kind::BITVECTOR_UGT :
+ case kind::BITVECTOR_UGE :
+ case kind::BITVECTOR_SLT :
+ case kind::BITVECTOR_SLE :
+ case kind::BITVECTOR_SGT :
+ case kind::BITVECTOR_SGE : {
+ printPredicate(term, os, map);
+ return;
+ }
+ case kind::BITVECTOR_EXTRACT :
+ case kind::BITVECTOR_REPEAT :
+ case kind::BITVECTOR_ZERO_EXTEND :
+ case kind::BITVECTOR_SIGN_EXTEND : {
+ printOperatorParametric(term, os, map);
+ return;
+ }
+ case kind::BITVECTOR_BITOF : {
+ printBitOf(term, os);
+ return;
+ }
+ case kind::VARIABLE:
+ case kind::SKOLEM: {
+ os << "(a_var_bv " << utils::getSize(term)<<" " << ProofManager::sanitize(term) <<")";
+ return;
+ }
+ default:
+ Unreachable();
+ }
+}
+
+void LFSCBitVectorProof::printBitOf(Expr term, std::ostream& os) {
+ Assert (term.getKind() == kind::BITVECTOR_BITOF);
+ unsigned bit = term.getOperator().getConst<BitVectorBitOf>().bitIndex;
+ Expr var = term[0];
+ Assert (var.getKind() == kind::VARIABLE ||
+ var.getKind() == kind::SKOLEM);
+ os << "(bitof " << ProofManager::sanitize(var) <<" " << bit <<")";
+}
+
+void LFSCBitVectorProof::printConstant(Expr term, std::ostream& os) {
+ Assert (term.isConst());
+ os <<"(a_bv " << utils::getSize(term)<<" ";
+ std::ostringstream paren;
+ int size = utils::getSize(term);
+ for (int i = size - 1; i >= 0; --i) {
+ os << "(bvc ";
+ os << (utils::getBit(term, i) ? "b1" : "b0") <<" ";
+ paren << ")";
+ }
+ os << " bvn)";
+ os << paren.str();
+}
+
+void LFSCBitVectorProof::printOperatorNary(Expr term, std::ostream& os, const LetMap& map) {
+ std::string op = utils::toLFSCKind(term.getKind());
+ std::ostringstream paren;
+ std::string holes = term.getKind() == kind::BITVECTOR_CONCAT ? "_ _ " : "";
+ unsigned size = term.getKind() == kind::BITVECTOR_CONCAT? utils::getSize(term) :
+ utils::getSize(term[0]); // cause of COMP
+
+ for (unsigned i = 0; i < term.getNumChildren() - 1; ++i) {
+ os <<"("<< op <<" " << size <<" " << holes;
+ }
+ d_proofEngine->printBoundTerm(term[0], os, map);
+ os <<" ";
+ for (unsigned i = 1; i < term.getNumChildren(); ++i) {
+ d_proofEngine->printBoundTerm(term[i], os, map);
+ os << ")";
+ }
+}
+
+void LFSCBitVectorProof::printOperatorUnary(Expr term, std::ostream& os, const LetMap& map) {
+ os <<"(";
+ os << utils::toLFSCKind(term.getKind()) << " " << utils::getSize(term) <<" ";
+ os << " ";
+ d_proofEngine->printBoundTerm(term[0], os, map);
+ os <<")";
+}
+
+void LFSCBitVectorProof::printPredicate(Expr term, std::ostream& os, const LetMap& map) {
+ os <<"(";
+ os << utils::toLFSCKind(term.getKind()) << " " << utils::getSize(term[0]) <<" ";
+ os << " ";
+ d_proofEngine->printBoundTerm(term[0], os, map);
+ os << " ";
+ d_proofEngine->printBoundTerm(term[1], os, map);
+ os <<")";
+}
+
+void LFSCBitVectorProof::printOperatorParametric(Expr term, std::ostream& os, const LetMap& map) {
+ os <<"(";
+ os << utils::toLFSCKind(term.getKind()) << " " << utils::getSize(term) <<" ";
+ os <<" ";
+ if (term.getKind() == kind::BITVECTOR_REPEAT) {
+ unsigned amount = term.getOperator().getConst<BitVectorRepeat>().repeatAmount;
+ os << amount <<" _ ";
+ }
+ if (term.getKind() == kind::BITVECTOR_SIGN_EXTEND) {
+ unsigned amount = term.getOperator().getConst<BitVectorSignExtend>().signExtendAmount;
+ os << amount <<" _ ";
+ }
+
+ if (term.getKind() == kind::BITVECTOR_ZERO_EXTEND) {
+ unsigned amount = term.getOperator().getConst<BitVectorZeroExtend>().zeroExtendAmount;
+ os << amount<<" _ ";
+ }
+ if (term.getKind() == kind::BITVECTOR_EXTRACT) {
+ unsigned low = utils::getExtractLow(term);
+ unsigned high = utils::getExtractHigh(term);
+ os << high <<" " << low << " " << utils::getSize(term[0]);
+ }
+ os <<" ";
+ Assert (term.getNumChildren() == 1);
+ d_proofEngine->printBoundTerm(term[0], os, map);
+ os <<")";
+}
+
+void LFSCBitVectorProof::printSort(Type type, std::ostream& os) {
+ Assert (type.isBitVector());
+ unsigned width = utils::getSize(type);
+ os << "(BitVec "<<width<<")";
+}
+
+void LFSCBitVectorProof::printTheoryLemmaProof(std::vector<Expr>& lemma, std::ostream& os, std::ostream& paren) {
+ Expr conflict = utils::mkSortedExpr(kind::OR, lemma);
+ if (d_bbConflictMap.find(conflict) != d_bbConflictMap.end()) {
+ std::ostringstream lemma_paren;
+ for (unsigned i = 0; i < lemma.size(); ++i) {
+ Expr lit = lemma[i];
+
+ if (lit.getKind() == kind::NOT) {
+ os << "(intro_assump_t _ _ _ ";
+ } else {
+ os << "(intro_assump_f _ _ _ ";
+ }
+ lemma_paren <<")";
+ // print corresponding literal in main sat solver
+ ProofManager* pm = ProofManager::currentPM();
+ CnfProof* cnf = pm->getCnfProof();
+ prop::SatLiteral main_lit = cnf->getLiteral(lit);
+ os << pm->getLitName(main_lit);
+ os <<" ";
+ // print corresponding literal in bv sat solver
+ prop::SatVariable bb_var = d_cnfProof->getLiteral(lit).getSatVariable();
+ os << pm->getAtomName(bb_var, "bb");
+ os <<"(\\unit"<<bb_var<<"\n";
+ lemma_paren <<")";
+ }
+ Expr lem = utils::mkOr(lemma);
+ Assert (d_bbConflictMap.find(lem) != d_bbConflictMap.end());
+ ClauseId lemma_id = d_bbConflictMap[lem];
+ d_resolutionProof->printAssumptionsResolution(lemma_id, os, lemma_paren);
+ os <<lemma_paren.str();
+ }else{
+ Debug("bv-proof") << std::endl << "; Print non-bitblast theory conflict " << conflict << std::endl;
+ BitVectorProof::printTheoryLemmaProof( lemma, os, paren );
+ }
+}
+void LFSCBitVectorProof::printDeclarations(std::ostream& os, std::ostream& paren) {
+ ExprSet::const_iterator it = d_declarations.begin();
+ ExprSet::const_iterator end = d_declarations.end();
+ for (; it != end; ++it) {
+ os << "(% " << ProofManager::sanitize(*it) <<" var_bv\n";
+ paren <<")";
+ }
+}
+
+
+void LFSCBitVectorProof::printTermBitblasting(Expr term, std::ostream& os) {
+ // TODO: once we have the operator elimination rules remove those that we
+ // eliminated
+ Assert (term.getType().isBitVector());
+ Kind kind = term.getKind();
+
+ if (Theory::isLeafOf(term, theory::THEORY_BV) &&
+ !term.isConst()) {
+ os << "(bv_bbl_var "<<utils::getSize(term) << " " << ProofManager::sanitize(term) <<" _ )";
+ return;
+ }
+
+ switch(kind) {
+ case kind::CONST_BITVECTOR : {
+ os << "(bv_bbl_const "<< utils::getSize(term) <<" _ ";
+ std::ostringstream paren;
+ int size = utils::getSize(term);
+ for (int i = size - 1; i>= 0; --i) {
+ os << "(bvc ";
+ os << (utils::getBit(term, i) ? "b1" : "b0") <<" ";
+ paren << ")";
+ }
+ os << " bvn)";
+ os << paren.str();
+ return;
+ }
+ case kind::BITVECTOR_AND :
+ case kind::BITVECTOR_OR :
+ case kind::BITVECTOR_XOR :
+ case kind::BITVECTOR_NAND :
+ case kind::BITVECTOR_NOR :
+ case kind::BITVECTOR_XNOR :
+ case kind::BITVECTOR_COMP :
+ case kind::BITVECTOR_MULT :
+ case kind::BITVECTOR_PLUS :
+ case kind::BITVECTOR_SUB :
+ case kind::BITVECTOR_CONCAT : {
+ for (unsigned i =0; i < term.getNumChildren() - 1; ++i) {
+ os <<"(bv_bbl_"<< utils::toLFSCKind(kind);
+ if (kind == kind::BITVECTOR_CONCAT) {
+ os << " " << utils::getSize(term) <<" _ ";
+ }
+ os <<" _ _ _ _ _ _ ";
+ }
+ os << getBBTermName(term[0]) <<" ";
+
+ for (unsigned i = 1; i < term.getNumChildren(); ++i) {
+ os << getBBTermName(term[i]);
+ os << ") ";
+ }
+ return;
+ }
+ case kind::BITVECTOR_NEG :
+ case kind::BITVECTOR_NOT :
+ case kind::BITVECTOR_ROTATE_LEFT :
+ case kind::BITVECTOR_ROTATE_RIGHT : {
+ os <<"(bv_bbl_"<<utils::toLFSCKind(kind);
+ os <<" _ _ _ _ ";
+ os << getBBTermName(term[0]);
+ os <<")";
+ return;
+ }
+ case kind::BITVECTOR_EXTRACT : {
+ os <<"(bv_bbl_"<<utils::toLFSCKind(kind) <<" ";
+ os << utils::getSize(term) << " ";
+ os << utils::getExtractHigh(term) << " ";
+ os << utils::getExtractLow(term) << " ";
+ os << " _ _ _ _ ";
+ os << getBBTermName(term[0]);
+ os <<")";
+ return;
+ }
+ case kind::BITVECTOR_REPEAT :
+ case kind::BITVECTOR_ZERO_EXTEND :
+ case kind::BITVECTOR_SIGN_EXTEND : {
+ os <<"(bv_bbl_"<<utils::toLFSCKind(kind) <<" ";
+ os << utils::getSize(term) <<" ";
+ if (term.getKind() == kind::BITVECTOR_REPEAT) {
+ unsigned amount = term.getOperator().getConst<BitVectorRepeat>().repeatAmount;
+ os << amount;
+ }
+ if (term.getKind() == kind::BITVECTOR_SIGN_EXTEND) {
+ unsigned amount = term.getOperator().getConst<BitVectorSignExtend>().signExtendAmount;
+ os << amount;
+ }
+
+ if (term.getKind() == kind::BITVECTOR_ZERO_EXTEND) {
+ unsigned amount = term.getOperator().getConst<BitVectorZeroExtend>().zeroExtendAmount;
+ os << amount;
+ }
+ os <<" _ _ _ _ ";
+ os << getBBTermName(term[0]);
+ os <<")";
+ return;
+ }
+ case kind::BITVECTOR_UDIV :
+ case kind::BITVECTOR_UREM :
+ case kind::BITVECTOR_UDIV_TOTAL :
+ case kind::BITVECTOR_UREM_TOTAL :
+ case kind::BITVECTOR_SDIV :
+ case kind::BITVECTOR_SREM :
+ case kind::BITVECTOR_SMOD :
+ case kind::BITVECTOR_SHL :
+ case kind::BITVECTOR_LSHR :
+ case kind::BITVECTOR_ASHR : {
+ // these are terms for which bit-blasting is not supported yet
+ std::ostringstream paren;
+ os <<"(trust_bblast_term _ ";
+ paren <<")";
+ d_proofEngine->printLetTerm(term, os);
+ os <<" ";
+ std::vector<Node> bits;
+ d_bitblaster->bbTerm(term, bits);
+
+ for (int i = utils::getSize(term) - 1; i >= 0; --i) {
+ os << "(bbltc ";
+ d_proofEngine->printLetTerm((bits[i]).toExpr(), os);
+ paren << ")";
+ }
+ os << "bbltn" << paren.str();
+ return;
+ }
+
+ default:
+ Unreachable("LFSCBitVectorProof Unknown operator");
+ }
+}
+
+void LFSCBitVectorProof::printAtomBitblasting(Expr atom, std::ostream& os) {
+ Kind kind = atom.getKind();
+ switch(kind) {
+ case kind::BITVECTOR_ULT :
+ case kind::BITVECTOR_ULE :
+ case kind::BITVECTOR_UGT :
+ case kind::BITVECTOR_UGE :
+ case kind::BITVECTOR_SLT :
+ case kind::BITVECTOR_SLE :
+ case kind::BITVECTOR_SGT :
+ case kind::BITVECTOR_SGE :
+ case kind::EQUAL:
+ {
+ os <<"(bv_bbl_" << utils::toLFSCKind(atom.getKind());
+ os << " _ _ _ _ _ _ ";
+ os << getBBTermName(atom[0])<<" " << getBBTermName(atom[1]) <<")";
+ return;
+ }
+ default:
+ Unreachable("LFSCBitVectorProof Unknown atom kind");
+ }
+}
+
+
+void LFSCBitVectorProof::printBitblasting(std::ostream& os, std::ostream& paren) {
+ // bit-blast terms
+ std::vector<Expr>::const_iterator it = d_bbTerms.begin();
+ std::vector<Expr>::const_iterator end = d_bbTerms.end();
+ for (; it != end; ++it) {
+ if (d_usedBB.find(*it) == d_usedBB.end() &&
+ options::bitblastMode() != theory::bv::BITBLAST_MODE_EAGER)
+ continue;
+ os <<"(decl_bblast _ _ _ ";
+ printTermBitblasting(*it, os);
+ os << "(\\ "<< getBBTermName(*it);
+ paren <<"\n))";
+ }
+ // bit-blast atoms
+ ExprToExpr::const_iterator ait = d_bbAtoms.begin();
+ ExprToExpr::const_iterator aend = d_bbAtoms.end();
+ for (; ait != aend; ++ait) {
+ if (d_usedBB.find(ait->first) == d_usedBB.end() &&
+ options::bitblastMode() != theory::bv::BITBLAST_MODE_EAGER)
+ continue;
+
+ os << "(th_let_pf _ ";
+ if (ait->first.getKind() == kind::CONST_BOOLEAN) {
+ bool val = ait->first.getConst<bool>();
+ os << "(iff_symm " << (val ? "true" : "false" ) << ")";
+ } else {
+ printAtomBitblasting(ait->first, os);
+ }
+
+ os <<"(\\ " << ProofManager::getPreprocessedAssertionName(ait->second) <<"\n";
+ paren <<"))";
+ }
+}
+
+void LFSCBitVectorProof::printResolutionProof(std::ostream& os,
+ std::ostream& paren) {
+ // collect the input clauses used
+ IdToSatClause used_lemmas;
+ IdToSatClause used_inputs;
+ d_resolutionProof->collectClausesUsed(used_inputs,
+ used_lemmas);
+ Assert (used_lemmas.empty());
+
+ // print mapping between theory atoms and internal SAT variables
+ os << ";; BB atom mapping\n";
+
+ NodeSet atoms;
+ d_cnfProof->collectAtomsForClauses(used_inputs,atoms);
+
+ // first print bit-blasting
+ printBitblasting(os, paren);
+
+ // print CNF conversion proof for bit-blasted facts
+ d_cnfProof->printAtomMapping(atoms, os, paren);
+ os << ";; Bit-blasting definitional clauses \n";
+ for (IdToSatClause::iterator it = used_inputs.begin();
+ it != used_inputs.end(); ++it) {
+ d_cnfProof->printCnfProofForClause(it->first, it->second, os, paren);
+ }
+
+ os << ";; Bit-blasting learned clauses \n";
+ d_resolutionProof->printResolutions(os, paren);
+}
+
+} /* namespace CVC4 */
--- /dev/null
+/********************* */
+/*! \file bitvector_proof.h
+ ** \verbatim
+ ** Original author: Liana Hadarean
+ ** Major contributors: none
+ ** Minor contributors (to current version): none
+ ** This file is part of the CVC4 project.
+ ** Copyright (c) 2009-2014 New York University and The University of Iowa
+ ** See the file COPYING in the top-level source directory for licensing
+ ** information.\endverbatim
+ **
+ ** \brief Bitvector proof
+ **
+ ** Bitvector proof
+ **/
+
+#include "cvc4_private.h"
+
+#ifndef __CVC4__BITVECTOR__PROOF_H
+#define __CVC4__BITVECTOR__PROOF_H
+
+//#include <cstdint>
+#include <ext/hash_map>
+#include <ext/hash_set>
+#include <iostream>
+#include <set>
+#include <sstream>
+#include <vector>
+
+#include "expr/expr.h"
+#include "proof/theory_proof.h"
+#include "prop/bvminisat/core/Solver.h"
+
+
+namespace CVC4 {
+
+namespace prop {
+class CnfStream;
+} /* namespace CVC4::prop */
+
+namespace theory {
+namespace bv {
+class TheoryBV;
+template <class T> class TBitblaster;
+} /* namespace CVC4::theory::bv */
+} /* namespace CVC4::theory */
+
+class CnfProof;
+} /* namespace CVC4 */
+
+namespace CVC4 {
+
+template <class Solver> class TSatProof;
+typedef TSatProof< CVC4::BVMinisat::Solver> BVSatProof;
+
+template <class Solver> class LFSCSatProof;
+typedef LFSCSatProof< CVC4::BVMinisat::Solver> LFSCBVSatProof;
+
+typedef __gnu_cxx::hash_set<Expr, ExprHashFunction> ExprSet;
+typedef __gnu_cxx::hash_map<Expr, ClauseId, ExprHashFunction> ExprToClauseId;
+typedef __gnu_cxx::hash_map<Expr, unsigned, ExprHashFunction> ExprToId;
+typedef __gnu_cxx::hash_map<Expr, Expr, ExprHashFunction> ExprToExpr;
+
+class BitVectorProof : public TheoryProof {
+protected:
+ ExprSet d_declarations;
+
+ ExprSet d_usedBB; // terms and formulas that are actually relevant to the proof
+
+ ExprSet d_seenBBTerms; // terms that need to be bit-blasted
+ std::vector<Expr> d_bbTerms; // order of bit-blasting
+ ExprToExpr d_bbAtoms; // atoms that need to be bit-blasted
+
+ // map from Expr representing normalized lemma to ClauseId in SAT solver
+ ExprToClauseId d_bbConflictMap;
+ BVSatProof* d_resolutionProof;
+
+ CnfProof* d_cnfProof;
+
+ bool d_isAssumptionConflict;
+ theory::bv::TBitblaster<Node>* d_bitblaster;
+ std::string getBBTermName(Expr expr);
+public:
+ BitVectorProof(theory::bv::TheoryBV* bv, TheoryProofEngine* proofEngine);
+
+ void initSatProof(CVC4::BVMinisat::Solver* solver);
+ void initCnfProof(prop::CnfStream* cnfStream, context::Context* ctx);
+ void setBitblaster(theory::bv::TBitblaster<Node>* bb);
+
+ BVSatProof* getSatProof();
+ CnfProof* getCnfProof() {return d_cnfProof; }
+ void finalizeConflicts(std::vector<Expr>& conflicts);
+
+ void startBVConflict(CVC4::BVMinisat::Solver::TCRef cr);
+ void startBVConflict(CVC4::BVMinisat::Solver::TLit lit);
+ /**
+ * All the
+ *
+ * @param confl an inconsistent set of bv literals
+ */
+ void endBVConflict(const BVMinisat::Solver::TLitVec& confl);
+ void markAssumptionConflict() { d_isAssumptionConflict = true; }
+ bool isAssumptionConflict() { return d_isAssumptionConflict; }
+
+ void registerTermBB(Expr term);
+ void registerAtomBB(Expr atom, Expr atom_bb);
+
+ virtual void registerTerm(Expr term);
+
+ virtual void printTermBitblasting(Expr term, std::ostream& os) = 0;
+ virtual void printAtomBitblasting(Expr term, std::ostream& os) = 0;
+
+ virtual void printBitblasting(std::ostream& os, std::ostream& paren) = 0;
+ virtual void printResolutionProof(std::ostream& os, std::ostream& paren) = 0;
+
+};
+
+class LFSCBitVectorProof: public BitVectorProof {
+
+ void printConstant(Expr term, std::ostream& os);
+ void printOperatorNary(Expr term, std::ostream& os, const LetMap& map);
+ void printOperatorUnary(Expr term, std::ostream& os, const LetMap& map);
+ void printPredicate(Expr term, std::ostream& os, const LetMap& map);
+ void printOperatorParametric(Expr term, std::ostream& os, const LetMap& map);
+ void printBitOf(Expr term, std::ostream& os);
+public:
+ LFSCBitVectorProof(theory::bv::TheoryBV* bv, TheoryProofEngine* proofEngine)
+ :BitVectorProof(bv, proofEngine)
+ {}
+ virtual void printTerm(Expr term, std::ostream& os, const LetMap& map);
+ virtual void printSort(Type type, std::ostream& os);
+ virtual void printTermBitblasting(Expr term, std::ostream& os);
+ virtual void printAtomBitblasting(Expr term, std::ostream& os);
+ virtual void printTheoryLemmaProof(std::vector<Expr>& lemma, std::ostream& os, std::ostream& paren);
+ virtual void printDeclarations(std::ostream& os, std::ostream& paren);
+ virtual void printBitblasting(std::ostream& os, std::ostream& paren);
+ virtual void printResolutionProof(std::ostream& os, std::ostream& paren);
+};
+
+}/* CVC4 namespace */
+
+#endif /* __CVC4__BITVECTOR__PROOF_H */
namespace CVC4 {
-CnfProof::CnfProof(CnfStream* stream)
+CnfProof::CnfProof(CnfStream* stream,
+ context::Context* ctx,
+ const std::string& name)
: d_cnfStream(stream)
-{}
+ , d_clauseToAssertion(ctx)
+ , d_assertionToProofRule(ctx)
+ , d_currentAssertionStack()
+ , d_currentDefinitionStack()
+ , d_clauseToDefinition(ctx)
+ , d_definitions()
+ , d_cnfDeps()
+ , d_name(name)
+{
+ // Setting the proof object for the CnfStream
+ d_cnfStream->setProof(this);
+}
+
+CnfProof::~CnfProof() {}
-CnfProof::~CnfProof() {
+bool CnfProof::isAssertion(Node node) {
+ return d_assertionToProofRule.find(node) !=
+ d_assertionToProofRule.end();
}
-Expr CnfProof::getAtom(prop::SatVariable var) {
- prop::SatLiteral lit (var);
- Node node = d_cnfStream->getNode(lit);
- Expr atom = node.toExpr();
- return atom;
+bool CnfProof::isDefinition(Node node) {
+ return d_definitions.find(node) !=
+ d_definitions.end();
+}
+
+ProofRule CnfProof::getProofRule(Node node) {
+ Assert (isAssertion(node));
+ NodeToProofRule::iterator it = d_assertionToProofRule.find(node);
+ return (*it).second;
+}
+ProofRule CnfProof::getProofRule(ClauseId clause) {
+ TNode assertion = getAssertionForClause(clause);
+ return getProofRule(assertion);
}
-prop::SatLiteral CnfProof::getLiteral(TNode atom) {
- return d_cnfStream->getLiteral(atom);
+Node CnfProof::getAssertionForClause(ClauseId clause) {
+ ClauseIdToNode::const_iterator it = d_clauseToAssertion.find(clause);
+ Assert (it != d_clauseToAssertion.end());
+ return (*it).second;
}
-Expr CnfProof::getAssertion(uint64_t id) {
- return d_cnfStream->getAssertion(id).toExpr();
+Node CnfProof::getDefinitionForClause(ClauseId clause) {
+ ClauseIdToNode::const_iterator it = d_clauseToDefinition.find(clause);
+ Assert (it != d_clauseToDefinition.end());
+ return (*it).second;
}
-void LFSCCnfProof::printAtomMapping(const prop::SatClause* clause, std::ostream& os, std::ostream& paren) {
- for (unsigned i = 0; i < clause->size(); ++i) {
- prop::SatLiteral lit = clause->operator[](i);
- if(d_atomsDeclared.find(lit.getSatVariable()) == d_atomsDeclared.end()) {
- d_atomsDeclared.insert(lit.getSatVariable());
- os << "(decl_atom ";
- if (ProofManager::currentPM()->getLogic().compare("QF_UF") == 0 ||
- ProofManager::currentPM()->getLogic().compare("QF_AX") == 0 ||
- ProofManager::currentPM()->getLogic().compare("QF_SAT") == 0) {
- Expr atom = getAtom(lit.getSatVariable());
- LFSCTheoryProof::printTerm(atom, os);
- } else {
- // print fake atoms for all other logics (for now)
- os << "true ";
- }
+void CnfProof::registerConvertedClause(ClauseId clause, bool explanation) {
+ Assert (clause != ClauseIdUndef &&
+ clause != ClauseIdError &&
+ clause != ClauseIdEmpty);
+
+ // Explanations do not need a CNF conversion proof since they are in CNF
+ // (they will only need a theory proof as they are theory valid)
+ if (explanation) {
+ Debug("proof:cnf") << "CnfProof::registerConvertedClause "
+ << clause << " explanation? " << explanation << std::endl;
+ Assert (d_explanations.find(clause) == d_explanations.end());
+ d_explanations.insert(clause);
+ return;
+ }
- os << " (\\ " << ProofManager::getVarName(lit.getSatVariable()) << " (\\ " << ProofManager::getAtomName(lit.getSatVariable()) << "\n";
- paren << ")))";
- }
+ Node current_assertion = getCurrentAssertion();
+ Node current_expr = getCurrentDefinition();
+
+ Debug("proof:cnf") << "CnfProof::registerConvertedClause "
+ << clause << " assertion = " << current_assertion
+ << clause << " definition = " << current_expr << std::endl;
+
+ setClauseAssertion(clause, current_assertion);
+ setClauseDefinition(clause, current_expr);
+}
+
+void CnfProof::setClauseAssertion(ClauseId clause, Node expr) {
+ Debug("proof:cnf") << "CnfProof::setClauseAssertion "
+ << clause << " assertion " << expr << std::endl;
+ // We can add the same clause from different assertions. In this
+ // case we keep the first assertion. For example asserting a /\ b
+ // and then b /\ c where b is an atom, would assert b twice (note
+ // that since b is top level, it is not cached by the CnfStream)
+ if (d_clauseToAssertion.find(clause) != d_clauseToAssertion.end())
+ return;
+
+ d_clauseToAssertion.insert (clause, expr);
+}
+
+void CnfProof::setClauseDefinition(ClauseId clause, Node definition) {
+ Debug("proof:cnf") << "CnfProof::setClauseDefinition "
+ << clause << " definition " << definition << std::endl;
+ // We keep the first definition
+ if (d_clauseToDefinition.find(clause) != d_clauseToDefinition.end())
+ return;
+
+ d_clauseToDefinition.insert(clause, definition);
+ d_definitions.insert(definition);
+}
+
+void CnfProof::registerAssertion(Node assertion, ProofRule reason) {
+ Debug("proof:cnf") << "CnfProof::registerAssertion "
+ << assertion << " reason " << reason << std::endl;
+ // We can obtain the assertion from different reasons (e.g. if the
+ // assertion is a lemma over shared terms both theories can generate
+ // the same lemma) We only need to prove the lemma in one way, so we
+ // keep the first reason.
+ if (isAssertion(assertion)) {
+ return;
}
+ d_assertionToProofRule.insert(assertion, reason);
}
-void LFSCCnfProof::printClauses(std::ostream& os, std::ostream& paren) {
- printPreprocess(os, paren);
- printInputClauses(os, paren);
- printTheoryLemmas(os, paren);
+void CnfProof::setCnfDependence(Node from, Node to) {
+ Debug("proof:cnf") << "CnfProof::setCnfDependence "
+ << "from " << from << std::endl
+ << " to " << to << std::endl;
+
+ Assert (from != to);
+ d_cnfDeps.insert(std::make_pair(from, to));
}
-void LFSCCnfProof::printPreprocess(std::ostream& os, std::ostream& paren) {
- os << " ;; Preprocessing \n";
- __gnu_cxx::hash_map< Node, std::vector<Node>, NodeHashFunction >::const_iterator it = ProofManager::currentPM()->begin_deps();
- __gnu_cxx::hash_map< Node, std::vector<Node>, NodeHashFunction >::const_iterator end = ProofManager::currentPM()->end_deps();
+void CnfProof::pushCurrentAssertion(Node assertion) {
+ Debug("proof:cnf") << "CnfProof::pushCurrentAssertion "
+ << assertion << std::endl;
- for (; it != end; ++it) {
- if( !it->second.empty() ){
- Expr e = it->first.toExpr();
- os << "(th_let_pf _ ";
+ d_currentAssertionStack.push_back(assertion);
+}
- //TODO
- Trace("cnf-pf-debug") << "; preprocess assertion : " << e << std::endl;
- os << "(trust_f ";
- LFSCTheoryProof::printTerm(e, os);
- os << ") ";
+void CnfProof::popCurrentAssertion() {
+ Assert (d_currentAssertionStack.size());
+
+ Debug("proof:cnf") << "CnfProof::popCurrentAssertion "
+ << d_currentAssertionStack.back() << std::endl;
+
+ d_currentAssertionStack.pop_back();
+}
- os << "(\\ A" << ProofManager::currentPM()->getAssertionCounter() << std::endl;
- ProofManager::currentPM()->setAssertion( e );
- paren << "))";
+Node CnfProof::getCurrentAssertion() {
+ Assert (d_currentAssertionStack.size());
+ return d_currentAssertionStack.back();
+}
+
+void CnfProof::pushCurrentDefinition(Node definition) {
+ Debug("proof:cnf") << "CnfProof::pushCurrentDefinition "
+ << definition << std::endl;
+
+ d_currentDefinitionStack.push_back(definition);
+}
+
+void CnfProof::popCurrentDefinition() {
+ Assert (d_currentDefinitionStack.size());
+
+ Debug("proof:cnf") << "CnfProof::popCurrentDefinition "
+ << d_currentDefinitionStack.back() << std::endl;
+
+ d_currentDefinitionStack.pop_back();
+}
+
+Node CnfProof::getCurrentDefinition() {
+ Assert (d_currentDefinitionStack.size());
+ return d_currentDefinitionStack.back();
+}
+
+
+Node CnfProof::getAtom(prop::SatVariable var) {
+ prop::SatLiteral lit (var);
+ Node node = d_cnfStream->getNode(lit);
+ return node;
+}
+
+
+void CnfProof::collectAtoms(const prop::SatClause* clause,
+ NodeSet& atoms) {
+ for (unsigned i = 0; i < clause->size(); ++i) {
+ SatLiteral lit = clause->operator[](i);
+ SatVariable var = lit.getSatVariable();
+ TNode atom = getAtom(var);
+ if (atoms.find(atom) == atoms.end()) {
+ Assert (atoms.find(atom) == atoms.end());
+ atoms.insert(atom);
+ }
+ }
+}
+
+prop::SatLiteral CnfProof::getLiteral(TNode atom) {
+ return d_cnfStream->getLiteral(atom);
+}
+
+void CnfProof::collectAtomsForClauses(const IdToSatClause& clauses,
+ NodeSet& atom_map) {
+ IdToSatClause::const_iterator it = clauses.begin();
+ for (; it != clauses.end(); ++it) {
+ const prop::SatClause* clause = it->second;
+ collectAtoms(clause, atom_map);
+ }
+
+}
+
+void CnfProof::collectAssertionsForClauses(const IdToSatClause& clauses,
+ NodeSet& assertions) {
+ IdToSatClause::const_iterator it = clauses.begin();
+ for (; it != clauses.end(); ++it) {
+ TNode used_assertion = getAssertionForClause(it->first);
+ assertions.insert(used_assertion);
+ // it can be the case that a definition for a clause is an assertion
+ // but it is not the assertion for the clause
+ // e.g. the assertions [(and a b), a]
+ TNode used_definition = getDefinitionForClause(it->first);
+ if (isAssertion(used_definition)) {
+ assertions.insert(used_definition);
}
}
}
-Expr LFSCCnfProof::clauseToExpr( const prop::SatClause& clause,
- std::map< Expr, unsigned >& childIndex,
- std::map< Expr, bool >& childPol ) {
+void LFSCCnfProof::printAtomMapping(const NodeSet& atoms,
+ std::ostream& os,
+ std::ostream& paren) {
+ NodeSet::const_iterator it = atoms.begin();
+ NodeSet::const_iterator end = atoms.end();
+
+ for (;it != end; ++it) {
+ os << "(decl_atom ";
+ Node atom = *it;
+ prop::SatVariable var = getLiteral(atom).getSatVariable();
+ //FIXME hideous
+ LFSCTheoryProofEngine* pe = (LFSCTheoryProofEngine*)ProofManager::currentPM()->getTheoryProofEngine();
+ pe->printLetTerm(atom.toExpr(), os);
+
+ os << " (\\ " << ProofManager::getVarName(var, d_name)
+ << " (\\ " << ProofManager::getAtomName(var, d_name) << "\n";
+ paren << ")))";
+ }
+}
+
+// maps each expr to the position it had in the clause and the polarity it had
+Node LFSCCnfProof::clauseToNode(const prop::SatClause& clause,
+ std::map<Node, unsigned>& childIndex,
+ std::map<Node, bool>& childPol ) {
std::vector< Node > children;
for (unsigned i = 0; i < clause.size(); ++i) {
prop::SatLiteral lit = clause[i];
prop::SatVariable var = lit.getSatVariable();
- Node atom = Node::fromExpr( getAtom(var) );
+ Node atom = getAtom(var);
children.push_back( lit.isNegated() ? atom.negate() : atom );
- childIndex[atom.toExpr()] = i;
- childPol[atom.toExpr()] = !lit.isNegated();
+ childIndex[atom] = i;
+ childPol[atom] = !lit.isNegated();
}
- return children.size()==1 ? children[0].toExpr() : NodeManager::currentNM()->mkNode( kind::OR, children ).toExpr();
+ return children.size()==1 ? children[0] :
+ NodeManager::currentNM()->mkNode(kind::OR, children );
}
-void LFSCCnfProof::printInputClauses(std::ostream& os, std::ostream& paren) {
- os << " ;; Clauses\n";
- ProofManager::clause_iterator it = ProofManager::currentPM()->begin_input_clauses();
- ProofManager::clause_iterator end = ProofManager::currentPM()->end_input_clauses();
-
-
- for (; it != end; ++it) {
- ClauseId id = it->first;
- const prop::SatClause* clause = it->second;
- printAtomMapping(clause, os, paren);
- os << "(satlem _ _ ";
- std::ostringstream clause_paren;
- printClause(*clause, os, clause_paren);
- os << "(clausify_false ";
-
- Assert( clause->size()>0 );
-
- Expr base_assertion = ProofManager::currentPM()->getFormulaForClauseId( id );
- ProofRule pr = ProofManager::currentPM()->getProofRuleForClauseId( id );
- Trace("cnf-pf") << std::endl;
- Trace("cnf-pf") << "; formula for clause id " << id << " : " << base_assertion << std::endl;
-
- //get the assertion for the clause id
- std::map< Expr, unsigned > childIndex;
- std::map< Expr, bool > childPol;
- Expr assertion = clauseToExpr( *clause, childIndex, childPol );
- //if there is no reason, construct assertion directly. This can happen for unit clauses.
- if( base_assertion.isNull() ){
- base_assertion = assertion;
- }
- //os_base is proof of base_assertion
- std::stringstream os_base;
- bool is_input = ProofManager::currentPM()->isInputAssertion( base_assertion, os_base );
-
- //get base assertion with polarity
- bool base_pol = base_assertion.getKind()!=kind::NOT;
- base_assertion = base_assertion.getKind()==kind::NOT ? base_assertion[0] : base_assertion;
-
- std::map< Expr, unsigned >::iterator itci = childIndex.find( base_assertion );
- bool is_in_clause = itci!=childIndex.end();
- unsigned base_index = is_in_clause ? itci->second : 0;
- Trace("cnf-pf") << "; input = " << is_input << ", is_in_clause = " << is_in_clause << ", id = " << id << ", assertion = " << assertion << ", base assertion = " << base_assertion << std::endl;
- if( !is_input ){
- Assert( is_in_clause );
- prop::SatLiteral blit = (*clause)[ base_index ];
- os_base << ProofManager::getLitName(blit);
- base_pol = !childPol[base_assertion];
+void LFSCCnfProof::printCnfProofForClause(ClauseId id,
+ const prop::SatClause* clause,
+ std::ostream& os,
+ std::ostream& paren) {
+ os << "(satlem _ _ ";
+ std::ostringstream clause_paren;
+ printClause(*clause, os, clause_paren);
+ os << "(clausify_false ";
+
+ // FIXMEEEEEEEEEEEE
+ // os <<"trust)";
+ // os << clause_paren.str()
+ // << " (\\ " << ProofManager::getInputClauseName(id, d_name) << "\n";
+ // paren << "))";
+
+ // return;
+
+ Assert( clause->size()>0 );
+
+ Node base_assertion = getDefinitionForClause(id);
+
+ //get the assertion for the clause id
+ std::map<Node, unsigned > childIndex;
+ std::map<Node, bool > childPol;
+ Node assertion = clauseToNode( *clause, childIndex, childPol );
+ //if there is no reason, construct assertion directly. This can happen for unit clauses.
+ if( base_assertion.isNull() ){
+ base_assertion = assertion;
+ }
+ //os_base is proof of base_assertion
+ std::stringstream os_base;
+
+ // checks if tautological definitional clause or top-level clause
+ // and prints the proof of the top-level formula
+ bool is_input = printProofTopLevel(base_assertion, os_base);
+
+ //get base assertion with polarity
+ bool base_pol = base_assertion.getKind()!=kind::NOT;
+ base_assertion = base_assertion.getKind()==kind::NOT ? base_assertion[0] : base_assertion;
+
+ std::map< Node, unsigned >::iterator itci = childIndex.find( base_assertion );
+ bool is_in_clause = itci!=childIndex.end();
+ unsigned base_index = is_in_clause ? itci->second : 0;
+ Trace("cnf-pf") << std::endl;
+ Trace("cnf-pf") << "; input = " << is_input << ", is_in_clause = " << is_in_clause << ", id = " << id << ", assertion = " << assertion << ", base assertion = " << base_assertion << std::endl;
+ if (!is_input){
+ Assert(is_in_clause);
+ prop::SatLiteral blit = (*clause)[ base_index ];
+ os_base << ProofManager::getLitName(blit, d_name);
+ base_pol = !childPol[base_assertion]; // WHY? if the case is =>
+ }
+ Trace("cnf-pf") << "; polarity of base assertion = " << base_pol << std::endl;
+ Trace("cnf-pf") << "; proof of base : " << os_base.str() << std::endl;
+
+ bool success = false;
+ if( is_input &&
+ is_in_clause &&
+ childPol[base_assertion]==base_pol ){
+ //if both in input and in clause, the proof is trivial. this is the case for unit clauses.
+ Trace("cnf-pf") << "; trivial" << std::endl;
+ os << "(contra _ ";
+ success = true;
+ prop::SatLiteral lit = (*clause)[itci->second];
+ if( base_pol ){
+ os << os_base.str() << " " << ProofManager::getLitName(lit, d_name);
+ }else{
+ os << ProofManager::getLitName(lit, d_name) << " " << os_base.str();
}
- Trace("cnf-pf") << "; polarity of base assertion = " << base_pol << std::endl;
- Trace("cnf-pf") << "; proof of base : " << os_base.str() << std::endl;
-
- bool success = false;
- if( is_input && is_in_clause && childPol[base_assertion]==base_pol ){
- //if both in input and in clause, the proof is trivial. this is the case for unit clauses.
- Trace("cnf-pf") << "; trivial" << std::endl;
- os << "(contra _ ";
- success = true;
- prop::SatLiteral lit = (*clause)[itci->second];
- if( base_pol ){
- os << os_base.str() << " " << ProofManager::getLitName(lit);
- }else{
- os << ProofManager::getLitName(lit) << " " << os_base.str();
+ os << ")";
+ } else if ((base_assertion.getKind()==kind::AND && !base_pol) ||
+ ((base_assertion.getKind()==kind::OR ||
+ base_assertion.getKind()==kind::IMPLIES) && base_pol)) {
+ Trace("cnf-pf") << "; and/or case 1" << std::endl;
+ success = true;
+ std::stringstream os_main;
+ std::stringstream os_paren;
+ //eliminate each one
+ for (int j = base_assertion.getNumChildren()-2; j >= 0; j--) {
+ Node child_base = base_assertion[j].getKind()==kind::NOT ?
+ base_assertion[j][0] : base_assertion[j];
+ bool child_pol = base_assertion[j].getKind()!=kind::NOT;
+
+ if( j==0 && base_assertion.getKind()==kind::IMPLIES ){
+ child_pol = !child_pol;
}
- os << ")";
- }else if( ( base_assertion.getKind()==kind::AND && !base_pol ) || ( ( base_assertion.getKind()==kind::OR || base_assertion.getKind()==kind::IMPLIES ) && base_pol ) ){
- Trace("cnf-pf") << "; and/or case 1" << std::endl;
- success = true;
- std::stringstream os_main;
- std::stringstream os_paren;
- //eliminate each one
- for( int j=base_assertion.getNumChildren()-2; j>=0; j-- ){
- Expr child_base = base_assertion[j].getKind()==kind::NOT ? base_assertion[j][0] : base_assertion[j];
- bool child_pol = base_assertion[j].getKind()!=kind::NOT;
- if( j==0 && base_assertion.getKind()==kind::IMPLIES ){
- child_pol = !child_pol;
+
+ Trace("cnf-pf-debug") << "; child " << j << " "
+ << child_base << " "
+ << child_pol << " "
+ << childPol[child_base] << std::endl;
+
+ std::map< Node, unsigned >::iterator itcic = childIndex.find( child_base );
+
+ if( itcic!=childIndex.end() ){
+ //Assert( child_pol==childPol[child_base] );
+ os_main << "(or_elim_1 _ _ ";
+ prop::SatLiteral lit = (*clause)[itcic->second];
+ // Should be if in the original formula it was negated
+ if( childPol[child_base] && base_pol ){
+ os_main << ProofManager::getLitName(lit, d_name) << " ";
+ }else{
+ os_main << "(not_not_intro _ " << ProofManager::getLitName(lit, d_name) << ") ";
}
- Trace("cnf-pf-debug") << "; child " << j << " " << child_base << " " << child_pol << " " << childPol[child_base] << std::endl;
- std::map< Expr, unsigned >::iterator itcic = childIndex.find( child_base );
- if( itcic!=childIndex.end() ){
- //Assert( child_pol==childPol[child_base] );
- os_main << "(or_elim_1 _ _ ";
- prop::SatLiteral lit = (*clause)[itcic->second];
- if( childPol[child_base] && base_pol ){
- os_main << ProofManager::getLitName(lit) << " ";
- }else{
- os_main << "(not_not_intro _ " << ProofManager::getLitName(lit) << ") ";
- }
- if( base_assertion.getKind()==kind::AND ){
- os_main << "(not_and_elim _ _ ";
- os_paren << ")";
- }
+ if( base_assertion.getKind()==kind::AND ){
+ os_main << "(not_and_elim _ _ ";
os_paren << ")";
- }else{
- success = false;
}
+ os_paren << ")";
+ }else{
+ success = false;
}
- if( success ){
- if( base_assertion.getKind()==kind::IMPLIES ){
- os_main << "(impl_elim _ _ ";
- }
- os_main << os_base.str();
- if( base_assertion.getKind()==kind::IMPLIES ){
- os_main << ")";
- }
- os_main << os_paren.str();
- int last_index = base_assertion.getNumChildren()-1;
- Expr child_base = base_assertion[last_index].getKind()==kind::NOT ? base_assertion[last_index][0] : base_assertion[last_index];
- //bool child_pol = base_assertion[last_index].getKind()!=kind::NOT;
- std::map< Expr, unsigned >::iterator itcic = childIndex.find( child_base );
- if( itcic!=childIndex.end() ){
- os << "(contra _ ";
- prop::SatLiteral lit = (*clause)[itcic->second];
- if( childPol[child_base] && base_pol ){
- os << os_main.str() << " " << ProofManager::getLitName(lit);
- }else{
- os << ProofManager::getLitName(lit) << " " << os_main.str();
- }
- os << ")";
- }else{
- success = false;
- }
+ }
+ if( success ){
+ if( base_assertion.getKind()==kind::IMPLIES ){
+ os_main << "(impl_elim _ _ ";
}
- }else if( ( base_assertion.getKind()==kind::AND && base_pol ) || ( ( base_assertion.getKind()==kind::OR || base_assertion.getKind()==kind::IMPLIES ) && !base_pol ) ){
- std::stringstream os_main;
- Expr iatom;
- if( is_in_clause ){
- Assert( assertion.getNumChildren()==2 );
- iatom = assertion[ base_index==0 ? 1 : 0];
- }else{
- Assert( assertion.getNumChildren()==1 );
- iatom = assertion[0];
+ os_main << os_base.str();
+ if( base_assertion.getKind()==kind::IMPLIES ){
+ os_main << ")";
}
- Trace("cnf-pf") << "; and/or case 2, iatom = " << iatom << std::endl;
- Expr e_base = iatom.getKind()==kind::NOT ? iatom[0] : iatom;
- bool e_pol = iatom.getKind()!=kind::NOT;
- std::map< Expr, unsigned >::iterator itcic = childIndex.find( e_base );
+ os_main << os_paren.str();
+ int last_index = base_assertion.getNumChildren()-1;
+ Node child_base = base_assertion[last_index].getKind()==kind::NOT ? base_assertion[last_index][0] : base_assertion[last_index];
+ //bool child_pol = base_assertion[last_index].getKind()!=kind::NOT;
+ std::map< Node, unsigned >::iterator itcic = childIndex.find( child_base );
if( itcic!=childIndex.end() ){
+ os << "(contra _ ";
prop::SatLiteral lit = (*clause)[itcic->second];
- //eliminate until we find iatom
- for( unsigned j=0; j<base_assertion.getNumChildren(); j++ ){
- Expr child_base = base_assertion[j].getKind()==kind::NOT ? base_assertion[j][0] : base_assertion[j];
- bool child_pol = base_assertion[j].getKind()!=kind::NOT;
- if( j==0 && base_assertion.getKind()==kind::IMPLIES ){
- child_pol = !child_pol;
+ if( childPol[child_base] && base_pol){
+ os << os_main.str() << " " << ProofManager::getLitName(lit, d_name);
+ }else{
+ os << ProofManager::getLitName(lit, d_name) << " " << os_main.str();
+ }
+ os << ")";
+ }else{
+ success = false;
+ }
+ }
+ }else if ((base_assertion.getKind()==kind::AND && base_pol) ||
+ ((base_assertion.getKind()==kind::OR ||
+ base_assertion.getKind()==kind::IMPLIES) && !base_pol)) {
+
+ std::stringstream os_main;
+
+ Node iatom;
+ if (is_in_clause) {
+ Assert( assertion.getNumChildren()==2 );
+ iatom = assertion[ base_index==0 ? 1 : 0];
+ } else {
+ Assert( assertion.getNumChildren()==1 );
+ iatom = assertion[0];
+ }
+
+ Trace("cnf-pf") << "; and/or case 2, iatom = " << iatom << std::endl;
+ Node e_base = iatom.getKind()==kind::NOT ? iatom[0] : iatom;
+ bool e_pol = iatom.getKind()!=kind::NOT;
+ std::map< Node, unsigned >::iterator itcic = childIndex.find( e_base );
+ if( itcic!=childIndex.end() ){
+ prop::SatLiteral lit = (*clause)[itcic->second];
+ //eliminate until we find iatom
+ for( unsigned j=0; j<base_assertion.getNumChildren(); j++ ){
+ Node child_base = base_assertion[j].getKind()==kind::NOT ? base_assertion[j][0] : base_assertion[j];
+ bool child_pol = base_assertion[j].getKind()!=kind::NOT;
+ if( j==0 && base_assertion.getKind()==kind::IMPLIES ){
+ child_pol = !child_pol;
+ }
+ if( e_base==child_base && (e_pol==child_pol)==(base_assertion.getKind()==kind::AND) ){
+ success = true;
+ bool elimNn =( ( base_assertion.getKind()==kind::OR || ( base_assertion.getKind()==kind::IMPLIES && j==1 ) ) && e_pol );
+ if( elimNn ){
+ os_main << "(not_not_elim _ ";
}
- if( e_base==child_base && (e_pol==child_pol)==(base_assertion.getKind()==kind::AND) ){
- success = true;
- bool elimNn =( ( base_assertion.getKind()==kind::OR || ( base_assertion.getKind()==kind::IMPLIES && j==1 ) ) && e_pol );
- if( elimNn ){
- os_main << "(not_not_elim _ ";
- }
- std::stringstream os_paren;
- if( j+1<base_assertion.getNumChildren() ){
- os_main << "(and_elim_1 _ _ ";
- if( base_assertion.getKind()==kind::OR || base_assertion.getKind()==kind::IMPLIES ){
- os_main << "(not_" << ( base_assertion.getKind()==kind::OR ? "or" : "impl" ) << "_elim _ _ ";
- os_paren << ")";
- }
+ std::stringstream os_paren;
+ if( j+1<base_assertion.getNumChildren() ){
+ os_main << "(and_elim_1 _ _ ";
+ if( base_assertion.getKind()==kind::OR || base_assertion.getKind()==kind::IMPLIES ){
+ os_main << "(not_" << ( base_assertion.getKind()==kind::OR ? "or" : "impl" ) << "_elim _ _ ";
os_paren << ")";
}
- for( unsigned k=0; k<j; k++ ){
- os_main << "(and_elim_2 _ _ ";
- if( base_assertion.getKind()==kind::OR || base_assertion.getKind()==kind::IMPLIES ){
- os_main << "(not_" << ( base_assertion.getKind()==kind::OR ? "or" : "impl" ) << "_elim _ _ ";
- os_paren << ")";
- }
+ os_paren << ")";
+ }
+ for( unsigned k=0; k<j; k++ ){
+ os_main << "(and_elim_2 _ _ ";
+ if( base_assertion.getKind()==kind::OR || base_assertion.getKind()==kind::IMPLIES ){
+ os_main << "(not_" << ( base_assertion.getKind()==kind::OR ? "or" : "impl" ) << "_elim _ _ ";
os_paren << ")";
}
- os_main << os_base.str() << os_paren.str();
- if( elimNn ){
- os_main << ")";
- }
- break;
+ os_paren << ")";
}
- }
- if( success ){
- os << "(contra _ ";
- if( !e_pol ){
- os << ProofManager::getLitName(lit) << " " << os_main.str();
- }else{
- os << os_main.str() << " " << ProofManager::getLitName(lit);
+ os_main << os_base.str() << os_paren.str();
+ if( elimNn ){
+ os_main << ")";
}
- os << ")";
- }
- }
- }else if( base_assertion.getKind()==kind::XOR || base_assertion.getKind()==kind::IFF ){
- //eliminate negation
- int num_nots_2 = 0;
- int num_nots_1 = 0;
- Kind k;
- if( !base_pol ){
- if( base_assertion.getKind()==kind::IFF ){
- num_nots_2 = 1;
- }
- k = kind::IFF;
- }else{
- k = base_assertion.getKind();
- }
- std::vector< unsigned > indices;
- std::vector< bool > pols;
- success = true;
- int elimNum = 0;
- for( unsigned i=0; i<2; i++ ){
- Expr child_base = base_assertion[i].getKind()==kind::NOT ? base_assertion[i][0] : base_assertion[i];
- bool child_pol = base_assertion[i].getKind()!=kind::NOT;
- std::map< Expr, unsigned >::iterator itcic = childIndex.find( child_base );
- if( itcic!=childIndex.end() ){
- indices.push_back( itcic->second );
- pols.push_back( childPol[child_base] );
- if( i==0 ){
- //figure out which way to elim
- elimNum = child_pol==childPol[child_base] ? 2 : 1;
- if( (elimNum==2)==(k==kind::IFF) ){
- num_nots_2++;
- }
- if( elimNum==1 ){
- num_nots_1++;
- }
- }
- }else{
- success = false;
break;
}
}
- Trace("cnf-pf") << std::endl << "; num nots = " << num_nots_2 << std::endl;
if( success ){
os << "(contra _ ";
- std::stringstream os_base_n;
- if( num_nots_2==2 ){
- os_base_n << "(not_not_elim _ ";
- }
- os_base_n << "(or_elim_1 _ _ ";
- prop::SatLiteral lit1 = (*clause)[indices[0]];
- if( !pols[0] || num_nots_1==1 ){
- os_base_n << "(not_not_intro _ " << ProofManager::getLitName(lit1) << ") ";
- }else{
- os_base_n << ProofManager::getLitName(lit1) << " ";
- }
- Assert( elimNum!=0 );
- os_base_n << "(" << ( k==kind::IFF ? "iff" : "xor" ) << "_elim_" << elimNum << " _ _ ";
- if( !base_pol ){
- os_base_n << "(not_" << ( base_assertion.getKind()==kind::IFF ? "iff" : "xor" ) << "_elim _ _ " << os_base.str() << ")";
- }else{
- os_base_n << os_base.str();
- }
- os_base_n << "))";
- if( num_nots_2==2 ){
- os_base_n << ")";
- num_nots_2 = 0;
- }
- prop::SatLiteral lit2 = (*clause)[indices[1]];
- if( pols[1]==(num_nots_2==0) ){
- os << os_base_n.str() << " ";
- if( num_nots_2==1 ){
- os << "(not_not_intro _ " << ProofManager::getLitName(lit2) << ")";
- }else{
- os << ProofManager::getLitName(lit2);
- }
+ if( !e_pol ){
+ os << ProofManager::getLitName(lit, d_name) << " " << os_main.str();
}else{
- os << ProofManager::getLitName(lit2) << " " << os_base_n.str();
+ os << os_main.str() << " " << ProofManager::getLitName(lit, d_name);
}
os << ")";
}
- }else if( base_assertion.getKind()==kind::ITE ){
- std::map< unsigned, unsigned > appears;
- std::map< unsigned, Expr > appears_expr;
- unsigned appears_count = 0;
- for( unsigned r=0; r<3; r++ ){
- Expr child_base = base_assertion[r].getKind()==kind::NOT ? base_assertion[r][0] : base_assertion[r];
- std::map< Expr, unsigned >::iterator itcic = childIndex.find( child_base );
- if( itcic!=childIndex.end() ){
- appears[r] = itcic->second;
- appears_expr[r] = child_base;
- appears_count++;
- }
+ }
+ }else if( base_assertion.getKind()==kind::XOR || base_assertion.getKind()==kind::IFF ){
+ //eliminate negation
+ int num_nots_2 = 0;
+ int num_nots_1 = 0;
+ Kind k;
+ if( !base_pol ){
+ if( base_assertion.getKind()==kind::IFF ){
+ num_nots_2 = 1;
}
- if( appears_count==2 ){
- success = true;
- int elimNum = 1;
- unsigned index1 = 0;
- unsigned index2 = 1;
- if( appears.find( 0 )==appears.end() ){
- elimNum = 3;
- index1 = 1;
- index2 = 2;
- }else if( appears.find( 1 )==appears.end() ){
- elimNum = 2;
- index1 = 0;
- index2 = 2;
- }
- std::stringstream os_main;
- os_main << "(or_elim_1 _ _ ";
- prop::SatLiteral lit1 = (*clause)[appears[index1]];
- if( !childPol[appears_expr[index1]] || elimNum==1 || ( elimNum==3 && !base_pol ) ){
- os_main << "(not_not_intro _ " << ProofManager::getLitName(lit1) << ") ";
- }else{
- os_main << ProofManager::getLitName(lit1) << " ";
- }
- os_main << "(" << ( base_pol ? "" : "not_" ) << "ite_elim_" << elimNum << " _ _ _ ";
- os_main << os_base.str() << "))";
- os << "(contra _ ";
- prop::SatLiteral lit2 = (*clause)[appears[index2]];
- if( !childPol[appears_expr[index2]] || !base_pol ){
- os << ProofManager::getLitName(lit2) << " " << os_main.str();
- }else{
- os << os_main.str() << " " << ProofManager::getLitName(lit2);
+ k = kind::IFF;
+ }else{
+ k = base_assertion.getKind();
+ }
+ std::vector< unsigned > indices;
+ std::vector< bool > pols;
+ success = true;
+ int elimNum = 0;
+ for( unsigned i=0; i<2; i++ ){
+ Node child_base = base_assertion[i].getKind()==kind::NOT ? base_assertion[i][0] : base_assertion[i];
+ bool child_pol = base_assertion[i].getKind()!=kind::NOT;
+ std::map< Node, unsigned >::iterator itcic = childIndex.find( child_base );
+ if( itcic!=childIndex.end() ){
+ indices.push_back( itcic->second );
+ pols.push_back( childPol[child_base] );
+ if( i==0 ){
+ //figure out which way to elim
+ elimNum = child_pol==childPol[child_base] ? 2 : 1;
+ if( (elimNum==2)==(k==kind::IFF) ){
+ num_nots_2++;
+ }
+ if( elimNum==1 ){
+ num_nots_1++;
+ }
}
- os << ")";
+ }else{
+ success = false;
+ break;
+ }
+ }
+ Trace("cnf-pf") << std::endl << "; num nots = " << num_nots_2 << std::endl;
+ if( success ){
+ os << "(contra _ ";
+ std::stringstream os_base_n;
+ if( num_nots_2==2 ){
+ os_base_n << "(not_not_elim _ ";
+ }
+ os_base_n << "(or_elim_1 _ _ ";
+ prop::SatLiteral lit1 = (*clause)[indices[0]];
+ if( !pols[0] || num_nots_1==1 ){
+ os_base_n << "(not_not_intro _ " << ProofManager::getLitName(lit1, d_name) << ") ";
+ }else{
+ os_base_n << ProofManager::getLitName(lit1, d_name) << " ";
}
- }else if( base_assertion.isConst() ){
- bool pol = base_assertion==NodeManager::currentNM()->mkConst( true ).toExpr();
- if( pol!=base_pol ){
- success = true;
- if( pol ){
- os << "(contra _ truth " << os_base.str() << ")";
+ Assert( elimNum!=0 );
+ os_base_n << "(" << ( k==kind::IFF ? "iff" : "xor" ) << "_elim_" << elimNum << " _ _ ";
+ if( !base_pol ){
+ os_base_n << "(not_" << ( base_assertion.getKind()==kind::IFF ? "iff" : "xor" ) << "_elim _ _ " << os_base.str() << ")";
+ }else{
+ os_base_n << os_base.str();
+ }
+ os_base_n << "))";
+ if( num_nots_2==2 ){
+ os_base_n << ")";
+ num_nots_2 = 0;
+ }
+ prop::SatLiteral lit2 = (*clause)[indices[1]];
+ if( pols[1]==(num_nots_2==0) ){
+ os << os_base_n.str() << " ";
+ if( num_nots_2==1 ){
+ os << "(not_not_intro _ " << ProofManager::getLitName(lit2, d_name) << ")";
}else{
- os << os_base.str();
+ os << ProofManager::getLitName(lit2, d_name);
}
+ }else{
+ os << ProofManager::getLitName(lit2, d_name) << " " << os_base_n.str();
}
+ os << ")";
}
-
- if( !success ){
- Trace("cnf-pf") << std::endl;
- Trace("cnf-pf") << ";!!!!!!!!! CnfProof : Can't process " << assertion << ", base = " << base_assertion << ", id = " << id << ", proof rule = " << pr << std::endl;
- Trace("cnf-pf") << ";!!!!!!!!! Clause is : ";
- for (unsigned i = 0; i < clause->size(); ++i) {
- Trace("cnf-pf") << (*clause)[i] << " ";
+ }else if( base_assertion.getKind()==kind::ITE ){
+ std::map< unsigned, unsigned > appears;
+ std::map< unsigned, Node > appears_expr;
+ unsigned appears_count = 0;
+ for( unsigned r=0; r<3; r++ ){
+ Node child_base = base_assertion[r].getKind()==kind::NOT ? base_assertion[r][0] : base_assertion[r];
+ std::map< Node, unsigned >::iterator itcic = childIndex.find( child_base );
+ if( itcic!=childIndex.end() ){
+ appears[r] = itcic->second;
+ appears_expr[r] = child_base;
+ appears_count++;
}
- Trace("cnf-pf") << std::endl;
- os << "trust-bad";
- }
-
- os << ")" << clause_paren.str()
- << " (\\ " << ProofManager::getInputClauseName(id) << "\n";
- paren << "))";
- }
-}
-
-void LFSCCnfProof::printTheoryLemmas(std::ostream& os, std::ostream& paren) {
- os << " ;; Theory Lemmas\n";
- ProofManager::ordered_clause_iterator it = ProofManager::currentPM()->begin_lemmas();
- ProofManager::ordered_clause_iterator end = ProofManager::currentPM()->end_lemmas();
-
- for(size_t n = 0; it != end; ++it, ++n) {
- if(n % 100 == 0) {
- Chat() << "proving theory conflicts...(" << n << "/" << ProofManager::currentPM()->num_lemmas() << ")" << std::endl;
}
-
- ClauseId id = it->first;
- const prop::SatClause* clause = it->second;
- NodeBuilder<> c(kind::AND);
- for(unsigned i = 0; i < clause->size(); ++i) {
- prop::SatLiteral lit = (*clause)[i];
- prop::SatVariable var = lit.getSatVariable();
- if(lit.isNegated()) {
- c << Node::fromExpr(getAtom(var));
- } else {
- c << Node::fromExpr(getAtom(var)).notNode();
+ if( appears_count==2 ){
+ success = true;
+ int elimNum = 1;
+ unsigned index1 = 0;
+ unsigned index2 = 1;
+ if( appears.find( 0 )==appears.end() ){
+ elimNum = 3;
+ index1 = 1;
+ index2 = 2;
+ }else if( appears.find( 1 )==appears.end() ){
+ elimNum = 2;
+ index1 = 0;
+ index2 = 2;
}
- }
- Node cl = c;
- if(ProofManager::getSatProof()->d_lemmaClauses.find(id) != ProofManager::getSatProof()->d_lemmaClauses.end()) {
- uint64_t proof_id = ProofManager::getSatProof()->d_lemmaClauses[id];
- TNode orig = d_cnfStream->getAssertion(proof_id & 0xffffffff);
- if(((proof_id >> 32) & 0xffffffff) == RULE_ARRAYS_EXT) {
- Debug("cores") << "; extensional lemma!" << std::endl;
- Assert(cl.getKind() == kind::AND && cl.getNumChildren() == 2 && cl[0].getKind() == kind::EQUAL && cl[0][0].getKind() == kind::SELECT);
- TNode myk = cl[0][0][1];
- Debug("cores") << "; so my skolemized k is " << myk << std::endl;
- os << "(ext _ _ " << orig[0][0] << " " << orig[0][1] << " (\\ " << myk << " (\\ " << ProofManager::getLemmaName(id) << "\n";
- paren << ")))";
+ std::stringstream os_main;
+ os_main << "(or_elim_1 _ _ ";
+ prop::SatLiteral lit1 = (*clause)[appears[index1]];
+ if( !childPol[appears_expr[index1]] || elimNum==1 || ( elimNum==3 && !base_pol ) ){
+ os_main << "(not_not_intro _ " << ProofManager::getLitName(lit1, d_name) << ") ";
+ }else{
+ os_main << ProofManager::getLitName(lit1, d_name) << " ";
+ }
+ os_main << "(" << ( base_pol ? "" : "not_" ) << "ite_elim_" << elimNum << " _ _ _ ";
+ os_main << os_base.str() << "))";
+ os << "(contra _ ";
+ prop::SatLiteral lit2 = (*clause)[appears[index2]];
+ if( !childPol[appears_expr[index2]] || !base_pol ){
+ os << ProofManager::getLitName(lit2, d_name) << " " << os_main.str();
+ }else{
+ os << os_main.str() << " " << ProofManager::getLitName(lit2, d_name);
}
+ os << ")";
}
- printAtomMapping(clause, os, paren);
- os << "(satlem _ _ ";
- std::ostringstream clause_paren;
- printClause(*clause, os, clause_paren);
-
- Debug("cores") << "\n;id is " << id << std::endl;
- if(ProofManager::getSatProof()->d_lemmaClauses.find(id) != ProofManager::getSatProof()->d_lemmaClauses.end()) {
- uint64_t proof_id = ProofManager::getSatProof()->d_lemmaClauses[id];
- Debug("cores") << ";getting id " << int32_t(proof_id & 0xffffffff) << std::endl;
- Assert(int32_t(proof_id & 0xffffffff) != -1);
- TNode orig = d_cnfStream->getAssertion(proof_id & 0xffffffff);
- Debug("cores") << "; ID is " << id << " and that's a lemma with " << ((proof_id >> 32) & 0xffffffff) << " / " << (proof_id & 0xffffffff) << std::endl;
- Debug("cores") << "; that means the lemma was " << orig << std::endl;
- if(((proof_id >> 32) & 0xffffffff) == RULE_ARRAYS_EXT) {
- Debug("cores") << "; extensional" << std::endl;
- os << "(clausify_false trust)\n";
- } else if(proof_id == 0) {
- // theory propagation caused conflict
- //ProofManager::currentPM()->printProof(os, cl);
- os << "(clausify_false trust)\n";
- } else if(((proof_id >> 32) & 0xffffffff) == RULE_CONFLICT) {
- os << "\n;; need to generate a (conflict) proof of " << cl << "\n";
- //ProofManager::currentPM()->printProof(os, cl);
- os << "(clausify_false trust)\n";
- } else {
- os << "\n;; need to generate a (lemma) proof of " << cl;
- os << "\n;; DON'T KNOW HOW !!\n";
- os << "(clausify_false trust)\n";
+ }else if( base_assertion.isConst() ){
+ bool pol = base_assertion==NodeManager::currentNM()->mkConst( true );
+ if( pol!=base_pol ){
+ success = true;
+ if( pol ){
+ os << "(contra _ truth " << os_base.str() << ")";
+ }else{
+ os << os_base.str();
}
- } else {
- os << "\n;; need to generate a (conflict) proof of " << cl << "\n";
- ProofManager::currentPM()->printProof(os, cl);
}
- os << clause_paren.str()
- << " (\\ " << ProofManager::getLemmaClauseName(id) << "\n";
- paren << "))";
}
+
+ if( !success ){
+ Trace("cnf-pf") << std::endl;
+ Trace("cnf-pf") << ";!!!!!!!!! CnfProof : Can't process " << assertion << ", base = " << base_assertion << ", id = " << id << std::endl;
+ Trace("cnf-pf") << ";!!!!!!!!! Clause is : ";
+ for (unsigned i = 0; i < clause->size(); ++i) {
+ Trace("cnf-pf") << (*clause)[i] << " ";
+ }
+ Trace("cnf-pf") << std::endl;
+ os << "trust-bad";
+ }
+
+ os << ")" << clause_paren.str()
+ << " (\\ " << ProofManager::getInputClauseName(id, d_name) << "\n";
+ paren << "))";
}
-void LFSCCnfProof::printClause(const prop::SatClause& clause, std::ostream& os, std::ostream& paren) {
+void LFSCCnfProof::printClause(const prop::SatClause& clause,
+ std::ostream& os,
+ std::ostream& paren) {
for (unsigned i = 0; i < clause.size(); ++i) {
prop::SatLiteral lit = clause[i];
prop::SatVariable var = lit.getSatVariable();
if (lit.isNegated()) {
- os << "(ast _ _ _ " << ProofManager::getAtomName(var) << " (\\ " << ProofManager::getLitName(lit) << " ";
+ os << "(ast _ _ _ " << ProofManager::getAtomName(var, d_name) <<" (\\ " << ProofManager::getLitName(lit, d_name) << " ";
paren << "))";
} else {
- os << "(asf _ _ _ " << ProofManager::getAtomName(var) << " (\\ " << ProofManager::getLitName(lit) << " ";
+ os << "(asf _ _ _ " << ProofManager::getAtomName(var, d_name) <<" (\\ " << ProofManager::getLitName(lit, d_name) << " ";
paren << "))";
}
}
}
+// print a proof of the top-level formula e, based on the input assertions
+bool LFSCCnfProof::printProofTopLevel(Node e, std::ostream& out) {
+ if (!isAssertion(e)) {
+ // check if deduced by CNF
+ // dependence on top level fact i.e. a depends on (a and b)
+ NodeToNode::const_iterator itd = d_cnfDeps.find(e);
+ if (itd != d_cnfDeps.end()) {
+ TNode parent = itd->second;
+ //check if parent is an input assertion
+ std::stringstream out_parent;
+ if (printProofTopLevel(parent, out_parent)) {
+ if(parent.getKind()==kind::AND ||
+ (parent.getKind()==kind::NOT && (parent[0].getKind()==kind::IMPLIES ||
+ parent[0].getKind()==kind::OR))) {
+ Node parent_base = parent.getKind()==kind::NOT ? parent[0] : parent;
+ Node e_base = e.getKind()==kind::NOT ? e[0] : e;
+ bool e_pol = e.getKind()!=kind::NOT;
+ for( unsigned i=0; i<parent_base.getNumChildren(); i++ ){
+ Node child_base = parent_base[i].getKind()==kind::NOT ? parent_base[i][0] : parent_base[i];
+ bool child_pol = parent_base[i].getKind()!=kind::NOT;
+ if( parent_base.getKind()==kind::IMPLIES && i==0 ){
+ child_pol = !child_pol;
+ }
+ if (e_base==child_base &&
+ (e_pol==child_pol)==(parent_base.getKind()==kind::AND)) {
+ bool elimNn = ((parent_base.getKind()==kind::OR ||
+ (parent_base.getKind()==kind::IMPLIES && i==1)) && e_pol);
+ if (elimNn) {
+ out << "(not_not_elim _ ";
+ }
+ std::stringstream out_paren;
+ if (i+1 < parent_base.getNumChildren()) {
+ out << "(and_elim_1 _ _ ";
+ if( parent_base.getKind()==kind::OR ||
+ parent_base.getKind()==kind::IMPLIES ){
+ out << "(not_" << ( parent_base.getKind()==kind::OR ? "or" : "impl" )
+ << "_elim _ _ ";
+ out_paren << ")";
+ }
+ out_paren << ")";
+ }
+ for( unsigned j=0; j<i; j++ ){
+ out << "(and_elim_2 _ _ ";
+ if( parent_base.getKind()==kind::OR || parent_base.getKind()==kind::IMPLIES ){
+ out << "(not_" << ( parent_base.getKind()==kind::OR ? "or" : "impl" ) << "_elim _ _ ";
+ out_paren << ")";
+ }
+ out_paren << ")";
+ }
+ out << out_parent.str();
+ out << out_paren.str();
+ if( elimNn ){
+ out << ")";
+ }
+ return true;
+ }
+ }
+ } else {
+ Trace("cnf-pf-debug") << "; isInputAssertion : parent of " << e
+ << " is not correct type (" << parent << ")" << std::endl;
+ }
+ } else {
+ Trace("cnf-pf-debug") << "; isInputAssertion : parent of " << e
+ << " is not input" << std::endl;
+ }
+ } else {
+ Trace("cnf-pf-debug") << "; isInputAssertion : " << e
+ << " has no parent" << std::endl;
+ }
+ return false;
+ } else {
+ out << ProofManager::getPreprocessedAssertionName(e);
+ return true;
+ }
+}
+
+
+
} /* CVC4 namespace */
#ifndef __CVC4__CNF_PROOF_H
#define __CVC4__CNF_PROOF_H
-#include <ext/hash_map>
+#include <ext/hash_map>
#include <ext/hash_set>
#include <iosfwd>
+#include "context/cdhashmap.h"
#include "proof/sat_proof.h"
+#include "proof/sat_proof.h"
+#include "util/proof.h"
#include "util/proof.h"
namespace CVC4 {
class CnfProof;
+typedef __gnu_cxx::hash_map<prop::SatVariable, Expr> SatVarToExpr;
+typedef __gnu_cxx::hash_map<Node, Node, NodeHashFunction> NodeToNode;
+typedef __gnu_cxx::hash_set<ClauseId> ClauseIdSet;
+
+typedef context::CDHashMap<ClauseId, Node> ClauseIdToNode;
+typedef context::CDHashMap<Node, ProofRule, NodeHashFunction> NodeToProofRule;
+
class CnfProof {
protected:
CVC4::prop::CnfStream* d_cnfStream;
- VarSet d_atomsDeclared;
+
+ /** Map from ClauseId to the assertion that lead to adding this clause **/
+ ClauseIdToNode d_clauseToAssertion;
+
+ /** Map from assertion to reason for adding assertion **/
+ NodeToProofRule d_assertionToProofRule;
+
+ /** Top of stack is assertion currently being converted to CNF **/
+ std::vector<Node> d_currentAssertionStack;
+
+ /** Top of stack is top-level fact currently being converted to CNF **/
+ std::vector<Node> d_currentDefinitionStack;
+
+
+ /** Map from ClauseId to the top-level fact that lead to adding this clause **/
+ ClauseIdToNode d_clauseToDefinition;
+
+ /** Top-level facts that follow from assertions during convertAndAssert **/
+ NodeSet d_definitions;
+
+ /** Map from top-level fact to facts/assertion that it follows from **/
+ NodeToNode d_cnfDeps;
+
+ ClauseIdSet d_explanations;
+
+ bool isDefinition(Node node);
+
+ Node getDefinitionForClause(ClauseId clause);
+
+ std::string d_name;
public:
- CnfProof(CVC4::prop::CnfStream* cnfStream);
+ CnfProof(CVC4::prop::CnfStream* cnfStream,
+ context::Context* ctx,
+ const std::string& name);
+
+
+ Node getAtom(prop::SatVariable var);
+ prop::SatLiteral getLiteral(TNode node);
+ void collectAtoms(const prop::SatClause* clause,
+ NodeSet& atoms);
+ void collectAtomsForClauses(const IdToSatClause& clauses,
+ NodeSet& atoms);
+ void collectAssertionsForClauses(const IdToSatClause& clauses,
+ NodeSet& assertions);
+
+ /** Methods for logging what the CnfStream does **/
+ // map the clause back to the current assertion where it came from
+ // if it is an explanation, it does not have a CNF proof since it is
+ // already in CNF
+ void registerConvertedClause(ClauseId clause, bool explanation=false);
+
+ /** Clause is one of the clauses defining the node expression*/
+ void setClauseDefinition(ClauseId clause, Node node);
+
+ /** Clause is one of the clauses defining top-level assertion node*/
+ void setClauseAssertion(ClauseId clause, Node node);
+
+ void registerAssertion(Node assertion, ProofRule reason);
+ void setCnfDependence(Node from, Node to);
+
+ void pushCurrentAssertion(Node assertion); // the current assertion being converted
+ void popCurrentAssertion();
+ Node getCurrentAssertion();
+
+ void pushCurrentDefinition(Node assertion); // the current Tseitin definition being converted
+ void popCurrentDefinition();
+ Node getCurrentDefinition();
+
+
+ // accessors for the leaf assertions that are being converted to CNF
+ bool isAssertion(Node node);
+ ProofRule getProofRule(Node assertion);
+ ProofRule getProofRule(ClauseId clause);
+ Node getAssertionForClause(ClauseId clause);
- Expr getAtom(prop::SatVariable var);
- Expr getAssertion(uint64_t id);
- prop::SatLiteral getLiteral(TNode atom);
+
+ /** Virtual methods for printing things **/
+ virtual void printAtomMapping(const NodeSet& atoms,
+ std::ostream& os,
+ std::ostream& paren) = 0;
- virtual void printClauses(std::ostream& os, std::ostream& paren) = 0;
+ virtual void printClause(const prop::SatClause& clause,
+ std::ostream& os,
+ std::ostream& paren) = 0;
+ virtual void printCnfProofForClause(ClauseId id,
+ const prop::SatClause* clause,
+ std::ostream& os,
+ std::ostream& paren) = 0;
virtual ~CnfProof();
};/* class CnfProof */
class LFSCCnfProof : public CnfProof {
- void printPreprocess(std::ostream& os, std::ostream& paren);
- void printInputClauses(std::ostream& os, std::ostream& paren);
- void printTheoryLemmas(std::ostream& os, std::ostream& paren);
- void printClause(const prop::SatClause& clause, std::ostream& os, std::ostream& paren);
- virtual void printAtomMapping(const prop::SatClause* clause, std::ostream& os, std::ostream& paren);
-
- Expr clauseToExpr( const prop::SatClause& clause,
- std::map< Expr, unsigned >& childIndex,
- std::map< Expr, bool >& childPol );
-
+ Node clauseToNode( const prop::SatClause& clause,
+ std::map<Node, unsigned>& childIndex,
+ std::map<Node, bool>& childPol );
+ bool printProofTopLevel(Node e, std::ostream& out);
public:
- LFSCCnfProof(CVC4::prop::CnfStream* cnfStream)
- : CnfProof(cnfStream)
+ LFSCCnfProof(CVC4::prop::CnfStream* cnfStream,
+ context::Context* ctx,
+ const std::string& name)
+ : CnfProof(cnfStream, ctx, name)
{}
+ ~LFSCCnfProof() {}
- virtual void printClauses(std::ostream& os, std::ostream& paren);
+ void printAtomMapping(const NodeSet& atoms,
+ std::ostream& os,
+ std::ostream& paren);
+
+ void printClause(const prop::SatClause& clause,
+ std::ostream& os,
+ std::ostream& paren);
+ void printCnfProofForClause(ClauseId id,
+ const prop::SatClause* clause,
+ std::ostream& os,
+ std::ostream& paren);
};/* class LFSCCnfProof */
} /* CVC4 namespace */
** See the file COPYING in the top-level source directory for licensing
** information.\endverbatim
**
- ** \brief Proof manager
+ ** \brief Proof macros
**
- ** Proof manager
+ ** Proof macros
**/
#include "cvc4_private.h"
*/
#ifdef CVC4_PROOF
-# define PROOF(x) if(options::proof() || options::unsatCores()) { x; }
-# define NULLPROOF(x) (options::proof() || options::unsatCores()) ? x : NULL
-# define PROOF_ON() (options::proof() || options::unsatCores())
+# define PROOF(x) if(CVC4::options::proof() || CVC4::options::unsatCores()) { x; }
+# define NULLPROOF(x) (CVC4::options::proof() || CVC4::options::unsatCores()) ? x : NULL
+# define PROOF_ON() (CVC4::options::proof() || CVC4::options::unsatCores())
+# define THEORY_PROOF(x) if(CVC4::options::proof()) { x; }
+# define THEORY_NULLPROOF(x) CVC4::options::proof() ? x : NULL
+# define THEORY_PROOF_ON() CVC4::options::proof()
#else /* CVC4_PROOF */
# define PROOF(x)
# define NULLPROOF(x) NULL
# define PROOF_ON() false
+# define THEORY_PROOF(x)
+# define THEORY_NULLPROOF(x) NULL
+# define THEORY_PROOF_ON() false
#endif /* CVC4_PROOF */
+#ifdef CVC4_PROOF_STATS /* CVC4_PROOF_STATS */
+# define PSTATS(x) { x; }
+#else
+# define PSTATS(x)
+#endif /* CVC4_PROOF_STATS */
#endif /* __CVC4__PROOF__PROOF_H */
** \todo document this file
**/
-#include "proof/proof_manager.h"
-
-#include "base/cvc4_assert.h"
#include "context/context.h"
+
+#include "proof/proof_manager.h"
#include "proof/cnf_proof.h"
-#include "proof/sat_proof.h"
#include "proof/theory_proof.h"
+#include "proof/bitvector_proof.h"
+#include "proof/proof_utils.h"
+#include "proof/sat_proof_implementation.h"
+#include "options/bv_options.h"
+
+#include "util/proof.h"
+#include "util/hash.h"
+
+#include "base/cvc4_assert.h"
#include "smt/smt_engine.h"
#include "smt/smt_engine_scope.h"
#include "smt_util/node_visitor.h"
#include "theory/uf/equality_engine.h"
#include "theory/uf/theory_uf.h"
#include "theory/valuation.h"
-#include "util/hash.h"
-#include "util/proof.h"
+
namespace CVC4 {
d_satProof(NULL),
d_cnfProof(NULL),
d_theoryProof(NULL),
- d_inputClauses(),
- d_theoryLemmas(),
- d_theoryPropagations(),
d_inputFormulas(),
d_inputCoreFormulas(),
d_outputCoreFormulas(),
d_nextId(0),
d_fullProof(NULL),
d_format(format),
- d_deps(),
- d_assertion_counter(1)
+ d_deps()
{
}
delete d_cnfProof;
delete d_theoryProof;
delete d_fullProof;
-
- for(IdToClause::iterator it = d_inputClauses.begin();
- it != d_inputClauses.end();
- ++it) {
- delete it->second;
- }
-
- for(OrderedIdToClause::iterator it = d_theoryLemmas.begin();
- it != d_theoryLemmas.end();
- ++it) {
- delete it->second;
- }
-
- // FIXME: memory leak because there are deleted theory lemmas that
- // were not used in the SatProof
}
ProofManager* ProofManager::currentPM() {
Assert (currentPM()->d_format == LFSC);
currentPM()->d_fullProof = new LFSCProof(smt,
- (LFSCSatProof*)getSatProof(),
+ (LFSCCoreSatProof*)getSatProof(),
(LFSCCnfProof*)getCnfProof(),
- (LFSCTheoryProof*)getTheoryProof());
+ (LFSCTheoryProofEngine*)getTheoryProofEngine());
return currentPM()->d_fullProof;
}
-SatProof* ProofManager::getSatProof() {
+CoreSatProof* ProofManager::getSatProof() {
Assert (currentPM()->d_satProof);
return currentPM()->d_satProof;
}
return currentPM()->d_cnfProof;
}
-TheoryProof* ProofManager::getTheoryProof() {
- //Assert (currentPM()->d_theoryProof);
+TheoryProofEngine* ProofManager::getTheoryProofEngine() {
+ Assert (options::proof());
+ Assert (currentPM()->d_theoryProof != NULL);
return currentPM()->d_theoryProof;
}
+UFProof* ProofManager::getUfProof() {
+ Assert (options::proof());
+ TheoryProof* pf = getTheoryProofEngine()->getTheoryProof(theory::THEORY_UF);
+ return (UFProof*)pf;
+}
+BitVectorProof* ProofManager::getBitVectorProof() {
+ Assert (options::proof());
+ TheoryProof* pf = getTheoryProofEngine()->getTheoryProof(theory::THEORY_BV);
+ return (BitVectorProof*)pf;
+}
+
+ArrayProof* ProofManager::getArrayProof() {
+ Assert (options::proof());
+ TheoryProof* pf = getTheoryProofEngine()->getTheoryProof(theory::THEORY_ARRAY);
+ return (ArrayProof*)pf;
+}
+
void ProofManager::initSatProof(Minisat::Solver* solver) {
Assert (currentPM()->d_satProof == NULL);
Assert(currentPM()->d_format == LFSC);
- currentPM()->d_satProof = new LFSCSatProof(solver);
+ currentPM()->d_satProof = new LFSCCoreSatProof(solver, "");
}
-void ProofManager::initCnfProof(prop::CnfStream* cnfStream) {
- Assert (currentPM()->d_cnfProof == NULL);
- Assert (currentPM()->d_format == LFSC);
- currentPM()->d_cnfProof = new LFSCCnfProof(cnfStream);
+void ProofManager::initCnfProof(prop::CnfStream* cnfStream,
+ context::Context* ctx) {
+ ProofManager* pm = currentPM();
+ Assert (pm->d_cnfProof == NULL);
+ Assert (pm->d_format == LFSC);
+ CnfProof* cnf = new LFSCCnfProof(cnfStream, ctx, "");
+ pm->d_cnfProof = cnf;
+ Assert(pm-> d_satProof != NULL);
+ pm->d_satProof->setCnfProof(cnf);
+
+ // true and false have to be setup in a special way
+ Node true_node = NodeManager::currentNM()->mkConst<bool>(true);
+ Node false_node = NodeManager::currentNM()->mkConst<bool>(false).notNode();
+
+ pm->d_cnfProof->pushCurrentAssertion(true_node);
+ pm->d_cnfProof->pushCurrentDefinition(true_node);
+ pm->d_cnfProof->registerConvertedClause(pm->d_satProof->getTrueUnit());
+ pm->d_cnfProof->popCurrentAssertion();
+ pm->d_cnfProof->popCurrentDefinition();
+
+ pm->d_cnfProof->pushCurrentAssertion(false_node);
+ pm->d_cnfProof->pushCurrentDefinition(false_node);
+ pm->d_cnfProof->registerConvertedClause(pm->d_satProof->getFalseUnit());
+ pm->d_cnfProof->popCurrentAssertion();
+ pm->d_cnfProof->popCurrentDefinition();
+
}
-void ProofManager::initTheoryProof() {
+void ProofManager::initTheoryProofEngine(SmtGlobals* globals) {
Assert (currentPM()->d_theoryProof == NULL);
Assert (currentPM()->d_format == LFSC);
- currentPM()->d_theoryProof = new LFSCTheoryProof();
+ currentPM()->d_theoryProof = new LFSCTheoryProofEngine(globals);
+}
+
+std::string ProofManager::getInputClauseName(ClauseId id,
+ const std::string& prefix) {
+ return append(prefix+".pb", id);
+}
+std::string ProofManager::getLemmaClauseName(ClauseId id,
+ const std::string& prefix) {
+ return append(prefix+".lemc", id);
}
+ std::string ProofManager::getLemmaName(ClauseId id,
+ const std::string& prefix) {
+ return append(prefix+"lem", id);
+}
+
+std::string ProofManager::getLearntClauseName(ClauseId id,
+ const std::string& prefix) {
+ return append(prefix+".cl", id);
+}
+std::string ProofManager::getVarName(prop::SatVariable var,
+ const std::string& prefix) {
+ return append(prefix+".v", var);
+}
+std::string ProofManager::getAtomName(prop::SatVariable var,
+ const std::string& prefix) {
+ return append(prefix+".a", var);
+}
+std::string ProofManager::getLitName(prop::SatLiteral lit,
+ const std::string& prefix) {
+ return append(prefix+".l", lit.toInt());
+}
+
-std::string ProofManager::getInputClauseName(ClauseId id) { return append("pb", id); }
-std::string ProofManager::getLemmaName(ClauseId id) { return append("lem", id); }
-std::string ProofManager::getLemmaClauseName(ClauseId id) { return append("lemc", id); }
-std::string ProofManager::getLearntClauseName(ClauseId id) { return append("cl", id); }
-std::string ProofManager::getVarName(prop::SatVariable var) { return append("var", var); }
-std::string ProofManager::getAtomName(prop::SatVariable var) { return append("atom", var); }
-std::string ProofManager::getLitName(prop::SatLiteral lit) { return append("lit", lit.toInt()); }
+std::string ProofManager::getPreprocessedAssertionName(Node node,
+ const std::string& prefix) {
+ node = node.getKind() == kind::BITVECTOR_EAGER_ATOM ? node[0] : node;
+ return append(prefix+".PA", node.getId());
+}
+std::string ProofManager::getAssertionName(Node node,
+ const std::string& prefix) {
+ return append(prefix+".A", node.getId());
+}
-std::string ProofManager::getAtomName(TNode atom) {
+std::string ProofManager::getAtomName(TNode atom,
+ const std::string& prefix) {
prop::SatLiteral lit = currentPM()->d_cnfProof->getLiteral(atom);
Assert(!lit.isNegated());
- return getAtomName(lit.getSatVariable());
+ return getAtomName(lit.getSatVariable(), prefix);
}
-std::string ProofManager::getLitName(TNode lit) {
- return getLitName(currentPM()->d_cnfProof->getLiteral(lit));
+std::string ProofManager::getLitName(TNode lit,
+ const std::string& prefix) {
+ return getLitName(currentPM()->d_cnfProof->getLiteral(lit), prefix);
+}
+
+std::string ProofManager::sanitize(TNode var) {
+ Assert (var.isVar());
+ std::string name = var.toString();
+ std::replace(name.begin(), name.end(), ' ', '_');
+ return name;
}
+
void ProofManager::traceDeps(TNode n) {
Debug("cores") << "trace deps " << n << std::endl;
+ if ((n.isConst() && n == NodeManager::currentNM()->mkConst<bool>(true)) ||
+ (n.getKind() == kind::NOT && n[0] == NodeManager::currentNM()->mkConst<bool>(false))) {
+ return;
+ }
if(d_inputCoreFormulas.find(n.toExpr()) != d_inputCoreFormulas.end()) {
// originating formula was in core set
Debug("cores") << " -- IN INPUT CORE LIST!" << std::endl;
}
}
-void ProofManager::addClause(ClauseId id, const prop::SatClause* clause, ClauseKind kind) {
- /*for (unsigned i = 0; i < clause->size(); ++i) {
- prop::SatLiteral lit = clause->operator[](i);
- d_propVars.insert(lit.getSatVariable());
- }*/
- if (kind == INPUT) {
- Debug("cores") << "; Add to inputClauses " << id << std::endl;
- d_inputClauses.insert(std::make_pair(id, clause));
- Assert(d_satProof->d_inputClauses.find(id) != d_satProof->d_inputClauses.end());
- Debug("cores") << "; core id is " << d_satProof->d_inputClauses[id] << std::endl;
- if(d_satProof->d_inputClauses[id] == uint64_t(-1)) {
- Debug("cores") << "; + constant unit (true or false)" << std::endl;
- } else if(options::unsatCores()) {
- Expr e = d_cnfProof->getAssertion(d_satProof->d_inputClauses[id] & 0xffffffff);
- Debug("cores") << "; core input assertion from CnfStream is " << e << std::endl;
- Debug("cores") << "; with proof rule " << ((d_satProof->d_inputClauses[id] & 0xffffffff00000000llu) >> 32) << std::endl;
- // Invalid proof rules are currently used for parts of CVC4 that don't
- // support proofs (these are e.g. unproven theory lemmas) or don't need
- // proofs (e.g. split lemmas). We can ignore these safely when
- // constructing unsat cores.
- if(((d_satProof->d_inputClauses[id] & 0xffffffff00000000llu) >> 32) != RULE_INVALID) {
- // trace dependences back to actual assertions
- traceDeps(Node::fromExpr(e));
- }
+void ProofManager::traceUnsatCore() {
+ Assert (options::unsatCores());
+ d_satProof->constructProof();
+ IdToSatClause used_lemmas;
+ IdToSatClause used_inputs;
+ d_satProof->collectClausesUsed(used_inputs,
+ used_lemmas);
+ IdToSatClause::const_iterator it = used_inputs.begin();
+ for(; it != used_inputs.end(); ++it) {
+ Node node = d_cnfProof->getAssertionForClause(it->first);
+ ProofRule rule = d_cnfProof->getProofRule(node);
+
+ Debug("cores") << "core input assertion " << node << std::endl;
+ Debug("cores") << "with proof rule " << rule << std::endl;
+ if (rule == RULE_TSEITIN ||
+ rule == RULE_GIVEN) {
+ // trace dependences back to actual assertions
+ // (this adds them to the unsat core)
+ traceDeps(node);
}
- } else {
- Assert(kind == THEORY_LEMMA);
- d_theoryLemmas.insert(std::make_pair(id, clause));
}
}
-void ProofManager::addAssertion(Expr formula, bool inUnsatCore) {
- Debug("cores") << "assert: " << formula << std::endl;
+void ProofManager::addAssertion(Expr formula) {
+ Debug("proof:pm") << "assert: " << formula << std::endl;
d_inputFormulas.insert(formula);
+}
+
+void ProofManager::addCoreAssertion(Expr formula) {
+ Debug("cores") << "assert: " << formula << std::endl;
d_deps[Node::fromExpr(formula)]; // empty vector of deps
- if(inUnsatCore || options::dumpUnsatCores() || options::checkUnsatCores()) {
- Debug("cores") << "adding to input core forms: " << formula << std::endl;
- d_inputCoreFormulas.insert(formula);
- }
+ d_inputCoreFormulas.insert(formula);
}
void ProofManager::addDependence(TNode n, TNode dep) {
d_logic = logic;
}
-void ProofManager::printProof(std::ostream& os, TNode n) {
- // no proofs here yet
-}
-void ProofManager::setCnfDep( Expr child, Expr parent ) {
- Debug("cores") << "CNF dep : " << child << " : " << parent << std::endl;
- d_cnf_dep[child] = parent;
-}
-Expr ProofManager::getFormulaForClauseId( ClauseId id ) {
- std::map< ClauseId, Expr >::const_iterator it = d_clause_id_to_assertion.find( id );
- if( it!=d_clause_id_to_assertion.end() ){
- return it->second;
- }else{
- Node ret;
- return ret.toExpr();
- }
-}
+LFSCProof::LFSCProof(SmtEngine* smtEngine,
+ LFSCCoreSatProof* sat,
+ LFSCCnfProof* cnf,
+ LFSCTheoryProofEngine* theory)
+ : d_satProof(sat)
+ , d_cnfProof(cnf)
+ , d_theoryProof(theory)
+ , d_smtEngine(smtEngine)
+{}
-ProofRule ProofManager::getProofRuleForClauseId( ClauseId id ) {
- std::map< ClauseId, ProofRule >::const_iterator it = d_clause_id_to_rule.find( id );
- if( it!=d_clause_id_to_rule.end() ){
- return it->second;
- }else{
- return RULE_INVALID;
- }
-}
+void LFSCProof::toStream(std::ostream& out) {
+ d_satProof->constructProof();
-void ProofManager::setAssertion( Expr e ) {
- d_assertion_to_id[e] = d_assertion_counter;
- d_assertion_counter++;
-}
-
-// if this function returns true, writes to out a proof of e based on input assertions
-bool ProofManager::isInputAssertion( Expr e, std::ostream& out ) {
- std::map< Expr, unsigned >::iterator itp = d_assertion_to_id.find( e );
- if( itp==d_assertion_to_id.end() ){
- //check if deduced by CNF
- std::map< Expr, Expr >::iterator itd = d_cnf_dep.find( e );
- if( itd!=d_cnf_dep.end() ){
- Expr parent = itd->second;
- //check if parent is an input assertion
- std::stringstream out_parent;
- if( isInputAssertion( parent, out_parent ) ){
- if( parent.getKind()==kind::AND || ( parent.getKind()==kind::NOT && ( parent[0].getKind()==kind::IMPLIES || parent[0].getKind()==kind::OR ) ) ){
- Expr parent_base = parent.getKind()==kind::NOT ? parent[0] : parent;
- Expr e_base = e.getKind()==kind::NOT ? e[0] : e;
- bool e_pol = e.getKind()!=kind::NOT;
- for( unsigned i=0; i<parent_base.getNumChildren(); i++ ){
- Expr child_base = parent_base[i].getKind()==kind::NOT ? parent_base[i][0] : parent_base[i];
- bool child_pol = parent_base[i].getKind()!=kind::NOT;
- if( parent_base.getKind()==kind::IMPLIES && i==0 ){
- child_pol = !child_pol;
- }
- if( e_base==child_base && (e_pol==child_pol)==(parent_base.getKind()==kind::AND) ){
- bool elimNn = ( ( parent_base.getKind()==kind::OR || ( parent_base.getKind()==kind::IMPLIES && i==1 ) ) && e_pol );
- if( elimNn ){
- out << "(not_not_elim _ ";
- }
- std::stringstream out_paren;
- if( i+1<parent_base.getNumChildren() ){
- out << "(and_elim_1 _ _ ";
- if( parent_base.getKind()==kind::OR || parent_base.getKind()==kind::IMPLIES ){
- out << "(not_" << ( parent_base.getKind()==kind::OR ? "or" : "impl" ) << "_elim _ _ ";
- out_paren << ")";
- }
- out_paren << ")";
- }
- for( unsigned j=0; j<i; j++ ){
- out << "(and_elim_2 _ _ ";
- if( parent_base.getKind()==kind::OR || parent_base.getKind()==kind::IMPLIES ){
- out << "(not_" << ( parent_base.getKind()==kind::OR ? "or" : "impl" ) << "_elim _ _ ";
- out_paren << ")";
- }
- out_paren << ")";
- }
- out << out_parent.str();
- out << out_paren.str();
- if( elimNn ){
- out << ")";
- }
- return true;
- }
- }
- }else{
- Trace("cnf-pf-debug") << "; isInputAssertion : parent of " << e << " is not correct type (" << parent << ")" << std::endl;
- }
- }else{
- Trace("cnf-pf-debug") << "; isInputAssertion : parent of " << e << " is not input" << std::endl;
- }
- }else{
- Trace("cnf-pf-debug") << "; isInputAssertion : " << e << " has no parent" << std::endl;
- }
- return false;
- }else{
- out << "A" << itp->second;
- return true;
+ // collecting leaf clauses in resolution proof
+ IdToSatClause used_lemmas;
+ IdToSatClause used_inputs;
+ d_satProof->collectClausesUsed(used_inputs,
+ used_lemmas);
+
+ // collecting assertions that lead to the clauses being asserted
+ NodeSet used_assertions;
+ d_cnfProof->collectAssertionsForClauses(used_inputs, used_assertions);
+
+ NodeSet atoms;
+ // collects the atoms in the clauses
+ d_cnfProof->collectAtomsForClauses(used_inputs, atoms);
+ d_cnfProof->collectAtomsForClauses(used_lemmas, atoms);
+
+ // collects the atoms in the assertions
+ for (NodeSet::const_iterator it = used_assertions.begin();
+ it != used_assertions.end(); ++it) {
+ utils::collectAtoms(*it, atoms);
}
-}
-void ProofManager::setRegisteringFormula( Node n, ProofRule proof_id ) {
- Trace("cnf-pf-debug") << "; set registering formula " << n << " proof rule = " << proof_id << std::endl;
- d_registering_assertion = n;
- d_registering_rule = proof_id;
-}
+ if (Debug.isOn("proof:pm")) {
+ // std::cout << NodeManager::currentNM();
+ Debug("proof:pm") << "LFSCProof::Used assertions: "<< std::endl;
+ for(NodeSet::const_iterator it = used_assertions.begin(); it != used_assertions.end(); ++it) {
+ Debug("proof:pm") << " " << *it << std::endl;
+ }
-void ProofManager::setRegisteredClauseId( ClauseId id ) {
- Trace("cnf-pf-debug") << "; set register clause id " << id << " " << d_registering_assertion << std::endl;
- if( !d_registering_assertion.isNull() ){
- d_clause_id_to_assertion[id] = d_registering_assertion.toExpr();
- d_clause_id_to_rule[id] = d_registering_rule;
- setRegisteringFormula( Node::null(), RULE_INVALID );
+ Debug("proof:pm") << "LFSCProof::Used atoms: "<< std::endl;
+ for(NodeSet::const_iterator it = atoms.begin(); it != atoms.end(); ++it) {
+ Debug("proof:pm") << " " << *it << std::endl;
+ }
}
-}
-LFSCProof::LFSCProof(SmtEngine* smtEngine, LFSCSatProof* sat, LFSCCnfProof* cnf, LFSCTheoryProof* theory)
- : d_satProof(sat)
- , d_cnfProof(cnf)
- , d_theoryProof(theory)
- , d_smtEngine(smtEngine)
-{
- d_satProof->constructProof();
-}
-void LFSCProof::toStream(std::ostream& out) {
+
smt::SmtScope scope(d_smtEngine);
std::ostringstream paren;
out << "(check\n";
out << " ;; Declarations\n";
- if (d_theoryProof == NULL) {
- d_theoryProof = new LFSCTheoryProof();
+
+ // declare the theory atoms
+ NodeSet::const_iterator it = atoms.begin();
+ NodeSet::const_iterator end = atoms.end();
+ for(; it != end; ++it) {
+ d_theoryProof->registerTerm((*it).toExpr());
}
- /*for(LFSCCnfProof::iterator i = d_cnfProof->begin_atom_mapping();
- i != d_cnfProof->end_atom_mapping();
- ++i) {
- d_theoryProof->addDeclaration(*i);
- }*/
+ // print out all the original assertions
d_theoryProof->printAssertions(out, paren);
- out << " ;; Proof of empty clause follows\n";
+
+
out << "(: (holds cln)\n";
- d_cnfProof->printClauses(out, paren);
- d_satProof->printResolutions(out, paren);
- paren <<")))\n;;";
- out << paren.str();
- out << "\n";
+
+ // print trust that input assertions are their preprocessed form
+ printPreprocessedAssertions(used_assertions, out, paren);
+
+ // print mapping between theory atoms and internal SAT variables
+ d_cnfProof->printAtomMapping(atoms, out, paren);
+
+ IdToSatClause::const_iterator cl_it = used_inputs.begin();
+ // print CNF conversion proof for each clause
+ for (; cl_it != used_inputs.end(); ++cl_it) {
+ d_cnfProof->printCnfProofForClause(cl_it->first, cl_it->second, out, paren);
+ }
+
+ // FIXME: for now assume all theory lemmas are in CNF form so
+ // distinguish between them and inputs
+ // print theory lemmas for resolution proof
+ d_theoryProof->printTheoryLemmas(used_lemmas, out, paren);
+
+
+ if (options::bitblastMode() == theory::bv::BITBLAST_MODE_EAGER && ProofManager::getBitVectorProof()) {
+ // print actual resolution proof
+ // d_satProof->printResolutions(out, paren);
+ ProofManager::getBitVectorProof()->getSatProof()->printResolutionEmptyClause(out, paren);
+ paren <<")))\n;;";
+ out << paren.str();
+ out << "\n";
+ } else {
+ // print actual resolution proof
+ d_satProof->printResolutions(out, paren);
+ d_satProof->printResolutionEmptyClause(out, paren);
+ paren <<")))\n;;";
+ out << paren.str();
+ out << "\n";
+ }
+}
+
+void LFSCProof::printPreprocessedAssertions(const NodeSet& assertions,
+ std::ostream& os,
+ std::ostream& paren) {
+ os << " ;; Preprocessing \n";
+ NodeSet::const_iterator it = assertions.begin();
+ NodeSet::const_iterator end = assertions.end();
+
+ for (; it != end; ++it) {
+ os << "(th_let_pf _ ";
+
+ //TODO
+ os << "(trust_f ";
+ ProofManager::currentPM()->getTheoryProofEngine()->printLetTerm((*it).toExpr(), os);
+ os << ") ";
+
+ os << "(\\ "<< ProofManager::getPreprocessedAssertionName(*it, "") << "\n";
+ paren << "))";
+
+ }
}
+
+
+//---from Morgan---
+bool ProofManager::hasOp(TNode n) const {
+ return d_bops.find(n) != d_bops.end();
+}
+
+Node ProofManager::lookupOp(TNode n) const {
+ std::map<Node, Node>::const_iterator i = d_bops.find(n);
+ Assert(i != d_bops.end());
+ return (*i).second;
+}
+
+Node ProofManager::mkOp(TNode n) {
+ if(n.getKind() != kind::BUILTIN) {
+ return n;
+ }
+ Node& op = d_ops[n];
+ if(op.isNull()) {
+ Debug("mgd") << "making an op for " << n << "\n";
+ std::stringstream ss;
+ ss << n;
+ std::string s = ss.str();
+ Debug("mgd") << " : " << s << std::endl;
+ std::vector<TypeNode> v;
+ v.push_back(NodeManager::currentNM()->integerType());
+ if(n.getConst<Kind>() == kind::SELECT) {
+ v.push_back(NodeManager::currentNM()->integerType());
+ v.push_back(NodeManager::currentNM()->integerType());
+ } else if(n.getConst<Kind>() == kind::STORE) {
+ v.push_back(NodeManager::currentNM()->integerType());
+ v.push_back(NodeManager::currentNM()->integerType());
+ v.push_back(NodeManager::currentNM()->integerType());
+ }
+ TypeNode type = NodeManager::currentNM()->mkFunctionType(v);
+ op = NodeManager::currentNM()->mkSkolem(s, type, " ignore", NodeManager::SKOLEM_NO_NOTIFY);
+ d_bops[op] = n;
+ }
+ return op;
+}
+//---end from Morgan---
+
+std::ostream& operator<<(std::ostream& out, CVC4::ProofRule k) {
+ switch(k) {
+ case RULE_GIVEN:
+ out << "RULE_GIVEN";
+ break;
+ case RULE_DERIVED:
+ out << "RULE_DERIVED";
+ break;
+ case RULE_RECONSTRUCT:
+ out << "RULE_RECONSTRUCT";
+ break;
+ case RULE_TRUST:
+ out << "RULE_TRUST";
+ break;
+ case RULE_INVALID:
+ out << "RULE_INVALID";
+ break;
+ case RULE_CONFLICT:
+ out << "RULE_CONFLICT";
+ break;
+ case RULE_TSEITIN:
+ out << "RULE_TSEITIN";
+ break;
+ case RULE_SPLIT:
+ out << "RULE_SPLIT";
+ break;
+ case RULE_ARRAYS_EXT:
+ out << "RULE_ARRAYS";
+ break;
+ case RULE_ARRAYS_ROW:
+ out << "RULE_ARRAYS";
+ break;
+ default:
+ out << "ProofRule Unknown! [" << unsigned(k) << "]";
+ }
+
+ return out;
+}
+
+
} /* CVC4 namespace */
namespace CVC4 {
+class SmtGlobals;
+
// forward declarations
namespace Minisat {
class Solver;
}/* Minisat namespace */
+namespace BVMinisat {
+ class Solver;
+}/* BVMinisat namespace */
+
namespace prop {
class CnfStream;
}/* CVC4::prop namespace */
class SmtEngine;
-typedef int ClauseId;
+typedef unsigned ClauseId;
+const ClauseId ClauseIdEmpty(-1);
+const ClauseId ClauseIdUndef(-2);
+const ClauseId ClauseIdError(-3);
class Proof;
-class SatProof;
+template <class Solver> class TSatProof;
+typedef TSatProof< CVC4::Minisat::Solver> CoreSatProof;
+
class CnfProof;
+class RewriterProof;
+class TheoryProofEngine;
class TheoryProof;
+class UFProof;
+class ArrayProof;
+class BitVectorProof;
+
+template <class Solver> class LFSCSatProof;
+typedef LFSCSatProof< CVC4::Minisat::Solver> LFSCCoreSatProof;
-class LFSCSatProof;
class LFSCCnfProof;
-class LFSCTheoryProof;
+class LFSCTheoryProofEngine;
+class LFSCUFProof;
+class LFSCBitVectorProof;
+class LFSCRewriterProof;
+
+template <class Solver> class ProofProxy;
+typedef ProofProxy< CVC4::Minisat::Solver> CoreProofProxy;
+typedef ProofProxy< CVC4::BVMinisat::Solver> BVProofProxy;
namespace prop {
typedef uint64_t SatVariable;
std::string append(const std::string& str, uint64_t num);
-typedef __gnu_cxx::hash_map < ClauseId, const prop::SatClause* > IdToClause;
-typedef std::map < ClauseId, const prop::SatClause* > OrderedIdToClause;
-typedef __gnu_cxx::hash_set<prop::SatVariable > VarSet;
+typedef __gnu_cxx::hash_map < ClauseId, prop::SatClause* > IdToSatClause;
typedef __gnu_cxx::hash_set<Expr, ExprHashFunction > ExprSet;
+typedef __gnu_cxx::hash_set<Node, NodeHashFunction > NodeSet;
+typedef __gnu_cxx::hash_map<Node, std::vector<Node>, NodeHashFunction > NodeToNodes;
+typedef std::hash_set<ClauseId> IdHashSet;
-typedef int ClauseId;
-
-enum ClauseKind {
- INPUT,
- THEORY_LEMMA,
- LEARNT
-};/* enum ClauseKind */
+typedef unsigned ClauseId;
enum ProofRule {
RULE_GIVEN, /* input assertion */
RULE_INVALID, /* assert-fail if this is ever needed in proof; use e.g. for split lemmas */
RULE_CONFLICT, /* re-construct as a conflict */
RULE_TSEITIN, /* Tseitin CNF transformation */
-
+ RULE_SPLIT, /* A splitting lemma of the form a v ~ a*/
+
RULE_ARRAYS_EXT, /* arrays, extensional */
RULE_ARRAYS_ROW, /* arrays, read-over-write */
};/* enum ProofRules */
class ProofManager {
-
- SatProof* d_satProof;
- CnfProof* d_cnfProof;
- TheoryProof* d_theoryProof;
+ CoreSatProof* d_satProof;
+ CnfProof* d_cnfProof;
+ TheoryProofEngine* d_theoryProof;
// information that will need to be shared across proofs
- IdToClause d_inputClauses;
- OrderedIdToClause d_theoryLemmas;
- IdToClause d_theoryPropagations;
ExprSet d_inputFormulas;
ExprSet d_inputCoreFormulas;
ExprSet d_outputCoreFormulas;
- //VarSet d_propVars;
int d_nextId;
Proof* d_fullProof;
ProofFormat d_format; // used for now only in debug builds
- __gnu_cxx::hash_map< Node, std::vector<Node>, NodeHashFunction > d_deps;
-
+ NodeToNodes d_deps;
// trace dependences back to unsat core
void traceDeps(TNode n);
- Node d_registering_assertion;
- ProofRule d_registering_rule;
- std::map< ClauseId, Expr > d_clause_id_to_assertion;
- std::map< ClauseId, ProofRule > d_clause_id_to_rule;
- std::map< Expr, Expr > d_cnf_dep;
- //LFSC number for assertions
- unsigned d_assertion_counter;
- std::map< Expr, unsigned > d_assertion_to_id;
protected:
LogicInfo d_logic;
// initialization
static void initSatProof(Minisat::Solver* solver);
- static void initCnfProof(CVC4::prop::CnfStream* cnfStream);
- static void initTheoryProof();
-
- static Proof* getProof(SmtEngine* smt);
- static SatProof* getSatProof();
- static CnfProof* getCnfProof();
- static TheoryProof* getTheoryProof();
-
+ static void initCnfProof(CVC4::prop::CnfStream* cnfStream,
+ context::Context* ctx);
+ static void initTheoryProofEngine(SmtGlobals* globals);
+
+ // getting various proofs
+ static Proof* getProof(SmtEngine* smt);
+ static CoreSatProof* getSatProof();
+ static CnfProof* getCnfProof();
+ static TheoryProofEngine* getTheoryProofEngine();
+ static TheoryProof* getTheoryProof( theory::TheoryId id );
+ static UFProof* getUfProof();
+ static BitVectorProof* getBitVectorProof();
+ static ArrayProof* getArrayProof();
+
// iterators over data shared by proofs
- typedef IdToClause::const_iterator clause_iterator;
- typedef OrderedIdToClause::const_iterator ordered_clause_iterator;
typedef ExprSet::const_iterator assertions_iterator;
- typedef VarSet::const_iterator var_iterator;
-
-
- __gnu_cxx::hash_map< Node, std::vector<Node>, NodeHashFunction >::const_iterator begin_deps() const { return d_deps.begin(); }
- __gnu_cxx::hash_map< Node, std::vector<Node>, NodeHashFunction >::const_iterator end_deps() const { return d_deps.end(); }
-
- clause_iterator begin_input_clauses() const { return d_inputClauses.begin(); }
- clause_iterator end_input_clauses() const { return d_inputClauses.end(); }
- size_t num_input_clauses() const { return d_inputClauses.size(); }
-
- ordered_clause_iterator begin_lemmas() const { return d_theoryLemmas.begin(); }
- ordered_clause_iterator end_lemmas() const { return d_theoryLemmas.end(); }
- size_t num_lemmas() const { return d_theoryLemmas.size(); }
+ // iterate over the assertions (these are arbitrary boolean formulas)
assertions_iterator begin_assertions() const { return d_inputFormulas.begin(); }
assertions_iterator end_assertions() const { return d_inputFormulas.end(); }
size_t num_assertions() const { return d_inputFormulas.size(); }
+
+//---from Morgan---
+ Node mkOp(TNode n);
+ Node lookupOp(TNode n) const;
+ bool hasOp(TNode n) const;
+
+ std::map<Node, Node> d_ops;
+ std::map<Node, Node> d_bops;
+//---end from Morgan---
+
+
+ // variable prefixes
+ static std::string getInputClauseName(ClauseId id, const std::string& prefix = "");
+ static std::string getLemmaClauseName(ClauseId id, const std::string& prefix = "");
+ static std::string getLemmaName(ClauseId id, const std::string& prefix = "");
+ static std::string getLearntClauseName(ClauseId id, const std::string& prefix = "");
+ static std::string getPreprocessedAssertionName(Node node, const std::string& prefix = "");
+ static std::string getAssertionName(Node node, const std::string& prefix = "");
+
+ static std::string getVarName(prop::SatVariable var, const std::string& prefix = "");
+ static std::string getAtomName(prop::SatVariable var, const std::string& prefix = "");
+ static std::string getAtomName(TNode atom, const std::string& prefix = "");
+ static std::string getLitName(prop::SatLiteral lit, const std::string& prefix = "");
+ static std::string getLitName(TNode lit, const std::string& prefix = "");
+
+ // for SMT variable names that have spaces and other things
+ static std::string sanitize(TNode var);
+
- void printProof(std::ostream& os, TNode n);
-
- void addAssertion(Expr formula, bool inUnsatCore);
- void addClause(ClauseId id, const prop::SatClause* clause, ClauseKind kind);
- // note that n depends on dep (for cores)
+ /** Add proof assertion - unlinke addCoreAssertion this is post definition expansion **/
+ void addAssertion(Expr formula);
+
+ /** Public unsat core methods **/
+ void addCoreAssertion(Expr formula);
+
void addDependence(TNode n, TNode dep);
void addUnsatCore(Expr formula);
+ void traceUnsatCore();
assertions_iterator begin_unsat_core() const { return d_outputCoreFormulas.begin(); }
assertions_iterator end_unsat_core() const { return d_outputCoreFormulas.end(); }
size_t size_unsat_core() const { return d_outputCoreFormulas.size(); }
int nextId() { return d_nextId++; }
- // variable prefixes
- static std::string getInputClauseName(ClauseId id);
- static std::string getLemmaName(ClauseId id);
- static std::string getLemmaClauseName(ClauseId id);
- static std::string getLearntClauseName(ClauseId id);
-
- static std::string getVarName(prop::SatVariable var);
- static std::string getAtomName(prop::SatVariable var);
- static std::string getAtomName(TNode atom);
- static std::string getLitName(prop::SatLiteral lit);
- static std::string getLitName(TNode lit);
-
void setLogic(const LogicInfo& logic);
const std::string getLogic() const { return d_logic.getLogicString(); }
+ LogicInfo & getLogicInfo() { return d_logic; }
-
- void setCnfDep( Expr child, Expr parent );
- Expr getFormulaForClauseId( ClauseId id );
- ProofRule getProofRuleForClauseId( ClauseId id );
- unsigned getAssertionCounter() { return d_assertion_counter; }
- void setAssertion( Expr e );
- bool isInputAssertion( Expr e, std::ostream& out );
-
-public: // AJR : FIXME this is hacky
- //currently, to map between ClauseId and Expr, requires:
- // (1) CnfStream::assertClause(...) to call setRegisteringFormula,
- // (2) SatProof::registerClause(...)/registerUnitClause(...) to call setRegisteredClauseId.
- //this is under the assumption that the first call at (2) is invoked for the clause corresponding to the Expr at (1).
- void setRegisteringFormula( Node n, ProofRule proof_id );
- void setRegisteredClauseId( ClauseId id );
};/* class ProofManager */
class LFSCProof : public Proof {
- LFSCSatProof* d_satProof;
+ LFSCCoreSatProof* d_satProof;
LFSCCnfProof* d_cnfProof;
- LFSCTheoryProof* d_theoryProof;
+ LFSCTheoryProofEngine* d_theoryProof;
SmtEngine* d_smtEngine;
+
+ // FIXME: hack until we get preprocessing
+ void printPreprocessedAssertions(const NodeSet& assertions,
+ std::ostream& os,
+ std::ostream& paren);
public:
- LFSCProof(SmtEngine* smtEngine, LFSCSatProof* sat, LFSCCnfProof* cnf, LFSCTheoryProof* theory);
+ LFSCProof(SmtEngine* smtEngine,
+ LFSCCoreSatProof* sat,
+ LFSCCnfProof* cnf,
+ LFSCTheoryProofEngine* theory);
virtual void toStream(std::ostream& out);
virtual ~LFSCProof() {}
};/* class LFSCProof */
+std::ostream& operator<<(std::ostream& out, CVC4::ProofRule k);
}/* CVC4 namespace */
+
+
#endif /* __CVC4__PROOF_MANAGER_H */
--- /dev/null
+/********************* */
+/*! \file proof_utils.cpp
+** \verbatim
+** Original author: Liana Hadarean
+** Major contributors: none
+** Minor contributors (to current version): none
+** This file is part of the CVC4 project.
+** Copyright (c) 2009-2014 New York University and The University of Iowa
+** See the file COPYING in the top-level source directory for licensing
+** information.\endverbatim
+**
+** \brief [[ Add one-line brief description here ]]
+**
+** [[ Add lengthier description here ]]
+** \todo document this file
+**/
+
+#include "proof/proof_utils.h"
+#include "theory/theory.h"
+
+namespace CVC4 {
+namespace utils {
+
+void collectAtoms(TNode node, CVC4::NodeSet& seen) {
+ if (seen.find(node) != seen.end())
+ return;
+ if (theory::Theory::theoryOf(node) != theory::THEORY_BOOL || node.isVar()) {
+ seen.insert(node);
+ return;
+ }
+
+ for (unsigned i = 0; i < node.getNumChildren(); ++i) {
+ collectAtoms(node[i], seen);
+ }
+}
+
+std::string toLFSCKind(Kind kind) {
+ switch(kind) {
+ // core kinds
+ case kind::OR : return "or";
+ case kind::AND: return "and";
+ case kind::XOR: return "xor";
+ case kind::EQUAL: return "=";
+ case kind::IFF: return "iff";
+ case kind::IMPLIES: return "impl";
+ case kind::NOT: return "not";
+
+ // bit-vector kinds
+ case kind::BITVECTOR_AND :
+ return "bvand";
+ case kind::BITVECTOR_OR :
+ return "bvor";
+ case kind::BITVECTOR_XOR :
+ return "bvxor";
+ case kind::BITVECTOR_NAND :
+ return "bvnand";
+ case kind::BITVECTOR_NOR :
+ return "bvnor";
+ case kind::BITVECTOR_XNOR :
+ return "bvxnor";
+ case kind::BITVECTOR_COMP :
+ return "bvcomp";
+ case kind::BITVECTOR_MULT :
+ return "bvmul";
+ case kind::BITVECTOR_PLUS :
+ return "bvadd";
+ case kind::BITVECTOR_SUB :
+ return "bvsub";
+ case kind::BITVECTOR_UDIV :
+ case kind::BITVECTOR_UDIV_TOTAL :
+ return "bvudiv";
+ case kind::BITVECTOR_UREM :
+ case kind::BITVECTOR_UREM_TOTAL :
+ return "bvurem";
+ case kind::BITVECTOR_SDIV :
+ return "bvsdiv";
+ case kind::BITVECTOR_SREM :
+ return "bvsrem";
+ case kind::BITVECTOR_SMOD :
+ return "bvsmod";
+ case kind::BITVECTOR_SHL :
+ return "bvshl";
+ case kind::BITVECTOR_LSHR :
+ return "bvlshr";
+ case kind::BITVECTOR_ASHR :
+ return "bvashr";
+ case kind::BITVECTOR_CONCAT :
+ return "concat";
+ case kind::BITVECTOR_NEG :
+ return "bvneg";
+ case kind::BITVECTOR_NOT :
+ return "bvnot";
+ case kind::BITVECTOR_ROTATE_LEFT :
+ return "rotate_left";
+ case kind::BITVECTOR_ROTATE_RIGHT :
+ return "rotate_right";
+ case kind::BITVECTOR_ULT :
+ return "bvult";
+ case kind::BITVECTOR_ULE :
+ return "bvule";
+ case kind::BITVECTOR_UGT :
+ return "bvugt";
+ case kind::BITVECTOR_UGE :
+ return "bvuge";
+ case kind::BITVECTOR_SLT :
+ return "bvslt";
+ case kind::BITVECTOR_SLE :
+ return "bvsle";
+ case kind::BITVECTOR_SGT :
+ return "bvsgt";
+ case kind::BITVECTOR_SGE :
+ return "bvsge";
+ case kind::BITVECTOR_EXTRACT :
+ return "extract";
+ case kind::BITVECTOR_REPEAT :
+ return "repeat";
+ case kind::BITVECTOR_ZERO_EXTEND :
+ return "zero_extend";
+ case kind::BITVECTOR_SIGN_EXTEND :
+ return "sign_extend";
+ default:
+ Unreachable();
+ }
+}
+
+} /* namespace CVC4::utils */
+} /* namespace CVC4 */
--- /dev/null
+/********************* */
+/*! \file proof_utils.h
+** \verbatim
+** Original author: Liana Hadarean
+** Major contributors: none
+** Minor contributors (to current version): none
+** This file is part of the CVC4 project.
+** Copyright (c) 2009-2014 New York University and The University of Iowa
+** See the file COPYING in the top-level source directory for licensing
+** information.\endverbatim
+**
+** \brief [[ Add one-line brief description here ]]
+**
+** [[ Add lengthier description here ]]
+** \todo document this file
+**/
+
+#include "cvc4_private.h"
+
+#pragma once
+
+#include <set>
+#include <vector>
+#include <sstream>
+#include "expr/node_manager.h"
+
+namespace CVC4 {
+
+typedef __gnu_cxx::hash_set<Expr, ExprHashFunction> ExprSet;
+typedef __gnu_cxx::hash_set<Node, NodeHashFunction> NodeSet;
+
+namespace utils {
+
+std::string toLFSCKind(Kind kind);
+
+inline unsigned getExtractHigh(Expr node) {
+ return node.getOperator().getConst<BitVectorExtract>().high;
+}
+
+inline unsigned getExtractLow(Expr node) {
+ return node.getOperator().getConst<BitVectorExtract>().low;
+}
+
+inline unsigned getSize(Type type) {
+ BitVectorType bv(type);
+ return bv.getSize();
+}
+
+
+inline unsigned getSize(Expr node) {
+ Assert (node.getType().isBitVector());
+ return getSize(node.getType());
+}
+
+inline Expr mkTrue() {
+ return NodeManager::currentNM()->toExprManager()->mkConst<bool>(true);
+}
+
+inline Expr mkFalse() {
+ return NodeManager::currentNM()->toExprManager()->mkConst<bool>(false);
+}
+inline BitVector mkBitVectorOnes(unsigned size) {
+ Assert(size > 0);
+ return BitVector(1, Integer(1)).signExtend(size - 1);
+}
+
+inline Expr mkExpr(Kind k , Expr expr) {
+ return NodeManager::currentNM()->toExprManager()->mkExpr(k, expr);
+}
+inline Expr mkExpr(Kind k , Expr e1, Expr e2) {
+ return NodeManager::currentNM()->toExprManager()->mkExpr(k, e1, e2);
+}
+inline Expr mkExpr(Kind k , std::vector<Expr>& children) {
+ return NodeManager::currentNM()->toExprManager()->mkExpr(k, children);
+}
+
+
+inline Expr mkOnes(unsigned size) {
+ BitVector val = mkBitVectorOnes(size);
+ return NodeManager::currentNM()->toExprManager()->mkConst<BitVector>(val);
+}
+
+inline Expr mkConst(unsigned size, unsigned int value) {
+ BitVector val(size, value);
+ return NodeManager::currentNM()->toExprManager()->mkConst<BitVector>(val);
+}
+
+inline Expr mkConst(const BitVector& value) {
+ return NodeManager::currentNM()->toExprManager()->mkConst<BitVector>(value);
+}
+
+inline Expr mkOr(const std::vector<Expr>& nodes) {
+ std::set<Expr> all;
+ all.insert(nodes.begin(), nodes.end());
+ Assert(all.size() != 0 );
+
+ if (all.size() == 1) {
+ // All the same, or just one
+ return nodes[0];
+ }
+
+
+ NodeBuilder<> disjunction(kind::OR);
+ std::set<Expr>::const_iterator it = all.begin();
+ std::set<Expr>::const_iterator it_end = all.end();
+ while (it != it_end) {
+ disjunction << Node::fromExpr(*it);
+ ++ it;
+ }
+
+ Node res = disjunction;
+ return res.toExpr();
+}/* mkOr() */
+
+
+inline Expr mkAnd(const std::vector<Expr>& conjunctions) {
+ std::set<Expr> all;
+ all.insert(conjunctions.begin(), conjunctions.end());
+
+ if (all.size() == 0) {
+ return mkTrue();
+ }
+
+ if (all.size() == 1) {
+ // All the same, or just one
+ return conjunctions[0];
+ }
+
+
+ NodeBuilder<> conjunction(kind::AND);
+ std::set<Expr>::const_iterator it = all.begin();
+ std::set<Expr>::const_iterator it_end = all.end();
+ while (it != it_end) {
+ conjunction << Node::fromExpr(*it);
+ ++ it;
+ }
+
+ Node res = conjunction;
+ return res.toExpr();
+}/* mkAnd() */
+
+inline Expr mkSortedExpr(Kind kind, const std::vector<Expr>& children) {
+ std::set<Expr> all;
+ all.insert(children.begin(), children.end());
+
+ if (all.size() == 0) {
+ return mkTrue();
+ }
+
+ if (all.size() == 1) {
+ // All the same, or just one
+ return children[0];
+ }
+
+
+ NodeBuilder<> res(kind);
+ std::set<Expr>::const_iterator it = all.begin();
+ std::set<Expr>::const_iterator it_end = all.end();
+ while (it != it_end) {
+ res << Node::fromExpr(*it);
+ ++ it;
+ }
+
+ return ((Node)res).toExpr();
+}/* mkSortedNode() */
+
+inline const bool getBit(Expr expr, unsigned i) {
+ Assert (i < utils::getSize(expr) &&
+ expr.isConst());
+ Integer bit = expr.getConst<BitVector>().extract(i, i).getValue();
+ return (bit == 1u);
+}
+
+void collectAtoms(TNode node, NodeSet& seen);
+
+
+}
+}
#define __CVC4__SAT__PROOF_H
#include <stdint.h>
-
#include <ext/hash_map>
#include <ext/hash_set>
#include <iosfwd>
#include <set>
#include <sstream>
#include <vector>
-
#include "expr/expr.h"
#include "proof/proof_manager.h"
+#include "util/proof.h"
+#include "util/statistics_registry.h"
+
namespace CVC4 {
-namespace Minisat {
- class Solver;
- typedef uint32_t CRef;
-}/* Minisat namespace */
-}
-#include "prop/minisat/core/SolverTypes.h"
-#include "util/proof.h"
-#include "prop/sat_solver_types.h"
-namespace std {
- using namespace __gnu_cxx;
-}/* std namespace */
-namespace CVC4 {
+class CnfProof;
/**
* Helper debugging functions
*/
-void printDebug(Minisat::Lit l);
-void printDebug(Minisat::Clause& c);
+template <class Solver> void printDebug(typename Solver::TLit l);
+template <class Solver> void printDebug(typename Solver::TClause& c);
+
+enum ClauseKind {
+ INPUT,
+ THEORY_LEMMA, // we need to distinguish because we must reprove deleted theory lemmas
+ LEARNT
+};/* enum ClauseKind */
+
+template <class Solver>
struct ResStep {
- Minisat::Lit lit;
+ typename Solver::TLit lit;
ClauseId id;
bool sign;
- ResStep(Minisat::Lit l, ClauseId i, bool s) :
+ ResStep(typename Solver::TLit l, ClauseId i, bool s) :
lit(l),
id(i),
sign(s)
{}
};/* struct ResStep */
-typedef std::vector< ResStep > ResSteps;
-typedef std::set < Minisat::Lit> LitSet;
-
+template <class Solver>
class ResChain {
+public:
+ typedef std::vector< ResStep<Solver> > ResSteps;
+ typedef std::set < typename Solver::TLit> LitSet;
+
private:
ClauseId d_start;
ResSteps d_steps;
LitSet* d_redundantLits;
public:
ResChain(ClauseId start);
- void addStep(Minisat::Lit, ClauseId, bool);
+ void addStep(typename Solver::TLit, ClauseId, bool);
bool redundantRemoved() { return (d_redundantLits == NULL || d_redundantLits->empty()); }
- void addRedundantLit(Minisat::Lit lit);
+ void addRedundantLit(typename Solver::TLit lit);
~ResChain();
// accessor methods
ClauseId getStart() { return d_start; }
LitSet* getRedundant() { return d_redundantLits; }
};/* class ResChain */
-typedef std::hash_map < ClauseId, Minisat::CRef > IdCRefMap;
-typedef std::hash_map < Minisat::CRef, ClauseId > ClauseIdMap;
-typedef std::hash_map < ClauseId, Minisat::Lit> IdUnitMap;
-typedef std::hash_map < int, ClauseId> UnitIdMap; //FIXME
-typedef std::hash_map < ClauseId, ResChain*> IdResMap;
-typedef std::hash_set < ClauseId > IdHashSet;
-typedef std::hash_map < ClauseId, uint64_t > IdProofRuleMap;
-typedef std::vector < ResChain* > ResStack;
-typedef std::hash_map <ClauseId, prop::SatClause* > IdToSatClause;
-typedef std::set < ClauseId > IdSet;
-typedef std::vector < Minisat::Lit > LitVector;
-typedef __gnu_cxx::hash_map<ClauseId, Minisat::Clause& > IdToMinisatClause;
-
-class SatProof;
-
-class ProofProxy : public ProofProxyAbstract {
-private:
- SatProof* d_proof;
-public:
- ProofProxy(SatProof* pf);
- void updateCRef(Minisat::CRef oldref, Minisat::CRef newref);
-};/* class ProofProxy */
-
+template <class Solver> class ProofProxy;
class CnfProof;
-class SatProof {
+template<class Solver>
+class TSatProof {
protected:
- Minisat::Solver* d_solver;
+ typedef std::set < typename Solver::TLit> LitSet;
+ typedef std::set < typename Solver::TVar> VarSet;
+ typedef std::hash_map < ClauseId, typename Solver::TCRef > IdCRefMap;
+ typedef std::hash_map < typename Solver::TCRef, ClauseId > ClauseIdMap;
+ typedef std::hash_map < ClauseId, typename Solver::TLit> IdUnitMap;
+ typedef std::hash_map < int, ClauseId> UnitIdMap;
+ typedef std::hash_map < ClauseId, ResChain<Solver>* > IdResMap;
+ typedef std::hash_map < ClauseId, uint64_t > IdProofRuleMap;
+ typedef std::vector < ResChain<Solver>* > ResStack;
+ //typedef std::hash_map <ClauseId, prop::SatClause* > IdToSatClause;
+ typedef std::set < ClauseId > IdSet;
+ typedef std::vector < typename Solver::TLit > LitVector;
+ typedef __gnu_cxx::hash_map<ClauseId, typename Solver::TClause& > IdToMinisatClause;
+ typedef __gnu_cxx::hash_map<ClauseId, LitVector* > IdToConflicts;
+
+ typename Solver::Solver* d_solver;
+ CnfProof* d_cnfProof;
+
// clauses
IdCRefMap d_idClause;
ClauseIdMap d_clauseId;
UnitIdMap d_unitId;
IdHashSet d_deleted;
IdToSatClause d_deletedTheoryLemmas;
-public:
- IdProofRuleMap d_inputClauses;
- IdProofRuleMap d_lemmaClauses;
+
protected:
+ IdHashSet d_inputClauses;
+ IdHashSet d_lemmaClauses;
+ VarSet d_assumptions; // assumption literals for bv solver
+ IdHashSet d_assumptionConflicts; // assumption conflicts not actually added to SAT solver
+ IdToConflicts d_assumptionConflictsDebug;
+
// resolutions
IdResMap d_resChains;
ResStack d_resStack;
const ClauseId d_emptyClauseId;
const ClauseId d_nullId;
// proxy class to break circular dependencies
- ProofProxy* d_proxy;
+ ProofProxy<Solver>* d_proxy;
// temporary map for updating CRefs
ClauseIdMap d_temp_clauseId;
- IdCRefMap d_temp_idClause;
+ IdCRefMap d_temp_idClause;
// unit conflict
ClauseId d_unitConflictId;
bool d_storedUnitConflict;
+
+ ClauseId d_trueLit;
+ ClauseId d_falseLit;
+
+ std::string d_name;
public:
- SatProof(Minisat::Solver* solver, bool checkRes = false);
- virtual ~SatProof();
+ TSatProof(Solver* solver, const std::string& name, bool checkRes = false);
+ virtual ~TSatProof();
+ void setCnfProof(CnfProof* cnf_proof);
protected:
void print(ClauseId id);
void printRes(ClauseId id);
- void printRes(ResChain* res);
+ void printRes(ResChain<Solver>* res);
bool isInputClause(ClauseId id);
- bool isTheoryConflict(ClauseId id);
bool isLemmaClause(ClauseId id);
+ bool isAssumptionConflict(ClauseId id);
bool isUnit(ClauseId id);
- bool isUnit(Minisat::Lit lit);
+ bool isUnit(typename Solver::TLit lit);
bool hasResolution(ClauseId id);
void createLitSet(ClauseId id, LitSet& set);
- void registerResolution(ClauseId id, ResChain* res);
-
- ClauseId getClauseId(Minisat::CRef clause);
- ClauseId getClauseId(Minisat::Lit lit);
- Minisat::CRef getClauseRef(ClauseId id);
- Minisat::Lit getUnit(ClauseId id);
- ClauseId getUnitId(Minisat::Lit lit);
- Minisat::Clause& getClause(Minisat::CRef ref);
+ void registerResolution(ClauseId id, ResChain<Solver>* res);
+
+ ClauseId getClauseId(typename Solver::TCRef clause);
+ ClauseId getClauseId(typename Solver::TLit lit);
+ typename Solver::TCRef getClauseRef(ClauseId id);
+ typename Solver::TLit getUnit(ClauseId id);
+ ClauseId getUnitId(typename Solver::TLit lit);
+ typename Solver::TClause& getClause(typename Solver::TCRef ref);
+ void getLitVec(ClauseId id, LitVector& vec);
virtual void toStream(std::ostream& out);
bool checkResolution(ClauseId id);
*
* @return
*/
- ClauseId resolveUnit(Minisat::Lit lit);
+ ClauseId resolveUnit(typename Solver::TLit lit);
/**
* Does a depth first search on removed literals and adds the literals
* to be removed in the proper order to the stack.
* @param removedSet the previously computed set of redundant literals
* @param removeStack the stack of literals in reverse order of resolution
*/
- void removedDfs(Minisat::Lit lit, LitSet* removedSet, LitVector& removeStack, LitSet& inClause, LitSet& seen);
- void removeRedundantFromRes(ResChain* res, ClauseId id);
+ void removedDfs(typename Solver::TLit lit, LitSet* removedSet, LitVector& removeStack, LitSet& inClause, LitSet& seen);
+ void removeRedundantFromRes(ResChain<Solver>* res, ClauseId id);
public:
- void startResChain(Minisat::CRef start);
- void addResolutionStep(Minisat::Lit lit, Minisat::CRef clause, bool sign);
+ void startResChain(typename Solver::TLit start);
+ void startResChain(typename Solver::TCRef start);
+ void addResolutionStep(typename Solver::TLit lit, typename Solver::TCRef clause, bool sign);
/**
* Pops the current resolution of the stack and stores it
* in the resolution map. Also registers the 'clause' parameter
* @param clause the clause the resolution is proving
*/
- void endResChain(Minisat::CRef clause);
- void endResChain(Minisat::Lit lit);
+ //void endResChain(typename Solver::TCRef clause);
+ void endResChain(typename Solver::TLit lit);
+ void endResChain(ClauseId id);
+ /**
+ * Pops the current resolution of the stack *without* storing it.
+ *
+ */
+ void cancelResChain();
+
/**
* Stores in the current derivation the redundant literals that were
* eliminated from the conflict clause during conflict clause minimization.
* @param lit the eliminated literal
*/
- void storeLitRedundant(Minisat::Lit lit);
+ void storeLitRedundant(typename Solver::TLit lit);
/// update the CRef Id maps when Minisat does memory reallocation x
- void updateCRef(Minisat::CRef old_ref, Minisat::CRef new_ref);
+ void updateCRef(typename Solver::TCRef old_ref, typename Solver::TCRef new_ref);
void finishUpdateCRef();
/**
*
* @param conflict
*/
- void finalizeProof(Minisat::CRef conflict);
+ void finalizeProof(typename Solver::TCRef conflict);
/// clause registration methods
- ClauseId registerClause(const Minisat::CRef clause, ClauseKind kind, uint64_t proof_id);
- ClauseId registerUnitClause(const Minisat::Lit lit, ClauseKind kind, uint64_t proof_id);
-
- void storeUnitConflict(Minisat::Lit lit, ClauseKind kind, uint64_t proof_id);
+ ClauseId registerClause(const typename Solver::TCRef clause,
+ ClauseKind kind);
+ ClauseId registerUnitClause(const typename Solver::TLit lit,
+ ClauseKind kind);
+ void registerTrueLit(const typename Solver::TLit lit);
+ void registerFalseLit(const typename Solver::TLit lit);
+
+ ClauseId getTrueUnit() const;
+ ClauseId getFalseUnit() const;
+
+
+ void registerAssumption(const typename Solver::TVar var);
+ ClauseId registerAssumptionConflict(const typename Solver::TLitVec& confl);
+
+ ClauseId storeUnitConflict(typename Solver::TLit lit,
+ ClauseKind kind);
+
/**
* Marks the deleted clauses as deleted. Note we may still use them in the final
* resolution.
* @param clause
*/
- void markDeleted(Minisat::CRef clause);
+ void markDeleted(typename Solver::TCRef clause);
bool isDeleted(ClauseId id) { return d_deleted.find(id) != d_deleted.end(); }
/**
* Constructs the resolution of ~q and resolves it with the current
* resolution thus eliminating q from the current clause
* @param q the literal to be resolved out
*/
- void resolveOutUnit(Minisat::Lit q);
+ void resolveOutUnit(typename Solver::TLit q);
/**
* Constructs the resolution of the literal lit. Called when a clause
* containing lit becomes satisfied and is removed.
* @param lit
*/
- void storeUnitResolution(Minisat::Lit lit);
-
- ProofProxy* getProxy() {return d_proxy; }
+ void storeUnitResolution(typename Solver::TLit lit);
+ ProofProxy<Solver>* getProxy() {return d_proxy; }
/**
- Constructs the SAT proof identifying the needed lemmas
+ * Constructs the SAT proof for the given clause,
+ * by collecting the needed clauses in the d_seen
+ * data-structures, also notifying the proofmanager.
*/
- void constructProof();
-
+ void constructProof(ClauseId id);
+ void constructProof() {
+ constructProof(d_emptyClauseId);
+ }
+ void collectClauses(ClauseId id);
+ prop::SatClause* buildClause(ClauseId id);
protected:
- IdSet d_seenLearnt;
- IdHashSet d_seenInput;
- IdHashSet d_seenTheoryConflicts;
- IdHashSet d_seenLemmas;
+ IdSet d_seenLearnt;
+ IdToSatClause d_seenInputs;
+ IdToSatClause d_seenLemmas;
+
+ std::string varName(typename Solver::TLit lit);
+ std::string clauseName(ClauseId id);
- inline std::string varName(Minisat::Lit lit);
- inline std::string clauseName(ClauseId id);
- void collectClauses(ClauseId id);
void addToProofManager(ClauseId id, ClauseKind kind);
+ void addToCnfProof(ClauseId id);
public:
+ virtual void printResolution(ClauseId id, std::ostream& out, std::ostream& paren) = 0;
virtual void printResolutions(std::ostream& out, std::ostream& paren) = 0;
-};/* class SatProof */
+ virtual void printResolutionEmptyClause(std::ostream& out, std::ostream& paren) = 0;
+ virtual void printAssumptionsResolution(ClauseId id, std::ostream& out, std::ostream& paren) = 0;
+
-class LFSCSatProof : public SatProof {
+ void collectClausesUsed(IdToSatClause& inputs,
+ IdToSatClause& lemmas);
+
+ void storeClauseGlue(ClauseId clause, int glue);
+
+private:
+ __gnu_cxx::hash_map<ClauseId, int> d_glueMap;
+ struct Statistics {
+ IntStat d_numLearnedClauses;
+ IntStat d_numLearnedInProof;
+ IntStat d_numLemmasInProof;
+ AverageStat d_avgChainLength;
+ HistogramStat<uint64_t> d_resChainLengths;
+ HistogramStat<uint64_t> d_usedResChainLengths;
+ HistogramStat<uint64_t> d_clauseGlue;
+ HistogramStat<uint64_t> d_usedClauseGlue;
+ Statistics(const std::string& name);
+ ~Statistics();
+ };
+
+ Statistics d_statistics;
+};/* class TSatProof */
+
+
+template <class S>
+class ProofProxy {
private:
- void printResolution(ClauseId id, std::ostream& out, std::ostream& paren);
+ TSatProof<S>* d_proof;
public:
- LFSCSatProof(Minisat::Solver* solver, bool checkRes = false)
- : SatProof(solver, checkRes)
+ ProofProxy(TSatProof<S>* pf);
+ void updateCRef(typename S::TCRef oldref, typename S::TCRef newref);
+};/* class ProofProxy */
+
+
+template <class SatSolver>
+class LFSCSatProof : public TSatProof<SatSolver> {
+private:
+
+public:
+ LFSCSatProof(SatSolver* solver, const std::string& name, bool checkRes = false)
+ : TSatProof<SatSolver>(solver, name, checkRes)
{}
+ virtual void printResolution(ClauseId id, std::ostream& out, std::ostream& paren);
virtual void printResolutions(std::ostream& out, std::ostream& paren);
+ virtual void printResolutionEmptyClause(std::ostream& out, std::ostream& paren);
+ virtual void printAssumptionsResolution(ClauseId id, std::ostream& out, std::ostream& paren);
};/* class LFSCSatProof */
+
+
+template<class Solver>
+prop::SatLiteral toSatLiteral(typename Solver::TLit lit);
+
+
+/**
+* Convert from minisat clause to SatClause
+*
+* @param minisat_cl
+* @param sat_cl
+*/
+template<class Solver>
+void toSatClause(const typename Solver::TClause& minisat_cl,
+ prop::SatClause& sat_cl);
+
+
}/* CVC4 namespace */
#endif /* __CVC4__SAT__PROOF_H */
--- /dev/null
+/********************* */
+/*! \file sat_proof_implementation.h
+ ** \verbatim
+ ** Original author: Liana Hadarean
+ ** Major contributors: Morgan Deters
+ ** Minor contributors (to current version): none
+ ** This file is part of the CVC4 project.
+ ** Copyright (c) 2009-2014 New York University and The University of Iowa
+ ** See the file COPYING in the top-level source directory for licensing
+ ** information.\endverbatim
+ **
+ ** \brief Resolution proof
+ **
+ ** Resolution proof
+ **/
+
+#include "cvc4_private.h"
+
+#ifndef __CVC4__SAT__PROOF_IMPLEMENTATION_H
+#define __CVC4__SAT__PROOF_IMPLEMENTATION_H
+
+#include "proof/sat_proof.h"
+#include "proof/cnf_proof.h"
+#include "prop/minisat/minisat.h"
+#include "prop/bvminisat/bvminisat.h"
+#include "prop/minisat/core/Solver.h"
+#include "prop/bvminisat/core/Solver.h"
+#include "prop/sat_solver_types.h"
+#include "smt/smt_statistics_registry.h"
+
+namespace CVC4 {
+
+template <class Solver>
+void printLit (typename Solver::TLit l) {
+ Debug("proof:sat") << (sign(l) ? "-" : "") << var(l) + 1;
+}
+
+template <class Solver>
+void printClause (typename Solver::TClause& c) {
+ for (int i = 0; i < c.size(); i++) {
+ Debug("proof:sat") << (sign(c[i]) ? "-" : "") << var(c[i]) + 1 << " ";
+ }
+}
+
+template <class Solver>
+void printClause (std::vector<typename Solver::TLit>& c) {
+ for (unsigned i = 0; i < c.size(); i++) {
+ Debug("proof:sat") << (sign(c[i]) ? "-" : "") << var(c[i]) + 1 << " ";
+ }
+}
+
+
+template <class Solver>
+void printLitSet(const std::set<typename Solver::TLit>& s) {
+ typename std::set < typename Solver::TLit>::const_iterator it = s.begin();
+ for(; it != s.end(); ++it) {
+ printLit<Solver>(*it);
+ Debug("proof:sat") << " ";
+ }
+ Debug("proof:sat") << std::endl;
+}
+
+// purely debugging functions
+template <class Solver>
+void printDebug (typename Solver::TLit l) {
+ Debug("proof:sat") << (sign(l) ? "-" : "") << var(l) + 1 << std::endl;
+}
+template <class Solver>
+void printDebug (typename Solver::TClause& c) {
+ for (int i = 0; i < c.size(); i++) {
+ Debug("proof:sat") << (sign(c[i]) ? "-" : "") << var(c[i]) + 1 << " ";
+ }
+ Debug("proof:sat") << std::endl;
+}
+
+
+/**
+ * Converts the clause associated to id to a set of literals
+ *
+ * @param id the clause id
+ * @param set the clause converted to a set of literals
+ */
+template <class Solver>
+void TSatProof<Solver>::createLitSet(ClauseId id, LitSet& set) {
+ Assert(set.empty());
+ if(isUnit(id)) {
+ set.insert(getUnit(id));
+ return;
+ }
+ if ( id == d_emptyClauseId) {
+ return;
+ }
+ // if it's an assumption
+ if (d_assumptionConflictsDebug.find(id) != d_assumptionConflictsDebug.end()) {
+ LitVector* clause = d_assumptionConflictsDebug[id];
+ for (unsigned i = 0; i < clause->size(); ++i) {
+ set.insert(clause->operator[](i));
+ }
+ return;
+ }
+
+ typename Solver::TCRef ref = getClauseRef(id);
+ typename Solver::TClause& c = getClause(ref);
+ for (int i = 0; i < c.size(); i++) {
+ set.insert(c[i]);
+ }
+}
+
+
+/**
+ * Resolves clause1 and clause2 on variable var and stores the
+ * result in clause1
+ * @param v
+ * @param clause1
+ * @param clause2
+ */
+template <class Solver>
+bool resolve(const typename Solver::TLit v,
+ std::set<typename Solver::TLit>& clause1,
+ std::set<typename Solver::TLit>& clause2, bool s) {
+ Assert(!clause1.empty());
+ Assert(!clause2.empty());
+ typename Solver::TLit var = sign(v) ? ~v : v;
+ if (s) {
+ // literal appears positive in the first clause
+ if( !clause2.count(~var)) {
+ if(Debug.isOn("proof:sat")) {
+ Debug("proof:sat") << "proof:resolve: Missing literal ";
+ printLit<Solver>(var);
+ Debug("proof:sat") << std::endl;
+ }
+ return false;
+ }
+ clause1.erase(var);
+ clause2.erase(~var);
+ typename std::set<typename Solver::TLit>::iterator it = clause2.begin();
+ for (; it!= clause2.end(); ++it) {
+ clause1.insert(*it);
+ }
+ } else {
+ // literal appears negative in the first clause
+ if( !clause1.count(~var) || !clause2.count(var)) {
+ if(Debug.isOn("proof:sat")) {
+ Debug("proof:sat") << "proof:resolve: Missing literal ";
+ printLit<Solver>(var);
+ Debug("proof:sat") << std::endl;
+ }
+ return false;
+ }
+ clause1.erase(~var);
+ clause2.erase(var);
+ typename std::set<typename Solver::TLit>::iterator it = clause2.begin();
+ for (; it!= clause2.end(); ++it) {
+ clause1.insert(*it);
+ }
+ }
+ return true;
+}
+
+/// ResChain
+template <class Solver>
+ResChain<Solver>::ResChain(ClauseId start) :
+ d_start(start),
+ d_steps(),
+ d_redundantLits(NULL)
+ {}
+template <class Solver>
+void ResChain<Solver>::addStep(typename Solver::TLit lit, ClauseId id, bool sign) {
+ ResStep<Solver> step(lit, id, sign);
+ d_steps.push_back(step);
+}
+
+template <class Solver>
+void ResChain<Solver>::addRedundantLit(typename Solver::TLit lit) {
+ if (d_redundantLits) {
+ d_redundantLits->insert(lit);
+ } else {
+ d_redundantLits = new LitSet();
+ d_redundantLits->insert(lit);
+ }
+}
+
+
+/// ProxyProof
+template <class Solver>
+ProofProxy<Solver>::ProofProxy(TSatProof<Solver>* proof):
+ d_proof(proof)
+{}
+
+template <class Solver>
+void ProofProxy<Solver>::updateCRef(typename Solver::TCRef oldref, typename Solver::TCRef newref) {
+ d_proof->updateCRef(oldref, newref);
+}
+
+
+/// SatProof
+template <class Solver>
+TSatProof<Solver>::TSatProof(Solver* solver, const std::string& name, bool checkRes)
+ : d_solver(solver)
+ , d_cnfProof(NULL)
+ , d_idClause()
+ , d_clauseId()
+ , d_idUnit()
+ , d_deleted()
+ , d_inputClauses()
+ , d_lemmaClauses()
+ , d_assumptions()
+ , d_assumptionConflicts()
+ , d_assumptionConflictsDebug()
+ , d_resChains()
+ , d_resStack()
+ , d_checkRes(checkRes)
+ , d_emptyClauseId(ClauseIdEmpty)
+ , d_nullId(-2)
+ , d_temp_clauseId()
+ , d_temp_idClause()
+ , d_unitConflictId()
+ , d_storedUnitConflict(false)
+ , d_trueLit(ClauseIdUndef)
+ , d_falseLit(ClauseIdUndef)
+ , d_name(name)
+ , d_seenLearnt()
+ , d_seenInputs()
+ , d_seenLemmas()
+ , d_statistics(name)
+{
+ d_proxy = new ProofProxy<Solver>(this);
+}
+
+template <class Solver>
+TSatProof<Solver>::~TSatProof() {
+ delete d_proxy;
+
+ // FIXME: double free if deleted clause also appears in d_seenLemmas?
+ IdToSatClause::iterator it = d_deletedTheoryLemmas.begin();
+ IdToSatClause::iterator end = d_deletedTheoryLemmas.end();
+
+ for (; it != end; ++it) {
+ ClauseId id = it->first;
+ // otherwise deleted in next loop
+ if (d_seenLemmas.find(id) == d_seenLemmas.end())
+ delete it->second;
+ }
+
+ IdToSatClause::iterator seen_it = d_seenLemmas.begin();
+ IdToSatClause::iterator seen_end = d_seenLemmas.end();
+
+ for (; seen_it != seen_end; ++seen_it) {
+ delete seen_it->second;
+ }
+
+ seen_it = d_seenInputs.begin();
+ seen_end = d_seenInputs.end();
+
+ for (; seen_it != seen_end; ++seen_it) {
+ delete seen_it->second;
+ }
+}
+
+template <class Solver>
+void TSatProof<Solver>::setCnfProof(CnfProof* cnf_proof) {
+ Assert (d_cnfProof == NULL);
+ d_cnfProof = cnf_proof;
+}
+
+/**
+ * Returns true if the resolution chain corresponding to id
+ * does resolve to the clause associated to id
+ * @param id
+ *
+ * @return
+ */
+template <class Solver>
+bool TSatProof<Solver>::checkResolution(ClauseId id) {
+ if(d_checkRes) {
+ bool validRes = true;
+ Assert(d_resChains.find(id) != d_resChains.end());
+ ResChain<Solver>* res = d_resChains[id];
+ LitSet clause1;
+ createLitSet(res->getStart(), clause1);
+ typename ResChain<Solver>::ResSteps& steps = res->getSteps();
+ for (unsigned i = 0; i < steps.size(); i++) {
+ typename Solver::TLit var = steps[i].lit;
+ LitSet clause2;
+ createLitSet (steps[i].id, clause2);
+ bool res = resolve<Solver> (var, clause1, clause2, steps[i].sign);
+ if(res == false) {
+ validRes = false;
+ break;
+ }
+ }
+ // compare clause we claimed to prove with the resolution result
+ if (isUnit(id)) {
+ // special case if it was a unit clause
+ typename Solver::TLit unit = getUnit(id);
+ validRes = clause1.size() == clause1.count(unit) && !clause1.empty();
+ return validRes;
+ }
+ if (id == d_emptyClauseId) {
+ return clause1.empty();
+ }
+
+ LitVector c;
+ getLitVec(id, c);
+
+ for (unsigned i = 0; i < c.size(); ++i) {
+ int count = clause1.erase(c[i]);
+ if (count == 0) {
+ if(Debug.isOn("proof:sat")) {
+ Debug("proof:sat") << "proof:checkResolution::literal not in computed result ";
+ printLit<Solver>(c[i]);
+ Debug("proof:sat") << "\n";
+ }
+ validRes = false;
+ }
+ }
+ validRes = clause1.empty();
+ if (! validRes) {
+ if(Debug.isOn("proof:sat")) {
+ Debug("proof:sat") << "proof:checkResolution::Invalid Resolution, unremoved literals: \n";
+ printLitSet<Solver>(clause1);
+ Debug("proof:sat") << "proof:checkResolution:: result should be: \n";
+ printClause<Solver>(c);
+ }
+ }
+ return validRes;
+
+ } else {
+ return true;
+ }
+}
+
+
+
+
+/// helper methods
+template <class Solver>
+ClauseId TSatProof<Solver>::getClauseId(typename Solver::TCRef ref) {
+ if(d_clauseId.find(ref) == d_clauseId.end()) {
+ Debug("proof:sat") << "Missing clause \n";
+ }
+ Assert(d_clauseId.find(ref) != d_clauseId.end());
+ return d_clauseId[ref];
+}
+
+template <class Solver>
+ClauseId TSatProof<Solver>::getClauseId(typename Solver::TLit lit) {
+ Assert(d_unitId.find(toInt(lit)) != d_unitId.end());
+ return d_unitId[toInt(lit)];
+}
+template <class Solver>
+typename Solver::TCRef TSatProof<Solver>::getClauseRef(ClauseId id) {
+ if (d_idClause.find(id) == d_idClause.end()) {
+ Debug("proof:sat") << "proof:getClauseRef cannot find clause "<<id<<" "
+ << ((d_deleted.find(id) != d_deleted.end()) ? "deleted" : "")
+ << (isUnit(id)? "Unit" : "") << std::endl;
+ }
+ Assert(d_idClause.find(id) != d_idClause.end());
+ return d_idClause[id];
+}
+
+template <class Solver>
+typename Solver::TClause& TSatProof<Solver>::getClause(typename Solver::TCRef ref) {
+ Assert(ref != Solver::TCRef_Undef);
+ Assert(ref >= 0 && ref < d_solver->ca.size());
+ return d_solver->ca[ref];
+}
+
+template <class Solver>
+void TSatProof<Solver>::getLitVec(ClauseId id, LitVector& vec) {
+ if (isUnit(id)) {
+ typename Solver::TLit lit = getUnit(id);
+ vec.push_back(lit);
+ return;
+ }
+ if (isAssumptionConflict(id)) {
+ vec = *(d_assumptionConflictsDebug[id]);
+ return;
+ }
+ typename Solver::TCRef cref = getClauseRef(id);
+ typename Solver::TClause& cl = getClause(cref);
+ for (int i = 0; i < cl.size(); ++i) {
+ vec.push_back(cl[i]);
+ }
+}
+
+
+template <class Solver>
+typename Solver::TLit TSatProof<Solver>::getUnit(ClauseId id) {
+ Assert(d_idUnit.find(id) != d_idUnit.end());
+ return d_idUnit[id];
+}
+template <class Solver>
+bool TSatProof<Solver>::isUnit(ClauseId id) {
+ return d_idUnit.find(id) != d_idUnit.end();
+}
+template <class Solver>
+bool TSatProof<Solver>::isUnit(typename Solver::TLit lit) {
+ return d_unitId.find(toInt(lit)) != d_unitId.end();
+}
+template <class Solver>
+ClauseId TSatProof<Solver>::getUnitId(typename Solver::TLit lit) {
+ Assert(isUnit(lit));
+ return d_unitId[toInt(lit)];
+}
+template <class Solver>
+bool TSatProof<Solver>::hasResolution(ClauseId id) {
+ return d_resChains.find(id) != d_resChains.end();
+}
+template <class Solver>
+bool TSatProof<Solver>::isInputClause(ClauseId id) {
+ return (d_inputClauses.find(id) != d_inputClauses.end());
+}
+template <class Solver>
+bool TSatProof<Solver>::isLemmaClause(ClauseId id) {
+ return (d_lemmaClauses.find(id) != d_lemmaClauses.end());
+}
+
+template <class Solver>
+bool TSatProof<Solver>::isAssumptionConflict(ClauseId id) {
+ return d_assumptionConflicts.find(id) != d_assumptionConflicts.end();
+}
+
+
+template <class Solver>
+void TSatProof<Solver>::print(ClauseId id) {
+ if (d_deleted.find(id) != d_deleted.end()) {
+ Debug("proof:sat") << "del"<<id;
+ } else if (isUnit(id)) {
+ printLit<Solver>(getUnit(id));
+ } else if (id == d_emptyClauseId) {
+ Debug("proof:sat") << "empty "<< std::endl;
+ }
+ else {
+ typename Solver::TCRef ref = getClauseRef(id);
+ printClause<Solver>(getClause(ref));
+ }
+}
+template <class Solver>
+void TSatProof<Solver>::printRes(ClauseId id) {
+ Assert(hasResolution(id));
+ Debug("proof:sat") << "id "<< id <<": ";
+ printRes(d_resChains[id]);
+}
+template <class Solver>
+void TSatProof<Solver>::printRes(ResChain<Solver>* res) {
+ ClauseId start_id = res->getStart();
+
+ if(Debug.isOn("proof:sat")) {
+ Debug("proof:sat") << "(";
+ print(start_id);
+ }
+
+ typename ResChain<Solver>::ResSteps& steps = res->getSteps();
+ for(unsigned i = 0; i < steps.size(); i++ ) {
+ typename Solver::TLit v = steps[i].lit;
+ ClauseId id = steps[i].id;
+
+ if(Debug.isOn("proof:sat")) {
+ Debug("proof:sat") << "[";
+ printLit<Solver>(v);
+ Debug("proof:sat") << "] ";
+ print(id);
+ }
+ }
+ Debug("proof:sat") << ") \n";
+}
+
+/// registration methods
+template <class Solver>
+ ClauseId TSatProof<Solver>::registerClause(typename Solver::TCRef clause,
+ ClauseKind kind) {
+ Assert(clause != Solver::TCRef_Undef);
+ typename ClauseIdMap::iterator it = d_clauseId.find(clause);
+ if (it == d_clauseId.end()) {
+ ClauseId newId = ProofManager::currentPM()->nextId();
+ d_clauseId.insert(std::make_pair(clause, newId));
+ d_idClause.insert(std::make_pair(newId, clause));
+ if (kind == INPUT) {
+ Assert(d_inputClauses.find(newId) == d_inputClauses.end());
+ d_inputClauses.insert(newId);
+ }
+ if (kind == THEORY_LEMMA) {
+ Assert(d_lemmaClauses.find(newId) == d_lemmaClauses.end());
+ d_lemmaClauses.insert(newId);
+ }
+ }
+
+ ClauseId id = d_clauseId[clause];
+ Assert(kind != INPUT || d_inputClauses.count(id));
+ Assert(kind != THEORY_LEMMA || d_lemmaClauses.count(id));
+
+ Debug("proof:sat:detailed") << "registerClause CRef: " << clause << " id: " << d_clauseId[clause]
+ <<" kind: " << kind << "\n";
+ //ProofManager::currentPM()->setRegisteredClauseId( d_clauseId[clause] );
+ return id;
+}
+
+template <class Solver>
+ClauseId TSatProof<Solver>::registerUnitClause(typename Solver::TLit lit,
+ ClauseKind kind) {
+ Debug("cores") << "registerUnitClause " << kind << std::endl;
+ typename UnitIdMap::iterator it = d_unitId.find(toInt(lit));
+ if (it == d_unitId.end()) {
+ ClauseId newId = ProofManager::currentPM()->nextId();
+ d_unitId.insert(std::make_pair(toInt(lit), newId));
+ d_idUnit.insert(std::make_pair(newId, lit));
+
+ if (kind == INPUT) {
+ Assert(d_inputClauses.find(newId) == d_inputClauses.end());
+ d_inputClauses.insert(newId);
+ }
+ if (kind == THEORY_LEMMA) {
+ Assert(d_lemmaClauses.find(newId) == d_lemmaClauses.end());
+ d_lemmaClauses.insert(newId);
+ }
+ }
+ ClauseId id = d_unitId[toInt(lit)];
+ Assert(kind != INPUT || d_inputClauses.count(id));
+ Assert(kind != THEORY_LEMMA || d_lemmaClauses.count(id));
+ Debug("proof:sat:detailed") << "registerUnitClause id: " << id
+ <<" kind: " << kind << "\n";
+ // ProofManager::currentPM()->setRegisteredClauseId( d_unitId[toInt(lit)] );
+ return id;
+}
+template <class Solver>
+void TSatProof<Solver>::registerTrueLit(const typename Solver::TLit lit) {
+ Assert (d_trueLit == ClauseIdUndef);
+ d_trueLit = registerUnitClause(lit, INPUT);
+}
+
+template <class Solver>
+void TSatProof<Solver>::registerFalseLit(const typename Solver::TLit lit) {
+ Assert (d_falseLit == ClauseIdUndef);
+ d_falseLit = registerUnitClause(lit, INPUT);
+}
+
+template <class Solver>
+ClauseId TSatProof<Solver>::getTrueUnit() const {
+ Assert (d_trueLit != ClauseIdUndef);
+ return d_trueLit;
+}
+
+template <class Solver>
+ClauseId TSatProof<Solver>::getFalseUnit() const {
+ Assert (d_falseLit != ClauseIdUndef);
+ return d_falseLit;
+}
+
+
+template <class Solver>
+void TSatProof<Solver>::registerAssumption(const typename Solver::TVar var) {
+ Assert (d_assumptions.find(var) == d_assumptions.end());
+ d_assumptions.insert(var);
+}
+
+template <class Solver>
+ClauseId TSatProof<Solver>::registerAssumptionConflict(const typename Solver::TLitVec& confl) {
+ Debug("proof:sat:detailed") << "registerAssumptionConflict " << std::endl;
+ // Uniqueness is checked in the bit-vector proof
+ // should be vars
+ for (int i = 0; i < confl.size(); ++i) {
+ Assert (d_assumptions.find(var(confl[i])) != d_assumptions.end());
+ }
+ ClauseId new_id = ProofManager::currentPM()->nextId();
+ d_assumptionConflicts.insert(new_id);
+ LitVector* vec_confl = new LitVector(confl.size());
+ for (int i = 0; i < confl.size(); ++i) {
+ vec_confl->operator[](i) = confl[i];
+ }
+ if (Debug.isOn("proof:sat:detailed")) {
+ printClause<Solver>(*vec_confl);
+ Debug("proof:sat:detailed") << "\n";
+ }
+
+ d_assumptionConflictsDebug[new_id] = vec_confl;
+ return new_id;
+}
+
+
+template <class Solver>
+void TSatProof<Solver>::removedDfs(typename Solver::TLit lit, LitSet* removedSet, LitVector& removeStack, LitSet& inClause, LitSet& seen) {
+ // if we already added the literal return
+ if (seen.count(lit)) {
+ return;
+ }
+
+ typename Solver::TCRef reason_ref = d_solver->reason(var(lit));
+ if (reason_ref == Solver::TCRef_Undef) {
+ seen.insert(lit);
+ removeStack.push_back(lit);
+ return;
+ }
+
+ int size = getClause(reason_ref).size();
+ for (int i = 1; i < size; i++ ) {
+ typename Solver::TLit v = getClause(reason_ref)[i];
+ if(inClause.count(v) == 0 && seen.count(v) == 0) {
+ removedDfs(v, removedSet, removeStack, inClause, seen);
+ }
+ }
+ if(seen.count(lit) == 0) {
+ seen.insert(lit);
+ removeStack.push_back(lit);
+ }
+}
+
+template <class Solver>
+void TSatProof<Solver>::removeRedundantFromRes(ResChain<Solver>* res, ClauseId id) {
+ LitSet* removed = res->getRedundant();
+ if (removed == NULL) {
+ return;
+ }
+
+ LitSet inClause;
+ createLitSet(id, inClause);
+
+ LitVector removeStack;
+ LitSet seen;
+ for (typename LitSet::iterator it = removed->begin(); it != removed->end(); ++it) {
+ removedDfs(*it, removed, removeStack, inClause, seen);
+ }
+
+ for (int i = removeStack.size()-1; i >= 0; --i) {
+ typename Solver::TLit lit = removeStack[i];
+ typename Solver::TCRef reason_ref = d_solver->reason(var(lit));
+ ClauseId reason_id;
+
+ if (reason_ref == Solver::TCRef_Undef) {
+ Assert(isUnit(~lit));
+ reason_id = getUnitId(~lit);
+ } else {
+ reason_id = registerClause(reason_ref, LEARNT);
+ }
+ res->addStep(lit, reason_id, !sign(lit));
+ }
+ removed->clear();
+}
+
+template <class Solver>
+void TSatProof<Solver>::registerResolution(ClauseId id, ResChain<Solver>* res) {
+ Assert(res != NULL);
+
+ removeRedundantFromRes(res, id);
+ Assert(res->redundantRemoved());
+
+ d_resChains[id] = res;
+ if(Debug.isOn("proof:sat")) {
+ printRes(id);
+ }
+ if(d_checkRes) {
+ Assert(checkResolution(id));
+ }
+
+ PSTATS(
+ d_statistics.d_resChainLengths << ((uint64_t)res->getSteps().size());
+ d_statistics.d_avgChainLength.addEntry((uint64_t)res->getSteps().size());
+ ++(d_statistics.d_numLearnedClauses);
+ )
+}
+
+
+/// recording resolutions
+template <class Solver>
+void TSatProof<Solver>::startResChain(typename Solver::TCRef start) {
+ ClauseId id = getClauseId(start);
+ ResChain<Solver>* res = new ResChain<Solver>(id);
+ d_resStack.push_back(res);
+}
+
+template <class Solver>
+void TSatProof<Solver>::startResChain(typename Solver::TLit start) {
+ ClauseId id = getUnitId(start);
+ ResChain<Solver>* res = new ResChain<Solver>(id);
+ d_resStack.push_back(res);
+}
+
+
+template <class Solver>
+void TSatProof<Solver>::addResolutionStep(typename Solver::TLit lit,
+ typename Solver::TCRef clause, bool sign) {
+ ClauseId id = registerClause(clause, LEARNT);
+ ResChain<Solver>* res = d_resStack.back();
+ res->addStep(lit, id, sign);
+}
+
+template <class Solver>
+void TSatProof<Solver>::endResChain(ClauseId id) {
+ Debug("proof:sat:detailed") <<"endResChain " << id << "\n";
+ Assert(d_resStack.size() > 0);
+ ResChain<Solver>* res = d_resStack.back();
+ registerResolution(id, res);
+ d_resStack.pop_back();
+}
+
+
+// template <class Solver>
+// void TSatProof<Solver>::endResChain(typename Solver::TCRef clause) {
+// Assert(d_resStack.size() > 0);
+// ClauseId id = registerClause(clause, LEARNT);
+// ResChain<Solver>* res = d_resStack.back();
+// registerResolution(id, res);
+// d_resStack.pop_back();
+// }
+
+template <class Solver>
+void TSatProof<Solver>::endResChain(typename Solver::TLit lit) {
+ Assert(d_resStack.size() > 0);
+ ClauseId id = registerUnitClause(lit, LEARNT);
+ Debug("proof:sat:detailed") <<"endResChain unit " << id << "\n";
+ ResChain<Solver>* res = d_resStack.back();
+ d_glueMap[id] = 1;
+ registerResolution(id, res);
+ d_resStack.pop_back();
+}
+
+
+template <class Solver>
+void TSatProof<Solver>::cancelResChain() {
+ Assert(d_resStack.size() > 0);
+ d_resStack.pop_back();
+}
+
+
+template <class Solver>
+void TSatProof<Solver>::storeLitRedundant(typename Solver::TLit lit) {
+ Assert(d_resStack.size() > 0);
+ ResChain<Solver>* res = d_resStack.back();
+ res->addRedundantLit(lit);
+}
+
+/// constructing resolutions
+template <class Solver>
+void TSatProof<Solver>::resolveOutUnit(typename Solver::TLit lit) {
+ ClauseId id = resolveUnit(~lit);
+ ResChain<Solver>* res = d_resStack.back();
+ res->addStep(lit, id, !sign(lit));
+}
+template <class Solver>
+void TSatProof<Solver>::storeUnitResolution(typename Solver::TLit lit) {
+ Debug("cores") << "STORE UNIT RESOLUTION" << std::endl;
+ resolveUnit(lit);
+}
+template <class Solver>
+ClauseId TSatProof<Solver>::resolveUnit(typename Solver::TLit lit) {
+ // first check if we already have a resolution for lit
+ if(isUnit(lit)) {
+ ClauseId id = getClauseId(lit);
+ Assert(hasResolution(id) || isInputClause(id) || isLemmaClause(id));
+ return id;
+ }
+ typename Solver::TCRef reason_ref = d_solver->reason(var(lit));
+ Assert(reason_ref != Solver::TCRef_Undef);
+
+ ClauseId reason_id = registerClause(reason_ref, LEARNT);
+
+ ResChain<Solver>* res = new ResChain<Solver>(reason_id);
+ // Here, the call to resolveUnit() can reallocate memory in the
+ // clause allocator. So reload reason ptr each time.
+ typename Solver::TClause* reason = &getClause(reason_ref);
+ for (int i = 0;
+ i < reason->size();
+ i++, reason = &getClause(reason_ref)) {
+ typename Solver::TLit l = (*reason)[i];
+ if(lit != l) {
+ ClauseId res_id = resolveUnit(~l);
+ res->addStep(l, res_id, !sign(l));
+ }
+ }
+ ClauseId unit_id = registerUnitClause(lit, LEARNT);
+ registerResolution(unit_id, res);
+ return unit_id;
+}
+template <class Solver>
+void TSatProof<Solver>::toStream(std::ostream& out) {
+ Debug("proof:sat") << "TSatProof<Solver>::printProof\n";
+ Unimplemented("native proof printing not supported yet");
+}
+template <class Solver>
+ClauseId TSatProof<Solver>::storeUnitConflict(typename Solver::TLit conflict_lit,
+ ClauseKind kind) {
+ Debug("cores") << "STORE UNIT CONFLICT" << std::endl;
+ Assert(!d_storedUnitConflict);
+ d_unitConflictId = registerUnitClause(conflict_lit, kind);
+ d_storedUnitConflict = true;
+ Debug("proof:sat:detailed") <<"storeUnitConflict " << d_unitConflictId << "\n";
+ return d_unitConflictId;
+}
+template <class Solver>
+void TSatProof<Solver>::finalizeProof(typename Solver::TCRef conflict_ref) {
+ Assert(d_resStack.size() == 0);
+ Assert(conflict_ref != Solver::TCRef_Undef);
+ ClauseId conflict_id;
+ if (conflict_ref == Solver::TCRef_Lazy) {
+ Assert(d_storedUnitConflict);
+ conflict_id = d_unitConflictId;
+
+ ResChain<Solver>* res = new ResChain<Solver>(conflict_id);
+ typename Solver::TLit lit = d_idUnit[conflict_id];
+ ClauseId res_id = resolveUnit(~lit);
+ res->addStep(lit, res_id, !sign(lit));
+
+ registerResolution(d_emptyClauseId, res);
+
+ return;
+ } else {
+ Assert(!d_storedUnitConflict);
+ conflict_id = registerClause(conflict_ref, LEARNT); //FIXME
+ }
+
+ if(Debug.isOn("proof:sat")) {
+ Debug("proof:sat") << "proof::finalizeProof Final Conflict ";
+ print(conflict_id);
+ }
+
+ ResChain<Solver>* res = new ResChain<Solver>(conflict_id);
+ // Here, the call to resolveUnit() can reallocate memory in the
+ // clause allocator. So reload conflict ptr each time.
+ typename Solver::TClause* conflict = &getClause(conflict_ref);
+ for (int i = 0;
+ i < conflict->size();
+ ++i, conflict = &getClause(conflict_ref)) {
+ typename Solver::TLit lit = (*conflict)[i];
+ ClauseId res_id = resolveUnit(~lit);
+ res->addStep(lit, res_id, !sign(lit));
+ }
+ registerResolution(d_emptyClauseId, res);
+}
+
+/// CRef manager
+template <class Solver>
+void TSatProof<Solver>::updateCRef(typename Solver::TCRef oldref,
+ typename Solver::TCRef newref) {
+ if (d_clauseId.find(oldref) == d_clauseId.end()) {
+ return;
+ }
+ ClauseId id = getClauseId(oldref);
+ Assert(d_temp_clauseId.find(newref) == d_temp_clauseId.end());
+ Assert(d_temp_idClause.find(id) == d_temp_idClause.end());
+ d_temp_clauseId[newref] = id;
+ d_temp_idClause[id] = newref;
+}
+template <class Solver>
+void TSatProof<Solver>::finishUpdateCRef() {
+ d_clauseId.swap(d_temp_clauseId);
+ d_temp_clauseId.clear();
+
+ d_idClause.swap(d_temp_idClause);
+ d_temp_idClause.clear();
+}
+template <class Solver>
+void TSatProof<Solver>::markDeleted(typename Solver::TCRef clause) {
+ if (d_clauseId.find(clause) != d_clauseId.end()) {
+ ClauseId id = getClauseId(clause);
+ Assert(d_deleted.find(id) == d_deleted.end());
+ d_deleted.insert(id);
+ if (isLemmaClause(id)) {
+ const typename Solver::TClause& minisat_cl = getClause(clause);
+ prop::SatClause* sat_cl = new prop::SatClause();
+ toSatClause<Solver>(minisat_cl, *sat_cl);
+ d_deletedTheoryLemmas.insert(std::make_pair(id, sat_cl));
+ }
+ }
+}
+
+// template<>
+// void toSatClause< ::BVMinisat::Solver> (const BVMinisat::Solver::TClause& minisat_cl,
+// prop::SatClause& sat_cl) {
+
+// prop::BVMinisatSatSolver::toSatClause(minisat_cl, sat_cl);
+// }
+
+
+
+template <class Solver>
+void TSatProof<Solver>::constructProof(ClauseId conflict) {
+ collectClauses(conflict);
+}
+
+template <class Solver>
+std::string TSatProof<Solver>::clauseName(ClauseId id) {
+ std::ostringstream os;
+ if (isInputClause(id)) {
+ os << ProofManager::getInputClauseName(id, d_name);
+ return os.str();
+ } else
+ if (isLemmaClause(id)) {
+ os << ProofManager::getLemmaClauseName(id, d_name);
+ return os.str();
+ }else {
+ os << ProofManager::getLearntClauseName(id, d_name);
+ return os.str();
+ }
+}
+
+template <class Solver>
+prop::SatClause* TSatProof<Solver>::buildClause(ClauseId id) {
+ if (isUnit(id)) {
+ typename Solver::TLit lit = getUnit(id);
+ prop::SatLiteral sat_lit = toSatLiteral<Solver>(lit);
+ prop::SatClause* clause = new prop::SatClause();
+ clause->push_back(sat_lit);
+ return clause;
+ }
+
+ if (isDeleted(id)) {
+ prop::SatClause* clause = d_deletedTheoryLemmas.find(id)->second;
+ return clause;
+ }
+
+ typename Solver::TCRef ref = getClauseRef(id);
+ const typename Solver::TClause& minisat_cl = getClause(ref);
+ prop::SatClause* clause = new prop::SatClause();
+ toSatClause<Solver>(minisat_cl, *clause);
+ return clause;
+}
+
+template <class Solver>
+void TSatProof<Solver>::collectClauses(ClauseId id) {
+ if (d_seenInputs.find(id) != d_seenInputs.end() ||
+ d_seenLemmas.find(id) != d_seenLemmas.end() ||
+ d_seenLearnt.find(id) != d_seenLearnt.end()) {
+ return;
+ }
+
+ if (isInputClause(id)) {
+ d_seenInputs.insert(std::make_pair(id, buildClause(id)));
+ return;
+ } else if (isLemmaClause(id)) {
+ d_seenLemmas.insert(std::make_pair(id, buildClause(id)));
+ return;
+ } else if (!isAssumptionConflict(id)) {
+ d_seenLearnt.insert(id);
+ }
+
+ Assert(d_resChains.find(id) != d_resChains.end());
+ ResChain<Solver>* res = d_resChains[id];
+ PSTATS(
+ d_statistics.d_usedResChainLengths << ((uint64_t)res->getSteps().size());
+ d_statistics.d_usedClauseGlue << ((uint64_t) d_glueMap[id]);
+ );
+ ClauseId start = res->getStart();
+ collectClauses(start);
+
+ typename ResChain<Solver>::ResSteps steps = res->getSteps();
+ for(size_t i = 0; i < steps.size(); i++) {
+ collectClauses(steps[i].id);
+ }
+}
+
+template <class Solver>
+void TSatProof<Solver>::collectClausesUsed(IdToSatClause& inputs,
+ IdToSatClause& lemmas) {
+ inputs = d_seenInputs;
+ lemmas = d_seenLemmas;
+ PSTATS (
+ d_statistics.d_numLearnedInProof.setData(d_seenLearnt.size());
+ d_statistics.d_numLemmasInProof.setData(d_seenLemmas.size());
+ );
+}
+
+template <class Solver>
+void TSatProof<Solver>::storeClauseGlue(ClauseId clause, int glue) {
+ Assert (d_glueMap.find(clause) == d_glueMap.end());
+ d_glueMap.insert(std::make_pair(clause, glue));
+}
+
+template <class Solver>
+TSatProof<Solver>::Statistics::Statistics(const std::string& prefix)
+ : d_numLearnedClauses("satproof::"+prefix+"::NumLearnedClauses", 0)
+ , d_numLearnedInProof("satproof::"+prefix+"::NumLearnedInProof", 0)
+ , d_numLemmasInProof("satproof::"+prefix+"::NumLemmasInProof", 0)
+ , d_avgChainLength("satproof::"+prefix+"::AvgResChainLength")
+ , d_resChainLengths("satproof::"+prefix+"::ResChainLengthsHist")
+ , d_usedResChainLengths("satproof::"+prefix+"::UsedResChainLengthsHist")
+ , d_clauseGlue("satproof::"+prefix+"::ClauseGlueHist")
+ , d_usedClauseGlue("satproof::"+prefix+"::UsedClauseGlueHist") {
+ smtStatisticsRegistry()->registerStat(&d_numLearnedClauses);
+ smtStatisticsRegistry()->registerStat(&d_numLearnedInProof);
+ smtStatisticsRegistry()->registerStat(&d_numLemmasInProof);
+ smtStatisticsRegistry()->registerStat(&d_avgChainLength);
+ smtStatisticsRegistry()->registerStat(&d_resChainLengths);
+ smtStatisticsRegistry()->registerStat(&d_usedResChainLengths);
+ smtStatisticsRegistry()->registerStat(&d_clauseGlue);
+ smtStatisticsRegistry()->registerStat(&d_usedClauseGlue);
+}
+
+template <class Solver>
+TSatProof<Solver>::Statistics::~Statistics() {
+ smtStatisticsRegistry()->unregisterStat(&d_numLearnedClauses);
+ smtStatisticsRegistry()->unregisterStat(&d_numLearnedInProof);
+ smtStatisticsRegistry()->unregisterStat(&d_numLemmasInProof);
+ smtStatisticsRegistry()->unregisterStat(&d_avgChainLength);
+ smtStatisticsRegistry()->unregisterStat(&d_resChainLengths);
+ smtStatisticsRegistry()->unregisterStat(&d_usedResChainLengths);
+ smtStatisticsRegistry()->unregisterStat(&d_clauseGlue);
+ smtStatisticsRegistry()->unregisterStat(&d_usedClauseGlue);
+}
+
+
+/// LFSCSatProof class
+template <class Solver>
+void LFSCSatProof<Solver>::printResolution(ClauseId id, std::ostream& out, std::ostream& paren) {
+ out << "(satlem_simplify _ _ _ ";
+
+ ResChain<Solver>* res = this->d_resChains[id];
+ typename ResChain<Solver>::ResSteps& steps = res->getSteps();
+
+ for (int i = steps.size()-1; i >= 0; i--) {
+ out << "(";
+ out << (steps[i].sign? "R" : "Q") << " _ _ ";
+ }
+
+ ClauseId start_id = res->getStart();
+ out << this->clauseName(start_id) << " ";
+
+ for(unsigned i = 0; i < steps.size(); i++) {
+ prop::SatVariable v = prop::MinisatSatSolver::toSatVariable(var(steps[i].lit));
+ out << this->clauseName(steps[i].id) << " "<<ProofManager::getVarName(v, this->d_name) <<")";
+ }
+
+ if (id == this->d_emptyClauseId) {
+ out <<"(\\empty empty)";
+ return;
+ }
+
+ out << "(\\" << this->clauseName(id) << "\n"; // bind to lemma name
+ paren << "))"; // closing parethesis for lemma binding and satlem
+}
+
+/// LFSCSatProof class
+template <class Solver>
+void LFSCSatProof<Solver>::printAssumptionsResolution(ClauseId id, std::ostream& out, std::ostream& paren) {
+ Assert (this->isAssumptionConflict(id));
+ // print the resolution proving the assumption conflict
+ printResolution(id, out, paren);
+ // resolve out assumptions to prove empty clause
+ out << "(satlem_simplify _ _ _ ";
+ std::vector<typename Solver::TLit>& confl = *(this->d_assumptionConflictsDebug[id]);
+
+ Assert (confl.size());
+
+ for (unsigned i = 0; i < confl.size(); ++i) {
+ prop::SatLiteral lit = toSatLiteral<Solver>(confl[i]);
+ out <<"(";
+ out << (lit.isNegated() ? "Q" : "R") <<" _ _ ";
+ }
+
+ out << this->clauseName(id)<< " ";
+ for (int i = confl.size() - 1; i >= 0; --i) {
+ prop::SatLiteral lit = toSatLiteral<Solver>(confl[i]);
+ prop::SatVariable v = lit.getSatVariable();
+ out << "unit"<< v <<" ";
+ out << ProofManager::getVarName(v, this->d_name) <<")";
+ }
+ out <<"(\\ e e)\n";
+ paren <<")";
+}
+
+
+template <class Solver>
+void LFSCSatProof<Solver>::printResolutions(std::ostream& out, std::ostream& paren) {
+ Debug("bv-proof") << "; print resolutions" << std::endl;
+ std::set<ClauseId>::iterator it = this->d_seenLearnt.begin();
+ for(; it!= this->d_seenLearnt.end(); ++it) {
+ if(*it != this->d_emptyClauseId) {
+ Debug("bv-proof") << "; print resolution for " << *it << std::endl;
+ printResolution(*it, out, paren);
+ }
+ }
+ Debug("bv-proof") << "; done print resolutions" << std::endl;
+}
+
+template <class Solver>
+void LFSCSatProof<Solver>::printResolutionEmptyClause(std::ostream& out, std::ostream& paren) {
+ printResolution(this->d_emptyClauseId, out, paren);
+}
+
+
+inline std::ostream& operator<<(std::ostream& out, CVC4::ClauseKind k) {
+ switch(k) {
+ case CVC4::INPUT:
+ out << "INPUT";
+ break;
+ case CVC4::THEORY_LEMMA:
+ out << "THEORY_LEMMA";
+ break;
+ case CVC4::LEARNT:
+ out << "LEARNT";
+ break;
+ default:
+ out << "ClauseKind Unknown! [" << unsigned(k) << "]";
+ }
+
+ return out;
+}
+
+}/* CVC4 namespace */
+
+#endif /* __CVC4__SAT__PROOF_IMPLEMENTATION_H */
** \todo document this file
**/
-#include "proof/theory_proof.h"
+#include "base/cvc4_assert.h"
+#include "context/context.h"
+#include "options/bv_options.h"
+#include "proof/array_proof.h"
+#include "proof/bitvector_proof.h"
+#include "proof/cnf_proof.h"
+#include "proof/cnf_proof.h"
#include "proof/proof_manager.h"
-using namespace CVC4;
+#include "proof/proof_utils.h"
+#include "proof/sat_proof.h"
+#include "proof/theory_proof.h"
+#include "proof/uf_proof.h"
+#include "prop/sat_solver_types.h"
+#include "smt/smt_engine.h"
+#include "smt/smt_engine_scope.h"
+#include "smt_util/node_visitor.h"
+#include "theory/arrays/theory_arrays.h"
+#include "theory/bv/theory_bv.h"
+#include "theory/output_channel.h"
+#include "theory/term_registration_visitor.h"
+#include "theory/uf/equality_engine.h"
+#include "theory/uf/theory_uf.h"
+#include "theory/valuation.h"
+#include "util/hash.h"
+#include "util/proof.h"
-TheoryProof::TheoryProof()
- : d_termDeclarations()
- , d_sortDeclarations()
- , d_declarationCache()
-{}
-void TheoryProof::addDeclaration(Expr term) {
- if (d_declarationCache.count(term)) {
- return;
- }
+namespace CVC4 {
+
+unsigned CVC4::LetCount::counter = 0;
+static unsigned LET_COUNT = 1;
+
+//for proof replay
+class ProofOutputChannel : public theory::OutputChannel {
+public:
+ Node d_conflict;
+ Proof* d_proof;
+ Node d_lemma;
- Type type = term.getType();
- if (type.isSort())
- d_sortDeclarations.insert(type);
- if (term.getKind() == kind::APPLY_UF) {
- Expr function = term.getOperator();
- d_termDeclarations.insert(function);
- } else if (term.isVariable()) {
- //Assert (type.isSort() || type.isBoolean());
- d_termDeclarations.insert(term);
+ ProofOutputChannel() : d_conflict(), d_proof(NULL) {}
+
+ void conflict(TNode n, Proof* pf) throw() {
+ Trace("theory-proof-debug") << "; CONFLICT: " << n << std::endl;
+ Assert(d_conflict.isNull());
+ Assert(!n.isNull());
+ d_conflict = n;
+ Assert(pf != NULL);
+ d_proof = pf;
}
- // recursively declare all other terms
- for (unsigned i = 0; i < term.getNumChildren(); ++i) {
- addDeclaration(term[i]);
+ bool propagate(TNode x) throw() {
+ Trace("theory-proof-debug") << "got a propagation: " << x << std::endl;
+ return true;
+ }
+ theory::LemmaStatus lemma(TNode n, ProofRule rule, bool, bool, bool) throw() {
+ Trace("theory-proof-debug") << "new lemma: " << n << std::endl;
+ d_lemma = n;
+ return theory::LemmaStatus(TNode::null(), 0);
+ }
+ theory::LemmaStatus splitLemma(TNode, bool) throw() {
+ AlwaysAssert(false);
+ return theory::LemmaStatus(TNode::null(), 0);
+ }
+ void requirePhase(TNode n, bool b) throw() {
+ Trace("theory-proof-debug") << "requirePhase " << n << " " << b << std::endl;
+ }
+ bool flipDecision() throw() {
+ AlwaysAssert(false);
+ return false;
+ }
+ void setIncomplete() throw() {
+ AlwaysAssert(false);
}
- d_declarationCache.insert(term);
+};/* class ProofOutputChannel */
+
+//for proof replay
+class MyPreRegisterVisitor {
+ theory::Theory* d_theory;
+ __gnu_cxx::hash_set<TNode, TNodeHashFunction> d_visited;
+public:
+ typedef void return_type;
+ MyPreRegisterVisitor(theory::Theory* theory)
+ : d_theory(theory)
+ , d_visited()
+ {}
+ bool alreadyVisited(TNode current, TNode parent) { return d_visited.find(current) != d_visited.end(); }
+ void visit(TNode current, TNode parent) {
+ if(theory::Theory::theoryOf(current) == d_theory->getId()) {
+ //Trace("theory-proof-debug") << "preregister " << current << std::endl;
+ d_theory->preRegisterTerm(current);
+ d_visited.insert(current);
+ }
+ }
+ void start(TNode node) { }
+ void done(TNode node) { }
+}; /* class MyPreRegisterVisitor */
+
+TheoryProofEngine::TheoryProofEngine(SmtGlobals* globals)
+ : d_registrationCache()
+ , d_theoryProofTable()
+ , d_globals(globals)
+{
+ d_theoryProofTable[theory::THEORY_BOOL] = new LFSCBooleanProof(this);
}
-std::string toLFSCKind(Kind kind) {
- switch(kind) {
- case kind::OR : return "or";
- case kind::AND: return "and";
- case kind::XOR: return "xor";
- case kind::EQUAL: return "=";
- case kind::IFF: return "iff";
- case kind::IMPLIES: return "impl";
- case kind::NOT: return "not";
- default:
- Unreachable();
+TheoryProofEngine::~TheoryProofEngine() {
+ TheoryProofTable::iterator it = d_theoryProofTable.begin();
+ TheoryProofTable::iterator end = d_theoryProofTable.end();
+ for (; it != end; ++it) {
+ delete it->second;
}
}
-void LFSCTheoryProof::printTerm(Expr term, std::ostream& os) {
- if (term.isVariable()) {
- if(term.getType().isBoolean()) {
- os << "(p_app " << term << ")";
- } else {
- os << term;
+
+void TheoryProofEngine::registerTheory(theory::Theory* th) {
+ if( th ){
+ theory::TheoryId id = th->getId();
+ if(d_theoryProofTable.find(id) == d_theoryProofTable.end()) {
+
+ Trace("theory-proof-debug") << "; register theory " << id << std::endl;
+
+ if (id == theory::THEORY_UF) {
+ d_theoryProofTable[id] = new LFSCUFProof((theory::uf::TheoryUF*)th, this);
+ return;
+ }
+
+ if (id == theory::THEORY_BV) {
+ BitVectorProof * bvp = new LFSCBitVectorProof((theory::bv::TheoryBV*)th, this);
+ d_theoryProofTable[id] = bvp;
+ ((theory::bv::TheoryBV*)th)->setProofLog( bvp );
+ return;
+ }
+ if (id == theory::THEORY_ARRAY) {
+ d_theoryProofTable[id] = new LFSCArrayProof((theory::arrays::TheoryArrays*)th, this);
+ return;
+ }
+ // TODO other theories
}
+ }
+}
+
+TheoryProof* TheoryProofEngine::getTheoryProof(theory::TheoryId id) {
+ Assert (d_theoryProofTable.find(id) != d_theoryProofTable.end());
+ return d_theoryProofTable[id];
+}
+
+void TheoryProofEngine::registerTerm(Expr term) {
+ if (d_registrationCache.count(term)) {
return;
}
- switch(Kind k = term.getKind()) {
- case kind::APPLY_UF: {
- if(term.getType().isBoolean()) {
- os << "(p_app ";
- }
- Expr func = term.getOperator();
+ theory::TheoryId theory_id = theory::Theory::theoryOf(term);
+
+ // don't need to register boolean terms
+ if (theory_id == theory::THEORY_BUILTIN ||
+ term.getKind() == kind::ITE) {
for (unsigned i = 0; i < term.getNumChildren(); ++i) {
- os << "(apply _ _ ";
+ registerTerm(term[i]);
}
- os << func << " ";
- for (unsigned i = 0; i < term.getNumChildren(); ++i) {
- printTerm(term[i], os);
- os << ")";
+ d_registrationCache.insert(term);
+ return;
+ }
+
+ if (!supportedTheory(theory_id)) return;
+
+ getTheoryProof(theory_id)->registerTerm(term);
+ d_registrationCache.insert(term);
+}
+
+theory::TheoryId TheoryProofEngine::getTheoryForLemma(ClauseId id) {
+ // TODO: now CNF proof has a map from formula to proof rule
+ // that should be checked to figure out what theory is responsible for this
+ ProofManager* pm = ProofManager::currentPM();
+
+ if (pm->getLogic() == "QF_UF") return theory::THEORY_UF;
+ if (pm->getLogic() == "QF_BV") return theory::THEORY_BV;
+ if (pm->getLogic() == "ALL_SUPPORTED") return theory::THEORY_BV;
+ Unreachable();
+}
+
+void LFSCTheoryProofEngine::bind(Expr term, LetMap& map, Bindings& let_order) {
+ LetMap::iterator it = map.find(term);
+ if (it != map.end()) {
+ LetCount& count = it->second;
+ count.increment();
+ return;
+ }
+ for (unsigned i = 0; i < term.getNumChildren(); ++i) {
+ bind(term[i], map, let_order);
+ }
+ unsigned new_id = LetCount::newId();
+ map[term] = LetCount(new_id);
+ let_order.push_back(LetOrderElement(term, new_id));
+}
+
+void LFSCTheoryProofEngine::printLetTerm(Expr term, std::ostream& os) {
+ LetMap map;
+ Bindings let_order;
+ bind(term, map, let_order);
+ std::ostringstream paren;
+ for (unsigned i = 0; i < let_order.size(); ++i) {
+ Expr current_expr = let_order[i].expr;
+ unsigned let_id = let_order[i].id;
+ LetMap::const_iterator it = map.find(current_expr);
+ Assert (it != map.end());
+ unsigned let_count = it->second.count;
+ Assert(let_count);
+ // skip terms that only appear once
+ if (let_count <= LET_COUNT) {
+ continue;
}
- if(term.getType().isBoolean()) {
- os << ")";
+
+ os << "(@ let"<<let_id << " ";
+ printTheoryTerm(current_expr, os, map);
+ paren <<")";
+ }
+ unsigned last_let_id = let_order.back().id;
+ Expr last = let_order.back().expr;
+ unsigned last_count = map.find(last)->second.count;
+ if (last_count <= LET_COUNT) {
+ printTheoryTerm(last, os, map);
+ }
+ else {
+ os << " let"<< last_let_id;
+ }
+ os << paren.str();
+}
+
+
+void LFSCTheoryProofEngine::printTheoryTerm(Expr term, std::ostream& os, const LetMap& map) {
+ theory::TheoryId theory_id = theory::Theory::theoryOf(term);
+ // boolean terms and ITEs are special because they
+ // are common to all theories
+ if (theory_id == theory::THEORY_BUILTIN ||
+ term.getKind() == kind::ITE ||
+ term.getKind() == kind::EQUAL) {
+ printCoreTerm(term, os, map);
+ return;
+ }
+ // dispatch to proper theory
+ getTheoryProof(theory_id)->printTerm(term, os, map);
+}
+
+void LFSCTheoryProofEngine::printSort(Type type, std::ostream& os) {
+ if (type.isSort()) {
+ getTheoryProof(theory::THEORY_UF)->printSort(type, os);
+ return;
+ }
+ if (type.isBitVector()) {
+ getTheoryProof(theory::THEORY_BV)->printSort(type, os);
+ return;
+ }
+
+ if (type.isArray()) {
+ getTheoryProof(theory::THEORY_ARRAY)->printSort(type, os);
+ return;
+ }
+ Unreachable();
+}
+
+void LFSCTheoryProofEngine::printAssertions(std::ostream& os, std::ostream& paren) {
+ unsigned counter = 0;
+ ProofManager::assertions_iterator it = ProofManager::currentPM()->begin_assertions();
+ ProofManager::assertions_iterator end = ProofManager::currentPM()->end_assertions();
+
+ // collect declarations first
+ for(; it != end; ++it) {
+ registerTerm(*it);
+ }
+ printDeclarations(os, paren);
+
+ it = ProofManager::currentPM()->begin_assertions();
+ for (; it != end; ++it) {
+ // FIXME: merge this with counter
+ os << "(% A" << counter++ << " (th_holds ";
+ printLetTerm(*it, os);
+ os << ")\n";
+ paren << ")";
+ }
+ //store map between assertion and counter
+ // ProofManager::currentPM()->setAssertion( *it );
+}
+
+void LFSCTheoryProofEngine::printDeclarations(std::ostream& os, std::ostream& paren) {
+ TheoryProofTable::const_iterator it = d_theoryProofTable.begin();
+ TheoryProofTable::const_iterator end = d_theoryProofTable.end();
+ for (; it != end; ++it) {
+ it->second->printDeclarations(os, paren);
+ }
+}
+
+void LFSCTheoryProofEngine::printTheoryLemmas(const IdToSatClause& lemmas,
+ std::ostream& os,
+ std::ostream& paren) {
+ os << " ;; Theory Lemmas \n";
+ ProofManager* pm = ProofManager::currentPM();
+ IdToSatClause::const_iterator it = lemmas.begin();
+ IdToSatClause::const_iterator end = lemmas.end();
+
+ // BitVector theory is special case: must know all
+ // conflicts needed ahead of time for resolution
+ // proof lemmas
+ std::vector<Expr> bv_lemmas;
+ for (; it != end; ++it) {
+ ClauseId id = it->first;
+ const prop::SatClause* clause = it->second;
+
+ theory::TheoryId theory_id = getTheoryForLemma(id);
+ if (theory_id != theory::THEORY_BV) continue;
+
+ std::vector<Expr> conflict;
+ for(unsigned i = 0; i < clause->size(); ++i) {
+ prop::SatLiteral lit = (*clause)[i];
+ Expr atom = pm->getCnfProof()->getAtom(lit.getSatVariable()).toExpr();
+ if (atom.isConst()) {
+ Assert (atom == utils::mkTrue() ||
+ (atom == utils::mkFalse() && lit.isNegated()));
+ continue;
+ }
+ Expr expr_lit = lit.isNegated() ? atom.notExpr() : atom;
+ conflict.push_back(expr_lit);
+ }
+ bv_lemmas.push_back(utils::mkSortedExpr(kind::OR, conflict));
+ }
+ // FIXME: ugly, move into bit-vector proof by adding lemma
+ // queue inside each theory_proof
+ BitVectorProof* bv = ProofManager::getBitVectorProof();
+ bv->finalizeConflicts(bv_lemmas);
+
+ bv->printResolutionProof(os, paren);
+
+ if (options::bitblastMode() == theory::bv::BITBLAST_MODE_EAGER) {
+ Assert (lemmas.size() == 1);
+ // nothing more to do (no combination with eager so far)
+ return;
+ }
+
+ it = lemmas.begin();
+
+ for (; it != end; ++it) {
+ ClauseId id = it->first;
+ const prop::SatClause* clause = it->second;
+ // printing clause as it appears in resolution proof
+ os << "(satlem _ _ ";
+ std::ostringstream clause_paren;
+ pm->getCnfProof()->printClause(*clause, os, clause_paren);
+
+ std::vector<Expr> clause_expr;
+ for(unsigned i = 0; i < clause->size(); ++i) {
+ prop::SatLiteral lit = (*clause)[i];
+ Expr atom = pm->getCnfProof()->getAtom(lit.getSatVariable()).toExpr();
+ if (atom.isConst()) {
+ Assert (atom == utils::mkTrue());
+ continue;
+ }
+ Expr expr_lit = lit.isNegated() ? atom.notExpr(): atom;
+ clause_expr.push_back(expr_lit);
}
+
+ // query appropriate theory for proof of clause
+ theory::TheoryId theory_id = getTheoryForLemma(id);
+ Debug("theory-proof-debug") << ";; Get theory lemma from " << theory_id << "..." << std::endl;
+ getTheoryProof(theory_id)->printTheoryLemmaProof(clause_expr, os, paren);
+ // os << " (clausify_false trust)";
+ os << clause_paren.str();
+ os << "( \\ " << pm->getLemmaClauseName(id) <<"\n";
+ paren << "))";
+ }
+}
+
+void LFSCTheoryProofEngine::printBoundTerm(Expr term, std::ostream& os, const LetMap& map) {
+ LetMap::const_iterator it = map.find(term);
+ Assert (it != map.end());
+ unsigned id = it->second.id;
+ unsigned count = it->second.count;
+ if (count > LET_COUNT) {
+ os <<"let"<<id;
+ return;
+ }
+ printTheoryTerm(term, os, map);
+}
+
+void LFSCTheoryProofEngine::printCoreTerm(Expr term, std::ostream& os, const LetMap& map) {
+ if (term.isVariable()) {
+ os << ProofManager::sanitize(term);
return;
}
+ Kind k = term.getKind();
+
+ switch(k) {
case kind::ITE:
- os << (term.getType().isBoolean() ? "(ifte " : "(ite _ ");
- printTerm(term[0], os);
+ os << (term.getType().isBoolean() ? "(ifte ": "(ite _ ");
+
+ printBoundTerm(term[0], os, map);
os << " ";
- printTerm(term[1], os);
+ printBoundTerm(term[1], os, map);
os << " ";
- printTerm(term[2], os);
+ printBoundTerm(term[2], os, map);
os << ")";
return;
case kind::EQUAL:
os << "(";
os << "= ";
- os << term[0].getType() << " ";
- printTerm(term[0], os);
+ printSort(term[0].getType(), os);
+ printBoundTerm(term[0], os, map);
os << " ";
- printTerm(term[1], os);
+ printBoundTerm(term[1], os, map);
os << ")";
return;
case kind::DISTINCT:
- os << "(not (= ";
- os << term[0].getType() << " ";
- printTerm(term[0], os);
- os << " ";
- printTerm(term[1], os);
- os << "))";
- return;
+ // Distinct nodes can have any number of chidlren.
+ Assert (term.getNumChildren() >= 2);
- case kind::OR:
- case kind::AND:
- case kind::XOR:
- case kind::IFF:
- case kind::IMPLIES:
- case kind::NOT:
- // print the Boolean operators
- os << "(" << toLFSCKind(k);
- if(term.getNumChildren() > 2) {
- // LFSC doesn't allow declarations with variable numbers of
- // arguments, so we have to flatten these N-ary versions.
- std::ostringstream paren;
+ if (term.getNumChildren() == 2) {
+ os << "(not (= ";
+ printSort(term[0].getType(), os);
+ printBoundTerm(term[0], os, map);
os << " ";
- for (unsigned i = 0; i < term.getNumChildren(); ++i) {
- printTerm(term[i], os);
- os << " ";
- if(i < term.getNumChildren() - 2) {
- os << "(" << toLFSCKind(k) << " ";
- paren << ")";
- }
- }
- os << paren.str() << ")";
+ printBoundTerm(term[1], os, map);
+ os << "))";
} else {
- // this is for binary and unary operators
+ unsigned numOfPairs = term.getNumChildren() * (term.getNumChildren() - 1) / 2;
+ for (unsigned i = 1; i < numOfPairs; ++i) {
+ os << "(and ";
+ }
+
for (unsigned i = 0; i < term.getNumChildren(); ++i) {
- os << " ";
- printTerm(term[i], os);
+ for (unsigned j = i + 1; j < term.getNumChildren(); ++j) {
+ if ((i != 0) || (j != 1)) {
+ os << "(not (= ";
+ printSort(term[0].getType(), os);
+ printBoundTerm(term[i], os, map);
+ os << " ";
+ printBoundTerm(term[j], os, map);
+ os << ")))";
+ } else {
+ os << "(not (= ";
+ printSort(term[0].getType(), os);
+ printBoundTerm(term[0], os, map);
+ os << " ";
+ printBoundTerm(term[1], os, map);
+ os << "))";
+ }
+ }
}
- os << ")";
}
- return;
- case kind::CONST_BOOLEAN:
- os << (term.getConst<bool>() ? "true" : "false");
return;
case kind::CHAIN: {
std::ostringstream paren;
for(size_t i = 1; i < n; ++i) {
if(i + 1 < n) {
- os << "(" << toLFSCKind(kind::AND) << " ";
+ os << "(" << utils::toLFSCKind(kind::AND) << " ";
paren << ")";
}
- os << "(" << toLFSCKind(op) << " ";
- printTerm(term[i - 1], os);
+ os << "(" << utils::toLFSCKind(op) << " ";
+ printBoundTerm(term[i - 1], os, map);
os << " ";
- printTerm(term[i], os);
+ printBoundTerm(term[i], os, map);
os << ")";
if(i + 1 < n) {
os << " ";
Unhandled(k);
}
- Unreachable();
}
-void LFSCTheoryProof::printAssertions(std::ostream& os, std::ostream& paren) {
- ProofManager::assertions_iterator it = ProofManager::currentPM()->begin_assertions();
- ProofManager::assertions_iterator end = ProofManager::currentPM()->end_assertions();
-
- // collect declarations first
- for(; it != end; ++it) {
- addDeclaration(*it);
+void TheoryProof::printTheoryLemmaProof(std::vector<Expr>& lemma, std::ostream& os, std::ostream& paren) {
+ //default method for replaying proofs: assert (negated) literals back to a fresh copy of the theory
+ Assert( d_theory!=NULL );
+ context::UserContext fakeContext;
+ ProofOutputChannel oc;
+ theory::Valuation v(NULL);
+ //make new copy of theory
+ theory::Theory* th;
+ Trace("theory-proof-debug") << ";; Print theory lemma proof, theory id = " << d_theory->getId() << std::endl;
+ if(d_theory->getId()==theory::THEORY_UF) {
+ th = new theory::uf::TheoryUF(&fakeContext, &fakeContext, oc, v,
+ ProofManager::currentPM()->getLogicInfo(),
+ ProofManager::currentPM()->getTheoryProofEngine()->d_globals,
+ "replay::");
+ } else if(d_theory->getId()==theory::THEORY_ARRAY) {
+ th = new theory::arrays::TheoryArrays(&fakeContext, &fakeContext, oc, v,
+ ProofManager::currentPM()->getLogicInfo(),
+ ProofManager::currentPM()->getTheoryProofEngine()->d_globals,
+ "replay::");
+ } else {
+ InternalError(std::string("can't generate theory-proof for ") + ProofManager::currentPM()->getLogic());
}
- printDeclarations(os, paren);
-
- it = ProofManager::currentPM()->begin_assertions();
- for (; it != end; ++it) {
- os << "(% A" << ProofManager::currentPM()->getAssertionCounter() << " (th_holds ";
- printTerm(*it, os);
- os << ")\n";
- paren << ")";
- //store map between assertion and counter
- ProofManager::currentPM()->setAssertion( *it );
+ th->produceProofs();
+ MyPreRegisterVisitor preRegVisitor(th);
+ for( unsigned i=0; i<lemma.size(); i++ ){
+ Node lit = Node::fromExpr( lemma[i] ).negate();
+ Trace("theory-proof-debug") << "; preregistering and asserting " << lit << std::endl;
+ NodeVisitor<MyPreRegisterVisitor>::run(preRegVisitor, lit);
+ th->assertFact(lit, false);
+ }
+ th->check(theory::Theory::EFFORT_FULL);
+ if(oc.d_conflict.isNull()) {
+ Trace("theory-proof-debug") << "; conflict is null" << std::endl;
+ Assert(!oc.d_lemma.isNull());
+ Trace("theory-proof-debug") << "; ++ but got lemma: " << oc.d_lemma << std::endl;
+ Trace("theory-proof-debug") << "; asserting " << oc.d_lemma[1].negate() << std::endl;
+ th->assertFact(oc.d_lemma[1].negate(), false);
+ th->check(theory::Theory::EFFORT_FULL);
}
+ oc.d_proof->toStream(os);
+ delete th;
}
-void LFSCTheoryProof::printDeclarations(std::ostream& os, std::ostream& paren) {
- // declaring the sorts
- for (SortSet::const_iterator it = d_sortDeclarations.begin(); it != d_sortDeclarations.end(); ++it) {
- os << "(% " << *it << " sort\n";
- paren << ")";
+bool TheoryProofEngine::supportedTheory(theory::TheoryId id) {
+ return (id == theory::THEORY_ARRAY ||
+ id == theory::THEORY_BV ||
+ id == theory::THEORY_UF ||
+ id == theory::THEORY_BOOL);
+}
+
+BooleanProof::BooleanProof(TheoryProofEngine* proofEngine)
+ : TheoryProof(NULL, proofEngine)
+{}
+
+void BooleanProof::registerTerm(Expr term) {
+ Assert (term.getType().isBoolean());
+
+ if (term.isVariable() && d_declarations.find(term) == d_declarations.end()) {
+ d_declarations.insert(term);
+ return;
+ }
+ for (unsigned i = 0; i < term.getNumChildren(); ++i) {
+ d_proofEngine->registerTerm(term[i]);
}
+}
- // declaring the terms
- for (ExprSet::const_iterator it = d_termDeclarations.begin(); it != d_termDeclarations.end(); ++it) {
- Expr term = *it;
+void LFSCBooleanProof::printTerm(Expr term, std::ostream& os, const LetMap& map) {
+ Assert (term.getType().isBoolean());
+ if (term.isVariable()) {
+ os << "(p_app " << ProofManager::sanitize(term) <<")";
+ return;
+ }
- os << "(% " << term << " ";
- os << "(term ";
-
- Type type = term.getType();
- if (type.isFunction()) {
- std::ostringstream fparen;
- FunctionType ftype = (FunctionType)type;
- std::vector<Type> args = ftype.getArgTypes();
- args.push_back(ftype.getRangeType());
- os << "(arrow";
- for (unsigned i = 0; i < args.size(); i++) {
- Type arg_type = args[i];
- //Assert (arg_type.isSort() || arg_type.isBoolean());
- os << " " << arg_type;
- if (i < args.size() - 2) {
- os << " (arrow";
- fparen << ")";
+ Kind k = term.getKind();
+ switch(k) {
+ case kind::OR:
+ case kind::AND:
+ case kind::XOR:
+ case kind::IFF:
+ case kind::IMPLIES:
+ case kind::NOT:
+ // print the Boolean operators
+ os << "(" << utils::toLFSCKind(k);
+ if(term.getNumChildren() > 2) {
+ // LFSC doesn't allow declarations with variable numbers of
+ // arguments, so we have to flatten these N-ary versions.
+ std::ostringstream paren;
+ os << " ";
+ for (unsigned i = 0; i < term.getNumChildren(); ++i) {
+ d_proofEngine->printBoundTerm(term[i], os, map);
+ os << " ";
+ if(i < term.getNumChildren() - 2) {
+ os << "(" << utils::toLFSCKind(k) << " ";
+ paren << ")";
}
}
- os << fparen.str() << "))\n";
+ os << paren.str() << ")";
} else {
- Assert (term.isVariable());
- //Assert (type.isSort() || type.isBoolean());
- os << type << ")\n";
+ // this is for binary and unary operators
+ for (unsigned i = 0; i < term.getNumChildren(); ++i) {
+ os << " ";
+ d_proofEngine->printBoundTerm(term[i], os, map);
+ }
+ os << ")";
}
- paren << ")";
+ return;
+
+ case kind::CONST_BOOLEAN:
+ os << (term.getConst<bool>() ? "true" : "false");
+ return;
+
+ default:
+ Unhandled(k);
}
+
}
+
+void LFSCBooleanProof::printSort(Type type, std::ostream& os) {
+ Assert (type.isBoolean());
+ os << "Bool";
+}
+void LFSCBooleanProof::printDeclarations(std::ostream& os, std::ostream& paren) {
+ for (ExprSet::const_iterator it = d_declarations.begin(); it != d_declarations.end(); ++it) {
+ Expr term = *it;
+
+ os << "(% " << ProofManager::sanitize(term) << " (term ";
+ printSort(term.getType(), os);
+ os <<")\n";
+ paren <<")";
+ }
+}
+
+void LFSCBooleanProof::printTheoryLemmaProof(std::vector<Expr>& lemma,
+ std::ostream& os,
+ std::ostream& paren) {
+ Unreachable("No boolean lemmas yet!");
+}
+
+} /* namespace CVC4 */
/********************* */
/*! \file theory_proof.h
- ** \verbatim
- ** Original author: Liana Hadarean
- ** Major contributors: Morgan Deters
- ** Minor contributors (to current version): none
- ** This file is part of the CVC4 project.
- ** Copyright (c) 2009-2014 New York University and The University of Iowa
- ** See the file COPYING in the top-level source directory for licensing
- ** information.\endverbatim
- **
- ** \brief A manager for UfProofs.
- **
- ** A manager for UfProofs.
- **
- **
- **/
+** \verbatim
+** Original author: Liana Hadarean
+** Major contributors: Morgan Deters
+** Minor contributors (to current version): none
+** This file is part of the CVC4 project.
+** Copyright (c) 2009-2014 New York University and The University of Iowa
+** See the file COPYING in the top-level source directory for licensing
+** information.\endverbatim
+**
+** \brief A manager for UfProofs.
+**
+** A manager for UfProofs.
+**
+**
+**/
#include "cvc4_private.h"
#ifndef __CVC4__THEORY_PROOF_H
#define __CVC4__THEORY_PROOF_H
+#include "util/proof.h"
+#include "expr/expr.h"
+#include "prop/sat_solver_types.h"
#include <ext/hash_set>
#include <iosfwd>
-#include "expr/expr.h"
-#include "util/proof.h"
namespace CVC4 {
- typedef __gnu_cxx::hash_set<Type, TypeHashFunction > SortSet;
- typedef __gnu_cxx::hash_set<Expr, ExprHashFunction > ExprSet;
-
- class TheoryProof {
- protected:
- ExprSet d_termDeclarations;
- SortSet d_sortDeclarations;
- ExprSet d_declarationCache;
-
- public:
- TheoryProof();
- virtual ~TheoryProof() {}
- virtual void printAssertions(std::ostream& os, std::ostream& paren) = 0;
- void addDeclaration(Expr atom);
- };
-
- class LFSCTheoryProof : public TheoryProof {
- void printDeclarations(std::ostream& os, std::ostream& paren);
- public:
- static void printTerm(Expr term, std::ostream& os);
- virtual void printAssertions(std::ostream& os, std::ostream& paren);
- };
+class SmtGlobals;
+
+namespace theory {
+class Theory;
+}
+
+typedef unsigned ClauseId;
+
+struct LetCount {
+ static unsigned counter;
+ static void resetCounter() { counter = 0; }
+ static unsigned newId() { return ++counter; }
+
+ unsigned count;
+ unsigned id;
+ LetCount()
+ : count(0)
+ , id(-1)
+ {}
+
+ void increment() { ++count; }
+ LetCount(unsigned i)
+ : count(1)
+ , id(i)
+ {}
+ LetCount(const LetCount& other)
+ : count(other.count)
+ , id (other.id)
+ {}
+ bool operator==(const LetCount &other) const {
+ return other.id == id && other.count == count;
+ }
+ LetCount& operator=(const LetCount &rhs) {
+ if (&rhs == this) return *this;
+ id = rhs.id;
+ count = rhs.count;
+ return *this;
+ }
+};
+
+struct LetOrderElement {
+ Expr expr;
+ unsigned id;
+ LetOrderElement(Expr e, unsigned i)
+ : expr(e)
+ , id(i)
+ {}
+
+ LetOrderElement()
+ : expr()
+ , id(-1)
+ {}
+};
+
+typedef __gnu_cxx::hash_map < ClauseId, prop::SatClause* > IdToSatClause;
+
+typedef __gnu_cxx::hash_map<Expr, LetCount, ExprHashFunction> LetMap;
+typedef std::vector<LetOrderElement> Bindings;
+
+class TheoryProof;
+typedef unsigned ClauseId;
+
+typedef __gnu_cxx::hash_set<Expr, ExprHashFunction > ExprSet;
+typedef std::map<theory::TheoryId, TheoryProof* > TheoryProofTable;
+
+class TheoryProofEngine {
+protected:
+ ExprSet d_registrationCache;
+ TheoryProofTable d_theoryProofTable;
+
+ /**
+ * Returns whether the theory is currently supported in proof
+ * production mode.
+ */
+ bool supportedTheory(theory::TheoryId id);
+public:
+ SmtGlobals* d_globals;
+
+ TheoryProofEngine(SmtGlobals* globals);
+ virtual ~TheoryProofEngine();
+ /**
+ * Print the theory term (could be atom) by delegating to the
+ * proper theory
+ *
+ * @param term
+ * @param os
+ *
+ * @return
+ */
+ virtual void printLetTerm(Expr term, std::ostream& os) = 0;
+ virtual void printBoundTerm(Expr term, std::ostream& os, const LetMap& map) = 0;
+ /**
+ * Print the proof representation of the given sort.
+ *
+ * @param os
+ */
+ virtual void printSort(Type type, std::ostream& os) = 0;
+ /**
+ * Print the theory assertions (arbitrary formulas over
+ * theory atoms)
+ *
+ * @param os
+ * @param paren closing parenthesis
+ */
+ virtual void printAssertions(std::ostream& os, std::ostream& paren) = 0;
+ /**
+ * Print proofs of all the theory lemmas (must prove
+ * actual clause used in resolution proof).
+ *
+ * @param os
+ * @param paren
+ */
+ virtual void printTheoryLemmas(const IdToSatClause& lemmas,
+ std::ostream& os,
+ std::ostream& paren) = 0;
+ /**
+ * Register theory atom (ensures all terms and atoms are declared).
+ *
+ * @param atom
+ */
+ void registerTerm(Expr atom);
+ /**
+ * Ensures that a theory proof class for the given theory
+ * is created.
+ *
+ * @param theory
+ */
+ void registerTheory(theory::Theory* theory);
+ theory::TheoryId getTheoryForLemma(ClauseId id);
+ TheoryProof* getTheoryProof(theory::TheoryId id);
+};
+
+class LFSCTheoryProofEngine : public TheoryProofEngine {
+ LetMap d_letMap;
+ void printTheoryTerm(Expr term, std::ostream& os, const LetMap& map);
+ void bind(Expr term, LetMap& map, Bindings& let_order);
+public:
+ LFSCTheoryProofEngine(SmtGlobals* globals)
+ : TheoryProofEngine(globals) {}
+
+ void printDeclarations(std::ostream& os, std::ostream& paren);
+ virtual void printCoreTerm(Expr term, std::ostream& os, const LetMap& map);
+ virtual void printLetTerm(Expr term, std::ostream& os);
+ virtual void printBoundTerm(Expr term, std::ostream& os, const LetMap& map);
+ virtual void printAssertions(std::ostream& os, std::ostream& paren);
+ virtual void printTheoryLemmas(const IdToSatClause& lemmas,
+ std::ostream& os,
+ std::ostream& paren);
+ virtual void printSort(Type type, std::ostream& os);
+};
+
+class TheoryProof {
+protected:
+ // Pointer to the theory for this proof
+ theory::Theory* d_theory;
+ TheoryProofEngine* d_proofEngine;
+public:
+ TheoryProof(theory::Theory* th, TheoryProofEngine* proofEngine)
+ : d_theory(th)
+ , d_proofEngine(proofEngine)
+ {}
+ virtual ~TheoryProof() {};
+ /**
+ * Print a term belonging to this theory.
+ *
+ * @param term expresion representing term
+ * @param os output stream
+ */
+ virtual void printTerm(Expr term, std::ostream& os, const LetMap& map) = 0;
+ /**
+ * Print the proof representation of the given type.
+ *
+ * @param type
+ * @param os
+ */
+ virtual void printSort(Type type, std::ostream& os) = 0;
+ /**
+ * Print a proof for the theory lemmas. Must prove
+ * clause representing lemmas to be used in resolution proof.
+ *
+ * @param os output stream
+ */
+ virtual void printTheoryLemmaProof(std::vector<Expr>& lemma, std::ostream& os, std::ostream& paren);
+ /**
+ * Print the variable/sorts declarations for this theory.
+ *
+ * @param os
+ * @param paren
+ */
+ virtual void printDeclarations(std::ostream& os, std::ostream& paren) = 0;
+ /**
+ * Register a term of this theory that appears in the proof.
+ *
+ * @param term
+ */
+ virtual void registerTerm(Expr term) = 0;
+};
+
+class BooleanProof : public TheoryProof {
+protected:
+ ExprSet d_declarations; // all the boolean variables
+public:
+ BooleanProof(TheoryProofEngine* proofEngine);
+
+ virtual void registerTerm(Expr term);
+
+ virtual void printTerm(Expr term, std::ostream& os, const LetMap& map) = 0;
+
+ virtual void printSort(Type type, std::ostream& os) = 0;
+ virtual void printTheoryLemmaProof(std::vector<Expr>& lemma, std::ostream& os, std::ostream& paren) = 0;
+ virtual void printDeclarations(std::ostream& os, std::ostream& paren) = 0;
+};
+
+class LFSCBooleanProof : public BooleanProof {
+public:
+ LFSCBooleanProof(TheoryProofEngine* proofEngine)
+ : BooleanProof(proofEngine)
+ {}
+ virtual void printTerm(Expr term, std::ostream& os, const LetMap& map);
+ virtual void printSort(Type type, std::ostream& os);
+ virtual void printTheoryLemmaProof(std::vector<Expr>& lemma, std::ostream& os, std::ostream& paren);
+ virtual void printDeclarations(std::ostream& os, std::ostream& paren);
+};
+
+
} /* CVC4 namespace */
#endif /* __CVC4__THEORY_PROOF_H */
--- /dev/null
+/********************* */
+/*! \file uf_proof.cpp
+** \verbatim
+** Original author: Liana Hadarean
+** Major contributors: none
+** Minor contributors (to current version): none
+** This file is part of the CVC4 project.
+** Copyright (c) 2009-2014 New York University and The University of Iowa
+** See the file COPYING in the top-level source directory for licensing
+** information.\endverbatim
+**
+** \brief [[ Add one-line brief description here ]]
+**
+** [[ Add lengthier description here ]]
+** \todo document this file
+**/
+
+#include "proof/theory_proof.h"
+#include "proof/proof_manager.h"
+#include "proof/uf_proof.h"
+#include "theory/uf/theory_uf.h"
+#include <stack>
+
+using namespace CVC4;
+using namespace CVC4::theory;
+using namespace CVC4::theory::uf;
+
+
+inline static Node eqNode(TNode n1, TNode n2) {
+ return NodeManager::currentNM()->mkNode(n1.getType().isBoolean() ? kind::IFF : kind::EQUAL, n1, n2);
+}
+
+// congrence matching term helper
+inline static bool match(TNode n1, TNode n2) {
+ Debug("mgd") << "match " << n1 << " " << n2 << std::endl;
+ if(ProofManager::currentPM()->hasOp(n1)) {
+ n1 = ProofManager::currentPM()->lookupOp(n1);
+ }
+ if(ProofManager::currentPM()->hasOp(n2)) {
+ n2 = ProofManager::currentPM()->lookupOp(n2);
+ }
+ Debug("mgd") << "+ match " << n1 << " " << n2 << std::endl;
+ if(n1 == n2) {
+ return true;
+ }
+ if(n1.getType().isFunction() && n2.hasOperator()) {
+ if(ProofManager::currentPM()->hasOp(n2.getOperator())) {
+ return n1 == ProofManager::currentPM()->lookupOp(n2.getOperator());
+ } else {
+ return n1 == n2.getOperator();
+ }
+ }
+ if(n2.getType().isFunction() && n1.hasOperator()) {
+ if(ProofManager::currentPM()->hasOp(n1.getOperator())) {
+ return n2 == ProofManager::currentPM()->lookupOp(n1.getOperator());
+ } else {
+ return n2 == n1.getOperator();
+ }
+ }
+ if(n1.hasOperator() && n2.hasOperator() && n1.getOperator() != n2.getOperator()) {
+ return false;
+ }
+ for(size_t i = 0; i < n1.getNumChildren() && i < n2.getNumChildren(); ++i) {
+ if(n1[i] != n2[i]) {
+ return false;
+ }
+ }
+ return true;
+}
+
+
+void ProofUF::toStream(std::ostream& out) {
+ Trace("theory-proof-debug") << "; Print UF proof..." << std::endl;
+ //AJR : carry this further?
+ LetMap map;
+ toStreamLFSC(out, ProofManager::getUfProof(), d_proof, map);
+}
+
+void ProofUF::toStreamLFSC(std::ostream& out, TheoryProof * tp, theory::eq::EqProof * pf, const LetMap& map) {
+ Debug("lfsc-uf") << "Printing uf proof in LFSC : " << std::endl;
+ pf->debug_print("lfsc-uf");
+ Debug("lfsc-uf") << std::endl;
+ toStreamRecLFSC( out, tp, pf, 0, map );
+}
+
+Node ProofUF::toStreamRecLFSC(std::ostream& out, TheoryProof * tp, theory::eq::EqProof * pf, unsigned tb, const LetMap& map) {
+ Debug("gk::proof") << std::endl << std::endl << "toStreamRecLFSC called. tb = " << tb << " . proof:" << std::endl;
+ pf->debug_print("gk::proof");
+ Debug("gk::proof") << std::endl;
+
+ if(tb == 0) {
+ Assert(pf->d_id == eq::MERGED_THROUGH_TRANS);
+ Assert(!pf->d_node.isNull());
+ Assert(pf->d_children.size() >= 2);
+
+ int neg = -1;
+ theory::eq::EqProof subTrans;
+ subTrans.d_id = eq::MERGED_THROUGH_TRANS;
+ subTrans.d_node = pf->d_node;
+
+ size_t i = 0;
+ while (i < pf->d_children.size()) {
+ // Look for the negative clause, with which we will form a contradiction.
+ if(!pf->d_children[i]->d_node.isNull() && pf->d_children[i]->d_node.getKind() == kind::NOT) {
+ Assert(neg < 0);
+ neg = i;
+ ++i;
+ }
+
+ // Handle congruence closures over equalities.
+ else if (pf->d_children[i]->d_id==eq::MERGED_THROUGH_CONGRUENCE && pf->d_children[i]->d_node.isNull()) {
+ Debug("gk::proof") << "Handling congruence over equalities" << std::endl;
+
+ // Gather the sequence of consecutive congruence closures.
+ std::vector<const theory::eq::EqProof *> congruenceClosures;
+ unsigned count;
+ Debug("gk::proof") << "Collecting congruence sequence" << std::endl;
+ for (count = 0;
+ i + count < pf->d_children.size() &&
+ pf->d_children[i + count]->d_id==eq::MERGED_THROUGH_CONGRUENCE &&
+ pf->d_children[i + count]->d_node.isNull();
+ ++count) {
+ Debug("gk::proof") << "Found a congruence: " << std::endl;
+ pf->d_children[i+count]->debug_print("gk::proof");
+ congruenceClosures.push_back(pf->d_children[i+count]);
+ }
+
+ Debug("gk::proof") << "Total number of congruences found: " << congruenceClosures.size() << std::endl;
+
+ // Determine if the "target" of the congruence sequence appears right before or right after the sequence.
+ bool targetAppearsBefore = true;
+ bool targetAppearsAfter = true;
+
+ if ((i == 0) || (i == 1 && neg == 0)) {
+ Debug("gk::proof") << "Target does not appear before" << std::endl;
+ targetAppearsBefore = false;
+ }
+
+ if ((i + count >= pf->d_children.size()) ||
+ (!pf->d_children[i + count]->d_node.isNull() &&
+ pf->d_children[i + count]->d_node.getKind() == kind::NOT)) {
+ Debug("gk::proof") << "Target does not appear after" << std::endl;
+ targetAppearsAfter = false;
+ }
+
+ // Assert that we have precisely one target clause.
+ Assert(targetAppearsBefore != targetAppearsAfter);
+
+ // Begin breaking up the congruences and ordering the equalities correctly.
+ std::vector<theory::eq::EqProof *> orderedEqualities;
+
+
+ // Insert target clause first.
+ if (targetAppearsBefore) {
+ orderedEqualities.push_back(pf->d_children[i - 1]);
+ // The target has already been added to subTrans; remove it.
+ subTrans.d_children.pop_back();
+ } else {
+ orderedEqualities.push_back(pf->d_children[i + count]);
+ }
+
+ // Start with the congruence closure closest to the target clause, and work our way back/forward.
+ if (targetAppearsBefore) {
+ for (unsigned j = 0; j < count; ++j) {
+ if (pf->d_children[i + j]->d_children[0]->d_id != eq::MERGED_THROUGH_REFLEXIVITY)
+ orderedEqualities.insert(orderedEqualities.begin(), pf->d_children[i + j]->d_children[0]);
+ if (pf->d_children[i + j]->d_children[1]->d_id != eq::MERGED_THROUGH_REFLEXIVITY)
+ orderedEqualities.insert(orderedEqualities.end(), pf->d_children[i + j]->d_children[1]);
+ }
+ } else {
+ for (unsigned j = 0; j < count; ++j) {
+ if (pf->d_children[i + count - 1 - j]->d_children[0]->d_id != eq::MERGED_THROUGH_REFLEXIVITY)
+ orderedEqualities.insert(orderedEqualities.begin(), pf->d_children[i + count - 1 - j]->d_children[0]);
+ if (pf->d_children[i + count - 1 - j]->d_children[1]->d_id != eq::MERGED_THROUGH_REFLEXIVITY)
+ orderedEqualities.insert(orderedEqualities.end(), pf->d_children[i + count - 1 - j]->d_children[1]);
+ }
+ }
+
+ // Copy the result into the main transitivity proof.
+ subTrans.d_children.insert(subTrans.d_children.end(), orderedEqualities.begin(), orderedEqualities.end());
+
+ // Increase i to skip over the children that have been processed.
+ i += count;
+ if (targetAppearsAfter) {
+ ++i;
+ }
+ }
+
+ // Else, just copy the child proof as is
+ else {
+ subTrans.d_children.push_back(pf->d_children[i]);
+ ++i;
+ }
+ }
+ Assert(neg >= 0);
+
+ Node n1;
+ std::stringstream ss;
+ //Assert(subTrans.d_children.size() == pf->d_children.size() - 1);
+ Debug("mgdx") << "\nsubtrans has " << subTrans.d_children.size() << " children\n";
+ if(pf->d_children.size() > 2) {
+ n1 = toStreamRecLFSC(ss, tp, &subTrans, 1, map);
+ } else {
+ n1 = toStreamRecLFSC(ss, tp, subTrans.d_children[0], 1, map);
+ Debug("mgdx") << "\nsubTrans unique child " << subTrans.d_children[0]->d_id << " was proven\ngot: " << n1 << std::endl;
+ }
+
+ Node n2 = pf->d_children[neg]->d_node;
+ Assert(n2.getKind() == kind::NOT);
+ out << "(clausify_false (contra _ ";
+ Debug("mgdx") << "\nhave proven: " << n1 << std::endl;
+ Debug("mgdx") << "n2 is " << n2[0] << std::endl;
+
+ if (n2[0].getNumChildren() > 0) { Debug("mgdx") << "\nn2[0]: " << n2[0][0] << std::endl; }
+ if (n1.getNumChildren() > 1) { Debug("mgdx") << "n1[1]: " << n1[1] << std::endl; }
+
+ if(n2[0].getKind() == kind::APPLY_UF) {
+ out << "(trans _ _ _ _ ";
+ out << "(symm _ _ _ ";
+ out << ss.str();
+ out << ") (pred_eq_f _ " << ProofManager::getLitName(n2[0]) << ")) t_t_neq_f))" << std::endl;
+ } else {
+ Assert((n1[0] == n2[0][0] && n1[1] == n2[0][1]) || (n1[1] == n2[0][0] && n1[0] == n2[0][1]));
+ if(n1[1] == n2[0][0]) {
+ out << "(symm _ _ _ " << ss.str() << ")";
+ } else {
+ out << ss.str();
+ }
+ out << " " << ProofManager::getLitName(n2[0]) << "))" << std::endl;
+ }
+ return Node();
+ }
+
+ switch(pf->d_id) {
+ case eq::MERGED_THROUGH_CONGRUENCE: {
+ Debug("mgd") << "\nok, looking at congruence:\n";
+ pf->debug_print("mgd");
+ std::stack<const theory::eq::EqProof*> stk;
+ for(const theory::eq::EqProof* pf2 = pf; pf2->d_id == eq::MERGED_THROUGH_CONGRUENCE; pf2 = pf2->d_children[0]) {
+ Assert(!pf2->d_node.isNull());
+ Assert(pf2->d_node.getKind() == kind::PARTIAL_APPLY_UF || pf2->d_node.getKind() == kind::BUILTIN || pf2->d_node.getKind() == kind::APPLY_UF || pf2->d_node.getKind() == kind::SELECT || pf2->d_node.getKind() == kind::STORE);
+ Assert(pf2->d_children.size() == 2);
+ out << "(cong _ _ _ _ _ _ ";
+ stk.push(pf2);
+ }
+ Assert(stk.top()->d_children[0]->d_id != eq::MERGED_THROUGH_CONGRUENCE);
+ NodeBuilder<> b1(kind::PARTIAL_APPLY_UF), b2(kind::PARTIAL_APPLY_UF);
+ const theory::eq::EqProof* pf2 = stk.top();
+ stk.pop();
+ Assert(pf2->d_id == eq::MERGED_THROUGH_CONGRUENCE);
+ Node n1 = toStreamRecLFSC(out, tp, pf2->d_children[0], tb + 1, map);
+ out << " ";
+ std::stringstream ss;
+ Node n2 = toStreamRecLFSC(ss, tp, pf2->d_children[1], tb + 1, map);
+ Debug("mgd") << "\nok, in FIRST cong[" << stk.size() << "]" << "\n";
+ pf2->debug_print("mgd");
+ Debug("mgd") << "looking at " << pf2->d_node << "\n";
+ Debug("mgd") << " " << n1 << "\n";
+ Debug("mgd") << " " << n2 << "\n";
+ int side = 0;
+ if(match(pf2->d_node, n1[0])) {
+ //if(tb == 1) {
+ Debug("mgd") << "SIDE IS 0\n";
+ //}
+ side = 0;
+ } else {
+ //if(tb == 1) {
+ Debug("mgd") << "SIDE IS 1\n";
+ //}
+ if(!match(pf2->d_node, n1[1])) {
+ Debug("mgd") << "IN BAD CASE, our first subproof is\n";
+ pf2->d_children[0]->debug_print("mgd");
+ }
+ Assert(match(pf2->d_node, n1[1]));
+ side = 1;
+ }
+ if(n1[side].getKind() == kind::APPLY_UF || n1[side].getKind() == kind::PARTIAL_APPLY_UF || n1[side].getKind() == kind::SELECT || n1[side].getKind() == kind::STORE) {
+ if(n1[side].getKind() == kind::APPLY_UF || n1[side].getKind() == kind::PARTIAL_APPLY_UF) {
+ b1 << n1[side].getOperator();
+ } else {
+ b1 << ProofManager::currentPM()->mkOp(n1[side].getOperator());
+ }
+ b1.append(n1[side].begin(), n1[side].end());
+ } else {
+ b1 << n1[side];
+ }
+ if(n1[1-side].getKind() == kind::PARTIAL_APPLY_UF || n1[1-side].getKind() == kind::APPLY_UF || n1[side].getKind() == kind::SELECT || n1[side].getKind() == kind::STORE) {
+ if(n1[1-side].getKind() == kind::PARTIAL_APPLY_UF || n1[1-side].getKind() == kind::APPLY_UF) {
+ b2 << n1[1-side].getOperator();
+ } else {
+ b2 << ProofManager::currentPM()->mkOp(n1[1-side].getOperator());
+ }
+ b2.append(n1[1-side].begin(), n1[1-side].end());
+ } else {
+ b2 << n1[1-side];
+ }
+ Debug("mgd") << "pf2->d_node " << pf2->d_node << std::endl;
+ Debug("mgd") << "b1.getNumChildren() " << b1.getNumChildren() << std::endl;
+ Debug("mgd") << "n1 " << n1 << std::endl;
+ Debug("mgd") << "n2 " << n2 << std::endl;
+ Debug("mgd") << "side " << side << std::endl;
+ if(pf2->d_node[b1.getNumChildren() - (pf2->d_node.getMetaKind() == kind::metakind::PARAMETERIZED ? 0 : 1)] == n2[side]) {
+ b1 << n2[side];
+ b2 << n2[1-side];
+ out << ss.str();
+ } else {
+ Assert(pf2->d_node[b1.getNumChildren() - (pf2->d_node.getMetaKind() == kind::metakind::PARAMETERIZED ? 0 : 1)] == n2[1-side]);
+ b1 << n2[1-side];
+ b2 << n2[side];
+ out << "(symm _ _ _ " << ss.str() << ")";
+ }
+ out << ")";
+ while(!stk.empty()) {
+ if(tb == 1) {
+ Debug("mgd") << "\nMORE TO DO\n";
+ }
+ pf2 = stk.top();
+ stk.pop();
+ Assert(pf2->d_id == eq::MERGED_THROUGH_CONGRUENCE);
+ out << " ";
+ ss.str("");
+ n2 = toStreamRecLFSC(ss, tp, pf2->d_children[1], tb + 1, map);
+ Debug("mgd") << "\nok, in cong[" << stk.size() << "]" << "\n";
+ Debug("mgd") << "looking at " << pf2->d_node << "\n";
+ Debug("mgd") << " " << n1 << "\n";
+ Debug("mgd") << " " << n2 << "\n";
+ Debug("mgd") << " " << b1 << "\n";
+ Debug("mgd") << " " << b2 << "\n";
+ if(pf2->d_node[b1.getNumChildren()] == n2[side]) {
+ b1 << n2[side];
+ b2 << n2[1-side];
+ out << ss.str();
+ } else {
+ Assert(pf2->d_node[b1.getNumChildren()] == n2[1-side]);
+ b1 << n2[1-side];
+ b2 << n2[side];
+ out << "(symm _ _ _ " << ss.str() << ")";
+ }
+ out << ")";
+ }
+ n1 = b1;
+ n2 = b2;
+ Debug("mgd") << "at end assert, got " << pf2->d_node << " and " << n1 << std::endl;
+ if(pf2->d_node.getKind() == kind::PARTIAL_APPLY_UF) {
+ Assert(n1 == pf2->d_node);
+ }
+ if(n1.getOperator().getType().getNumChildren() == n1.getNumChildren() + 1) {
+ if(ProofManager::currentPM()->hasOp(n1.getOperator())) {
+ b1.clear(ProofManager::currentPM()->lookupOp(n2.getOperator()).getConst<Kind>());
+ } else {
+ b1.clear(kind::APPLY_UF);
+ b1 << n1.getOperator();
+ }
+ b1.append(n1.begin(), n1.end());
+ n1 = b1;
+ Debug("mgd") << "at[2] end assert, got " << pf2->d_node << " and " << n1 << std::endl;
+ if(pf2->d_node.getKind() == kind::APPLY_UF) {
+ Assert(n1 == pf2->d_node);
+ }
+ }
+ if(n2.getOperator().getType().getNumChildren() == n2.getNumChildren() + 1) {
+ if(ProofManager::currentPM()->hasOp(n2.getOperator())) {
+ b2.clear(ProofManager::currentPM()->lookupOp(n2.getOperator()).getConst<Kind>());
+ } else {
+ b2.clear(kind::APPLY_UF);
+ b2 << n2.getOperator();
+ }
+ b2.append(n2.begin(), n2.end());
+ n2 = b2;
+ }
+ Node n = (side == 0 ? eqNode(n1, n2) : eqNode(n2, n1));
+ if(tb == 1) {
+ Debug("mgdx") << "\ncong proved: " << n << "\n";
+ }
+ return n;
+ }
+
+ case eq::MERGED_THROUGH_REFLEXIVITY:
+ Assert(!pf->d_node.isNull());
+ Assert(pf->d_children.empty());
+ out << "(refl _ ";
+ tp->printTerm(NodeManager::currentNM()->toExpr(pf->d_node), out, map);
+ out << ")";
+ return eqNode(pf->d_node, pf->d_node);
+
+ case eq::MERGED_THROUGH_EQUALITY:
+ Assert(!pf->d_node.isNull());
+ Assert(pf->d_children.empty());
+ out << ProofManager::getLitName(pf->d_node.negate());
+ return pf->d_node;
+
+ case eq::MERGED_THROUGH_TRANS: {
+ Assert(!pf->d_node.isNull());
+ Assert(pf->d_children.size() >= 2);
+ std::stringstream ss;
+ Debug("mgd") << "\ndoing trans proof[[\n";
+ pf->debug_print("mgd");
+ Debug("mgd") << "\n";
+ Node n1 = toStreamRecLFSC(ss, tp, pf->d_children[0], tb + 1, map);
+ Debug("mgd") << "\ndoing trans proof, got n1 " << n1 << "\n";
+ if(tb == 1) {
+ Debug("mgdx") << "\ntrans proof[0], got n1 " << n1 << "\n";
+ }
+
+ bool identicalEqualities = false;
+ bool evenLengthSequence;
+ Node nodeAfterEqualitySequence;
+
+ for(size_t i = 1; i < pf->d_children.size(); ++i) {
+ std::stringstream ss1(ss.str()), ss2;
+ ss.str("");
+ Node n2 = toStreamRecLFSC(ss2, tp, pf->d_children[i], tb + 1, map);
+
+ // The following branch is dedicated to handling sequences of identical equalities,
+ // i.e. trans[ a=b, a=b, a=b ].
+ //
+ // There are two cases:
+ // 1. The number of equalities is odd. Then, the sequence can be collapsed to just one equality,
+ // i.e. a=b.
+ // 2. The number of equalities is even. Now, we have two options: a=a or b=b. To determine this,
+ // we look at the node after the equality sequence. If it needs a, we go for a=a; and if it needs
+ // b, we go for b=b. If there is no following node, we look at the goal of the transitivity proof,
+ // and use it to determine which option we need.
+ if(n2.getKind() == kind::EQUAL || n2.getKind() == kind::IFF) {
+ if (((n1[0] == n2[0]) && (n1[1] == n2[1])) || ((n1[0] == n2[1]) && (n1[1] == n2[0]))) {
+ // We are in a sequence of identical equalities
+
+ Debug("gk::proof") << "Detected identical equalities: " << std::endl << "\t" << n1 << std::endl;
+
+ if (!identicalEqualities) {
+ // The sequence of identical equalities has started just now
+ identicalEqualities = true;
+
+ Debug("gk::proof") << "The sequence is just beginning. Determining length..." << std::endl;
+
+ // Determine whether the length of this sequence is odd or even.
+ evenLengthSequence = true;
+ bool sequenceOver = false;
+ size_t j = i + 1;
+
+ while (j < pf->d_children.size() && !sequenceOver) {
+ std::stringstream dontCare;
+ nodeAfterEqualitySequence = toStreamRecLFSC(dontCare, tp, pf->d_children[j], tb + 1, map );
+
+ if (((nodeAfterEqualitySequence[0] == n1[0]) && (nodeAfterEqualitySequence[1] == n1[1])) ||
+ ((nodeAfterEqualitySequence[0] == n1[1]) && (nodeAfterEqualitySequence[1] == n1[0]))) {
+ evenLengthSequence = !evenLengthSequence;
+ } else {
+ sequenceOver = true;
+ }
+
+ ++j;
+ }
+
+ if (evenLengthSequence) {
+ // If the length is even, we need to apply transitivity for the "correct" hand of the equality.
+
+ Debug("gk::proof") << "Equality sequence of even length" << std::endl;
+ Debug("gk::proof") << "n1 is: " << n1 << std::endl;
+ Debug("gk::proof") << "n2 is: " << n2 << std::endl;
+ Debug("gk::proof") << "pf-d_node is: " << pf->d_node << std::endl;
+ Debug("gk::proof") << "Next node is: " << nodeAfterEqualitySequence << std::endl;
+
+ ss << "(trans _ _ _ _ ";
+
+ // If the sequence is at the very end of the transitivity proof, use pf->d_node to guide us.
+ if (!sequenceOver) {
+ if (match(n1[0], pf->d_node[0])) {
+ n1 = eqNode(n1[0], n1[0]);
+ ss << ss1.str() << " (symm _ _ _ " << ss1.str() << ")";
+ } else if (match(n1[1], pf->d_node[1])) {
+ n1 = eqNode(n1[1], n1[1]);
+ ss << " (symm _ _ _ " << ss1.str() << ")" << ss1.str();
+ } else {
+ Debug("gk::proof") << "Error: identical equalities over, but hands don't match what we're proving."
+ << std::endl;
+ Assert(false);
+ }
+ } else {
+ // We have a "next node". Use it to guide us.
+
+ Assert(nodeAfterEqualitySequence.getKind() == kind::EQUAL ||
+ nodeAfterEqualitySequence.getKind() == kind::IFF);
+
+ if ((n1[0] == nodeAfterEqualitySequence[0]) || (n1[0] == nodeAfterEqualitySequence[1])) {
+
+ // Eliminate n1[1]
+ ss << ss1.str() << " (symm _ _ _ " << ss1.str() << ")";
+ n1 = eqNode(n1[0], n1[0]);
+
+ } else if ((n1[1] == nodeAfterEqualitySequence[0]) || (n1[1] == nodeAfterEqualitySequence[1])) {
+
+ // Eliminate n1[0]
+ ss << " (symm _ _ _ " << ss1.str() << ")" << ss1.str();
+ n1 = eqNode(n1[1], n1[1]);
+
+ } else {
+ Debug("gk::proof") << "Error: even length sequence, but I don't know which hand to keep!" << std::endl;
+ Assert(false);
+ }
+ }
+
+ ss << ")";
+
+ } else {
+ Debug("gk::proof") << "Equality sequence length is odd!" << std::endl;
+ ss.str(ss1.str());
+ }
+
+ Debug("gk::proof") << "Have proven: " << n1 << std::endl;
+ } else {
+ ss.str(ss1.str());
+ }
+
+ // Ignore the redundancy.
+ continue;
+ }
+ }
+
+ if (identicalEqualities) {
+ // We were in a sequence of identical equalities, but it has now ended. Resume normal operation.
+ identicalEqualities = false;
+ }
+
+ Debug("mgd") << "\ndoing trans proof, got n2 " << n2 << "\n";
+ if(tb == 1) {
+ Debug("mgdx") << "\ntrans proof[" << i << "], got n2 " << n2 << "\n";
+ Debug("mgdx") << (n2.getKind() == kind::EQUAL || n2.getKind() == kind::IFF) << "\n";
+
+ if ((n1.getNumChildren() >= 2) && (n2.getNumChildren() >= 2)) {
+ Debug("mgdx") << n1[0].getId() << " " << n1[1].getId() << " / " << n2[0].getId() << " " << n2[1].getId() << "\n";
+ Debug("mgdx") << n1[0].getId() << " " << n1[0] << "\n";
+ Debug("mgdx") << n1[1].getId() << " " << n1[1] << "\n";
+ Debug("mgdx") << n2[0].getId() << " " << n2[0] << "\n";
+ Debug("mgdx") << n2[1].getId() << " " << n2[1] << "\n";
+ Debug("mgdx") << (n1[0] == n2[0]) << "\n";
+ Debug("mgdx") << (n1[1] == n2[1]) << "\n";
+ Debug("mgdx") << (n1[0] == n2[1]) << "\n";
+ Debug("mgdx") << (n1[1] == n2[0]) << "\n";
+ }
+ }
+ ss << "(trans _ _ _ _ ";
+
+ if((n2.getKind() == kind::EQUAL || n2.getKind() == kind::IFF) &&
+ (n1.getKind() == kind::EQUAL || n1.getKind() == kind::IFF))
+ // Both elements of the transitivity rule are equalities/iffs
+ {
+ if(n1[0] == n2[0]) {
+ if(tb == 1) { Debug("mgdx") << "case 1\n"; }
+ n1 = eqNode(n1[1], n2[1]);
+ ss << "(symm _ _ _ " << ss1.str() << ") " << ss2.str();
+ } else if(n1[1] == n2[1]) {
+ if(tb == 1) { Debug("mgdx") << "case 2\n"; }
+ n1 = eqNode(n1[0], n2[0]);
+ ss << ss1.str() << " (symm _ _ _ " << ss2.str() << ")";
+ } else if(n1[0] == n2[1]) {
+ if(tb == 1) { Debug("mgdx") << "case 3\n"; }
+ n1 = eqNode(n2[0], n1[1]);
+ ss << ss2.str() << " " << ss1.str();
+ if(tb == 1) { Debug("mgdx") << "++ proved " << n1 << "\n"; }
+ } else if(n1[1] == n2[0]) {
+ if(tb == 1) { Debug("mgdx") << "case 4\n"; }
+ n1 = eqNode(n1[0], n2[1]);
+ ss << ss1.str() << " " << ss2.str();
+ } else {
+ Warning() << "\n\ntrans proof failure at step " << i << "\n\n";
+ Warning() << "0 proves " << n1 << "\n";
+ Warning() << "1 proves " << n2 << "\n\n";
+ pf->debug_print("mgdx",0);
+ //toStreamRec(Warning.getStream(), pf, 0);
+ Warning() << "\n\n";
+ Unreachable();
+ }
+ Debug("mgd") << "++ trans proof[" << i << "], now have " << n1 << std::endl;
+ } else if(n1.getKind() == kind::EQUAL || n1.getKind() == kind::IFF) {
+ // n1 is an equality/iff, but n2 is a predicate
+ if(n1[0] == n2) {
+ n1 = n1[1];
+ ss << "(symm _ _ _ " << ss1.str() << ") (pred_eq_t _ " << ss2.str() << ")";
+ } else if(n1[1] == n2) {
+ n1 = n1[0];
+ ss << ss1.str() << " (pred_eq_t _ " << ss2.str() << ")";
+ } else {
+ Unreachable();
+ }
+ } else if(n2.getKind() == kind::EQUAL || n2.getKind() == kind::IFF) {
+ // n2 is an equality/iff, but n1 is a predicate
+ if(n2[0] == n1) {
+ n1 = n2[1];
+ ss << "(symm _ _ _ " << ss2.str() << ") (pred_eq_t _ " << ss1.str() << ")";
+ } else if(n2[1] == n1) {
+ n1 = n2[0];
+ ss << ss2.str() << " (pred_eq_t _ " << ss1.str() << ")";
+ } else {
+ Unreachable();
+ }
+ } else {
+ // Both n1 and n2 are prediacates. Don't know what to do...
+ Unreachable();
+ }
+
+ ss << ")";
+ }
+ out << ss.str();
+ Debug("mgd") << "\n++ trans proof done, have proven " << n1 << std::endl;
+ return n1;
+ }
+
+ case eq::MERGED_ARRAYS_ROW: {
+ Debug("mgd") << "row lemma: " << pf->d_node << std::endl;
+ Assert(pf->d_node.getKind() == kind::EQUAL);
+ TNode t1, t2, t3, t4;
+ Node ret;
+ if(pf->d_node[1].getKind() == kind::SELECT &&
+ pf->d_node[1][0].getKind() == kind::STORE &&
+ pf->d_node[0].getKind() == kind::SELECT &&
+ pf->d_node[0][0] == pf->d_node[1][0][0] &&
+ pf->d_node[0][1] == pf->d_node[1][1]) {
+ t2 = pf->d_node[1][0][1];
+ t3 = pf->d_node[1][1];
+ t1 = pf->d_node[0][0];
+ t4 = pf->d_node[1][0][2];
+ ret = pf->d_node[1].eqNode(pf->d_node[0]);
+ Debug("mgd") << "t1 " << t1 << "\nt2 " << t2 << "\nt3 " << t3 << "\nt4 " << t4 << "\n";
+ } else {
+ Assert(pf->d_node[0].getKind() == kind::SELECT &&
+ pf->d_node[0][0].getKind() == kind::STORE &&
+ pf->d_node[1].getKind() == kind::SELECT &&
+ pf->d_node[1][0] == pf->d_node[0][0][0] &&
+ pf->d_node[1][1] == pf->d_node[0][1]);
+ t2 = pf->d_node[0][0][1];
+ t3 = pf->d_node[0][1];
+ t1 = pf->d_node[1][0];
+ t4 = pf->d_node[0][0][2];
+ ret = pf->d_node;
+ Debug("mgd") << "t1 " << t1 << "\nt2 " << t2 << "\nt3 " << t3 << "\nt4 " << t4 << "\n";
+ }
+ out << "(row _ _ ";
+ tp->printTerm(t2.toExpr(), out, map);
+ out << " ";
+ tp->printTerm(t3.toExpr(), out, map);
+ out << " ";
+ tp->printTerm(t1.toExpr(), out, map);
+ out << " ";
+ tp->printTerm(t4.toExpr(), out, map);
+ out << " " << ProofManager::getLitName(t2.eqNode(t3)) << ")";
+ return ret;
+ }
+
+ case eq::MERGED_ARRAYS_ROW1: {
+ Debug("mgd") << "row1 lemma: " << pf->d_node << std::endl;
+ Assert(pf->d_node.getKind() == kind::EQUAL);
+ TNode t1, t2, t3;
+ Node ret;
+ if(pf->d_node[1].getKind() == kind::SELECT &&
+ pf->d_node[1][0].getKind() == kind::STORE &&
+ pf->d_node[1][0][1] == pf->d_node[1][1] &&
+ pf->d_node[1][0][2] == pf->d_node[0]) {
+ t1 = pf->d_node[1][0][0];
+ t2 = pf->d_node[1][0][1];
+ t3 = pf->d_node[0];
+ ret = pf->d_node[1].eqNode(pf->d_node[0]);
+ Debug("mgd") << "t1 " << t1 << "\nt2 " << t2 << "\nt3 " << t3 << "\n";
+ } else {
+ Assert(pf->d_node[0].getKind() == kind::SELECT &&
+ pf->d_node[0][0].getKind() == kind::STORE &&
+ pf->d_node[0][0][1] == pf->d_node[0][1] &&
+ pf->d_node[0][0][2] == pf->d_node[1]);
+ t1 = pf->d_node[0][0][0];
+ t2 = pf->d_node[0][0][1];
+ t3 = pf->d_node[1];
+ ret = pf->d_node;
+ Debug("mgd") << "t1 " << t1 << "\nt2 " << t2 << "\nt3 " << t3 << "\n";
+ }
+ out << "(row1 _ _ ";
+ tp->printTerm(t1.toExpr(), out, map);
+ out << " ";
+ tp->printTerm(t2.toExpr(), out, map);
+ out << " ";
+ tp->printTerm(t3.toExpr(), out, map);
+ out << ")";
+ return ret;
+ }
+
+ default:
+ Assert(!pf->d_node.isNull());
+ Assert(pf->d_children.empty());
+ Debug("mgd") << "theory proof: " << pf->d_node << " by rule " << int(pf->d_id) << std::endl;
+ AlwaysAssert(false);
+ return pf->d_node;
+ }
+}
+
+UFProof::UFProof(theory::uf::TheoryUF* uf, TheoryProofEngine* pe)
+ : TheoryProof(uf, pe)
+{}
+
+void UFProof::registerTerm(Expr term) {
+ // already registered
+ if (d_declarations.find(term) != d_declarations.end())
+ return;
+
+ Type type = term.getType();
+ if (type.isSort()) {
+ // declare uninterpreted sorts
+ d_sorts.insert(type);
+ }
+
+ if (term.getKind() == kind::APPLY_UF) {
+ Expr function = term.getOperator();
+ d_declarations.insert(function);
+ }
+
+ if (term.isVariable()) {
+ d_declarations.insert(term);
+ }
+
+ // recursively declare all other terms
+ for (unsigned i = 0; i < term.getNumChildren(); ++i) {
+ // could belong to other theories
+ d_proofEngine->registerTerm(term[i]);
+ }
+}
+
+void LFSCUFProof::printTerm(Expr term, std::ostream& os, const LetMap& map) {
+ Assert (Theory::theoryOf(term) == THEORY_UF);
+
+ if (term.getKind() == kind::VARIABLE ||
+ term.getKind() == kind::SKOLEM) {
+ os << term;
+ return;
+ }
+
+ Assert (term.getKind() == kind::APPLY_UF);
+
+ if(term.getType().isBoolean()) {
+ os << "(p_app ";
+ }
+ Expr func = term.getOperator();
+ for (unsigned i = 0; i < term.getNumChildren(); ++i) {
+ os << "(apply _ _ ";
+ }
+ os << func << " ";
+ for (unsigned i = 0; i < term.getNumChildren(); ++i) {
+ printTerm(term[i], os, map);
+ os << ")";
+ }
+ if(term.getType().isBoolean()) {
+ os << ")";
+ }
+}
+
+void LFSCUFProof::printSort(Type type, std::ostream& os) {
+ Assert (type.isSort());
+ os << type <<" ";
+}
+
+void LFSCUFProof::printTheoryLemmaProof(std::vector<Expr>& lemma, std::ostream& os, std::ostream& paren) {
+ os << " ;; UF Theory Lemma \n;;";
+ for (unsigned i = 0; i < lemma.size(); ++i) {
+ os << lemma[i] <<" ";
+ }
+ os <<"\n";
+ //os << " (clausify_false trust)";
+ UFProof::printTheoryLemmaProof( lemma, os, paren );
+}
+
+void LFSCUFProof::printDeclarations(std::ostream& os, std::ostream& paren) {
+ // declaring the sorts
+ for (TypeSet::const_iterator it = d_sorts.begin(); it != d_sorts.end(); ++it) {
+ os << "(% " << *it << " sort\n";
+ paren << ")";
+ }
+
+ // declaring the terms
+ for (ExprSet::const_iterator it = d_declarations.begin(); it != d_declarations.end(); ++it) {
+ Expr term = *it;
+
+ os << "(% " << ProofManager::sanitize(term) << " ";
+ os << "(term ";
+
+ Type type = term.getType();
+ if (type.isFunction()) {
+ std::ostringstream fparen;
+ FunctionType ftype = (FunctionType)type;
+ std::vector<Type> args = ftype.getArgTypes();
+ args.push_back(ftype.getRangeType());
+ os << "(arrow";
+ for (unsigned i = 0; i < args.size(); i++) {
+ Type arg_type = args[i];
+ os << " " << arg_type;
+ if (i < args.size() - 2) {
+ os << " (arrow";
+ fparen << ")";
+ }
+ }
+ os << fparen.str() << "))\n";
+ } else {
+ Assert (term.isVariable());
+ os << type << ")\n";
+ }
+ paren << ")";
+ }
+}
--- /dev/null
+/********************* */
+/*! \file uf_proof.h
+ ** \verbatim
+ ** Original author: Liana Hadarean
+ ** Major contributors: none
+ ** Minor contributors (to current version): none
+ ** This file is part of the CVC4 project.
+ ** Copyright (c) 2009-2014 New York University and The University of Iowa
+ ** See the file COPYING in the top-level source directory for licensing
+ ** information.\endverbatim
+ **
+ ** \brief UF proof
+ **
+ ** UF proof
+ **/
+
+#include "cvc4_private.h"
+
+#ifndef __CVC4__UF__PROOF_H
+#define __CVC4__UF__PROOF_H
+
+#include "expr/expr.h"
+#include "proof/proof_manager.h"
+#include "theory/uf/equality_engine.h"
+
+namespace CVC4 {
+
+//proof object outputted by TheoryUF
+class ProofUF : public Proof {
+private:
+ static Node toStreamRecLFSC(std::ostream& out, TheoryProof * tp, theory::eq::EqProof * pf, unsigned tb, const LetMap& map);
+public:
+ ProofUF( theory::eq::EqProof * pf ) : d_proof( pf ) {}
+ //it is simply an equality engine proof
+ theory::eq::EqProof * d_proof;
+ void toStream(std::ostream& out);
+ static void toStreamLFSC(std::ostream& out, TheoryProof * tp, theory::eq::EqProof * pf, const LetMap& map);
+};
+
+
+namespace theory {
+namespace uf {
+class TheoryUF;
+}
+}
+
+typedef __gnu_cxx::hash_set<Type, TypeHashFunction > TypeSet;
+
+
+class UFProof : public TheoryProof {
+protected:
+ TypeSet d_sorts; // all the uninterpreted sorts in this theory
+ ExprSet d_declarations; // all the variable/function declarations
+
+public:
+ UFProof(theory::uf::TheoryUF* uf, TheoryProofEngine* proofEngine);
+
+ virtual void registerTerm(Expr term);
+};
+
+class LFSCUFProof : public UFProof {
+public:
+ LFSCUFProof(theory::uf::TheoryUF* uf, TheoryProofEngine* proofEngine)
+ : UFProof(uf, proofEngine)
+ {}
+ virtual void printTerm(Expr term, std::ostream& os, const LetMap& map);
+ virtual void printSort(Type type, std::ostream& os);
+ virtual void printTheoryLemmaProof(std::vector<Expr>& lemma, std::ostream& os, std::ostream& paren);
+ virtual void printDeclarations(std::ostream& os, std::ostream& paren);
+};
+
+
+}/* CVC4 namespace */
+
+#endif /* __CVC4__UF__PROOF_H */
#include "prop/bvminisat/bvminisat.h"
#include "prop/bvminisat/simp/SimpSolver.h"
+#include "proof/sat_proof.h"
#include "util/statistics_registry.h"
namespace CVC4 {
d_minisat->setNotify(d_minisatNotify);
}
-void BVMinisatSatSolver::addClause(SatClause& clause, bool removable, uint64_t proof_id) {
+ClauseId BVMinisatSatSolver::addClause(SatClause& clause,
+ bool removable) {
Debug("sat::minisat") << "Add clause " << clause <<"\n";
BVMinisat::vec<BVMinisat::Lit> minisat_clause;
toMinisatClause(clause, minisat_clause);
// for(unsigned i = 0; i < minisat_clause.size(); ++i) {
// d_minisat->setFrozen(BVMinisat::var(minisat_clause[i]), true);
// }
- d_minisat->addClause(minisat_clause);
+ ClauseId clause_id = ClauseIdError;
+ d_minisat->addClause(minisat_clause, clause_id);
+ THEORY_PROOF(Assert (clause_id != ClauseIdError););
+ return clause_id;
}
SatValue BVMinisatSatSolver::propagate() {
d_minisat->popAssumption();
}
+void BVMinisatSatSolver::setProofLog( BitVectorProof * bvp ) {
+ d_minisat->setProofLog( bvp );
+}
+
SatVariable BVMinisatSatSolver::newVar(bool isTheoryAtom, bool preRegister, bool canErase){
return d_minisat->newVar(true, true, !canErase);
}
return result;
}
+bool BVMinisatSatSolver::ok() const {
+ return d_minisat->okay();
+}
+
void BVMinisatSatSolver::getUnsatCore(SatClause& unsatCore) {
// TODO add assertion to check the call was after an unsat call
for (int i = 0; i < d_minisat->conflict.size(); ++i) {
Assert(clause.size() == (unsigned)minisat_clause.size());
}
-void BVMinisatSatSolver::toSatClause(BVMinisat::vec<BVMinisat::Lit>& clause,
- SatClause& sat_clause) {
+void BVMinisatSatSolver::toSatClause(const BVMinisat::Clause& clause,
+ SatClause& sat_clause) {
for (int i = 0; i < clause.size(); ++i) {
sat_clause.push_back(toSatLiteral(clause[i]));
}
} /* namespace CVC4::prop */
} /* namespace CVC4 */
+
+namespace CVC4 {
+template<>
+prop::SatLiteral toSatLiteral< BVMinisat::Solver>(BVMinisat::Solver::TLit lit) {
+ return prop::BVMinisatSatSolver::toSatLiteral(lit);
+}
+
+template<>
+void toSatClause< BVMinisat::Solver> (const BVMinisat::Solver::TClause& minisat_cl,
+ prop::SatClause& sat_cl) {
+ prop::BVMinisatSatSolver::toSatClause(minisat_cl, sat_cl);
+}
+
+}
+
+
}
void notify(BVMinisat::vec<BVMinisat::Lit>& clause) {
SatClause satClause;
- toSatClause(clause, satClause);
+ for (int i = 0; i < clause.size(); ++i) {
+ satClause.push_back(toSatLiteral(clause[i]));
+ }
d_notify->notify(satClause);
}
void setNotify(Notify* notify);
- void addClause(SatClause& clause, bool removable, uint64_t proof_id);
+ ClauseId addClause(SatClause& clause, bool removable);
SatValue propagate();
SatValue solve();
SatValue solve(long unsigned int&);
+ bool ok() const;
void getUnsatCore(SatClause& unsatCore);
SatValue value(SatLiteral l);
static SatValue toSatLiteralValue(BVMinisat::lbool res);
static void toMinisatClause(SatClause& clause, BVMinisat::vec<BVMinisat::Lit>& minisat_clause);
- static void toSatClause (BVMinisat::vec<BVMinisat::Lit>& clause, SatClause& sat_clause);
+ static void toSatClause (const BVMinisat::Clause& clause, SatClause& sat_clause);
void addMarkerLiteral(SatLiteral lit);
void explain(SatLiteral lit, std::vector<SatLiteral>& explanation);
SatValue assertAssumption(SatLiteral lit, bool propagate);
void popAssumption();
+
+ void setProofLog( BitVectorProof * bvp );
private:
/* Disable the default constructor. */
#include "options/bv_options.h"
#include "options/smt_options.h"
#include "theory/interrupted.h"
+#include "proof/proof_manager.h"
+#include "proof/bitvector_proof.h"
+#include "proof/sat_proof.h"
+#include "proof/sat_proof_implementation.h"
#include "util/utility.h"
namespace CVC4 {
static const char* _cat = "CORE";
-// static DoubleOption opt_var_decay (_cat, "var-decay", "The variable activity decay factor", 0.95, DoubleRange(0, false, 1, false));
-// static DoubleOption opt_clause_decay (_cat, "cla-decay", "The clause activity decay factor", 0.999, DoubleRange(0, false, 1, false));
-// static DoubleOption opt_random_var_freq (_cat, "rnd-freq", "The frequency with which the decision heuristic tries to choose a random variable", 0.0, DoubleRange(0, true, 1, true));
-// static DoubleOption opt_random_seed (_cat, "rnd-seed", "Used by the random variable selection", 91648253, DoubleRange(0, false, HUGE_VAL, false));
-// static IntOption opt_ccmin_mode (_cat, "ccmin-mode", "Controls conflict clause minimization (0=none, 1=basic, 2=deep)", 0, IntRange(0, 2));
-// static IntOption opt_phase_saving (_cat, "phase-saving", "Controls the level of phase saving (0=none, 1=limited, 2=full)", 2, IntRange(0, 2));
-// static BoolOption opt_rnd_init_act (_cat, "rnd-init", "Randomize the initial activity", false);
-// static BoolOption opt_luby_restart (_cat, "luby", "Use the Luby restart sequence", true);
-// static IntOption opt_restart_first (_cat, "rfirst", "The base restart interval", 100, IntRange(1, INT32_MAX));
-// static DoubleOption opt_restart_inc (_cat, "rinc", "Restart interval increase factor", 1.5, DoubleRange(1, false, HUGE_VAL, false));
-// static DoubleOption opt_garbage_frac (_cat, "gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered", 0.20, DoubleRange(0, false, HUGE_VAL, false));
-
-
static DoubleOption opt_var_decay (_cat, "var-decay", "The variable activity decay factor", 0.95, DoubleRange(0, false, 1, false));
static DoubleOption opt_clause_decay (_cat, "cla-decay", "The clause activity decay factor", 0.999, DoubleRange(0, false, 1, false));
static DoubleOption opt_random_var_freq (_cat, "rnd-freq", "The frequency with which the decision heuristic tries to choose a random variable", 0, DoubleRange(0, true, 1, true));
static DoubleOption opt_restart_inc (_cat, "rinc", "Restart interval increase factor", 3, DoubleRange(1, false, HUGE_VAL, false));
static DoubleOption opt_garbage_frac (_cat, "gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered", 0.20, DoubleRange(0, false, HUGE_VAL, false));
+//=================================================================================================
+// Proof declarations
+CRef Solver::TCRef_Undef = CRef_Undef;
+CRef Solver::TCRef_Lazy = CRef_Undef - 1; // no real lazy ref here
+
+
//=================================================================================================
// Constructor/Destructor:
, conflict_budget (-1)
, propagation_budget (-1)
, asynch_interrupt (false)
+ , d_bvp (NULL)
{
// Create the constant variables
varTrue = newVar(true, false);
}
-bool Solver::addClause_(vec<Lit>& ps)
+bool Solver::addClause_(vec<Lit>& ps, ClauseId& id)
{
if (decisionLevel() > 0) {
cancelUntil(0);
}
- if (!ok) return false;
+ if (!ok) {
+ id = ClauseIdUndef;
+ return false;
+ }
// Check if clause is satisfied and remove false/duplicate literals:
+ // TODO proof for duplicate literals removal?
sort(ps);
Lit p; int i, j;
- for (i = j = 0, p = lit_Undef; i < ps.size(); i++)
- if (value(ps[i]) == l_True || ps[i] == ~p)
- return true;
- else if (value(ps[i]) != l_False && ps[i] != p)
- ps[j++] = p = ps[i];
+ int falseLiteralsCount = 0;
+
+ for (i = j = 0, p = lit_Undef; i < ps.size(); i++) {
+ // tautologies are ignored
+ if (value(ps[i]) == l_True || ps[i] == ~p) {
+ id = ClauseIdUndef;
+ return true;
+ }
+
+ // Ignore repeated literals
+ if (ps[i] == p) {
+ continue;
+ }
+
+ if (value(ps[i]) == l_False) {
+ if (!THEORY_PROOF_ON())
+ continue;
+ ++falseLiteralsCount;
+ }
+ ps[j++] = p = ps[i];
+ }
+
ps.shrink(i - j);
clause_added = true;
- if (ps.size() == 0)
+ Assert(falseLiteralsCount == 0 || THEORY_PROOF_ON());
+
+ if(falseLiteralsCount == 0) {
+ if (ps.size() == 0) {
+ Assert (!THEORY_PROOF_ON());
return ok = false;
- else if (ps.size() == 1){
+ }
+ else if (ps.size() == 1){
+ if(d_bvp){ id = d_bvp->getSatProof()->registerUnitClause(ps[0], INPUT);}
uncheckedEnqueue(ps[0]);
- return ok = (propagate() == CRef_Undef);
- } else {
+ CRef confl_ref = propagate();
+ ok = (confl_ref == CRef_Undef);
+ if(d_bvp){ if (!ok) d_bvp->getSatProof()->finalizeProof(confl_ref); }
+ return ok;
+ } else {
CRef cr = ca.alloc(ps, false);
clauses.push(cr);
attachClause(cr);
+ if(d_bvp){ id = d_bvp->getSatProof()->registerClause(cr, INPUT);}
+ }
+ return ok;
}
- return ok;
+
+ if (falseLiteralsCount != 0 && THEORY_PROOF_ON()) {
+ // we are in a conflicting state
+ if (ps.size() == falseLiteralsCount && falseLiteralsCount == 1) {
+ if(d_bvp){ id = d_bvp->getSatProof()->storeUnitConflict(ps[0], INPUT); }
+ if(d_bvp){ d_bvp->getSatProof()->finalizeProof(CVC4::BVMinisat::CRef_Lazy); }
+ return ok = false;
+ }
+
+ assign_lt lt(*this);
+ sort(ps, lt);
+
+ CRef cr = ca.alloc(ps, false);
+ clauses.push(cr);
+ attachClause(cr);
+
+ if(d_bvp){id = d_bvp->getSatProof()->registerClause(cr, INPUT);}
+
+ if(ps.size() == falseLiteralsCount) {
+ if(d_bvp){ d_bvp->getSatProof()->finalizeProof(cr); }
+ return ok = false;
+ }
+
+ // Check if it propagates
+ if (ps.size() == falseLiteralsCount + 1) {
+ Clause& cl = ca[cr];
+
+ Assert (value(cl[0]) == l_Undef);
+ uncheckedEnqueue(cl[0], cr);
+ Assert (cl.size() > 1);
+ CRef confl = propagate();
+ ok = (confl == CRef_Undef);
+ if(!ok) {
+ if(d_bvp){
+ if(ca[confl].size() == 1) {
+ id = d_bvp->getSatProof()->storeUnitConflict(ca[confl][0], LEARNT);
+ d_bvp->getSatProof()->finalizeProof(CVC4::BVMinisat::CRef_Lazy);
+ } else {
+ d_bvp->getSatProof()->finalizeProof(confl);
+ }
+ }
+ }
+ }
+ }
+ return ok;
}
void Solver::attachClause(CRef cr) {
void Solver::detachClause(CRef cr, bool strict) {
const Clause& c = ca[cr];
+ if(d_bvp){ d_bvp->getSatProof()->markDeleted(cr); }
+
assert(c.size() > 1);
if (strict){
int index = trail.size() - 1;
bool done = false;
+
+ if(d_bvp){ d_bvp->getSatProof()->startResChain(confl); }
+
do{
assert(confl != CRef_Undef); // (otherwise should be UIP)
Clause& c = ca[confl];
for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){
Lit q = c[j];
- if (!seen[var(q)] && level(var(q)) > 0){
+ if (!seen[var(q)] && level(var(q)) > 0) {
varBumpActivity(var(q));
seen[var(q)] = 1;
if (level(var(q)) >= decisionLevel())
else
out_learnt.push(q);
}
+
+ if (level(var(q)) == 0) {
+ if(d_bvp){ d_bvp->getSatProof()->resolveOutUnit(q); }
+ }
}
// Select next clause to look at:
seen[var(p)] = 0;
pathC--;
+ if ( pathC > 0 && confl != CRef_Undef ) {
+ if(d_bvp){ d_bvp->getSatProof()->addResolutionStep(p, confl, sign(p));}
+ }
+
switch (uip) {
case UIP_FIRST:
done = pathC == 0;
for (i = 1; i < out_learnt.size(); i++)
abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict)
- for (i = j = 1; i < out_learnt.size(); i++)
- if (reason(var(out_learnt[i])) == CRef_Undef || !litRedundant(out_learnt[i], abstract_level))
+ for (i = j = 1; i < out_learnt.size(); i++) {
+ if (reason(var(out_learnt[i])) == CRef_Undef) {
+ out_learnt[j++] = out_learnt[i];
+ } else {
+ // Check if the literal is redundant
+ if (!litRedundant(out_learnt[i], abstract_level)) {
+ // Literal is not redundant
out_learnt[j++] = out_learnt[i];
+ } else {
+ if(d_bvp){ d_bvp->getSatProof()->storeLitRedundant(out_learnt[i]); }
+ }
+ }
+ }
}else if (ccmin_mode == 1){
+ Unreachable();
for (i = j = 1; i < out_learnt.size(); i++){
Var x = var(out_learnt[i]);
analyze_stack.clear(); analyze_stack.push(p);
int top = analyze_toclear.size();
while (analyze_stack.size() > 0){
- assert(reason(var(analyze_stack.last())) != CRef_Undef);
- Clause& c = ca[reason(var(analyze_stack.last()))]; analyze_stack.pop();
+ CRef c_reason = reason(var(analyze_stack.last()));
+ assert(c_reason != CRef_Undef);
+ Clause& c = ca[c_reason];
+ int c_size = c.size();
+ analyze_stack.pop();
- for (int i = 1; i < c.size(); i++){
+ for (int i = 1; i < c_size; i++){
Lit p = c[i];
if (!seen[var(p)] && level(var(p)) > 0){
if (reason(var(p)) != CRef_Undef && (abstractLevel(var(p)) & abstract_levels) != 0){
seen[var(cl[i])] = 1;
}
- for (int i = trail.size() - 1; i >= trail_lim[0]; i--) {
+ int end = options::proof() ? 0 : trail_lim[0];
+ for (int i = trail.size() - 1; i >= end; i--) {
Var x = var(trail[i]);
if (seen[x]) {
if (reason(x) == CRef_Undef) {
// we skip p if was a learnt unit
if (x != var(p)) {
- assert (marker[x] == 2);
- assert (level(x) > 0);
- out_conflict.push(~trail[i]);
+ if (marker[x] == 2) {
+ assert (level(x) > 0);
+ out_conflict.push(~trail[i]);
+ } else {
+ if(d_bvp){d_bvp->getSatProof()->resolveOutUnit(~(trail[i])); }
+ }
+ } else {
+ if(d_bvp){d_bvp->getSatProof()->resolveOutUnit(~p);}
}
} else {
Clause& c = ca[reason(x)];
- for (int j = 1; j < c.size(); j++)
+ if(d_bvp){d_bvp->getSatProof()->addResolutionStep(trail[i],reason(x), sign(trail[i]));}
+
+ for (int j = 1; j < c.size(); j++) {
if (level(var(c[j])) > 0)
seen[var(c[j])] = 1;
+ if(d_bvp){
+ if (level(var(c[j])) == 0) {
+ d_bvp->getSatProof()->resolveOutUnit(c[j]);
+ seen[var(c[j])] = 0; // we don't need to resolve it out again
+ }
+ }
+ }
}
seen[x] = 0;
}
out_conflict.push(p);
}
- if (decisionLevel() == 0)
- return;
+ if(d_bvp){
+ if (level(var(p)) == 0 && d_bvp->isAssumptionConflict()) {
+ Assert ( marker[var(p)] == 2);
+ if (reason(var(p)) == CRef_Undef) {
+ d_bvp->startBVConflict(p);
+ }
+ }
+ }
+
+ if (decisionLevel() == 0 && !options::proof()) {
+ return;
+ }
seen[var(p)] = 1;
-
- for (int i = trail.size()-1; i >= trail_lim[0]; i--){
+ int end = options::proof() ? 0 : trail_lim[0];
+
+ for (int i = trail.size()-1; i >= end; i--){
Var x = var(trail[i]);
if (seen[x]) {
if (reason(x) == CRef_Undef) {
out_conflict.push(~trail[i]);
} else {
Clause& c = ca[reason(x)];
- for (int j = 1; j < c.size(); j++)
- if (level(var(c[j])) > 0)
+ if(d_bvp){
+ if (d_bvp->isAssumptionConflict() &&
+ trail[i] == p) {
+ d_bvp->startBVConflict(reason(x));
+ } else {
+ d_bvp->getSatProof()->addResolutionStep(trail[i], reason(x), sign(trail[i]));
+ }
+ }
+ for (int j = 1; j < c.size(); j++) {
+ if (level(var(c[j])) > 0) {
seen[var(c[j])] = 1;
+ }
+ if(d_bvp){
+ if (level(var(c[j])) == 0) {
+ d_bvp->getSatProof()->resolveOutUnit(c[j]);
+ }
+ }
+ }
}
seen[x] = 0;
}
}
lbool Solver::assertAssumption(Lit p, bool propagate) {
+ // TODO need to somehow mark the assumption as unit in the current context?
+ // it's not always unit though, but this would be useful for debugging
// assert(marker[var(p)] == 1);
+
if (decisionLevel() > assumptions.size()) {
cancelUntil(assumptions.size());
}
if (c->getLevel() > 0) {
assumptions.push(p);
} else {
- if (!addClause(p)) {
+ ClauseId id;
+ if (!addClause(p, id)) {
conflict.push(~p);
return l_False;
}
}
}
+void Solver::addMarkerLiteral(Var var) {
+ // make sure it wasn't already marked
+ Assert(marker[var] == 0);
+ marker[var] = 1;
+ if(d_bvp){d_bvp->getSatProof()->registerAssumption(var);}
+}
+
+
/*_________________________________________________________________________________________________
|
| propagate : [void] -> [Clause*]
int i, j;
for (i = j = 0; i < cs.size(); i++){
Clause& c = ca[cs[i]];
- if (satisfied(c))
+ if (satisfied(c)) {
+ if (locked(c)) {
+ // store a resolution of the literal c propagated
+ if(d_bvp){ d_bvp->getSatProof()->storeUnitResolution(c[0]); }
+ }
removeClause(cs[i]);
+ }
else
cs[j++] = cs[i];
}
if (confl != CRef_Undef){
// CONFLICT
conflicts++; conflictC++;
- if (decisionLevel() == 0) return l_False;
+
+ if (decisionLevel() == 0) {
+ // can this happen for bv?
+ if(d_bvp){ d_bvp->getSatProof()->finalizeProof(confl);}
+ return l_False;
+ }
learnt_clause.clear();
analyze(confl, learnt_clause, backtrack_level, uip);
learnts.push(cr);
attachClause(cr);
claBumpActivity(ca[cr]);
+ if(d_bvp){
+ ClauseId id = d_bvp->getSatProof()->registerClause(cr, LEARNT);
+ PSTATS(
+ __gnu_cxx::hash_set<int> cl_levels;
+ for (int i = 0; i < learnt_clause.size(); ++i) {
+ cl_levels.insert(level(var(learnt_clause[i])));
+ }
+ if( d_bvp ){ d_bvp->getSatProof()->storeClauseGlue(id, cl_levels.size()); }
+ )
+ d_bvp->getSatProof()->endResChain(id);
+ }
}
-
+
+ if (learnt_clause.size() == 1) {
+ // learning a unit clause
+ if(d_bvp){ d_bvp->getSatProof()->endResChain(learnt_clause[0]);}
+ }
+
// if the uip was an assumption we are unsat
if (level(var(p)) <= assumptions.size()) {
for (int i = 0; i < learnt_clause.size(); ++i) {
assert (level(var(learnt_clause[i])) <= decisionLevel());
seen[var(learnt_clause[i])] = 1;
}
+
+ // Starting new resolution chain for bit-vector proof
+ if( d_bvp ){
+ if (cr == CRef_Undef) {
+ d_bvp->startBVConflict(learnt_clause[0]);
+ }
+ else {
+ d_bvp->startBVConflict(cr);
+ }
+ }
analyzeFinal(p, conflict);
+ if(d_bvp){ d_bvp->endBVConflict(conflict); }
Debug("bvminisat::search") << OUTPUT_TAG << " conflict on assumptions " << std::endl;
return l_False;
}
CRef new_confl = propagate();
if (new_confl != CRef_Undef) {
// we have a conflict we now need to explain it
- analyzeFinal2(p, new_confl, conflict);
+ // TODO: proof for analyzeFinal2
+ if(d_bvp){ d_bvp->startBVConflict(new_confl); }
+ analyzeFinal2(p, new_confl, conflict);
+ if(d_bvp){ d_bvp->endBVConflict(conflict); }
return l_False;
}
}
newDecisionLevel();
}else if (value(p) == l_False){
marker[var(p)] = 2;
+
+ if(d_bvp){ d_bvp->markAssumptionConflict(); }
analyzeFinal(~p, conflict);
+ if(d_bvp){ d_bvp->endBVConflict(conflict); }
Debug("bvminisat::search") << OUTPUT_TAG << " assumption false, we're unsat" << std::endl;
return l_False;
}else{
//
void Solver::explain(Lit p, std::vector<Lit>& explanation) {
- vec<Lit> queue;
- queue.push(p);
-
Debug("bvminisat::explain") << OUTPUT_TAG << "starting explain of " << p << std::endl;
- __gnu_cxx::hash_set<Var> visited;
- visited.insert(var(p));
+ // top level fact, no explanation necessary
+ if (level(var(p)) == 0) {
+ if(d_bvp){
+ // the only way a marker variable is
+ if (reason(var(p)) == CRef_Undef) {
+ d_bvp->startBVConflict(p);
+ vec<Lit> confl;
+ confl.push(p);
+ d_bvp->endBVConflict(confl);
+ return;
+ }
+ }
+ if (!THEORY_PROOF_ON())
+ return;
+ }
- while(queue.size() > 0) {
- Lit l = queue.last();
-
- Debug("bvminisat::explain") << OUTPUT_TAG << "processing " << l << std::endl;
-
- assert(value(l) == l_True);
- queue.pop();
- if (reason(var(l)) == CRef_Undef) {
- if (level(var(l)) == 0) continue;
- Assert(marker[var(l)] == 2);
- explanation.push_back(l);
- visited.insert(var(l));
- } else {
- Clause& c = ca[reason(var(l))];
- for (int i = 1; i < c.size(); ++i) {
- if (level(var(c[i])) > 0 && visited.count(var(c[i])) == 0) {
- queue.push(~c[i]);
- visited.insert(var(c[i]));
+ seen[var(p)] = 1;
+
+ // if we are called at decisionLevel = 0 trail_lim is empty
+ int bottom = options::proof() ? 0 : trail_lim[0];
+ for (int i = trail.size()-1; i >= bottom; i--){
+ Var x = var(trail[i]);
+ if (seen[x]) {
+ if (reason(x) == CRef_Undef) {
+ if (marker[x] == 2) {
+ assert(level(x) > 0);
+ explanation.push_back(trail[i]);
+ } else {
+ Assert (level(x) == 0);
+ if(d_bvp){ d_bvp->getSatProof()->resolveOutUnit(~(trail[i])); }
+ }
+
+ } else {
+ Clause& c = ca[reason(x)];
+ if(d_bvp){
+ if (p == trail[i]) {
+ d_bvp->startBVConflict(reason(var(p)));
+ } else {
+ d_bvp->getSatProof()->addResolutionStep(trail[i], reason(x), sign(trail[i]));
+ }
+ }
+ for (int j = 1; j < c.size(); j++) {
+ if (level(var(c[j])) > 0 || options::proof()) {
+ seen[var(c[j])] = 1;
+ }
}
}
+ seen[x] = 0;
}
}
+ seen[var(p)] = 0;
+
+ if(d_bvp){
+ vec<Lit> conflict_clause;
+ conflict_clause.push(p);
+ for(unsigned i = 0; i < explanation.size(); ++i) {
+ conflict_clause.push(~explanation[i]);
+ }
+ d_bvp->endBVConflict(conflict_clause);
+ }
}
-
+void Solver::setProofLog( BitVectorProof * bvp ) {
+ d_bvp = bvp;
+ d_bvp->initSatProof(this);
+ d_bvp->getSatProof()->registerTrueLit(mkLit(varTrue, false));
+ d_bvp->getSatProof()->registerFalseLit(mkLit(varFalse, true));
+}
//=================================================================================================
// Writing CNF to DIMACS:
// printf(" >>> RELOCING: %s%d\n", sign(p)?"-":"", var(p)+1);
vec<Watcher>& ws = watches[p];
for (int j = 0; j < ws.size(); j++)
- ca.reloc(ws[j].cref, to);
+ ca.reloc(ws[j].cref, to, d_bvp ? d_bvp->getSatProof()->getProxy() : NULL);
}
// All reasons:
Var v = var(trail[i]);
if (reason(v) != CRef_Undef && (ca[reason(v)].reloced() || locked(ca[reason(v)])))
- ca.reloc(vardata[v].reason, to);
+ ca.reloc(vardata[v].reason, to, d_bvp ? d_bvp->getSatProof()->getProxy() : NULL);
}
// All learnt:
//
for (int i = 0; i < learnts.size(); i++)
- ca.reloc(learnts[i], to);
+ ca.reloc(learnts[i], to, d_bvp ? d_bvp->getSatProof()->getProxy() : NULL);
// All original:
//
for (int i = 0; i < clauses.size(); i++)
- ca.reloc(clauses[i], to);
+ ca.reloc(clauses[i], to, d_bvp ? d_bvp->getSatProof()->getProxy() : NULL);
+
+ if(d_bvp){ d_bvp->getSatProof()->finishUpdateCRef(); }
}
to.moveTo(ca);
}
+void ClauseAllocator::reloc(CRef& cr, ClauseAllocator& to, CVC4::BVProofProxy* proxy)
+{
+ CRef old = cr; // save the old reference
+
+ Clause& c = operator[](cr);
+ if (c.reloced()) { cr = c.relocation(); return; }
+
+ cr = to.alloc(c, c.learnt());
+ c.relocate(cr);
+ if (proxy) {
+ proxy->updateCRef(old, cr);
+ }
+
+ // Copy extra data-fields:
+ // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
+ to[cr].mark(c.mark());
+ if (to[cr].learnt()) to[cr].activity() = c.activity();
+ else if (to[cr].has_extra()) to[cr].calcAbstraction();
+}
+
} /* CVC4::BVMinisat namespace */
} /* CVC4 namespace */
#include "prop/bvminisat/mtl/Heap.h"
#include "prop/bvminisat/mtl/Alg.h"
#include "prop/bvminisat/utils/Options.h"
-
#include "context/cdhashmap.h"
+#include "proof/sat_proof.h"
#include <ext/hash_set>
#include <vector>
namespace CVC4 {
+
+typedef unsigned ClauseId;
+namespace BVMinisat {
+class Solver;
+}
+
+class BitVectorProof;
+
namespace BVMinisat {
/** Interface for minisat callbacks */
//=================================================================================================
// Solver -- the main class:
class Solver {
-
+ friend class CVC4::TSatProof< CVC4::BVMinisat::Solver>;
+public:
+ typedef Var TVar;
+ typedef Lit TLit;
+ typedef Clause TClause;
+ typedef CRef TCRef;
+ typedef vec<Lit> TLitVec;
+
+ static CRef TCRef_Undef;
+ static CRef TCRef_Lazy;
+private:
/** To notify */
Notify* notify;
Var falseVar() const { return varFalse; }
- bool addClause (const vec<Lit>& ps); // Add a clause to the solver.
+ bool addClause (const vec<Lit>& ps, ClauseId& id); // Add a clause to the solver.
bool addEmptyClause(); // Add the empty clause, making the solver contradictory.
- bool addClause (Lit p); // Add a unit clause to the solver.
- bool addClause (Lit p, Lit q); // Add a binary clause to the solver.
- bool addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
- bool addClause_( vec<Lit>& ps); // Add a clause to the solver without making superflous internal copy. Will
+ bool addClause (Lit p, ClauseId& id); // Add a unit clause to the solver.
+ bool addClause (Lit p, Lit q, ClauseId& id); // Add a binary clause to the solver.
+ bool addClause (Lit p, Lit q, Lit r, ClauseId& id); // Add a ternary clause to the solver.
+ bool addClause_( vec<Lit>& ps, ClauseId& id); // Add a clause to the solver without making superflous internal copy. Will
// change the passed vector 'ps'.
// Solving:
// Bitvector Propagations
//
- void addMarkerLiteral(Var var) {
- // make sure it wasn't already marked
- Assert(marker[var] == 0);
- marker[var] = 1;
- }
+ void addMarkerLiteral(Var var);
bool need_to_propagate; // true if we added new clauses, set to true in propagation
bool only_bcp; // solving mode in which only boolean constraint propagation is done
void setOnlyBCP (bool val) { only_bcp = val;}
void explain(Lit l, std::vector<Lit>& explanation);
+
+ void setProofLog( CVC4::BitVectorProof * bvp );
protected:
int64_t conflict_budget; // -1 means no budget.
int64_t propagation_budget; // -1 means no budget.
bool asynch_interrupt;
+
+ //proof log
+ CVC4::BitVectorProof * d_bvp;
// Main internal methods:
//
// Returns a random integer 0 <= x < size. Seed must never be 0.
static inline int irand(double& seed, int size) {
return (int)(drand(seed) * size); }
+
+ // Less than for literals in an added clause when proofs are on.
+ struct assign_lt {
+ Solver& solver;
+ assign_lt(Solver& solver) : solver(solver) {}
+ bool operator () (Lit x, Lit y) {
+ lbool x_value = solver.value(x);
+ lbool y_value = solver.value(y);
+ // Two unassigned literals are sorted arbitrarily
+ if (x_value == l_Undef && y_value == l_Undef) {
+ return x < y;
+ }
+ // Unassigned literals are put to front
+ if (x_value == l_Undef) return true;
+ if (y_value == l_Undef) return false;
+ // Literals of the same value are sorted by decreasing levels
+ if (x_value == y_value) {
+ return solver.level(var(x)) > solver.level(var(y));
+ } else {
+ // True literals go up front
+ if (x_value == l_True) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ }
+ };
+
};
// NOTE: enqueue does not set the ok flag! (only public methods do)
inline bool Solver::enqueue (Lit p, CRef from) { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); }
-inline bool Solver::addClause (const vec<Lit>& ps) { ps.copyTo(add_tmp); return addClause_(add_tmp); }
-inline bool Solver::addEmptyClause () { add_tmp.clear(); return addClause_(add_tmp); }
-inline bool Solver::addClause (Lit p) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
-inline bool Solver::addClause (Lit p, Lit q) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
-inline bool Solver::addClause (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline bool Solver::addClause (const vec<Lit>& ps, ClauseId& id) { ps.copyTo(add_tmp); return addClause_(add_tmp, id); }
+inline bool Solver::addEmptyClause () { add_tmp.clear(); ClauseId tmp; return addClause_(add_tmp, tmp); }
+inline bool Solver::addClause (Lit p, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp, id); }
+inline bool Solver::addClause (Lit p, Lit q, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp, id); }
+inline bool Solver::addClause (Lit p, Lit q, Lit r, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp, id); }
inline bool Solver::locked (const Clause& c) const { return value(c[0]) == l_True && reason(var(c[0])) != CRef_Undef && ca.lea(reason(var(c[0]))) == &c; }
inline void Solver::newDecisionLevel() { trail_lim.push(trail.size()); }
#include "prop/bvminisat/mtl/Alloc.h"
namespace CVC4 {
+namespace BVMinisat {
+class Solver;
+}
+template <class Solver> class ProofProxy;
+typedef ProofProxy<BVMinisat::Solver> BVProofProxy;
+}
+
+namespace CVC4 {
+
namespace BVMinisat {
//=================================================================================================
const CRef CRef_Undef = RegionAllocator<uint32_t>::Ref_Undef;
+const CRef CRef_Lazy = RegionAllocator<uint32_t>::Ref_Undef - 1;
+
class ClauseAllocator : public RegionAllocator<uint32_t>
{
static int clauseWord32Size(int size, bool has_extra){
RegionAllocator<uint32_t>::free(clauseWord32Size(c.size(), c.has_extra()));
}
- void reloc(CRef& cr, ClauseAllocator& to)
- {
- Clause& c = operator[](cr);
-
- if (c.reloced()) { cr = c.relocation(); return; }
-
- cr = to.alloc(c, c.learnt());
- c.relocate(cr);
-
- // Copy extra data-fields:
- // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
- to[cr].mark(c.mark());
- if (to[cr].learnt()) to[cr].activity() = c.activity();
- else if (to[cr].has_extra()) to[cr].calcAbstraction();
- }
+ void reloc(CRef& cr, ClauseAllocator& to, CVC4::BVProofProxy* proxy = NULL);
};
#include "options/bv_options.h"
#include "options/smt_options.h"
#include "utils/System.h"
+#include "proof/proof.h"
namespace CVC4 {
namespace BVMinisat {
, asymm_lits (0)
, eliminated_vars (0)
, elimorder (1)
- , use_simplification (true)
+ , use_simplification (!PROOF_ON())
, occurs (ClauseDeleted(ca))
, elim_heap (ElimLt(n_occ))
, bwdsub_assigns (0)
-bool SimpSolver::addClause_(vec<Lit>& ps)
+bool SimpSolver::addClause_(vec<Lit>& ps, ClauseId& id)
{
#ifndef NDEBUG
for (int i = 0; i < ps.size(); i++)
if (use_rcheck && implied(ps))
return true;
- if (!Solver::addClause_(ps))
+ if (!Solver::addClause_(ps, id))
return false;
if (use_simplification && clauses.size() == nclauses + 1){
// Produce clauses in cross product:
vec<Lit>& resolvent = add_tmp;
for (int i = 0; i < pos.size(); i++)
- for (int j = 0; j < neg.size(); j++)
- if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addClause_(resolvent))
- return false;
+ for (int j = 0; j < neg.size(); j++) {
+ ClauseId id = -1;
+ if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) &&
+ !addClause_(resolvent, id))
+ return false;
+ }
// Free occurs list for this variable:
occurs[v].clear(true);
}
removeClause(cls[i]);
-
- if (!addClause_(subst_clause))
+ ClauseId id;
+ if (!addClause_(subst_clause, id))
return ok = false;
}
// Problem specification:
//
Var newVar (bool polarity = true, bool dvar = true, bool freeze = false);
- bool addClause (const vec<Lit>& ps);
+ bool addClause (const vec<Lit>& ps, ClauseId& id);
bool addEmptyClause(); // Add the empty clause to the solver.
- bool addClause (Lit p); // Add a unit clause to the solver.
- bool addClause (Lit p, Lit q); // Add a binary clause to the solver.
- bool addClause (Lit p, Lit q, Lit r); // Add a ternary clause to the solver.
- bool addClause_( vec<Lit>& ps);
+ bool addClause (Lit p, ClauseId& id); // Add a unit clause to the solver.
+ bool addClause (Lit p, Lit q, ClauseId& id); // Add a binary clause to the solver.
+ bool addClause (Lit p, Lit q, Lit r, ClauseId& id); // Add a ternary clause to the solver.
+ bool addClause_( vec<Lit>& ps, ClauseId& id);
bool substitute(Var v, Lit x); // Replace all occurences of v with x (may cause a contradiction).
// Variable mode:
elim_heap.update(v); }
-inline bool SimpSolver::addClause (const vec<Lit>& ps) { ps.copyTo(add_tmp); return addClause_(add_tmp); }
-inline bool SimpSolver::addEmptyClause() { add_tmp.clear(); return addClause_(add_tmp); }
-inline bool SimpSolver::addClause (Lit p) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp); }
-inline bool SimpSolver::addClause (Lit p, Lit q) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp); }
-inline bool SimpSolver::addClause (Lit p, Lit q, Lit r) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp); }
+inline bool SimpSolver::addClause (const vec<Lit>& ps, ClauseId& id) { ps.copyTo(add_tmp); return addClause_(add_tmp, id); }
+inline bool SimpSolver::addEmptyClause() { add_tmp.clear(); ClauseId id; return addClause_(add_tmp, id); }
+inline bool SimpSolver::addClause (Lit p, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp, id); }
+inline bool SimpSolver::addClause (Lit p, Lit q, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp, id); }
+inline bool SimpSolver::addClause (Lit p, Lit q, Lit r, ClauseId& id) { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp, id); }
inline void SimpSolver::setFrozen (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } }
inline lbool SimpSolver::solve ( bool do_simp, bool turn_off_simp) {
#include "options/bv_options.h"
#include "proof/proof_manager.h"
#include "proof/sat_proof.h"
+#include "proof/cnf_proof.h"
#include "prop/cnf_stream.h"
#include "prop/minisat/minisat.h"
#include "prop/prop_engine.h"
CnfStream::CnfStream(SatSolver* satSolver, Registrar* registrar,
context::Context* context, SmtGlobals* globals,
- bool fullLitToNodeMap)
+ bool fullLitToNodeMap, std::string name)
: d_satSolver(satSolver),
d_booleanVariables(context),
d_nodeToLiteralMap(context),
d_fullLitToNodeMap(fullLitToNodeMap),
d_convertAndAssertCounter(0),
d_registrar(registrar),
- d_assertionTable(context),
+ d_name(name),
+ d_cnfProof(NULL),
d_globals(globals),
d_removable(false) {
}
TseitinCnfStream::TseitinCnfStream(SatSolver* satSolver, Registrar* registrar,
context::Context* context,
- SmtGlobals* globals, bool fullLitToNodeMap)
- : CnfStream(satSolver, registrar, context, globals, fullLitToNodeMap)
+ SmtGlobals* globals, bool fullLitToNodeMap,
+ std::string name)
+ : CnfStream(satSolver, registrar, context, globals, fullLitToNodeMap, name)
{}
-void CnfStream::assertClause(TNode node, SatClause& c, ProofRule proof_id) {
- Debug("cnf") << "Inserting into stream " << c << " node = " << node << ", proof id = " << proof_id << endl;
+void CnfStream::assertClause(TNode node, SatClause& c) {
+ Debug("cnf") << "Inserting into stream " << c << " node = " << node << endl;
if(Dump.isOn("clauses")) {
if(c.size() == 1) {
Dump("clauses") << AssertCommand(Expr(getNode(c[0]).toExpr()));
Dump("clauses") << AssertCommand(Expr(n.toExpr()));
}
}
- //store map between clause and original formula
- PROOF(ProofManager::currentPM()->setRegisteringFormula( node, proof_id ); );
- d_satSolver->addClause(c, d_removable, d_proofId);
- PROOF(ProofManager::currentPM()->setRegisteringFormula( Node::null(), RULE_INVALID ); );
+
+ PROOF(if (d_cnfProof) d_cnfProof->pushCurrentDefinition(node););
+
+ ClauseId clause_id = d_satSolver->addClause(c, d_removable);
+ if (clause_id == ClauseIdUndef) return; // nothing to store (no clause was added)
+
+ PROOF
+ (
+ if (d_cnfProof) {
+ Assert (clause_id != ClauseIdError);
+ d_cnfProof->registerConvertedClause(clause_id);
+ d_cnfProof->popCurrentDefinition();
+ }
+ );
}
-void CnfStream::assertClause(TNode node, SatLiteral a, ProofRule proof_id) {
+void CnfStream::assertClause(TNode node, SatLiteral a) {
SatClause clause(1);
clause[0] = a;
- assertClause(node, clause, proof_id);
+ assertClause(node, clause);
}
-void CnfStream::assertClause(TNode node, SatLiteral a, SatLiteral b, ProofRule proof_id) {
+void CnfStream::assertClause(TNode node, SatLiteral a, SatLiteral b) {
SatClause clause(2);
clause[0] = a;
clause[1] = b;
- assertClause(node, clause, proof_id);
+ assertClause(node, clause);
}
-void CnfStream::assertClause(TNode node, SatLiteral a, SatLiteral b, SatLiteral c, ProofRule proof_id) {
+void CnfStream::assertClause(TNode node, SatLiteral a, SatLiteral b, SatLiteral c) {
SatClause clause(3);
clause[0] = a;
clause[1] = b;
clause[2] = c;
- assertClause(node, clause, proof_id);
+ assertClause(node, clause);
}
bool CnfStream::hasLiteral(TNode n) const {
void TseitinCnfStream::ensureLiteral(TNode n) {
// These are not removable and have no proof ID
d_removable = false;
- d_proofId = uint64_t(-1);
Debug("cnf") << "ensureLiteral(" << n << ")" << endl;
if(hasLiteral(n)) {
}
SatLiteral CnfStream::newLiteral(TNode node, bool isTheoryAtom, bool preRegister, bool canEliminate) {
- Debug("cnf") << "newLiteral(" << node << ", " << isTheoryAtom << ")" << endl;
+ Debug("cnf") << d_name << "::newLiteral(" << node << ", " << isTheoryAtom << ")" << endl;
Assert(node.getKind() != kind::NOT);
// Get the literal for this node
if (preRegister) {
// In case we are re-entered due to lemmas, save our state
bool backupRemovable = d_removable;
- uint64_t backupProofId= d_proofId;
+ // Should be fine since cnfProof current assertion is stack based.
d_registrar->preRegister(node);
d_removable = backupRemovable;
- d_proofId = backupProofId;
}
// Here, you can have it
}
}
+void CnfStream::setProof(CnfProof* proof) {
+ Assert (d_cnfProof == NULL);
+ d_cnfProof = proof;
+}
+
SatLiteral CnfStream::convertAtom(TNode node) {
Debug("cnf") << "convertAtom(" << node << ")" << endl;
SatLiteral xorLit = newLiteral(xorNode);
- assertClause(xorNode.negate(), a, b, ~xorLit, RULE_TSEITIN);
- assertClause(xorNode.negate(), ~a, ~b, ~xorLit, RULE_TSEITIN);
- assertClause(xorNode, a, ~b, xorLit, RULE_TSEITIN);
- assertClause(xorNode, ~a, b, xorLit, RULE_TSEITIN);
+ assertClause(xorNode.negate(), a, b, ~xorLit);
+ assertClause(xorNode.negate(), ~a, ~b, ~xorLit);
+ assertClause(xorNode, a, ~b, xorLit);
+ assertClause(xorNode, ~a, b, xorLit);
return xorLit;
}
// lit | ~(a_1 | a_2 | a_3 | ... | a_n)
// (lit | ~a_1) & (lit | ~a_2) & (lit & ~a_3) & ... & (lit & ~a_n)
for(unsigned i = 0; i < n_children; ++i) {
- assertClause(orNode, orLit, ~clause[i], RULE_TSEITIN);
+ assertClause(orNode, orLit, ~clause[i]);
}
// lit -> (a_1 | a_2 | a_3 | ... | a_n)
// ~lit | a_1 | a_2 | a_3 | ... | a_n
clause[n_children] = ~orLit;
// This needs to go last, as the clause might get modified by the SAT solver
- assertClause(orNode.negate(), clause, RULE_TSEITIN);
+ assertClause(orNode.negate(), clause);
// Return the literal
return orLit;
// ~lit | (a_1 & a_2 & a_3 & ... & a_n)
// (~lit | a_1) & (~lit | a_2) & ... & (~lit | a_n)
for(unsigned i = 0; i < n_children; ++i) {
- assertClause(andNode.negate(), ~andLit, ~clause[i], RULE_TSEITIN);
+ assertClause(andNode.negate(), ~andLit, ~clause[i]);
}
// lit <- (a_1 & a_2 & a_3 & ... a_n)
// lit | ~a_1 | ~a_2 | ~a_3 | ... | ~a_n
clause[n_children] = andLit;
// This needs to go last, as the clause might get modified by the SAT solver
- assertClause(andNode, clause, RULE_TSEITIN);
+ assertClause(andNode, clause);
return andLit;
}
// lit -> (a->b)
// ~lit | ~ a | b
- assertClause(impliesNode.negate(), ~impliesLit, ~a, b, RULE_TSEITIN);
+ assertClause(impliesNode.negate(), ~impliesLit, ~a, b);
// (a->b) -> lit
// ~(~a | b) | lit
// (a | l) & (~b | l)
- assertClause(impliesNode, a, impliesLit, RULE_TSEITIN);
- assertClause(impliesNode, ~b, impliesLit, RULE_TSEITIN);
+ assertClause(impliesNode, a, impliesLit);
+ assertClause(impliesNode, ~b, impliesLit);
return impliesLit;
}
// lit -> ((a-> b) & (b->a))
// ~lit | ((~a | b) & (~b | a))
// (~a | b | ~lit) & (~b | a | ~lit)
- assertClause(iffNode.negate(), ~a, b, ~iffLit, RULE_TSEITIN);
- assertClause(iffNode.negate(), a, ~b, ~iffLit, RULE_TSEITIN);
+ assertClause(iffNode.negate(), ~a, b, ~iffLit);
+ assertClause(iffNode.negate(), a, ~b, ~iffLit);
// (a<->b) -> lit
// ~((a & b) | (~a & ~b)) | lit
// (~(a & b)) & (~(~a & ~b)) | lit
// ((~a | ~b) & (a | b)) | lit
// (~a | ~b | lit) & (a | b | lit)
- assertClause(iffNode, ~a, ~b, iffLit, RULE_TSEITIN);
- assertClause(iffNode, a, b, iffLit, RULE_TSEITIN);
+ assertClause(iffNode, ~a, ~b, iffLit);
+ assertClause(iffNode, a, b, iffLit);
return iffLit;
}
// lit -> (t | e) & (b -> t) & (!b -> e)
// lit -> (t | e) & (!b | t) & (b | e)
// (!lit | t | e) & (!lit | !b | t) & (!lit | b | e)
- assertClause(iteNode.negate(), ~iteLit, thenLit, elseLit, RULE_TSEITIN);
- assertClause(iteNode.negate(), ~iteLit, ~condLit, thenLit, RULE_TSEITIN);
- assertClause(iteNode.negate(), ~iteLit, condLit, elseLit, RULE_TSEITIN);
+ assertClause(iteNode.negate(), ~iteLit, thenLit, elseLit);
+ assertClause(iteNode.negate(), ~iteLit, ~condLit, thenLit);
+ assertClause(iteNode.negate(), ~iteLit, condLit, elseLit);
// If ITE is false then one of the branches is false and the condition
// implies which one
// !lit -> (!t | !e) & (b -> !t) & (!b -> !e)
// !lit -> (!t | !e) & (!b | !t) & (b | !e)
// (lit | !t | !e) & (lit | !b | !t) & (lit | b | !e)
- assertClause(iteNode, iteLit, ~thenLit, ~elseLit, RULE_TSEITIN);
- assertClause(iteNode, iteLit, ~condLit, ~thenLit, RULE_TSEITIN);
- assertClause(iteNode, iteLit, condLit, ~elseLit, RULE_TSEITIN);
+ assertClause(iteNode, iteLit, ~thenLit, ~elseLit);
+ assertClause(iteNode, iteLit, ~condLit, ~thenLit);
+ assertClause(iteNode, iteLit, condLit, ~elseLit);
return iteLit;
}
else return ~nodeLit;
}
-void TseitinCnfStream::convertAndAssertAnd(TNode node, bool negated, ProofRule proof_id) {
+void TseitinCnfStream::convertAndAssertAnd(TNode node, bool negated) {
Assert(node.getKind() == AND);
if (!negated) {
// If the node is a conjunction, we handle each conjunct separately
for(TNode::const_iterator conjunct = node.begin(), node_end = node.end();
conjunct != node_end; ++conjunct ) {
- PROOF(ProofManager::currentPM()->setCnfDep( (*conjunct).toExpr(), node.toExpr() ) );
- convertAndAssert(*conjunct, false, proof_id);
+ PROOF(if (d_cnfProof) d_cnfProof->setCnfDependence(*conjunct, node););
+ convertAndAssert(*conjunct, false);
}
} else {
// If the node is a disjunction, we construct a clause and assert it
clause[i] = toCNF(*disjunct, true);
}
Assert(disjunct == node.end());
- assertClause(node.negate(), clause, proof_id);
+ assertClause(node.negate(), clause);
}
}
-void TseitinCnfStream::convertAndAssertOr(TNode node, bool negated, ProofRule proof_id) {
+void TseitinCnfStream::convertAndAssertOr(TNode node, bool negated) {
Assert(node.getKind() == OR);
if (!negated) {
// If the node is a disjunction, we construct a clause and assert it
clause[i] = toCNF(*disjunct, false);
}
Assert(disjunct == node.end());
- assertClause(node, clause, proof_id);
+ assertClause(node, clause);
} else {
// If the node is a conjunction, we handle each conjunct separately
for(TNode::const_iterator conjunct = node.begin(), node_end = node.end();
conjunct != node_end; ++conjunct ) {
- PROOF(ProofManager::currentPM()->setCnfDep( (*conjunct).negate().toExpr(), node.negate().toExpr() ) );
- convertAndAssert(*conjunct, true, proof_id);
+ PROOF(if (d_cnfProof) d_cnfProof->setCnfDependence((*conjunct).negate(), node.negate()););
+ convertAndAssert(*conjunct, true);
}
}
}
-void TseitinCnfStream::convertAndAssertXor(TNode node, bool negated, ProofRule proof_id) {
+void TseitinCnfStream::convertAndAssertXor(TNode node, bool negated) {
if (!negated) {
// p XOR q
SatLiteral p = toCNF(node[0], false);
SatClause clause1(2);
clause1[0] = ~p;
clause1[1] = ~q;
- assertClause(node, clause1, proof_id);
+ assertClause(node, clause1);
SatClause clause2(2);
clause2[0] = p;
clause2[1] = q;
- assertClause(node, clause2, proof_id);
+ assertClause(node, clause2);
} else {
// !(p XOR q) is the same as p <=> q
SatLiteral p = toCNF(node[0], false);
SatClause clause1(2);
clause1[0] = ~p;
clause1[1] = q;
- assertClause(node.negate(), clause1, proof_id);
+ assertClause(node.negate(), clause1);
SatClause clause2(2);
clause2[0] = p;
clause2[1] = ~q;
- assertClause(node.negate(), clause2, proof_id);
+ assertClause(node.negate(), clause2);
}
}
-void TseitinCnfStream::convertAndAssertIff(TNode node, bool negated, ProofRule proof_id) {
+void TseitinCnfStream::convertAndAssertIff(TNode node, bool negated) {
if (!negated) {
// p <=> q
SatLiteral p = toCNF(node[0], false);
SatClause clause1(2);
clause1[0] = ~p;
clause1[1] = q;
- assertClause(node, clause1, proof_id);
+ assertClause(node, clause1);
SatClause clause2(2);
clause2[0] = p;
clause2[1] = ~q;
- assertClause(node, clause2, proof_id);
+ assertClause(node, clause2);
} else {
// !(p <=> q) is the same as p XOR q
SatLiteral p = toCNF(node[0], false);
SatClause clause1(2);
clause1[0] = ~p;
clause1[1] = ~q;
- assertClause(node.negate(), clause1, proof_id);
+ assertClause(node.negate(), clause1);
SatClause clause2(2);
clause2[0] = p;
clause2[1] = q;
- assertClause(node.negate(), clause2, proof_id);
+ assertClause(node.negate(), clause2);
}
}
-void TseitinCnfStream::convertAndAssertImplies(TNode node, bool negated, ProofRule proof_id) {
+void TseitinCnfStream::convertAndAssertImplies(TNode node, bool negated) {
if (!negated) {
// p => q
SatLiteral p = toCNF(node[0], false);
SatClause clause(2);
clause[0] = ~p;
clause[1] = q;
- assertClause(node, clause, proof_id);
+ assertClause(node, clause);
} else {// Construct the
- PROOF(ProofManager::currentPM()->setCnfDep( node[0].toExpr(), node.negate().toExpr() ) );
- PROOF(ProofManager::currentPM()->setCnfDep( node[1].negate().toExpr(), node.negate().toExpr() ) );
+ PROOF(if (d_cnfProof) d_cnfProof->setCnfDependence(node[0], node.negate()););
+ PROOF(if (d_cnfProof) d_cnfProof->setCnfDependence(node[1].negate(), node.negate()););
// !(p => q) is the same as (p && ~q)
- convertAndAssert(node[0], false, proof_id);
- convertAndAssert(node[1], true, proof_id);
+ convertAndAssert(node[0], false);
+ convertAndAssert(node[1], true);
}
}
-void TseitinCnfStream::convertAndAssertIte(TNode node, bool negated, ProofRule proof_id) {
+void TseitinCnfStream::convertAndAssertIte(TNode node, bool negated) {
// ITE(p, q, r)
SatLiteral p = toCNF(node[0], false);
SatLiteral q = toCNF(node[1], negated);
SatClause clause1(2);
clause1[0] = ~p;
clause1[1] = q;
- assertClause(nnode, clause1, proof_id);
+ assertClause(nnode, clause1);
SatClause clause2(2);
clause2[0] = p;
clause2[1] = r;
- assertClause(nnode, clause2, proof_id);
+ assertClause(nnode, clause2);
}
// At the top level we must ensure that all clauses that are asserted are
// not unit, except for the direct assertions. This allows us to remove the
// clauses later when they are not needed anymore (lemmas for example).
-void TseitinCnfStream::convertAndAssert(TNode node, bool removable, bool negated, ProofRule proof_id, TNode from) {
- Debug("cnf") << "convertAndAssert(" << node << ", removable = " << (removable ? "true" : "false") << ", negated = " << (negated ? "true" : "false") << ")" << endl;
+void TseitinCnfStream::convertAndAssert(TNode node,
+ bool removable,
+ bool negated,
+ ProofRule proof_id,
+ TNode from) {
+ Debug("cnf") << "convertAndAssert(" << node
+ << ", removable = " << (removable ? "true" : "false")
+ << ", negated = " << (negated ? "true" : "false") << ")" << endl;
d_removable = removable;
- if(options::proof() || options::unsatCores()) {
- // Encode the assertion ID in the proof_id to store with generated clauses.
- uint64_t assertionTableIndex = d_assertionTable.size();
- Assert((uint64_t(proof_id) & 0xffffffff00000000llu) == 0 && (assertionTableIndex & 0xffffffff00000000llu) == 0, "proof_id/table_index collision");
- d_proofId = assertionTableIndex | (uint64_t(proof_id) << 32);
- d_assertionTable.push_back(from.isNull() ? node : from);
- Debug("cores") << "; cnf is " << assertionTableIndex << " asst " << node << " proof_id " << proof_id << " from " << from << endl;
- } else {
- // We aren't producing proofs or unsat cores; use an invalid proof id.
- d_proofId = uint64_t(-1);
- }
- convertAndAssert(node, negated, proof_id);
+ PROOF
+ (if (d_cnfProof) {
+ Node assertion = negated ? node.notNode() : (Node)node;
+ Node from_assertion = negated? from.notNode() : (Node) from;
+
+ if (proof_id != RULE_INVALID) {
+ d_cnfProof->pushCurrentAssertion(from.isNull() ? assertion : from_assertion);
+ d_cnfProof->registerAssertion(from.isNull() ? assertion : from_assertion, proof_id);
+ }
+ else {
+ d_cnfProof->pushCurrentAssertion(assertion);
+ d_cnfProof->registerAssertion(assertion, proof_id);
+ }
+ });
+
+ convertAndAssert(node, negated);
+ PROOF(if (d_cnfProof) d_cnfProof->popCurrentAssertion(); );
}
-void TseitinCnfStream::convertAndAssert(TNode node, bool negated, ProofRule proof_id) {
- Debug("cnf") << "convertAndAssert(" << node << ", negated = " << (negated ? "true" : "false") << ")" << endl;
+void TseitinCnfStream::convertAndAssert(TNode node, bool negated) {
+ Debug("cnf") << "convertAndAssert(" << node
+ << ", negated = " << (negated ? "true" : "false") << ")" << endl;
if (d_convertAndAssertCounter % ResourceManager::getFrequencyCount() == 0) {
NodeManager::currentResourceManager()->spendResource(options::cnfStep());
switch(node.getKind()) {
case AND:
- convertAndAssertAnd(node, negated, proof_id);
+ convertAndAssertAnd(node, negated);
break;
case OR:
- convertAndAssertOr(node, negated, proof_id);
+ convertAndAssertOr(node, negated);
break;
case IFF:
- convertAndAssertIff(node, negated, proof_id);
+ convertAndAssertIff(node, negated);
break;
case XOR:
- convertAndAssertXor(node, negated, proof_id);
+ convertAndAssertXor(node, negated);
break;
case IMPLIES:
- convertAndAssertImplies(node, negated, proof_id);
+ convertAndAssertImplies(node, negated);
break;
case ITE:
- convertAndAssertIte(node, negated, proof_id);
+ convertAndAssertIte(node, negated);
break;
case NOT:
- convertAndAssert(node[0], !negated, proof_id);
+ convertAndAssert(node[0], !negated);
break;
default:
{
nnode = node.negate();
}
// Atoms
- assertClause(nnode, toCNF(node, negated), proof_id);
+ assertClause(nnode, toCNF(node, negated));
}
break;
}
/** The "registrar" for pre-registration of terms */
Registrar* d_registrar;
- /** A table of assertions, used for regenerating proofs. */
- context::CDList<Node> d_assertionTable;
+ /** The name of this CNF stream*/
+ std::string d_name;
+
+ /** Pointer to the proof corresponding to this CnfStream */
+ CnfProof* d_cnfProof;
/** Container for misc. globals. */
SmtGlobals* d_globals;
return node;
}
- /**
- * A reference into the assertion table, used to map clauses back to
- * their "original" input assertion/lemma. This variable is manipulated
- * by the top-level convertAndAssert(). This is needed in proofs-enabled
- * runs, to justify where the SAT solver's clauses came from.
- */
- uint64_t d_proofId;
-
/**
* Are we asserting a removable clause (true) or a permanent clause (false).
* This is set at the beginning of convertAndAssert so that it doesn't
* @param node the node giving rise to this clause
* @param clause the clause to assert
*/
- void assertClause(TNode node, SatClause& clause, ProofRule proof_id);
+ void assertClause(TNode node, SatClause& clause);
/**
* Asserts the unit clause to the sat solver.
* @param node the node giving rise to this clause
* @param a the unit literal of the clause
*/
- void assertClause(TNode node, SatLiteral a, ProofRule proof_id);
+ void assertClause(TNode node, SatLiteral a);
/**
* Asserts the binary clause to the sat solver.
* @param a the first literal in the clause
* @param b the second literal in the clause
*/
- void assertClause(TNode node, SatLiteral a, SatLiteral b, ProofRule proof_id);
+ void assertClause(TNode node, SatLiteral a, SatLiteral b);
/**
* Asserts the ternary clause to the sat solver.
* @param b the second literal in the clause
* @param c the thirs literal in the clause
*/
- void assertClause(TNode node, SatLiteral a, SatLiteral b, SatLiteral c, ProofRule proof_id);
+ void assertClause(TNode node, SatLiteral a, SatLiteral b, SatLiteral c);
/**
* Acquires a new variable from the SAT solver to represent the node
* @param registrar the entity that takes care of preregistration of Nodes
* @param context the context that the CNF should respect
* @param fullLitToNodeMap maintain a full SAT-literal-to-Node mapping,
+ * @param name string identifier to distinguish between different instances
* even for non-theory literals
*/
- CnfStream(SatSolver* satSolver, Registrar* registrar, context::Context* context, SmtGlobals* globals, bool fullLitToNodeMap = false);
+ CnfStream(SatSolver* satSolver,
+ Registrar* registrar,
+ context::Context* context,
+ SmtGlobals* globals,
+ bool fullLitToNodeMap = false,
+ std::string name="");
/**
* Destructs a CnfStream. This implementation does nothing, but we
*/
SatLiteral getLiteral(TNode node);
- /**
- * Get the assertion with a given ID. (Used for reconstructing proofs.)
- */
- TNode getAssertion(uint64_t id) {
- return d_assertionTable[id];
- }
-
/**
* Returns the Boolean variables from the input problem.
*/
return d_literalToNodeMap;
}
+ void setProof(CnfProof* proof);
};/* class CnfStream */
* @param removable is this something that can be erased
* @param negated true if negated
*/
- void convertAndAssert(TNode node, bool removable, bool negated, ProofRule proof_id, TNode from = TNode::null());
+ void convertAndAssert(TNode node, bool removable,
+ bool negated, ProofRule rule, TNode from = TNode::null());
/**
* Constructs the stream to use the given sat solver.
* @param fullLitToNodeMap maintain a full SAT-literal-to-Node mapping,
* even for non-theory literals
*/
- TseitinCnfStream(SatSolver* satSolver, Registrar* registrar, context::Context* context, SmtGlobals* globals, bool fullLitToNodeMap = false);
+ TseitinCnfStream(SatSolver* satSolver, Registrar* registrar, context::Context* context, SmtGlobals* globals, bool fullLitToNodeMap = false, std::string name = "");
private:
/**
* Same as above, except that removable is remembered.
*/
- void convertAndAssert(TNode node, bool negated, ProofRule proof_id);
+ void convertAndAssert(TNode node, bool negated);
// Each of these formulas handles takes care of a Node of each Kind.
//
SatLiteral handleAnd(TNode node);
SatLiteral handleOr(TNode node);
- void convertAndAssertAnd(TNode node, bool negated, ProofRule proof_id);
- void convertAndAssertOr(TNode node, bool negated, ProofRule proof_id);
- void convertAndAssertXor(TNode node, bool negated, ProofRule proof_id);
- void convertAndAssertIff(TNode node, bool negated, ProofRule proof_id);
- void convertAndAssertImplies(TNode node, bool negated, ProofRule proof_id);
- void convertAndAssertIte(TNode node, bool negated, ProofRule proof_id);
+ void convertAndAssertAnd(TNode node, bool negated);
+ void convertAndAssertOr(TNode node, bool negated);
+ void convertAndAssertXor(TNode node, bool negated);
+ void convertAndAssertIff(TNode node, bool negated);
+ void convertAndAssertImplies(TNode node, bool negated);
+ void convertAndAssertIte(TNode node, bool negated);
/**
* Transforms the node into CNF recursively.
#include "base/output.h"
#include "options/prop_options.h"
#include "proof/proof_manager.h"
+#include "proof/sat_proof_implementation.h"
#include "proof/sat_proof.h"
#include "prop/minisat/core/Solver.h"
#include "prop/minisat/minisat.h"
#include "prop/theory_proxy.h"
#include "smt_util/command.h"
+
using namespace CVC4::prop;
namespace CVC4 {
//=================================================================================================
// Options:
-
static const char* _cat = "CORE";
static DoubleOption opt_var_decay (_cat, "var-decay", "The variable activity decay factor", 0.95, DoubleRange(0, false, 1, false));
static DoubleOption opt_restart_inc (_cat, "rinc", "Restart interval increase factor", 3, DoubleRange(1, false, HUGE_VAL, false));
static DoubleOption opt_garbage_frac (_cat, "gc-frac", "The fraction of wasted memory allowed before a garbage collection is triggered", 0.20, DoubleRange(0, false, HUGE_VAL, false));
+//=================================================================================================
+// Proof declarations
+CRef Solver::TCRef_Undef = CRef_Undef;
+CRef Solver::TCRef_Lazy = CRef_Lazy;
class ScopedBool {
bool& watch;
// Assert the constants
uncheckedEnqueue(mkLit(varTrue, false));
uncheckedEnqueue(mkLit(varFalse, true));
- PROOF( ProofManager::getSatProof()->registerUnitClause(mkLit(varTrue, false), INPUT, uint64_t(-1)); )
- PROOF( ProofManager::getSatProof()->registerUnitClause(mkLit(varFalse, true), INPUT, uint64_t(-1)); )
+ // FIXME: these should be axioms I believe
+ PROOF
+ (
+ ProofManager::getSatProof()->registerTrueLit(mkLit(varTrue, false));
+ ProofManager::getSatProof()->registerFalseLit(mkLit(varFalse, true));
+ );
}
// Get the explanation from the theory
SatClause explanation_cl;
- proxy->explainPropagation(MinisatSatSolver::toSatLiteral(l), explanation_cl);
+ // FIXME: at some point return a tag with the theory that spawned you
+ proxy->explainPropagation(MinisatSatSolver::toSatLiteral(l),
+ explanation_cl);
vec<Lit> explanation;
MinisatSatSolver::toMinisatClause(explanation_cl, explanation);
// Construct the reason
CRef real_reason = ca.alloc(explLevel, explanation, true);
- PROOF (ProofManager::getSatProof()->registerClause(real_reason, THEORY_LEMMA, (uint64_t(RULE_CONFLICT) << 32)); );
+ // FIXME: at some point will need more information about where this explanation
+ // came from (ie. the theory/sharing)
+ PROOF (ClauseId id = ProofManager::getSatProof()->registerClause(real_reason, THEORY_LEMMA);
+ ProofManager::getCnfProof()->registerConvertedClause(id, true);
+ // no need to pop current assertion as this is not converted to cnf
+ );
vardata[x] = VarData(real_reason, level(x), user_level(x), intro_level(x), trail_index(x));
clauses_removable.push(real_reason);
attachClause(real_reason);
return real_reason;
}
-bool Solver::addClause_(vec<Lit>& ps, bool removable, uint64_t proof_id)
+bool Solver::addClause_(vec<Lit>& ps, bool removable, ClauseId& id)
{
if (!ok) return false;
clauseLevel = std::max(clauseLevel, intro_level(var(ps[i])));
// Tautologies are ignored
if (ps[i] == ~p) {
+ id = ClauseIdUndef;
// Clause can be ignored
return true;
}
// Clauses with 0-level true literals are also ignored
if (value(ps[i]) == l_True && level(var(ps[i])) == 0 && user_level(var(ps[i])) == 0) {
+ id = ClauseIdUndef;
return true;
}
// Ignore repeated literals
lemmas.push();
ps.copyTo(lemmas.last());
lemmas_removable.push(removable);
- Debug("cores") << "lemma push " << proof_id << " " << (proof_id & 0xffffffff) << std::endl;
- lemmas_proof_id.push(proof_id);
+ PROOF(
+ // Store the expression being converted to CNF until
+ // the clause is actually created
+ Node assertion = ProofManager::getCnfProof()->getCurrentAssertion();
+ Node def = ProofManager::getCnfProof()->getCurrentDefinition();
+ lemmas_cnf_assertion.push_back(std::make_pair(assertion, def));
+ id = ClauseIdUndef;
+ );
+ // does it have to always be a lemma?
+ // PROOF(id = ProofManager::getSatProof()->registerUnitClause(ps[0], THEORY_LEMMA););
+ // PROOF(id = ProofManager::getSatProof()->registerTheoryLemma(ps););
+ // Debug("cores") << "lemma push " << proof_id << " " << (proof_id & 0xffffffff) << std::endl;
+ // lemmas_proof_id.push(proof_id);
} else {
// If all false, we're in conflict
if (ps.size() == falseLiteralsCount) {
// construct the clause below to give to the proof manager
// as the final conflict.
if(falseLiteralsCount == 1) {
- PROOF( ProofManager::getSatProof()->storeUnitConflict(ps[0], INPUT, proof_id); )
+ PROOF( id = ProofManager::getSatProof()->storeUnitConflict(ps[0], INPUT); )
PROOF( ProofManager::getSatProof()->finalizeProof(CVC4::Minisat::CRef_Lazy); )
return ok = false;
}
attachClause(cr);
if(PROOF_ON()) {
- PROOF( ProofManager::getSatProof()->registerClause(cr, INPUT, proof_id); )
+ PROOF(
+ id = ProofManager::getSatProof()->registerClause(cr, INPUT);
+ )
if(ps.size() == falseLiteralsCount) {
PROOF( ProofManager::getSatProof()->finalizeProof(cr); )
return ok = false;
if(assigns[var(ps[0])] == l_Undef) {
assert(assigns[var(ps[0])] != l_False);
uncheckedEnqueue(ps[0], cr);
- Debug("cores") << "i'm registering a unit clause, input, proof id " << proof_id << std::endl;
- PROOF( if(ps.size() == 1) { ProofManager::getSatProof()->registerUnitClause(ps[0], INPUT, proof_id); } );
+ Debug("cores") << "i'm registering a unit clause, input" << std::endl;
+ PROOF(
+ if(ps.size() == 1) {
+ id = ProofManager::getSatProof()->registerUnitClause(ps[0], INPUT);
+ }
+ );
CRef confl = propagate(CHECK_WITHOUT_THEORY);
if(! (ok = (confl == CRef_Undef)) ) {
if(ca[confl].size() == 1) {
- PROOF( ProofManager::getSatProof()->storeUnitConflict(ca[confl][0], LEARNT, proof_id); );
+ PROOF( id = ProofManager::getSatProof()->storeUnitConflict(ca[confl][0], LEARNT); );
PROOF( ProofManager::getSatProof()->finalizeProof(CVC4::Minisat::CRef_Lazy); )
} else {
PROOF( ProofManager::getSatProof()->finalizeProof(confl); );
for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++){
Lit q = c[j];
- if (!seen[var(q)] && level(var(q)) > 0){
+ if (!seen[var(q)] && level(var(q)) > 0) {
varBumpActivity(var(q));
seen[var(q)] = 1;
if (level(var(q)) >= decisionLevel())
uint32_t abstract_level = 0;
for (i = 1; i < out_learnt.size(); i++)
abstract_level |= abstractLevel(var(out_learnt[i])); // (maintain an abstraction of levels involved in conflict)
-
+
for (i = j = 1; i < out_learnt.size(); i++) {
if (reason(var(out_learnt[i])) == CRef_Undef) {
out_learnt[j++] = out_learnt[i];
proxy->explainPropagation(MinisatSatSolver::toSatLiteral(p), explanation_cl);
vec<Lit> explanation;
MinisatSatSolver::toMinisatClause(explanation_cl, explanation);
- addClause(explanation, true, 0);
+ ClauseId id; // FIXME: mark it as explanation here somehow?
+ addClause(explanation, true, id);
}
}
}
attachClause(cr);
claBumpActivity(ca[cr]);
uncheckedEnqueue(learnt_clause[0], cr);
-
- PROOF( ProofManager::getSatProof()->endResChain(cr); )
+ PROOF(
+ ClauseId id = ProofManager::getSatProof()->registerClause(cr, LEARNT);
+ PSTATS(
+ __gnu_cxx::hash_set<int> cl_levels;
+ for (int i = 0; i < learnt_clause.size(); ++i) {
+ cl_levels.insert(level(var(learnt_clause[i])));
+ }
+ ProofManager::getSatProof()->storeClauseGlue(id, cl_levels.size());
+ )
+ ProofManager::getSatProof()->endResChain(id);
+ );
}
varDecayActivity();
// Last index in the trail
int backtrack_index = trail.size();
+ PROOF(Assert (lemmas.size() == (int)lemmas_cnf_assertion.size()););
+
// Attach all the clauses and enqueue all the propagations
for (int i = 0; i < lemmas.size(); ++ i)
{
// The current lemma
vec<Lit>& lemma = lemmas[i];
bool removable = lemmas_removable[i];
- uint64_t proof_id = lemmas_proof_id[i];
- Debug("cores") << "pulled lemma proof id " << proof_id << " " << (proof_id & 0xffffffff) << std::endl;
// Attach it if non-unit
CRef lemma_ref = CRef_Undef;
}
lemma_ref = ca.alloc(clauseLevel, lemma, removable);
- PROOF( ProofManager::getSatProof()->registerClause(lemma_ref, THEORY_LEMMA, proof_id); );
+ PROOF
+ (
+ TNode cnf_assertion = lemmas_cnf_assertion[i].first;
+ TNode cnf_def = lemmas_cnf_assertion[i].second;
+
+ ClauseId id = ProofManager::getSatProof()->registerClause(lemma_ref, THEORY_LEMMA);
+ ProofManager::getCnfProof()->setClauseAssertion(id, cnf_assertion);
+ ProofManager::getCnfProof()->setClauseDefinition(id, cnf_def);
+ );
if (removable) {
clauses_removable.push(lemma_ref);
} else {
}
attachClause(lemma_ref);
} else {
- PROOF( ProofManager::getSatProof()->registerUnitClause(lemma[0], THEORY_LEMMA, proof_id); );
+ PROOF
+ (
+ Node cnf_assertion = lemmas_cnf_assertion[i].first;
+ Node cnf_def = lemmas_cnf_assertion[i].second;
+
+ ClauseId id = ProofManager::getSatProof()->registerUnitClause(lemma[0], THEORY_LEMMA);
+ ProofManager::getCnfProof()->setClauseAssertion(id, cnf_assertion);
+ ProofManager::getCnfProof()->setClauseDefinition(id, cnf_def);
+ );
}
// If the lemma is propagating enqueue its literal (or set the conflict)
} else {
Debug("minisat::lemmas") << "Solver::updateLemmas(): unit conflict or empty clause" << std::endl;
conflict = CRef_Lazy;
- PROOF( ProofManager::getSatProof()->storeUnitConflict(lemma[0], LEARNT, proof_id); );
+ PROOF( ProofManager::getSatProof()->storeUnitConflict(lemma[0], LEARNT); );
}
} else {
Debug("minisat::lemmas") << "lemma size is " << lemma.size() << std::endl;
}
}
+ PROOF(Assert (lemmas.size() == (int)lemmas_cnf_assertion.size()););
// Clear the lemmas
lemmas.clear();
+ lemmas_cnf_assertion.clear();
lemmas_removable.clear();
- lemmas_proof_id.clear();
if (conflict != CRef_Undef) {
theoryConflict = true;
return conflict;
}
+void ClauseAllocator::reloc(CRef& cr, ClauseAllocator& to, CVC4::CoreProofProxy* proxy)
+{
+
+ // FIXME what is this CRef_lazy
+ if (cr == CRef_Lazy) return;
+
+ CRef old = cr; // save the old reference
+ Clause& c = operator[](cr);
+ if (c.reloced()) { cr = c.relocation(); return; }
+
+ cr = to.alloc(c.level(), c, c.removable());
+ c.relocate(cr);
+ if (proxy) {
+ proxy->updateCRef(old, cr);
+ }
+ // Copy extra data-fields:
+ // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
+ to[cr].mark(c.mark());
+ if (to[cr].removable()) to[cr].activity() = c.activity();
+ else if (to[cr].has_extra()) to[cr].calcAbstraction();
+}
+
inline bool Solver::withinBudget(uint64_t ammount) const {
Assert (proxy);
// spendResource sets async_interrupt or throws UnsafeInterruptException
namespace CVC4 {
- class SatProof;
+template <class Solver> class TSatProof;
- namespace prop {
- class TheoryProxy;
- }/* CVC4::prop namespace */
+namespace prop {
+ class TheoryProxy;
+}/* CVC4::prop namespace */
}/* CVC4 namespace */
+typedef unsigned ClauseId;
+
namespace CVC4 {
namespace Minisat {
/** The only two CVC4 entry points to the private solver data */
friend class CVC4::prop::TheoryProxy;
- friend class CVC4::SatProof;
+ friend class CVC4::TSatProof<Minisat::Solver>;
+
+public:
+ static CRef TCRef_Undef;
+ static CRef TCRef_Lazy;
+
+ typedef Var TVar;
+ typedef Lit TLit;
+ typedef Clause TClause;
+ typedef CRef TCRef;
+ typedef vec<Lit> TLitVec;
+
protected:
/** The pointer to the proxy that provides interfaces to the SMT engine */
/** Is the lemma removable */
vec<bool> lemmas_removable;
- /** Proof IDs for lemmas */
- vec<uint64_t> lemmas_proof_id;
+ /** Nodes being converted to CNF */
+ std::vector< std::pair<CVC4::Node, CVC4::Node > >lemmas_cnf_assertion;
/** Do a another check if FULL_EFFORT was the last one */
bool recheck;
void push ();
void pop ();
- // CVC4 adds the "proof_id" here to refer to the input assertion/lemma
- // that produced this clause
- bool addClause (const vec<Lit>& ps, bool removable, uint64_t proof_id); // Add a clause to the solver.
- bool addEmptyClause(bool removable); // Add the empty clause, making the solver contradictory.
- bool addClause (Lit p, bool removable, uint64_t proof_id); // Add a unit clause to the solver.
- bool addClause (Lit p, Lit q, bool removable, uint64_t proof_id); // Add a binary clause to the solver.
- bool addClause (Lit p, Lit q, Lit r, bool removable, uint64_t proof_id); // Add a ternary clause to the solver.
- bool addClause_( vec<Lit>& ps, bool removable, uint64_t proof_id); // Add a clause to the solver without making superflous internal copy. Will
+ // addClause returns the ClauseId corresponding to the clause added in the
+ // reference parameter id.
+ bool addClause (const vec<Lit>& ps, bool removable, ClauseId& id); // Add a clause to the solver.
+ bool addEmptyClause(bool removable); // Add the empty clause, making the solver contradictory.
+ bool addClause (Lit p, bool removable, ClauseId& id); // Add a unit clause to the solver.
+ bool addClause (Lit p, Lit q, bool removable, ClauseId& id); // Add a binary clause to the solver.
+ bool addClause (Lit p, Lit q, Lit r, bool removable, ClauseId& id); // Add a ternary clause to the solver.
+ bool addClause_( vec<Lit>& ps, bool removable, ClauseId& id); // Add a clause to the solver without making superflous internal copy. Will
// change the passed vector 'ps'.
// Solving:
// NOTE: enqueue does not set the ok flag! (only public methods do)
inline bool Solver::enqueue (Lit p, CRef from) { return value(p) != l_Undef ? value(p) != l_False : (uncheckedEnqueue(p, from), true); }
-inline bool Solver::addClause (const vec<Lit>& ps, bool removable, uint64_t proof_id)
- { ps.copyTo(add_tmp); return addClause_(add_tmp, removable, proof_id); }
-inline bool Solver::addEmptyClause (bool removable) { add_tmp.clear(); return addClause_(add_tmp, removable, uint64_t(-1)); }
-inline bool Solver::addClause (Lit p, bool removable, uint64_t proof_id)
- { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp, removable, proof_id); }
-inline bool Solver::addClause (Lit p, Lit q, bool removable, uint64_t proof_id)
- { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp, removable, proof_id); }
-inline bool Solver::addClause (Lit p, Lit q, Lit r, bool removable, uint64_t proof_id)
- { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp, removable, proof_id); }
+inline bool Solver::addClause (const vec<Lit>& ps, bool removable, ClauseId& id)
+ { ps.copyTo(add_tmp); return addClause_(add_tmp, removable, id); }
+inline bool Solver::addEmptyClause (bool removable) { add_tmp.clear(); ClauseId tmp; return addClause_(add_tmp, removable, tmp); }
+inline bool Solver::addClause (Lit p, bool removable, ClauseId& id)
+ { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp, removable, id); }
+inline bool Solver::addClause (Lit p, Lit q, bool removable, ClauseId& id)
+ { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp, removable, id); }
+inline bool Solver::addClause (Lit p, Lit q, Lit r, bool removable, ClauseId& id)
+ { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp, removable, id); }
inline bool Solver::locked (const Clause& c) const { return value(c[0]) == l_True && isPropagatedBy(var(c[0]), c); }
inline void Solver::newDecisionLevel() { trail_lim.push(trail.size()); flipped.push(false); context->push(); if(Dump.isOn("state")) { Dump("state") << CVC4::PushCommand(); } }
}
-} /* Minisat */
-}
-
+class Solver;
-
-namespace CVC4 {
class ProofProxyAbstract {
public:
virtual ~ProofProxyAbstract() {}
virtual void updateCRef(Minisat::CRef oldref, Minisat::CRef newref) = 0;
};
-}
+
+} /* namespace CVC4::Minisat */
+} /* namespace CVC4 */
+namespace CVC4 {
+template <class Solver> class ProofProxy;
+typedef ProofProxy<CVC4::Minisat::Solver> CoreProofProxy;
+}
namespace CVC4 {
namespace Minisat{
RegionAllocator<uint32_t>::free(clauseWord32Size(c.size(), c.has_extra()));
}
- void reloc(CRef& cr, ClauseAllocator& to, CVC4::ProofProxyAbstract* proxy = NULL)
- {
-
- // FIXME what is this CRef_lazy
- if (cr == CRef_Lazy) return;
-
- CRef old = cr; // save the old reference
- Clause& c = operator[](cr);
- if (c.reloced()) { cr = c.relocation(); return; }
-
- cr = to.alloc(c.level(), c, c.removable());
- c.relocate(cr);
- if (proxy) {
- proxy->updateCRef(old, cr);
- }
- // Copy extra data-fields:
- // (This could be cleaned-up. Generalize Clause-constructor to be applicable here instead?)
- to[cr].mark(c.mark());
- if (to[cr].removable()) to[cr].activity() = c.activity();
- else if (to[cr].has_extra()) to[cr].calcAbstraction();
- }
+ void reloc(CRef& cr, ClauseAllocator& to, CVC4::CoreProofProxy* proxy = NULL);
+ // Implementation moved to Solver.cc.
};
#include "options/prop_options.h"
#include "options/smt_options.h"
#include "prop/minisat/simp/SimpSolver.h"
+#include "proof/sat_proof.h"
#include "util/statistics_registry.h"
namespace CVC4 {
Assert(clause.size() == (unsigned)minisat_clause.size());
}
-void MinisatSatSolver::toSatClause(Minisat::vec<Minisat::Lit>& clause,
- SatClause& sat_clause) {
- for (int i = 0; i < clause.size(); ++i) {
- sat_clause.push_back(toSatLiteral(clause[i]));
- }
- Assert((unsigned)clause.size() == sat_clause.size());
-}
-
void MinisatSatSolver::toSatClause(const Minisat::Clause& clause,
SatClause& sat_clause) {
for (int i = 0; i < clause.size(); ++i) {
d_minisat->restart_inc = options::satRestartInc();
}
-void MinisatSatSolver::addClause(SatClause& clause, bool removable, uint64_t proof_id) {
+ClauseId MinisatSatSolver::addClause(SatClause& clause, bool removable) {
Minisat::vec<Minisat::Lit> minisat_clause;
toMinisatClause(clause, minisat_clause);
- d_minisat->addClause(minisat_clause, removable, proof_id);
+ ClauseId clause_id = ClauseIdError;
+ // FIXME: This relies on the invariant that when ok() is false
+ // the SAT solver does not add the clause (which is what Minisat currently does)
+ if (!ok()) {
+ return ClauseIdUndef;
+ }
+ d_minisat->addClause(minisat_clause, removable, clause_id);
+ PROOF( Assert (clause_id != ClauseIdError););
+ return clause_id;
}
SatVariable MinisatSatSolver::newVar(bool isTheoryAtom, bool preRegister, bool canErase) {
return toSatLiteralValue(d_minisat->solve());
}
+bool MinisatSatSolver::ok() const {
+ return d_minisat->okay();
+}
void MinisatSatSolver::interrupt() {
d_minisat->interrupt();
} /* namespace CVC4::prop */
} /* namespace CVC4 */
+
+
+namespace CVC4 {
+template<>
+prop::SatLiteral toSatLiteral< CVC4::Minisat::Solver>(Minisat::Solver::TLit lit) {
+ return prop::MinisatSatSolver::toSatLiteral(lit);
+}
+
+template<>
+void toSatClause< CVC4::Minisat::Solver> (const CVC4::Minisat::Solver::TClause& minisat_cl,
+ prop::SatClause& sat_cl) {
+ prop::MinisatSatSolver::toSatClause(minisat_cl, sat_cl);
+}
+
+} /* namespace CVC4 */
+
+
//(Commented because not in use) static bool tobool(SatValue val);
static void toMinisatClause(SatClause& clause, Minisat::vec<Minisat::Lit>& minisat_clause);
- static void toSatClause (Minisat::vec<Minisat::Lit>& clause, SatClause& sat_clause);
static void toSatClause (const Minisat::Clause& clause, SatClause& sat_clause);
void initialize(context::Context* context, TheoryProxy* theoryProxy);
- void addClause(SatClause& clause, bool removable, uint64_t proof_id);
+ ClauseId addClause(SatClause& clause, bool removable);
SatVariable newVar(bool isTheoryAtom, bool preRegister, bool canErase);
SatVariable trueVar() { return d_minisat->trueVar(); }
SatValue solve();
SatValue solve(long unsigned int&);
+ bool ok() const;
+
void interrupt();
SatValue value(SatLiteral l);
-bool SimpSolver::addClause_(vec<Lit>& ps, bool removable, uint64_t proof_id)
+bool SimpSolver::addClause_(vec<Lit>& ps, bool removable, ClauseId& id)
{
#ifndef NDEBUG
if (use_simplification) {
if (use_rcheck && implied(ps))
return true;
- if (!Solver::addClause_(ps, removable, proof_id))
+ if (!Solver::addClause_(ps, removable, id))
return false;
if (use_simplification && clauses_persistent.size() == nclauses + 1){
for (int i = 0; i < cls.size(); i++)
removeClause(cls[i]);
+ ClauseId id = ClauseIdUndef;
// Produce clauses in cross product:
vec<Lit>& resolvent = add_tmp;
for (int i = 0; i < pos.size(); i++)
for (int j = 0; j < neg.size(); j++) {
bool removable = ca[pos[i]].removable() && ca[pos[neg[j]]].removable();
- if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) && !addClause_(resolvent, removable, uint64_t(-1))) {
+ if (merge(ca[pos[i]], ca[neg[j]], v, resolvent) &&
+ !addClause_(resolvent, removable, id)) {
return false;
}
}
}
removeClause(cls[i]);
-
- if (!addClause_(subst_clause, c.removable(), uint64_t(-1))) {
+ ClauseId id = ClauseIdUndef;
+ if (!addClause_(subst_clause, c.removable(), id)) {
return ok = false;
}
}
// Problem specification:
//
Var newVar (bool polarity = true, bool dvar = true, bool isTheoryAtom = false, bool preRegister = false, bool canErase = true);
- bool addClause (const vec<Lit>& ps, bool removable, uint64_t proof_id);
- bool addEmptyClause(bool removable, uint64_t proof_id); // Add the empty clause to the solver.
- bool addClause (Lit p, bool removable, uint64_t proof_id); // Add a unit clause to the solver.
- bool addClause (Lit p, Lit q, bool removable, uint64_t proof_id); // Add a binary clause to the solver.
- bool addClause (Lit p, Lit q, Lit r, bool removable, uint64_t proof_id); // Add a ternary clause to the solver.
- bool addClause_(vec<Lit>& ps, bool removable, uint64_t proof_id);
+ bool addClause (const vec<Lit>& ps, bool removable, ClauseId& id);
+ bool addEmptyClause(bool removable); // Add the empty clause to the solver.
+ bool addClause (Lit p, bool removable, ClauseId& id); // Add a unit clause to the solver.
+ bool addClause (Lit p, Lit q, bool removable, ClauseId& id); // Add a binary clause to the solver.
+ bool addClause (Lit p, Lit q, Lit r, bool removable, ClauseId& id); // Add a ternary clause to the solver.
+ bool addClause_(vec<Lit>& ps, bool removable, ClauseId& id);
bool substitute(Var v, Lit x); // Replace all occurences of v with x (may cause a contradiction).
// Variable mode:
elim_heap.update(v); }
-inline bool SimpSolver::addClause (const vec<Lit>& ps, bool removable, uint64_t proof_id)
- { ps.copyTo(add_tmp); return addClause_(add_tmp, removable, proof_id); }
-inline bool SimpSolver::addEmptyClause(bool removable, uint64_t proof_id) { add_tmp.clear(); return addClause_(add_tmp, removable, proof_id); }
-inline bool SimpSolver::addClause (Lit p, bool removable, uint64_t proof_id)
- { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp, removable, proof_id); }
-inline bool SimpSolver::addClause (Lit p, Lit q, bool removable, uint64_t proof_id)
- { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp, removable, proof_id); }
-inline bool SimpSolver::addClause (Lit p, Lit q, Lit r, bool removable, uint64_t proof_id)
- { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp, removable, proof_id); }
+inline bool SimpSolver::addClause(const vec<Lit>& ps, bool removable, ClauseId& id)
+{ ps.copyTo(add_tmp); return addClause_(add_tmp, removable, id); }
+inline bool SimpSolver::addEmptyClause(bool removable) { add_tmp.clear(); ClauseId id=-1; return addClause_(add_tmp, removable, id); }
+inline bool SimpSolver::addClause (Lit p, bool removable, ClauseId& id)
+ { add_tmp.clear(); add_tmp.push(p); return addClause_(add_tmp, removable, id); }
+inline bool SimpSolver::addClause (Lit p, Lit q, bool removable, ClauseId& id)
+ { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); return addClause_(add_tmp, removable, id); }
+inline bool SimpSolver::addClause (Lit p, Lit q, Lit r, bool removable, ClauseId& id)
+ { add_tmp.clear(); add_tmp.push(p); add_tmp.push(q); add_tmp.push(r); return addClause_(add_tmp, removable, id); }
inline void SimpSolver::setFrozen (Var v, bool b) { frozen[v] = (char)b; if (use_simplification && !b) { updateElimHeap(v); } }
// the solver can always return unknown due to resource limiting
d_decisionEngine->setSatSolver(d_satSolver);
d_decisionEngine->setCnfStream(d_cnfStream);
- PROOF (ProofManager::currentPM()->initCnfProof(d_cnfStream); );
+ PROOF (
+ ProofManager::currentPM()->initCnfProof(d_cnfStream, userContext);
+ );
}
PropEngine::~PropEngine() {
d_cnfStream->convertAndAssert(node, false, false, RULE_GIVEN);
}
-void PropEngine::assertLemma(TNode node, bool negated, bool removable, ProofRule rule, TNode from) {
+void PropEngine::assertLemma(TNode node, bool negated,
+ bool removable,
+ ProofRule rule,
+ TNode from) {
//Assert(d_inCheckSat, "Sat solver should be in solve()!");
Debug("prop::lemmas") << "assertLemma(" << node << ")" << endl;
#include "util/statistics_registry.h"
namespace CVC4 {
+
+class BitVectorProof;
+
namespace prop {
class TheoryProxy;
+typedef unsigned ClauseId;
+
class SatSolver {
public:
virtual ~SatSolver() throw(AssertionException) { }
/** Assert a clause in the solver. */
- virtual void addClause(SatClause& clause, bool removable, uint64_t proof_id) = 0;
+ virtual ClauseId addClause(SatClause& clause,
+ bool removable) = 0;
/**
* Create a new boolean variable in the solver.
/** Get the current assertion level */
virtual unsigned getAssertionLevel() const = 0;
+ /** Check if the solver is in an inconsistent state */
+ virtual bool ok() const = 0;
+
+
};/* class SatSolver */
virtual void popAssumption() = 0;
+ virtual bool ok() const = 0;
+
+ virtual void setProofLog( BitVectorProof * bvp ) {}
+
};/* class BVSatSolverInterface */
virtual bool flipDecision() = 0;
virtual bool isDecision(SatVariable decn) const = 0;
-
+
+ virtual bool ok() const = 0;
};/* class DPLLSatSolverInterface */
inline std::ostream& operator <<(std::ostream& out, prop::SatLiteral lit) {
class SatSolverFactory {
public:
- static BVSatSolverInterface* createMinisat(context::Context* mainSatContext, StatisticsRegistry* registry, const std::string& name = "");
+ static BVSatSolverInterface* createMinisat(context::Context* mainSatContext,
+ StatisticsRegistry* registry,
+ const std::string& name = "");
static DPLLSatSolverInterface* createDPLLMinisat(StatisticsRegistry* registry);
};/* class SatSolverFactory */
#include "options/decision_options.h"
#include "prop/cnf_stream.h"
#include "prop/prop_engine.h"
+#include "proof/cnf_proof.h"
#include "smt_util/lemma_input_channel.h"
#include "smt_util/lemma_output_channel.h"
#include "smt/smt_statistics_registry.h"
#include "theory/theory_engine.h"
#include "util/statistics_registry.h"
+
namespace CVC4 {
namespace prop {
TNode lNode = d_cnfStream->getNode(l);
Debug("prop-explain") << "explainPropagation(" << lNode << ")" << std::endl;
Node theoryExplanation = d_theoryEngine->getExplanation(lNode);
+ PROOF(ProofManager::getCnfProof()->pushCurrentAssertion(theoryExplanation); );
Debug("prop-explain") << "explainPropagation() => " << theoryExplanation << std::endl;
if (theoryExplanation.getKind() == kind::AND) {
Node::const_iterator it = theoryExplanation.begin();
d_stats = new SmtEngineStatistics();
d_stats->d_resourceUnitsUsed.setData(
d_private->getResourceManager()->getResourceUsage());
+
+ // The ProofManager is constructed before any other proof objects such as
+ // SatProof and TheoryProofs. The TheoryProofEngine and the SatProof are
+ // initialized in TheoryEngine and PropEngine respectively.
+ Assert(d_proofManager == NULL);
+ PROOF( d_proofManager = new ProofManager(); );
+
// We have mutual dependency here, so we add the prop engine to the theory
// engine later (it is non-essential there)
d_theoryEngine = new TheoryEngine(d_context, d_userContext,
// Add the theories
for(TheoryId id = theory::THEORY_FIRST; id < theory::THEORY_LAST; ++id) {
TheoryConstructor::addTheory(d_theoryEngine, id);
+ //register with proof engine if applicable
+ THEORY_PROOF(ProofManager::currentPM()->getTheoryProofEngine()->registerTheory(d_theoryEngine->theoryOf(id)); );
}
// global push/pop around everything, to ensure proper destruction
// ensure that our heuristics are properly set up
setDefaults();
- Assert(d_proofManager == NULL);
- PROOF( d_proofManager = new ProofManager(); );
-
d_decisionEngine = new DecisionEngine(d_context, d_userContext);
d_decisionEngine->init(); // enable appropriate strategies
}
d_dumpCommands.clear();
- PROOF( ProofManager::currentPM()->setLogic(d_logic.getLogicString()); );
+ PROOF( ProofManager::currentPM()->setLogic(d_logic); );
}
void SmtEngine::finalOptionsAreSet() {
Trace("smt-proc") << "SmtEnginePrivate::processAssertions() : post-definition-expansion" << endl;
dumpAssertions("post-definition-expansion", d_assertions);
+ // save the assertions now
+ THEORY_PROOF
+ (
+ for (unsigned i = 0; i < d_assertions.size(); ++i) {
+ ProofManager::currentPM()->addAssertion(d_assertions[i].toExpr());
+ }
+ );
+
Debug("smt") << " d_assertions : " << d_assertions.size() << endl;
if( options::ceGuidedInst() ){
PROOF(
if( inInput ){
// n is an input assertion
- ProofManager::currentPM()->addAssertion(n.toExpr(), inUnsatCore);
+ if (inUnsatCore || options::dumpUnsatCores() || options::checkUnsatCores())
+ ProofManager::currentPM()->addCoreAssertion(n.toExpr());
}else{
// n is the result of an unknown preprocessing step, add it to dependency map to null
ProofManager::currentPM()->addDependence(n, Node::null());
throw ModalException("Cannot get an unsat core unless immediately preceded by UNSAT/VALID response.");
}
- d_proofManager->getProof(this);// just to trigger core creation
+ d_proofManager->traceUnsatCore();// just to trigger core creation
return UnsatCore(this, d_proofManager->begin_unsat_core(), d_proofManager->end_unsat_core());
#else /* IS_PROOFS_BUILD */
throw ModalException("This build of CVC4 doesn't have proof support (required for unsat cores).");
Chat() << "checking proof..." << endl;
if( !(d_logic.isPure(theory::THEORY_BOOL) ||
+ d_logic.isPure(theory::THEORY_BV) ||
(d_logic.isPure(theory::THEORY_UF) &&
! d_logic.hasCardinalityConstraints())) ||
d_logic.isQuantified()) {
// no checking for these yet
- Notice() << "Notice: no proof-checking for non-UF/Bool proofs yet" << endl;
+ Notice() << "Notice: no proof-checking for non-UF/Bool/BV proofs yet" << endl;
return;
}
a.use_nested_app = false;
a.compile_lib = false;
init();
- check_file(pfFile, args());
+ check_file(pfFile, a);
close(fd);
#else /* IS_PROOFS_BUILD */
#include "base/output.h"
#include "base/tls.h"
#include "expr/node_manager.h"
+#include "proof/proof.h"
+#include "proof/proof_manager.h"
#include "options/smt_options.h"
#include "smt/smt_engine.h"
#include "util/configuration_private.h"
return s_smtEngine_current != NULL;
}
+// FIXME: Maybe move into SmtScope?
inline ProofManager* currentProofManager() {
#if IS_PROOFS_BUILD
Assert(options::proof() || options::unsatCores());
void GetProofCommand::invoke(SmtEngine* smtEngine) throw() {
try {
+ d_smtEngine = smtEngine;
d_result = smtEngine->getProof();
d_commandStatus = CommandSuccess::instance();
} catch(UnsafeInterruptException& e) {
if(! ok()) {
this->Command::printResult(out, verbosity);
} else {
+ smt::SmtScope scope(d_smtEngine);
d_result->toStream(out);
}
}
Command* GetProofCommand::exportTo(ExprManager* exprManager, ExprManagerMapCollection& variableMap) {
GetProofCommand* c = new GetProofCommand();
c->d_result = d_result;
+ c->d_smtEngine = d_smtEngine;
return c;
}
Command* GetProofCommand::clone() const {
GetProofCommand* c = new GetProofCommand();
c->d_result = d_result;
+ c->d_smtEngine = d_smtEngine;
return c;
}
class CVC4_PUBLIC GetProofCommand : public Command {
protected:
Proof* d_result;
+ SmtEngine* d_smtEngine;
public:
GetProofCommand() throw();
~GetProofCommand() throw() {}
#include "smt_util/command.h"
#include "theory/rewriter.h"
#include "theory/theory_model.h"
+#include "proof/theory_proof.h"
+#include "proof/proof_manager.h"
#include "theory/valuation.h"
-
using namespace std;
namespace CVC4 {
TheoryArrays::TheoryArrays(context::Context* c, context::UserContext* u,
OutputChannel& out, Valuation valuation,
- const LogicInfo& logicInfo, SmtGlobals* globals)
- : Theory(THEORY_ARRAY, c, u, out, valuation, logicInfo, globals),
- d_numRow("theory::arrays::number of Row lemmas", 0),
- d_numExt("theory::arrays::number of Ext lemmas", 0),
- d_numProp("theory::arrays::number of propagations", 0),
- d_numExplain("theory::arrays::number of explanations", 0),
- d_numNonLinear("theory::arrays::number of calls to setNonLinear", 0),
- d_numSharedArrayVarSplits("theory::arrays::number of shared array var splits", 0),
- d_numGetModelValSplits("theory::arrays::number of getModelVal splits", 0),
- d_numGetModelValConflicts("theory::arrays::number of getModelVal conflicts", 0),
- d_numSetModelValSplits("theory::arrays::number of setModelVal splits", 0),
- d_numSetModelValConflicts("theory::arrays::number of setModelVal conflicts", 0),
- d_ppEqualityEngine(u, "theory::arrays::TheoryArraysPP" , true),
+ const LogicInfo& logicInfo, SmtGlobals* globals,
+ std::string name)
+ : Theory(THEORY_ARRAY, c, u, out, valuation, logicInfo, globals, name),
+ d_numRow(name + "theory::arrays::number of Row lemmas", 0),
+ d_numExt(name + "theory::arrays::number of Ext lemmas", 0),
+ d_numProp(name + "theory::arrays::number of propagations", 0),
+ d_numExplain(name + "theory::arrays::number of explanations", 0),
+ d_numNonLinear(name + "theory::arrays::number of calls to setNonLinear", 0),
+ d_numSharedArrayVarSplits(name + "theory::arrays::number of shared array var splits", 0),
+ d_numGetModelValSplits(name + "theory::arrays::number of getModelVal splits", 0),
+ d_numGetModelValConflicts(name + "theory::arrays::number of getModelVal conflicts", 0),
+ d_numSetModelValSplits(name + "theory::arrays::number of setModelVal splits", 0),
+ d_numSetModelValConflicts(name + "theory::arrays::number of setModelVal conflicts", 0),
+ d_ppEqualityEngine(u, name + "theory::arrays::TheoryArraysPP" , true),
d_ppFacts(u),
// d_ppCache(u),
d_literalsToPropagate(c),
d_literalsToPropagateIndex(c, 0),
d_isPreRegistered(c),
- d_mayEqualEqualityEngine(c, "theory::arrays::TheoryArraysMayEqual", true),
+ d_mayEqualEqualityEngine(c, name + "theory::arrays::TheoryArraysMayEqual", true),
d_notify(*this),
- d_equalityEngine(d_notify, c, "theory::arrays::TheoryArrays", true),
+ d_equalityEngine(d_notify, c, name + "theory::arrays::TheoryArrays", true),
d_conflict(c, false),
d_backtracker(c),
d_infoMap(c, &d_backtracker),
weakEquivBuildCond(r[0], r[1], conjunctions);
weakEquivBuildCond(r2[0], r[1], conjunctions);
lemma = mkAnd(conjunctions, true);
- d_out->lemma(lemma, false, false, true);
+ // LSH FIXME: which kind of arrays lemma is this
+ d_out->lemma(lemma, RULE_INVALID, false, false, true);
d_readTableContext->pop();
return;
}
TheoryArrays(context::Context* c, context::UserContext* u, OutputChannel& out,
Valuation valuation, const LogicInfo& logicInfo,
- SmtGlobals* globals);
+ SmtGlobals* globals, std::string name = "");
~TheoryArrays();
void setMasterEqualityEngine(eq::EqualityEngine* eq);
Assert(node.getKind() == kind::BITVECTOR_AND &&
bits.size() == 0);
-
- for(unsigned j = 0; j < utils::getSize(node); ++j) {
- std::vector<T> and_j;
- for (unsigned i = 0; i < node.getNumChildren(); ++i) {
- std::vector<T> current;
- bb->bbTerm(node[i], current);
- and_j.push_back(current[j]);
- Assert(utils::getSize(node) == current.size());
+
+ bb->bbTerm(node[0], bits);
+ std::vector<T> current;
+ for(unsigned j = 1; j < node.getNumChildren(); ++j) {
+ bb->bbTerm(node[j], current);
+ for (unsigned i = 0; i < utils::getSize(node); ++i) {
+ bits[i] = mkAnd(bits[i], current[i]);
}
- bits.push_back(mkAnd(and_j));
+ current.clear();
}
+ Assert (bits.size() == utils::getSize(node));
}
template <class T>
Assert(node.getKind() == kind::BITVECTOR_OR &&
bits.size() == 0);
-
- for(unsigned j = 0; j < utils::getSize(node); ++j) {
- std::vector<T> or_j;
- for (unsigned i = 0; i < node.getNumChildren(); ++i) {
- std::vector<T> current;
- bb->bbTerm(node[i], current);
- or_j.push_back(current[j]);
- Assert(utils::getSize(node) == current.size());
+
+ bb->bbTerm(node[0], bits);
+ std::vector<T> current;
+ for(unsigned j = 1; j < node.getNumChildren(); ++j) {
+ bb->bbTerm(node[j], current);
+ for (unsigned i = 0; i < utils::getSize(node); ++i) {
+ bits[i] = mkOr(bits[i], current[i]);
}
- bits.push_back(mkOr(or_j));
+ current.clear();
}
+ Assert (bits.size() == utils::getSize(node));
}
template <class T>
Assert(node.getKind() == kind::BITVECTOR_XOR &&
bits.size() == 0);
-
- for(unsigned j = 0; j < utils::getSize(node); ++j) {
- std::vector<T> first;
- bb->bbTerm(node[0], first);
- T bitj = first[j];
-
- for (unsigned i = 1; i < node.getNumChildren(); ++i) {
- std::vector<T> current;
- bb->bbTerm(node[i], current);
- bitj = mkXor(bitj, current[j]);
- Assert(utils::getSize(node) == current.size());
+
+ bb->bbTerm(node[0], bits);
+ std::vector<T> current;
+ for(unsigned j = 1; j < node.getNumChildren(); ++j) {
+ bb->bbTerm(node[j], current);
+ for (unsigned i = 0; i < utils::getSize(node); ++i) {
+ bits[i] = mkXor(bits[i], current[i]);
}
- bits.push_back(bitj);
+ current.clear();
}
+ Assert (bits.size() == utils::getSize(node));
}
template <class T>
T carry_in = mkFalse<T>();
T carry_out;
for(unsigned j = 0; j < res.size() -k; ++j) {
- T aj = mkAnd(a[j], b[k]);
+ T aj = mkAnd(b[k], a[j]);
carry_out = mkOr(mkAnd(res[j+k], aj),
mkAnd( mkXor(res[j+k], aj), carry_in));
res[j+k] = mkXor(mkXor(res[j+k], aj), carry_in);
TermDefMap d_termCache;
ModelCache d_modelCache;
+ BitVectorProof * d_bvp;
+
void initAtomBBStrategies();
void initTermBBStrategies();
protected:
bool hasBBTerm(TNode node) const;
void getBBTerm(TNode node, Bits& bits) const;
- void storeBBTerm(TNode term, const Bits& bits);
+ virtual void storeBBTerm(TNode term, const Bits& bits);
/**
* Return a constant representing the value of a in the model.
* If fullModel is true set unconstrained bits to 0. If not return
void bbAtom(TNode node);
Node getBBAtom(TNode atom) const;
void storeBBAtom(TNode atom, Node atom_bb);
- bool hasBBAtom(TNode atom) const;
+ void storeBBTerm(TNode node, const Bits& bits);
+ bool hasBBAtom(TNode atom) const;
+
TLazyBitblaster(context::Context* c, bv::TheoryBV* bv, const std::string name="", bool emptyNotify = false);
~TLazyBitblaster() throw();
/**
* constants to equivalence classes that don't already have them
*/
void collectModelInfo(TheoryModel* m, bool fullModel);
+ void setProofLog( BitVectorProof * bvp );
typedef TNodeSet::const_iterator vars_iterator;
vars_iterator beginVars() { return d_variables.begin(); }
bool hasBBAtom(TNode atom) const;
void bbFormula(TNode formula);
void storeBBAtom(TNode atom, Node atom_bb);
+ void storeBBTerm(TNode node, const Bits& bits);
+
bool assertToSat(TNode node, bool propagate = true);
bool solve();
void collectModelInfo(TheoryModel* m, bool fullModel);
+ void setProofLog( BitVectorProof * bvp );
};
class BitblastingRegistrar: public prop::Registrar {
TBitblaster<T>::TBitblaster()
: d_termCache()
, d_modelCache()
+ , d_bvp( NULL )
{
initAtomBBStrategies();
initTermBBStrategies();
#include "options/bv_options.h"
#include "theory/bv/bitblaster_template.h"
+#include "proof/bitvector_proof.h"
#include "theory/bv/bv_eager_solver.h"
using namespace std;
d_aigBitblaster = new AigBitblaster();
} else {
d_bitblaster = new EagerBitblaster(d_bv);
+ THEORY_PROOF(
+ if( d_bvp ){
+ d_bitblaster->setProofLog( d_bvp );
+ d_bvp->setBitblaster(d_bitblaster);
+ }
+ );
}
}
AlwaysAssert(!d_useAig && d_bitblaster);
d_bitblaster->collectModelInfo(m, fullModel);
}
+
+void EagerBitblastSolver::setProofLog( BitVectorProof * bvp ) {
+ d_bvp = bvp;
+}
EagerBitblaster* d_bitblaster;
AigBitblaster* d_aigBitblaster;
bool d_useAig;
- TheoryBV* d_bv;
+
+ TheoryBV* d_bv;
+ BitVectorProof * d_bvp;
public:
EagerBitblastSolver(theory::bv::TheoryBV* bv);
bool isInitialized();
void initialize();
void collectModelInfo(theory::TheoryModel* m, bool fullModel);
+ void setProofLog( BitVectorProof * bvp );
};
}
/** The bit-vector theory */
TheoryBV* d_bv;
+ /** proof log */
+ BitVectorProof * d_bvp;
AssertionQueue d_assertionQueue;
context::CDO<uint32_t> d_assertionIndex;
public:
return res;
}
virtual void assertFact(TNode fact) { d_assertionQueue.push_back(fact); }
+ virtual void setProofLog( BitVectorProof * bvp ) {}
AssertionQueue::const_iterator assertionsBegin() { return d_assertionQueue.begin(); }
AssertionQueue::const_iterator assertionsEnd() { return d_assertionQueue.end(); }
};
#include "theory/bv/bv_subtheory_bitblast.h"
#include "theory/bv/theory_bv.h"
#include "theory/bv/theory_bv_utils.h"
+#include "proof/proof_manager.h"
+#include "proof/bitvector_proof.h"
using namespace std;
using namespace CVC4::context;
d_abstractionModule(NULL),
d_quickCheck(options::bitvectorQuickXplain() ? new BVQuickCheck("bb", bv) : NULL),
d_quickXplain(options::bitvectorQuickXplain() ? new QuickXPlain("bb", d_quickCheck) : NULL)
-{}
+{
+}
BitblastSolver::~BitblastSolver() {
delete d_quickXplain;
return val;
}
-// Node BitblastSolver::getModelValueRec(TNode node)
-// {
-// Node val;
-// if (node.isConst()) {
-// return node;
-// }
-// NodeMap::iterator it = d_modelCache.find(node);
-// if (it != d_modelCache.end()) {
-// val = (*it).second;
-// Debug("bitvector-model") << node << " => (cached) " << val <<"\n";
-// return val;
-// }
-// if (d_bv->isLeaf(node)) {
-// val = d_bitblaster->getVarValue(node);
-// if (val == Node()) {
-// // If no value in model, just set to 0
-// val = utils::mkConst(utils::getSize(node), (unsigned)0);
-// }
-// } else {
-// NodeBuilder<> valBuilder(node.getKind());
-// if (node.getMetaKind() == kind::metakind::PARAMETERIZED) {
-// valBuilder << node.getOperator();
-// }
-// for (unsigned i = 0; i < node.getNumChildren(); ++i) {
-// valBuilder << getModelValueRec(node[i]);
-// }
-// val = valBuilder;
-// val = Rewriter::rewrite(val);
-// }
-// Assert(val.isConst());
-// d_modelCache[node] = val;
-// Debug("bitvector-model") << node << " => " << val <<"\n";
-// return val;
-// }
void BitblastSolver::setConflict(TNode conflict) {
d_bv->setConflict(final_conflict);
}
+void BitblastSolver::setProofLog( BitVectorProof * bvp ) {
+ d_bitblaster->setProofLog( bvp );
+ bvp->setBitblaster(d_bitblaster);
+}
+
}/* namespace CVC4::theory::bv */
}/* namespace CVC4::theory */
}/* namespace CVC4 */
+
void bitblastQueue();
void setAbstraction(AbstractionModule* module);
uint64_t computeAtomWeight(TNode atom);
+ void setProofLog( BitVectorProof * bvp );
};
-}
-}
-}
+} /* namespace CVC4::theory::bv */
+} /* namespace CVC4::theory */
+} /* namespace CVC4 */
#include "options/bv_options.h"
#include "prop/cnf_stream.h"
#include "prop/sat_solver_factory.h"
+#include "proof/bitvector_proof.h"
#include "smt/smt_statistics_registry.h"
#include "theory/bv/bitblaster_template.h"
#include "theory/bv/theory_bv.h"
#include "theory/theory_model.h"
-using namespace CVC4;
-using namespace CVC4::theory;
-using namespace CVC4::theory::bv;
-
namespace CVC4 {
namespace theory {
namespace bv {
d_bitblastingRegistrar = new BitblastingRegistrar(this);
d_nullContext = new context::Context();
- d_satSolver = prop::SatSolverFactory::createMinisat(
- d_nullContext, smtStatisticsRegistry(), "EagerBitblaster");
- d_cnfStream = new prop::TseitinCnfStream(d_satSolver, d_bitblastingRegistrar,
- d_nullContext, d_bv->globals());
-
+ d_satSolver = prop::SatSolverFactory::createMinisat(d_nullContext,
+ smtStatisticsRegistry(),
+ "EagerBitblaster");
+ d_cnfStream = new prop::TseitinCnfStream(d_satSolver,
+ d_bitblastingRegistrar,
+ d_nullContext,
+ d_bv->globals(),
+ options::proof(),
+ "EagerBitblaster");
+
MinisatEmptyNotify* notify = new MinisatEmptyNotify();
d_satSolver->setNotify(notify);
+ d_bvp = NULL;
}
EagerBitblaster::~EagerBitblaster() {
// the bitblasted definition of the atom
Node normalized = Rewriter::rewrite(node);
Node atom_bb = normalized.getKind() != kind::CONST_BOOLEAN ?
- Rewriter::rewrite(d_atomBBStrategies[normalized.getKind()](normalized, this)) :
- normalized;
+ d_atomBBStrategies[normalized.getKind()](normalized, this) :
+ normalized;
+
+ if (!options::proof()) {
+ atom_bb = Rewriter::rewrite(atom_bb);
+ }
+
// asserting that the atom is true iff the definition holds
Node atom_definition = utils::mkNode(kind::IFF, node, atom_bb);
- AlwaysAssert (options::bitblastMode() == theory::bv::BITBLAST_MODE_EAGER);
- storeBBAtom(node, atom_definition);
+ AlwaysAssert (options::bitblastMode() == theory::bv::BITBLAST_MODE_EAGER);
+ storeBBAtom(node, atom_bb);
d_cnfStream->convertAndAssert(atom_definition, false, false, RULE_INVALID, TNode::null());
}
void EagerBitblaster::storeBBAtom(TNode atom, Node atom_bb) {
- // no need to store the definition for the lazy bit-blaster
- d_bbAtoms.insert(atom);
+ if( d_bvp ){
+ d_bvp->registerAtomBB(atom.toExpr(), atom_bb.toExpr());
+ }
+ d_bbAtoms.insert(atom);
}
+void EagerBitblaster::storeBBTerm(TNode node, const Bits& bits) {
+ if( d_bvp ){ d_bvp->registerTermBB(node.toExpr()); }
+ d_termCache.insert(std::make_pair(node, bits));
+}
+
+
bool EagerBitblaster::hasBBAtom(TNode atom) const {
return d_bbAtoms.find(atom) != d_bbAtoms.end();
}
}
}
+void EagerBitblaster::setProofLog( BitVectorProof * bvp ) {
+ d_bvp = bvp;
+ d_satSolver->setProofLog(bvp);
+ bvp->initCnfProof(d_cnfStream, d_nullContext);
+}
+
bool EagerBitblaster::isSharedTerm(TNode node) {
return d_bv->d_sharedTermsSet.find(node) != d_bv->d_sharedTermsSet.end();
}
#include "theory/bv/theory_bv.h"
#include "theory/rewriter.h"
#include "theory/theory_model.h"
-#include "theory_bv_utils.h"
+#include "proof/bitvector_proof.h"
+#include "proof/proof_manager.h"
+#include "theory/bv/theory_bv_utils.h"
namespace CVC4 {
namespace theory {
c, smtStatisticsRegistry(), name);
d_nullRegistrar = new prop::NullRegistrar();
d_nullContext = new context::Context();
- d_cnfStream = new prop::TseitinCnfStream(d_satSolver, d_nullRegistrar,
- d_nullContext, d_bv->globals());
+ d_cnfStream = new prop::TseitinCnfStream(d_satSolver,
+ d_nullRegistrar,
+ d_nullContext,
+ d_bv->globals(),
+ options::proof(),
+ "LazyBitblaster");
d_satSolverNotify = d_emptyNotify ?
(prop::BVSatSolverInterface::Notify*) new MinisatEmptyNotify() :
// the bitblasted definition of the atom
Node normalized = Rewriter::rewrite(node);
Node atom_bb = normalized.getKind() != kind::CONST_BOOLEAN ?
- Rewriter::rewrite(d_atomBBStrategies[normalized.getKind()](normalized, this)) :
- normalized;
+ d_atomBBStrategies[normalized.getKind()](normalized, this) : normalized;
+
+ if (!options::proof()) {
+ atom_bb = Rewriter::rewrite(atom_bb);
+ }
+
// asserting that the atom is true iff the definition holds
Node atom_definition = utils::mkNode(kind::IFF, node, atom_bb);
storeBBAtom(node, atom_bb);
}
void TLazyBitblaster::storeBBAtom(TNode atom, Node atom_bb) {
- // no need to store the definition for the lazy bit-blaster
+ // No need to store the definition for the lazy bit-blaster (unless proofs are enabled).
+ if( d_bvp != NULL ){
+ d_bvp->registerAtomBB(atom.toExpr(), atom_bb.toExpr());
+ }
d_bbAtoms.insert(atom);
}
+void TLazyBitblaster::storeBBTerm(TNode node, const Bits& bits) {
+ if( d_bvp ){ d_bvp->registerTermBB(node.toExpr()); }
+ d_termCache.insert(std::make_pair(node, bits));
+}
+
+
bool TLazyBitblaster::hasBBAtom(TNode atom) const {
return d_bbAtoms.find(atom) != d_bbAtoms.end();
}
}
}
+void TLazyBitblaster::setProofLog( BitVectorProof * bvp ){
+ d_bvp = bvp;
+ d_satSolver->setProofLog( bvp );
+ bvp->initCnfProof(d_cnfStream, d_nullContext);
+}
+
void TLazyBitblaster::clearSolver() {
Assert (d_ctx->getLevel() == 0);
delete d_satSolver;
#include "theory/bv/theory_bv_rewriter.h"
#include "theory/bv/theory_bv_utils.h"
#include "theory/theory_model.h"
+#include "proof/theory_proof.h"
+#include "proof/proof_manager.h"
#include "theory/valuation.h"
using namespace CVC4::context;
}
}
-
void TheoryBV::check(Effort e)
{
if (done() && !fullEffort(e)) {
// return the explanation
Node explanation = utils::mkAnd(assumptions);
Debug("bitvector::explain") << "TheoryBV::explain(" << node << ") => " << explanation << std::endl;
+ Debug("bitvector::explain") << "TheoryBV::explain done. \n";
return explanation;
}
return changed;
}
+void TheoryBV::setProofLog( BitVectorProof * bvp ) {
+ if( options::bitblastMode() == theory::bv::BITBLAST_MODE_EAGER ){
+ d_eagerSolver->setProofLog( bvp );
+ }else{
+ for( unsigned i=0; i< d_subtheories.size(); i++ ){
+ d_subtheories[i]->setProofLog( bvp );
+ }
+ }
+}
+
void TheoryBV::setConflict(Node conflict) {
if (options::bvAbstraction()) {
Node new_conflict = d_abstractionModule->simplifyConflict(conflict);
void ppStaticLearn(TNode in, NodeBuilder<>& learned);
void presolve();
- bool applyAbstraction(const std::vector<Node>& assertions, std::vector<Node>& new_assertions);
+
+ bool applyAbstraction(const std::vector<Node>& assertions, std::vector<Node>& new_assertions);
+
+ void setProofLog( BitVectorProof * bvp );
private:
void sendConflict();
- void lemma(TNode node) { d_out->lemma(node); d_lemmasAdded = true; }
+ void lemma(TNode node) { d_out->lemma(node, RULE_CONFLICT); d_lemmasAdded = true; }
void checkForLemma(TNode node);
-
friend class LazyBitblaster;
friend class TLazyBitblaster;
friend class EagerBitblaster;
template<> inline
Node RewriteRule<ReflexivityEq>::apply(TNode node) {
Debug("bv-rewrite") << "RewriteRule<ReflexivityEq>(" << node << ")" << std::endl;
- return node[1].eqNode(node[0]);
+ Node res = node[1].eqNode(node[0]);
+ return res;
}
}
TNode a = node[0];
TNode b = node[1];
Node xorNode = utils::mkNode(kind::BITVECTOR_XOR, a, b);
- return utils::mkNode(kind::BITVECTOR_NOT, xorNode);
+ Node result = utils::mkNode(kind::BITVECTOR_NOT, xorNode);
+ return result;
}
children.push_back(node[i]);
}
}
-
- return utils::mkNode(kind::BITVECTOR_XOR, children);
+ Node res = utils::mkNode(kind::BITVECTOR_XOR, children);
+ return res;
}
template<> inline
Node RewriteRule<NotIdemp>::apply(TNode node) {
- Debug("bv-rewrite") << "RewriteRule<XorIdemp>(" << node << ")" << std::endl;
+ Debug("bv-rewrite") << "RewriteRule<NotIdemp>(" << node << ")" << std::endl;
return node[0][0];
}
return node.getType().getBitVectorSize();
}
-// this seems to behave strangely
-inline const Integer& getBit(TNode node, unsigned i) {
- Assert (0);
- Assert (node.getKind() == kind::CONST_BITVECTOR);
- return node.getConst<BitVector>().extract(i, i).getValue();
+inline const bool getBit(TNode node, unsigned i) {
+ Assert (i < utils::getSize(node) &&
+ node.getKind() == kind::CONST_BITVECTOR);
+ Integer bit = node.getConst<BitVector>().extract(i, i).getValue();
+ return (bit == 1u);
}
inline Node mkTrue() {
#include "base/cvc4_assert.h"
#include "smt/logic_exception.h"
#include "theory/interrupted.h"
+#include "proof/proof_manager.h"
#include "util/resource_manager.h"
namespace CVC4 {
* assigned false), or else a literal by itself (in the case of a
* unit conflict) which is assigned TRUE (and T-conflicting) in the
* current assignment.
+ * @param pf - a proof of the conflict. This is only non-null if proofs
+ * are enabled.
*/
- virtual void conflict(TNode n) throw(AssertionException, UnsafeInterruptException) = 0;
+ virtual void conflict(TNode n, Proof* pf = NULL) throw(AssertionException, UnsafeInterruptException) = 0;
/**
* Propagate a theory literal.
* been detected. (This requests a split.)
*
* @param n - a theory lemma valid at decision level 0
+ * @param rule - the proof rule for this lemma
* @param removable - whether the lemma can be removed at any point
* @param preprocess - whether to apply more aggressive preprocessing
* @param sendAtoms - whether to ensure atoms are sent to the theory
* @return the "status" of the lemma, including user level at which
* the lemma resides; the lemma will be removed when this user level pops
*/
- virtual LemmaStatus lemma(TNode n, bool removable = false,
- bool preprocess = false, bool sendAtoms = false)
- throw(TypeCheckingExceptionPrivate, AssertionException, UnsafeInterruptException, LogicException) = 0;
+ virtual LemmaStatus lemma(TNode n, ProofRule rule,
+ bool removable = false,
+ bool preprocess = false,
+ bool sendAtoms = false)
+ throw(TypeCheckingExceptionPrivate, AssertionException, UnsafeInterruptException) = 0;
+
+ /**
+ * Variant of the lemma function that does not require providing a proof rule.
+ */
+ virtual LemmaStatus lemma(TNode n,
+ bool removable = false,
+ bool preprocess = false,
+ bool sendAtoms = false)
+ throw(TypeCheckingExceptionPrivate, AssertionException, UnsafeInterruptException) {
+ return lemma(n, RULE_INVALID, removable, preprocess, sendAtoms);
+ }
+
/**
* Request a split on a new theory atom. This is equivalent to
* calling lemma({OR n (NOT n)}).
class RewriterInitializer {
static RewriterInitializer s_rewriterInitializer;
- RewriterInitializer() { Rewriter::init(); }
+ RewriterInitializer() {
+ Rewriter::init();
+ }
~RewriterInitializer() { Rewriter::shutdown(); }
};/* class RewriterInitializer */
// Incorporate the children if necessary
if (rewriteStackTop.node.getNumChildren() > 0) {
- rewriteStackTop.node = rewriteStackTop.builder;
+ Node rewritten = rewriteStackTop.builder;
+ rewriteStackTop.node = rewritten;
rewriteStackTop.theoryId = theoryOf(rewriteStackTop.node);
}
Assert(s_rewriteStack->find(response.node) == s_rewriteStack->end());
s_rewriteStack->insert(response.node);
#endif
- rewriteStackTop.node = rewriteTo(newTheoryId, response.node);
+ Node rewritten = rewriteTo(newTheoryId, response.node);
+ rewriteStackTop.node = rewritten;
#ifdef CVC4_ASSERTIONS
s_rewriteStack->erase(response.node);
#endif
Theory::Theory(TheoryId id, context::Context* satContext, context::UserContext* userContext,
OutputChannel& out, Valuation valuation, const LogicInfo& logicInfo,
- SmtGlobals* globals) throw()
+ SmtGlobals* globals, std::string name) throw()
: d_id(id)
+ , d_instanceName(name)
, d_satContext(satContext)
, d_userContext(userContext)
, d_logicInfo(logicInfo)
, d_sharedTermsIndex(satContext, 0)
, d_careGraph(NULL)
, d_quantEngine(NULL)
- , d_checkTime(statName(id, "checkTime"))
- , d_computeCareGraphTime(statName(id, "computeCareGraphTime"))
+ , d_checkTime(getFullInstanceName() + "::checkTime")
+ , d_computeCareGraphTime(getFullInstanceName() + "::computeCareGraphTime")
, d_sharedTerms(satContext)
, d_out(&out)
, d_valuation(valuation)
- , d_proofEnabled(false)
+ , d_proofsEnabled(false)
, d_globals(globals)
{
smtStatisticsRegistry()->registerStat(&d_checkTime);
*/
TheoryId d_id;
+ /** Name of this theory instance. Along with the TheoryId this should provide
+ * an unique string identifier for each instance of a Theory class. We need
+ * this to ensure unique statistics names over multiple theory instances. */
+ std::string d_instanceName;
+
/**
* The SAT search context for the Theory.
*/
/** time spent in theory combination */
TimerStat d_computeCareGraphTime;
- static std::string statName(TheoryId id, const char* statName) {
- std::stringstream ss;
- ss << "theory<" << id << ">::" << statName;
- return ss.str();
- }
-
/**
* The only method to add suff to the care graph.
*/
*/
Theory(TheoryId id, context::Context* satContext, context::UserContext* userContext,
OutputChannel& out, Valuation valuation, const LogicInfo& logicInfo,
- SmtGlobals* globals) throw();
+ SmtGlobals* globals, std::string name = "") throw(); // taking : No default.
/**
* This is called at shutdown time by the TheoryEngine, just before
*/
Valuation d_valuation;
+ /**
+ * Whether proofs are enabled
+ *
+ */
+ bool d_proofsEnabled;
+
/**
* Returns the next assertion in the assertFact() queue.
*
void printFacts(std::ostream& os) const;
void debugPrintFacts() const;
- /**
- * Whether proofs are enabled
- *
- */
- bool d_proofEnabled;
-
SmtGlobals* d_globals;
public:
return d_id;
}
+ std::string getFullInstanceName() const {
+ std::stringstream ss;
+ ss << "theory<" << d_id << ">" << d_instanceName;
+ return ss.str();
+ }
+
+
/**
* Get the SAT context associated to this Theory.
*/
*/
virtual std::pair<bool, Node> entailmentCheck(TNode lit, const EntailmentCheckParameters* params = NULL, EntailmentCheckSideEffects* out = NULL);
-
+ /**
+ * Turn on proof-production mode.
+ */
+ void produceProofs() { d_proofsEnabled = true; }
+
/** Returns a pointer to the globals copy the theory is using. */
SmtGlobals* globals() { return d_globals; }
#include "options/options.h"
#include "options/quantifiers_options.h"
#include "proof/proof_manager.h"
-#include "proof/proof_manager.h"
+#include "proof/theory_proof.h"
#include "smt/logic_exception.h"
#include "smt_util/ite_removal.h"
#include "smt_util/lemma_output_channel.h"
namespace CVC4 {
void TheoryEngine::finishInit() {
- PROOF (ProofManager::initTheoryProof(); );
-
// initialize the quantifiers engine
d_quantEngine = new QuantifiersEngine(d_context, d_userContext, this);
d_true = NodeManager::currentNM()->mkConst<bool>(true);
d_false = NodeManager::currentNM()->mkConst<bool>(false);
+ PROOF (ProofManager::currentPM()->initTheoryProofEngine(d_globals); );
+
d_iteUtilities = new ITEUtilities(d_iteRemover.getContainsVisitor());
smtStatisticsRegistry()->registerStat(&d_arithSubstitutionsAdded);
printAssertions("theory::assertions::fulleffort");
}
}
-
+
// Note that we've discharged all the facts
d_factsAsserted = false;
// must build model at this point
d_curr_model_builder->buildModel(d_curr_model, true);
}
- Trace("theory::assertions-model") << endl;
+ Trace("theory::assertions-model") << endl;
if (Trace.isOn("theory::assertions-model")) {
printAssertions("theory::assertions-model");
}
// We need to split on it
Debug("combineTheories") << "TheoryEngine::combineTheories(): requesting a split " << endl;
- lemma(equality.orNode(equality.notNode()), false, false, false, carePair.theory);
+ lemma(equality.orNode(equality.notNode()), RULE_INVALID, false, false, false, carePair.theory);
// This code is supposed to force preference to follow what the theory models already have
// but it doesn't seem to make a big difference - need to explore more -Clark
// if (true) {
}
}
-theory::LemmaStatus TheoryEngine::lemma(TNode node, bool negated, bool removable, bool preprocess, theory::TheoryId atomsTo) {
+theory::LemmaStatus TheoryEngine::lemma(TNode node,
+ ProofRule rule,
+ bool negated,
+ bool removable,
+ bool preprocess,
+ theory::TheoryId atomsTo) {
// For resource-limiting (also does a time check).
// spendResource();
}
// assert to prop engine
- d_propEngine->assertLemma(additionalLemmas[0], negated, removable, RULE_INVALID, node);
+ d_propEngine->assertLemma(additionalLemmas[0], negated, removable, rule, node);
for (unsigned i = 1; i < additionalLemmas.size(); ++ i) {
additionalLemmas[i] = theory::Rewriter::rewrite(additionalLemmas[i]);
- d_propEngine->assertLemma(additionalLemmas[i], false, removable, RULE_INVALID, node);
+ d_propEngine->assertLemma(additionalLemmas[i], false, removable, rule, node);
}
// WARNING: Below this point don't assume additionalLemmas[0] to be not negated.
Node fullConflict = mkExplanation(explanationVector);
Debug("theory::conflict") << "TheoryEngine::conflict(" << conflict << ", " << theoryId << "): full = " << fullConflict << endl;
Assert(properConflict(fullConflict));
- lemma(fullConflict, true, true, false, THEORY_LAST);
+ lemma(fullConflict, RULE_CONFLICT, true, true, false, THEORY_LAST);
} else {
// When only one theory, the conflict should need no processing
Assert(properConflict(conflict));
- lemma(conflict, true, true, false, THEORY_LAST);
+ lemma(conflict, RULE_CONFLICT, true, true, false, THEORY_LAST);
}
}
if (options::produceModels())
throw ModalException("Slicer does not currently support model generation. Use --bv-eq-slicer=off");
useSlicer = true;
-
+
} else if (options::bitvectorEqualitySlicer() == bv::BITVECTOR_SLICER_OFF) {
return;
-
+
} else if (options::bitvectorEqualitySlicer() == bv::BITVECTOR_SLICER_AUTO) {
if (options::incrementalSolving() ||
options::produceModels())
return;
- useSlicer = true;
+ useSlicer = true;
bv::utils::TNodeBoolMap cache;
for (unsigned i = 0; i < assertions.size(); ++i) {
- useSlicer = useSlicer && bv::utils::isCoreTerm(assertions[i], cache);
+ useSlicer = useSlicer && bv::utils::isCoreTerm(assertions[i], cache);
}
}
-
+
if (useSlicer) {
- bv::TheoryBV* bv_theory = (bv::TheoryBV*)d_theoryTable[THEORY_BV];
+ bv::TheoryBV* bv_theory = (bv::TheoryBV*)d_theoryTable[THEORY_BV];
bv_theory->enableCoreTheorySlicer();
}
-
+
}
void TheoryEngine::ppBvToBool(const std::vector<Node>& assertions, std::vector<Node>& new_assertions) {
}
bool TheoryEngine::ppBvAbstraction(const std::vector<Node>& assertions, std::vector<Node>& new_assertions) {
- bv::TheoryBV* bv_theory = (bv::TheoryBV*)d_theoryTable[THEORY_BV];
- return bv_theory->applyAbstraction(assertions, new_assertions);
+ bv::TheoryBV* bv_theory = (bv::TheoryBV*)d_theoryTable[THEORY_BV];
+ return bv_theory->applyAbstraction(assertions, new_assertions);
}
void TheoryEngine::mkAckermanizationAsssertions(std::vector<Node>& assertions) {
- bv::TheoryBV* bv_theory = (bv::TheoryBV*)d_theoryTable[THEORY_BV];
+ bv::TheoryBV* bv_theory = (bv::TheoryBV*)d_theoryTable[THEORY_BV];
bv_theory->mkAckermanizationAsssertions(assertions);
}
}
}
- void conflict(TNode conflictNode) throw(AssertionException, UnsafeInterruptException) {
+ void conflict(TNode conflictNode, Proof* pf = NULL) throw(AssertionException, UnsafeInterruptException) {
Trace("theory::conflict") << "EngineOutputChannel<" << d_theory << ">::conflict(" << conflictNode << ")" << std::endl;
+ Assert(pf == NULL); // theory shouldn't be producing proofs yet
++ d_statistics.conflicts;
d_engine->d_outputChannelUsed = true;
d_engine->conflict(conflictNode, d_theory);
return d_engine->propagate(literal, d_theory);
}
- theory::LemmaStatus lemma(TNode lemma, bool removable = false, bool preprocess = false, bool sendAtoms = false) throw(TypeCheckingExceptionPrivate, AssertionException, UnsafeInterruptException, LogicException) {
+ theory::LemmaStatus lemma(TNode lemma,
+ ProofRule rule,
+ bool removable = false,
+ bool preprocess = false,
+ bool sendAtoms = false)
+ throw(TypeCheckingExceptionPrivate, AssertionException, UnsafeInterruptException) {
Trace("theory::lemma") << "EngineOutputChannel<" << d_theory << ">::lemma(" << lemma << ")" << std::endl;
++ d_statistics.lemmas;
d_engine->d_outputChannelUsed = true;
- return d_engine->lemma(lemma, false, removable, preprocess, sendAtoms ? d_theory : theory::THEORY_LAST);
+ return d_engine->lemma(lemma, rule, false, removable, preprocess, sendAtoms ? d_theory: theory::THEORY_LAST);
}
theory::LemmaStatus splitLemma(TNode lemma, bool removable = false) throw(TypeCheckingExceptionPrivate, AssertionException, UnsafeInterruptException) {
Trace("theory::lemma") << "EngineOutputChannel<" << d_theory << ">::lemma(" << lemma << ")" << std::endl;
++ d_statistics.lemmas;
d_engine->d_outputChannelUsed = true;
- return d_engine->lemma(lemma, false, removable, false, d_theory);
+ return d_engine->lemma(lemma, RULE_SPLIT, false, removable, false, d_theory);
}
void demandRestart() throw(TypeCheckingExceptionPrivate, AssertionException, UnsafeInterruptException) {
"A boolean variable asserted to be true to force a restart");
Trace("theory::restart") << "EngineOutputChannel<" << d_theory << ">::restart(" << restartVar << ")" << std::endl;
++ d_statistics.restartDemands;
- lemma(restartVar, true);
+ lemma(restartVar, RULE_INVALID, true);
}
void requirePhase(TNode n, bool phase)
* @param removable can the lemma be remove (restrictions apply)
* @param needAtoms if not THEORY_LAST, then
*/
- theory::LemmaStatus lemma(TNode node, bool negated, bool removable, bool preprocess, theory::TheoryId atomsTo);
+ theory::LemmaStatus lemma(TNode node,
+ ProofRule rule,
+ bool negated,
+ bool removable,
+ bool preprocess,
+ theory::TheoryId atomsTo);
/** Enusre that the given atoms are send to the given theory */
void ensureLemmaAtoms(const std::vector<TNode>& atoms, theory::TheoryId theory);
void safePoint(uint64_t ammount) throw(Interrupted, AssertionException) {}
- void conflict(TNode n)
+ void conflict(TNode n, Proof* pf = NULL)
throw(AssertionException, UnsafeInterruptException) {
push(CONFLICT, n);
}
push(PROPAGATE_AS_DECISION, n);
}
- LemmaStatus lemma(TNode n, bool removable, bool preprocess, bool sendAtoms) throw(AssertionException, UnsafeInterruptException) {
+ LemmaStatus lemma(TNode n, ProofRule rule,
+ bool removable = false,
+ bool preprocess = false,
+ bool sendAtoms = false) throw(AssertionException, UnsafeInterruptException) {
push(LEMMA, n);
return LemmaStatus(Node::null(), 0);
}
// How many children are not constants yet
d_subtermsToEvaluate[result] = t.getNumChildren();
for (unsigned i = 0; i < t.getNumChildren(); ++ i) {
- if (isConstant(getNodeId(t[i]))) {
- Debug("equality::evaluation") << d_name << "::eq::addTermInternal(" << t << "): evaluates " << t[i] << std::endl;
- subtermEvaluates(result);
- }
+ if (isConstant(getNodeId(t[i]))) {
+ Debug("equality::evaluation") << d_name << "::eq::addTermInternal(" << t << "): evaluates " << t[i] << std::endl;
+ subtermEvaluates(result);
+ }
}
}
} else {
} else if (d_constantsAreTriggers && d_isConstant[result]) {
// Non-Boolean constants are trigger terms for all tags
EqualityNodeId tId = getNodeId(t);
- // Setup the new set
+ // Setup the new set
Theory::Set newSetTags = 0;
EqualityNodeId newSetTriggers[THEORY_LAST];
unsigned newSetTriggersSize = THEORY_LAST;
Debug("equality") << d_name << "::eq::merge(" << class1.getFind() << "," << class2.getFind() << "): " << d_nodes[currentId] << " in " << d_nodes[funId] << std::endl;
const FunctionApplication& fun = d_applications[useNode.getApplicationId()].normalized;
// If it's interpreted and we can interpret
- if (fun.isInterpreted() && class1isConstant && !d_isInternal[currentId]) {
- // Get the actual term id
- TNode term = d_nodes[funId];
- subtermEvaluates(getNodeId(term));
- }
- // Check if there is an application with find arguments
+ if (fun.isInterpreted() && class1isConstant && !d_isInternal[currentId]) {
+ // Get the actual term id
+ TNode term = d_nodes[funId];
+ subtermEvaluates(getNodeId(term));
+ }
+ // Check if there is an application with find arguments
EqualityNodeId aNormalized = getEqualityNode(fun.a).getFind();
EqualityNodeId bNormalized = getEqualityNode(fun.b).getFind();
FunctionApplication funNormalized(fun.type, aNormalized, bNormalized);
// If the nodes are the same, we're done
if (t1Id == t2Id){
if( eqp ) {
- eqp->d_node = d_nodes[t1Id];
+ eqp->d_node = ProofManager::currentPM()->mkOp(d_nodes[t1Id]);
}
return;
}
MergeReasonType reasonType = d_equalityEdges[currentEdge].getReasonType();
Debug("equality") << d_name << "::eq::getExplanation(): currentEdge = " << currentEdge << ", currentNode = " << currentNode << std::endl;
+ Debug("equality") << d_name << " in currentEdge = (" << d_nodes[currentNode] << "," << d_nodes[edge.getNodeId()] << ")" << std::endl;
EqProof * eqpc = NULL;
//make child proof if a proof is being constructed
if( eqpc ){
eqpc->d_children.push_back( eqpc1 );
eqpc->d_children.push_back( eqpc2 );
+ Debug("equality-pf") << "Congruence : " << d_nodes[currentNode] << " " << d_nodes[edgeNode] << std::endl;
+ if( d_nodes[currentNode].getKind()==kind::EQUAL ){
+ //leave node null for now
+ eqpc->d_node = Node::null();
+ }else{
+ Debug("equality-pf") << d_nodes[f1.a] << " / " << d_nodes[f2.a] << ", " << d_nodes[f1.b] << " / " << d_nodes[f2.b] << std::endl;
+ if(d_nodes[f1.a].getKind() == kind::APPLY_UF ||
+ d_nodes[f1.a].getKind() == kind::SELECT ||
+ d_nodes[f1.a].getKind() == kind::STORE) {
+ eqpc->d_node = d_nodes[f1.a];
+ } else {
+ eqpc->d_node = NodeManager::currentNM()->mkNode(kind::PARTIAL_APPLY_UF, ProofManager::currentPM()->mkOp(d_nodes[f1.a]), d_nodes[f1.b]);
+ }
+ }
}
Debug("equality") << pop;
break;
// Construct the equality
Debug("equality") << d_name << "::eq::getExplanation(): adding: " << d_equalityEdges[currentEdge].getReason() << std::endl;
if( eqpc ){
- if( reasonType==MERGED_THROUGH_EQUALITY ){
+ if(reasonType == MERGED_THROUGH_EQUALITY) {
eqpc->d_node = d_equalityEdges[currentEdge].getReason();
- }else{
- //theory-specific proof rule : TODO
- eqpc->d_id = reasonType;
- //eqpc->d_node = d_equalityEdges[currentEdge].getNodeId();
+ } else {
+ // theory-specific proof rule
+ eqpc->d_node = d_nodes[d_equalityEdges[currentEdge].getNodeId()].eqNode(d_nodes[currentNode]);
+ Debug("equality-pf") << "theory eq : " << eqpc->d_node << std::endl;
}
+ eqpc->d_id = reasonType;
}
equalities.push_back(d_equalityEdges[currentEdge].getReason());
break;
currentEdge = bfsQueue[currentIndex].edgeId;
currentIndex = bfsQueue[currentIndex].previousIndex;
+ //---from Morgan---
+ if(eqpc != NULL && eqpc->d_id == MERGED_THROUGH_REFLEXIVITY) {
+ if(eqpc->d_node.isNull()) {
+ Assert(eqpc->d_children.size() == 1);
+ EqProof *p = eqpc;
+ eqpc = p->d_children[0];
+ delete p;
+ } else {
+ Assert(eqpc->d_children.empty());
+ }
+ }
+ //---end from Morgan---
+
eqp_trans.push_back( eqpc );
} while (currentEdge != null_id);
- if( eqp ){
- eqp->d_id = MERGED_THROUGH_TRANS;
- eqp->d_children.insert( eqp->d_children.end(), eqp_trans.begin(), eqp_trans.end() );
+ if(eqp) {
+ if(eqp_trans.size() == 1) {
+ *eqp = *eqp_trans[0];
+ delete eqp_trans[0];
+ } else {
+ eqp->d_id = MERGED_THROUGH_TRANS;
+ eqp->d_children.insert( eqp->d_children.end(), eqp_trans.begin(), eqp_trans.end() );
+ eqp->d_node = NodeManager::currentNM()->mkNode(d_nodes[t1Id].getType().isBoolean() ? kind::IFF : kind::EQUAL, d_nodes[t1Id], d_nodes[t2Id]);
+ }
}
// Done
return d_current == null_id;
}
-
-void EqProof::debug_print( const char * c, unsigned tb ){
+void EqProof::debug_print( const char * c, unsigned tb ) const{
for( unsigned i=0; i<tb; i++ ) { Debug( c ) << " "; }
Debug( c ) << d_id << "(";
if( !d_children.empty() || !d_node.isNull() ){
MergeReasonType d_id;
Node d_node;
std::vector< EqProof * > d_children;
- void debug_print( const char * c, unsigned tb = 0 );
-};
+ void debug_print( const char * c, unsigned tb = 0 ) const;
+};/* class EqProof */
} // Namespace eq
} // Namespace theory
operator COMBINED_CARDINALITY_CONSTRAINT 1 "combined cardinality constraint; parameter is a positive integer constant k that bounds the sum of the cardinalities of all sorts in the signature"
typerule COMBINED_CARDINALITY_CONSTRAINT ::CVC4::theory::uf::CombinedCardinalityConstraintTypeRule
+parameterized PARTIAL_APPLY_UF APPLY_UF 1: "partial uninterpreted function application"
+typerule PARTIAL_APPLY_UF ::CVC4::theory::uf::PartialTypeRule
+
operator CARDINALITY_VALUE 1 "cardinality value of sort S: first parameter is (any) term of sort S"
typerule CARDINALITY_VALUE ::CVC4::theory::uf::CardinalityValueTypeRule
d_reps.clear();
}
-SymmetryBreaker::SymmetryBreaker(context::Context* context) :
+SymmetryBreaker::SymmetryBreaker(context::Context* context,
+ std::string name) :
ContextNotifyObj(context),
d_assertionsToRerun(context),
d_rerunningAssertions(false),
d_template(),
d_normalizationCache(),
d_termEqs(),
- d_termEqsOnly() {
+ d_termEqsOnly(),
+ d_name(name),
+ d_stats(d_name)
+{
}
class SBGuard {
Debug("ufsymm") << "UFSYMM =====================================================" << endl
<< "UFSYMM have " << d_permutations.size() << " permutation sets" << endl;
if(!d_permutations.empty()) {
- { TimerStat::CodeTimer codeTimer(d_initNormalizationTimer);
+ { TimerStat::CodeTimer codeTimer(d_stats.d_initNormalizationTimer);
// normalize d_phi
for(vector<Node>::iterator i = d_phi.begin(); i != d_phi.end(); ++i) {
for(Permutations::iterator i = d_permutations.begin();
i != d_permutations.end();
++i) {
- ++d_permutationSetsConsidered;
+ ++(d_stats.d_permutationSetsConsidered);
const Permutation& p = *i;
Debug("ufsymm") << "UFSYMM looking at permutation: " << p << endl;
size_t n = p.size() - 1;
if(invariantByPermutations(p)) {
- ++d_permutationSetsInvariant;
+ ++(d_stats.d_permutationSetsInvariant);
selectTerms(p);
set<Node> cts;
while(!d_terms.empty() && cts.size() <= n) {
Node d;
if(disj.getNumChildren() > 1) {
d = disj;
- ++d_clauses;
+ ++(d_stats.d_clauses);
} else {
d = disj[0];
disj.clear();
- ++d_units;
+ ++(d_stats.d_units);
}
if(Debug.isOn("ufsymm")) {
Debug("ufsymm") << "UFSYMM symmetry-breaking clause: " << d << endl;
}
bool SymmetryBreaker::invariantByPermutations(const Permutation& p) {
- TimerStat::CodeTimer codeTimer(d_invariantByPermutationsTimer);
+ TimerStat::CodeTimer codeTimer(d_stats.d_invariantByPermutationsTimer);
// use d_phi
Debug("ufsymm") << "UFSYMM invariantByPermutations()? " << p << endl;
}
void SymmetryBreaker::selectTerms(const Permutation& p) {
- TimerStat::CodeTimer codeTimer(d_selectTermsTimer);
+ TimerStat::CodeTimer codeTimer(d_stats.d_selectTermsTimer);
// use d_phi, put into d_terms
Debug("ufsymm") << "UFSYMM selectTerms(): " << p << endl;
}
}
+SymmetryBreaker::Statistics::Statistics(std::string name)
+ : d_clauses(name + "theory::uf::symmetry_breaker::clauses", 0)
+ , d_units(name + "theory::uf::symmetry_breaker::units", 0)
+ , d_permutationSetsConsidered(name + "theory::uf::symmetry_breaker::permutationSetsConsidered", 0)
+ , d_permutationSetsInvariant(name + "theory::uf::symmetry_breaker::permutationSetsInvariant", 0)
+ , d_invariantByPermutationsTimer(name + "theory::uf::symmetry_breaker::timers::invariantByPermutations")
+ , d_selectTermsTimer(name + "theory::uf::symmetry_breaker::timers::selectTerms")
+ , d_initNormalizationTimer(name + "theory::uf::symmetry_breaker::timers::initNormalization")
+{
+ smtStatisticsRegistry()->registerStat(&d_clauses);
+ smtStatisticsRegistry()->registerStat(&d_units);
+ smtStatisticsRegistry()->registerStat(&d_permutationSetsConsidered);
+ smtStatisticsRegistry()->registerStat(&d_permutationSetsInvariant);
+ smtStatisticsRegistry()->registerStat(&d_invariantByPermutationsTimer);
+ smtStatisticsRegistry()->registerStat(&d_selectTermsTimer);
+ smtStatisticsRegistry()->registerStat(&d_initNormalizationTimer);
+}
+
+SymmetryBreaker::Statistics::~Statistics()
+{
+ smtStatisticsRegistry()->unregisterStat(&d_clauses);
+ smtStatisticsRegistry()->unregisterStat(&d_units);
+ smtStatisticsRegistry()->unregisterStat(&d_permutationSetsConsidered);
+ smtStatisticsRegistry()->unregisterStat(&d_permutationSetsInvariant);
+ smtStatisticsRegistry()->unregisterStat(&d_invariantByPermutationsTimer);
+ smtStatisticsRegistry()->unregisterStat(&d_selectTermsTimer);
+ smtStatisticsRegistry()->unregisterStat(&d_initNormalizationTimer);
+}
+
SymmetryBreaker::Terms::iterator
SymmetryBreaker::selectMostPromisingTerm(Terms& terms) {
// use d_phi
Node normInternal(TNode phi, size_t level);
Node norm(TNode n);
+ std::string d_name;
+
// === STATISTICS ===
/** number of new clauses that come from the SymmetryBreaker */
- KEEP_STATISTIC(IntStat,
- d_clauses,
- "theory::uf::symmetry_breaker::clauses", 0);
- /** number of new clauses that come from the SymmetryBreaker */
- KEEP_STATISTIC(IntStat,
- d_units,
- "theory::uf::symmetry_breaker::units", 0);
- /** number of potential permutation sets we found */
- KEEP_STATISTIC(IntStat,
- d_permutationSetsConsidered,
- "theory::uf::symmetry_breaker::permutationSetsConsidered", 0);
- /** number of invariant permutation sets we found */
- KEEP_STATISTIC(IntStat,
- d_permutationSetsInvariant,
- "theory::uf::symmetry_breaker::permutationSetsInvariant", 0);
- /** time spent in invariantByPermutations() */
- KEEP_STATISTIC(TimerStat,
- d_invariantByPermutationsTimer,
- "theory::uf::symmetry_breaker::timers::invariantByPermutations");
- /** time spent in selectTerms() */
- KEEP_STATISTIC(TimerStat,
- d_selectTermsTimer,
- "theory::uf::symmetry_breaker::timers::selectTerms");
- /** time spent in initial round of normalization */
- KEEP_STATISTIC(TimerStat,
- d_initNormalizationTimer,
- "theory::uf::symmetry_breaker::timers::initNormalization");
+ struct Statistics {
+ /** number of new clauses that come from the SymmetryBreaker */
+ IntStat d_clauses;
+ IntStat d_units;
+ /** number of potential permutation sets we found */
+ IntStat d_permutationSetsConsidered;
+ /** number of invariant permutation sets we found */
+ IntStat d_permutationSetsInvariant;
+ /** time spent in invariantByPermutations() */
+ TimerStat d_invariantByPermutationsTimer;
+ /** time spent in selectTerms() */
+ TimerStat d_selectTermsTimer;
+ /** time spent in initial round of normalization */
+ TimerStat d_initNormalizationTimer;
+
+ Statistics(std::string name);
+ ~Statistics();
+ };
+
+ Statistics d_stats;
protected:
public:
- SymmetryBreaker(context::Context* context);
+ SymmetryBreaker(context::Context* context, std::string name = "");
~SymmetryBreaker() throw() {}
void assertFormula(TNode phi);
void apply(std::vector<Node>& newClauses);
#include "options/quantifiers_options.h"
#include "options/smt_options.h"
#include "options/uf_options.h"
+#include "proof/proof_manager.h"
+#include "proof/theory_proof.h"
+#include "proof/uf_proof.h"
#include "theory/theory_model.h"
#include "theory/type_enumerator.h"
#include "theory/uf/theory_uf_strong_solver.h"
using namespace std;
-using namespace CVC4;
-using namespace CVC4::theory;
-using namespace CVC4::theory::uf;
+
+namespace CVC4 {
+namespace theory {
+namespace uf {
/** Constructs a new instance of TheoryUF w.r.t. the provided context.*/
TheoryUF::TheoryUF(context::Context* c, context::UserContext* u,
OutputChannel& out, Valuation valuation,
- const LogicInfo& logicInfo, SmtGlobals* globals)
- : Theory(THEORY_UF, c, u, out, valuation, logicInfo, globals),
+ const LogicInfo& logicInfo, SmtGlobals* globals, std::string name)
+ : Theory(THEORY_UF, c, u, out, valuation, logicInfo, globals, name),
d_notify(*this),
/* The strong theory solver can be notified by EqualityEngine::init(),
* so make sure it's initialized first. */
d_thss(NULL),
- d_equalityEngine(d_notify, c, "theory::uf::TheoryUF", true),
+ d_equalityEngine(d_notify, c, name + "theory::uf::TheoryUF", true),
d_conflict(c, false),
d_literalsToPropagate(c),
d_literalsToPropagateIndex(c, 0),
d_functionsTerms(c),
- d_symb(u)
+ d_symb(u, name)
{
// The kinds we are treating as function application in congruence
d_equalityEngine.addFunctionKind(kind::APPLY_UF);
}
}
-void TheoryUF::explain(TNode literal, std::vector<TNode>& assumptions) {
+void TheoryUF::explain(TNode literal, std::vector<TNode>& assumptions, eq::EqProof* pf) {
// Do the work
bool polarity = literal.getKind() != kind::NOT;
TNode atom = polarity ? literal : literal[0];
- eq::EqProof * eqp = d_proofEnabled ? new eq::EqProof : NULL;
if (atom.getKind() == kind::EQUAL || atom.getKind() == kind::IFF) {
- d_equalityEngine.explainEquality(atom[0], atom[1], polarity, assumptions, eqp);
+ d_equalityEngine.explainEquality(atom[0], atom[1], polarity, assumptions, pf);
} else {
- d_equalityEngine.explainPredicate(atom, polarity, assumptions, eqp);
+ d_equalityEngine.explainPredicate(atom, polarity, assumptions, pf);
}
- //for now, just print debug
- //TODO : send the proof outwards : d_out->conflict( lem, eqp );
- if( eqp ){
- eqp->debug_print("uf-pf");
+ if( pf ){
+ Debug("uf-pf") << std::endl;
+ pf->debug_print("uf-pf");
}
}
Node TheoryUF::explain(TNode literal) {
+ return explain(literal, NULL);
+}
+
+Node TheoryUF::explain(TNode literal, eq::EqProof* pf) {
Debug("uf") << "TheoryUF::explain(" << literal << ")" << std::endl;
std::vector<TNode> assumptions;
- explain(literal, assumptions);
+ explain(literal, assumptions, pf);
return mkAnd(assumptions);
}
}/* TheoryUF::computeCareGraph() */
void TheoryUF::conflict(TNode a, TNode b) {
- //TODO: create EqProof at this level if d_proofEnabled = true
+ eq::EqProof* pf = d_proofsEnabled ? new eq::EqProof() : NULL;
if (a.getKind() == kind::CONST_BOOLEAN) {
- d_conflictNode = explain(a.iffNode(b));
+ d_conflictNode = explain(a.iffNode(b),pf);
} else {
- d_conflictNode = explain(a.eqNode(b));
+ d_conflictNode = explain(a.eqNode(b),pf);
}
- d_out->conflict(d_conflictNode);
+ ProofUF * puf = d_proofsEnabled ? new ProofUF( pf ) : NULL;
+ d_out->conflict(d_conflictNode, puf);
d_conflict = true;
}
d_thss->assertDisequal(t1, t2, reason);
}
}
+
+
+} /* namespace CVC4::theory::uf */
+} /* namespace CVC4::theory */
+} /* namespace CVC4 */
/**
* Explain why this literal is true by adding assumptions
+ * with proof (if "pf" is non-NULL).
*/
- void explain(TNode literal, std::vector<TNode>& assumptions);
+ void explain(TNode literal, std::vector<TNode>& assumptions, eq::EqProof* pf);
+ /**
+ * Explain a literal, with proof (if "pf" is non-NULL).
+ */
+ Node explain(TNode literal, eq::EqProof* pf);
+
/** Literals to propagate */
context::CDList<Node> d_literalsToPropagate;
/** Constructs a new instance of TheoryUF w.r.t. the provided context.*/
TheoryUF(context::Context* c, context::UserContext* u, OutputChannel& out,
Valuation valuation, const LogicInfo& logicInfo,
- SmtGlobals* globals);
+ SmtGlobals* globals, std::string name = "");
~TheoryUF();
}
};/* class CardinalityConstraintTypeRule */
+class PartialTypeRule {
+public:
+ inline static TypeNode computeType(NodeManager* nodeManager, TNode n, bool check)
+ throw (TypeCheckingExceptionPrivate, AssertionException) {
+ return n.getOperator().getType().getRangeType();
+ }
+};/* class PartialTypeRule */
+
class CardinalityValueTypeRule {
public:
inline static TypeNode computeType(NodeManager* nodeManager, TNode n, bool check)
# If a test shouldn't be run in e.g. competition mode,
# put it below in "TESTS +="
+# FIXME: Proof checking takes too long. Add this back.
+# fuzz15.delta01.smt
+
# Regression tests for SMT inputs
SMT_TESTS = \
fuzz01.smt \
fuzz12.smt \
fuzz13.smt \
fuzz14.smt \
- fuzz15.delta01.smt \
fuzz16.delta01.smt \
fuzz17.delta01.smt \
fuzz18.delta01.smt \
calc2_sec2_shifter_mult_bmc15.atlas.delta01.smt \
smtcompbug.smt \
unsound1.smt2 \
- unsound1-reduced.smt2
+ unsound1-reduced.smt2 \
+ bv-proof00.smt
# Regression tests for SMT2 inputs
SMT2_TESTS = divtest.smt2
--- /dev/null
+(benchmark fuzzsmt
+:logic QF_BV
+:status unsat
+:extrafuns ((v0 BitVec[7]))
+:extrafuns ((v1 BitVec[1]))
+:extrafuns ((v2 BitVec[7]))
+:extrafuns ((v3 BitVec[5]))
+:formula
+(let (?e4 bv9[4])
+(let (?e5 bv1[3])
+(let (?e6 bv15[5])
+(let (?e7 (ite (bvuge (sign_extend[2] v3) v2) bv1[1] bv0[1]))
+(let (?e8 (ite (distinct ?e7 v1) bv1[1] bv0[1]))
+(let (?e9 (bvxor (zero_extend[2] ?e6) v2))
+(let (?e10 (bvcomp ?e9 v2))
+(let (?e11 (bvnot ?e6))
+(let (?e12 (bvsub (sign_extend[6] ?e10) v2))
+(let (?e13 (bvneg v3))
+(let (?e14 (extract[0:0] ?e5))
+(let (?e15 (ite (bvugt ?e6 (sign_extend[4] ?e14)) bv1[1] bv0[1]))
+(let (?e16 (bvcomp ?e4 (sign_extend[1] ?e5)))
+(let (?e17 (bvnot ?e5))
+(let (?e18 (ite (= bv1[1] (extract[3:3] v0)) v2 v2))
+(let (?e19 (bvadd (sign_extend[4] ?e5) ?e12))
+(let (?e20 (bvnor (sign_extend[6] ?e15) ?e18))
+(let (?e21 (bvnor v0 (zero_extend[2] ?e11)))
+(let (?e22 (bvadd (zero_extend[4] ?e7) ?e13))
+(let (?e23 (ite (bvslt ?e18 v0) bv1[1] bv0[1]))
+(let (?e24 (zero_extend[0] ?e18))
+(let (?e25 (bvxnor ?e18 v0))
+(let (?e26 (ite (bvsge (zero_extend[6] ?e14) v0) bv1[1] bv0[1]))
+(let (?e27 (bvneg ?e13))
+(let (?e28 (bvxnor ?e13 ?e13))
+(let (?e29 (bvneg ?e12))
+(let (?e30 (zero_extend[3] v1))
+(let (?e31 (ite (bvsgt ?e29 ?e19) bv1[1] bv0[1]))
+(let (?e32 (ite (= bv1[1] (extract[5:5] ?e9)) ?e28 (sign_extend[2] ?e5)))
+(let (?e33 (bvcomp ?e14 ?e31))
+(let (?e34 (repeat[1] ?e25))
+(let (?e35 (ite (distinct ?e34 ?e21) bv1[1] bv0[1]))
+(let (?e36 (bvneg v0))
+(let (?e37 (ite (bvugt (sign_extend[2] ?e13) ?e19) bv1[1] bv0[1]))
+(let (?e38 (ite (distinct (sign_extend[4] ?e17) ?e24) bv1[1] bv0[1]))
+(let (?e39 (bvsub ?e29 (zero_extend[2] ?e13)))
+(let (?e40 (ite (bvule (sign_extend[2] ?e6) ?e21) bv1[1] bv0[1]))
+(let (?e41 (bvneg ?e9))
+(let (?e42 (ite (bvsle ?e29 ?e39) bv1[1] bv0[1]))
+(let (?e43 (bvneg ?e16))
+(let (?e44 (bvand v0 ?e41))
+(let (?e45 (bvnand ?e16 ?e15))
+(let (?e46 (bvand ?e13 (sign_extend[4] ?e43)))
+(let (?e47 (concat ?e31 ?e37))
+(let (?e48 (sign_extend[7] ?e43))
+(let (?e49 (bvnor ?e12 (sign_extend[6] ?e16)))
+(let (?e50 (bvmul v2 (sign_extend[2] ?e22)))
+(let (?e51 (ite (bvugt ?e34 ?e25) bv1[1] bv0[1]))
+(let (?e52 (sign_extend[1] ?e20))
+(let (?e53 (ite (bvslt ?e7 ?e51) bv1[1] bv0[1]))
+(let (?e54 (bvnand (sign_extend[6] ?e53) ?e36))
+(let (?e55 (extract[0:0] ?e43))
+(let (?e56 (bvnor v3 (sign_extend[4] ?e15)))
+(let (?e57 (zero_extend[5] ?e42))
+(let (?e58 (ite (bvult ?e37 ?e40) bv1[1] bv0[1]))
+(let (?e59 (bvashr ?e39 ?e18))
+(let (?e60 (ite (bvuge (zero_extend[4] ?e17) ?e39) bv1[1] bv0[1]))
+(let (?e61 (bvashr (sign_extend[7] ?e38) ?e52))
+(let (?e62 (bvashr (sign_extend[1] v2) ?e52))
+(let (?e63 (ite (= bv1[1] (extract[2:2] v2)) (zero_extend[3] ?e30) ?e25))
+(let (?e64 (ite (bvslt ?e23 ?e51) bv1[1] bv0[1]))
+(let (?e65 (ite (bvsgt ?e41 (sign_extend[6] ?e7)) bv1[1] bv0[1]))
+(let (?e66 (extract[0:0] ?e54))
+(let (?e67 (bvsub (zero_extend[4] ?e5) ?e63))
+(let (?e68 (ite (bvsle ?e33 ?e53) bv1[1] bv0[1]))
+(let (?e69 (bvnor v0 (sign_extend[4] ?e17)))
+(let (?e70 (ite (bvugt (zero_extend[6] v1) ?e67) bv1[1] bv0[1]))
+(let (?e71 (bvor ?e12 ?e49))
+(let (?e72 (ite (bvuge ?e34 (zero_extend[6] ?e16)) bv1[1] bv0[1]))
+(let (?e73 (ite (bvugt ?e63 (zero_extend[2] v3)) bv1[1] bv0[1]))
+(let (?e74 (bvnot v0))
+(let (?e75 (ite (bvsge ?e18 (sign_extend[4] ?e17)) bv1[1] bv0[1]))
+(let (?e76 (bvcomp (sign_extend[5] ?e7) ?e57))
+(let (?e77 (ite (bvsgt (zero_extend[7] ?e66) ?e62) bv1[1] bv0[1]))
+(let (?e78 (concat ?e39 ?e42))
+(let (?e79 (bvnor ?e67 v0))
+(let (?e80 (bvnor ?e32 v3))
+(let (?e81 (ite (= bv1[1] (extract[0:0] ?e5)) ?e57 (sign_extend[5] ?e37)))
+(let (?e82 (rotate_left[1] ?e5))
+(let (?e83 (bvcomp (sign_extend[2] ?e27) ?e69))
+(let (?e84 (bvshl (zero_extend[2] ?e32) ?e41))
+(let (?e85 (bvashr ?e51 ?e68))
+(let (?e86 (bvnand ?e8 ?e76))
+(let (?e87 (ite (bvsge (sign_extend[4] ?e23) ?e27) bv1[1] bv0[1]))
+(let (?e88 (ite (= bv1[1] (extract[0:0] ?e73)) ?e22 (zero_extend[4] ?e35)))
+(let (?e89 (bvnot ?e46))
+(let (?e90 (bvxnor ?e19 (zero_extend[1] ?e81)))
+(let (?e91 (repeat[1] ?e27))
+(let (?e92 (bvneg ?e31))
+(let (?e93 (ite (distinct ?e52 (sign_extend[7] ?e92)) bv1[1] bv0[1]))
+(let (?e94 (bvmul (sign_extend[6] ?e70) ?e90))
+(let (?e95 (bvneg ?e54))
+(let (?e96 (ite (bvsge (zero_extend[4] ?e33) ?e56) bv1[1] bv0[1]))
+(let (?e97 (ite (bvule ?e69 ?e50) bv1[1] bv0[1]))
+(let (?e98 (bvshl (sign_extend[7] ?e70) ?e48))
+(let (?e99 (zero_extend[2] ?e70))
+(let (?e100 (rotate_left[0] ?e17))
+(let (?e101 (ite (= bv1[1] (extract[0:0] ?e70)) ?e95 (zero_extend[2] ?e80)))
+(let (?e102 (ite (bvule (sign_extend[1] ?e100) ?e30) bv1[1] bv0[1]))
+(let (?e103 (bvnor (sign_extend[6] ?e58) ?e71))
+(let (?e104 (bvashr ?e25 (zero_extend[2] ?e11)))
+(let (?e105 (ite (bvule ?e59 ?e63) bv1[1] bv0[1]))
+(let (?e106 (ite (= bv1[1] (extract[1:1] ?e11)) (sign_extend[2] ?e56) ?e9))
+(let (?e107 (bvor ?e90 (zero_extend[6] ?e42)))
+(let (?e108 (bvnot ?e18))
+(let (?e109 (ite (bvult (sign_extend[6] ?e10) ?e41) bv1[1] bv0[1]))
+(let (?e110 (bvxnor (sign_extend[6] ?e86) ?e20))
+(let (?e111 (concat ?e42 ?e105))
+(let (?e112 (ite (bvsle (zero_extend[1] ?e104) ?e98) bv1[1] bv0[1]))
+(let (?e113 (bvashr ?e20 ?e39))
+(let (?e114 (bvnand ?e63 ?e94))
+(let (?e115 (bvxor ?e110 (zero_extend[6] ?e85)))
+(let (?e116 (bvxor (sign_extend[1] ?e12) ?e48))
+(let (?e117 (bvxor (zero_extend[6] ?e77) ?e67))
+(let (?e118 (rotate_right[0] ?e51))
+(let (?e119 (bvnot ?e73))
+(let (?e120 (ite (bvuge ?e89 (sign_extend[4] ?e65)) bv1[1] bv0[1]))
+(let (?e121 (bvashr (sign_extend[6] ?e83) ?e18))
+(let (?e122 (rotate_right[0] ?e68))
+(let (?e123 (rotate_left[0] ?e87))
+(let (?e124 (bvand ?e19 (zero_extend[1] ?e57)))
+(let (?e125 (ite (bvsge (sign_extend[6] ?e93) ?e74) bv1[1] bv0[1]))
+(let (?e126 (bvshl (zero_extend[6] ?e97) ?e103))
+(let (?e127 (bvor ?e29 (sign_extend[6] ?e65)))
+(let (?e128 (bvnor ?e62 (sign_extend[1] ?e24)))
+(let (?e129 (ite (bvult ?e94 (sign_extend[6] ?e76)) bv1[1] bv0[1]))
+(let (?e130 (rotate_right[0] ?e10))
+(let (?e131 (sign_extend[1] ?e71))
+(let (?e132 (ite (bvuge ?e5 (sign_extend[2] ?e66)) bv1[1] bv0[1]))
+(let (?e133 (ite (= ?e55 ?e26) bv1[1] bv0[1]))
+(let (?e134 (ite (bvslt (sign_extend[2] ?e32) ?e127) bv1[1] bv0[1]))
+(let (?e135 (sign_extend[6] ?e102))
+(let (?e136 (bvxnor ?e101 (sign_extend[2] ?e13)))
+(let (?e137 (ite (bvslt (sign_extend[7] ?e83) ?e98) bv1[1] bv0[1]))
+(let (?e138 (ite (bvugt ?e79 ?e67) bv1[1] bv0[1]))
+(let (?e139 (bvsub (zero_extend[6] ?e73) ?e9))
+(let (?e140 (bvxor (zero_extend[6] ?e137) ?e21))
+(let (?e141 (bvnand ?e90 (zero_extend[2] ?e80)))
+(let (?e142 (ite (bvugt ?e90 (zero_extend[6] ?e38)) bv1[1] bv0[1]))
+(let (?e143 (repeat[2] ?e30))
+(let (?e144 (ite (bvuge ?e135 (sign_extend[2] v3)) bv1[1] bv0[1]))
+(let (?e145 (bvxnor (zero_extend[4] ?e82) ?e113))
+(let (?e146 (sign_extend[0] ?e140))
+(let (?e147 (bvmul ?e146 (zero_extend[2] ?e27)))
+(let (?e148 (ite (bvult ?e84 (sign_extend[1] ?e81)) bv1[1] bv0[1]))
+(let (?e149 (bvshl ?e135 (sign_extend[6] ?e26)))
+(let (?e150 (bvmul ?e71 ?e20))
+(let (?e151 (bvshl ?e125 ?e37))
+(let (?e152 (ite (bvult ?e36 (zero_extend[6] ?e53)) bv1[1] bv0[1]))
+(let (?e153 (bvneg ?e106))
+(let (?e154 (ite (bvsgt ?e143 ?e131) bv1[1] bv0[1]))
+(let (?e155 (zero_extend[0] ?e47))
+(let (?e156 (bvadd ?e120 ?e138))
+(let (?e157 (bvxnor ?e138 v1))
+(let (?e158 (rotate_left[0] ?e70))
+(let (?e159 (ite (bvsle ?e30 (zero_extend[3] ?e8)) bv1[1] bv0[1]))
+(let (?e160 (bvnot ?e134))
+(let (?e161 (ite (bvslt ?e71 (zero_extend[6] ?e66)) bv1[1] bv0[1]))
+(let (?e162 (extract[0:0] ?e79))
+(let (?e163 (bvnand (sign_extend[4] ?e137) ?e80))
+(let (?e164 (ite (bvult (sign_extend[6] ?e154) ?e135) bv1[1] bv0[1]))
+(let (?e165 (sign_extend[1] ?e156))
+(let (?e166 (ite (bvugt ?e149 (zero_extend[6] ?e55)) bv1[1] bv0[1]))
+(let (?e167 (ite (= bv1[1] (extract[0:0] ?e164)) (sign_extend[2] ?e31) ?e5))
+(let (?e168 (zero_extend[5] ?e73))
+(let (?e169 (bvand ?e39 (zero_extend[2] ?e13)))
+(let (?e170 (ite (bvsgt (zero_extend[6] ?e66) ?e44) bv1[1] bv0[1]))
+(let (?e171 (ite (bvsle ?e114 (zero_extend[6] ?e26)) bv1[1] bv0[1]))
+(let (?e172 (ite (bvult ?e52 (sign_extend[7] ?e171)) bv1[1] bv0[1]))
+(let (?e173 (ite (bvugt (sign_extend[4] ?e30) ?e78) bv1[1] bv0[1]))
+(let (?e174 (bvadd ?e121 (sign_extend[6] ?e151)))
+(let (?e175 (ite (bvult (sign_extend[6] ?e130) ?e34) bv1[1] bv0[1]))
+(let (?e176 (bvand ?e135 v2))
+(let (?e177 (bvneg ?e152))
+(let (?e178 (ite (distinct ?e42 ?e35) bv1[1] bv0[1]))
+(let (?e179 (bvadd (sign_extend[2] ?e89) ?e39))
+(let (?e180 (bvnor ?e10 ?e118))
+(let (?e181 (ite (bvugt ?e134 ?e148) bv1[1] bv0[1]))
+(let (?e182 (ite (= ?e36 ?e108) bv1[1] bv0[1]))
+(let (?e183 (bvxor v1 ?e86))
+(let (?e184 (bvsub (sign_extend[6] ?e181) ?e59))
+(let (?e185 (bvor (sign_extend[2] ?e33) ?e5))
+(let (?e186 (rotate_right[0] ?e161))
+(let (?e187 (bvcomp ?e29 (zero_extend[6] ?e87)))
+(let (?e188 (bvmul (zero_extend[1] ?e69) ?e62))
+(let (?e189 (bvor ?e150 (zero_extend[6] ?e170)))
+(let (?e190 (repeat[6] ?e26))
+(let (?e191 (bvnot ?e75))
+(let (?e192 (bvnand ?e182 ?e35))
+(let (?e193 (ite (= bv1[1] (extract[0:0] ?e123)) ?e7 ?e73))
+(let (?e194 (bvneg ?e60))
+(let (?e195 (bvshl ?e62 (zero_extend[6] ?e165)))
+(let (?e196 (bvneg ?e95))
+(let (?e197 (bvnot ?e58))
+(let (?e198 (bvneg ?e56))
+(let (?e199 (bvashr ?e170 ?e138))
+(let (?e200 (bvcomp (zero_extend[6] ?e35) ?e139))
+(let (?e201 (sign_extend[0] ?e157))
+(let (?e202 (extract[0:0] ?e7))
+(let (?e203 (ite (bvule ?e18 ?e107) bv1[1] bv0[1]))
+(let (?e204 (bvxor ?e54 ?e150))
+(let (?e205 (bvxor ?e107 ?e114))
+(let (?e206 (ite (bvule ?e62 (zero_extend[1] ?e153)) bv1[1] bv0[1]))
+(let (?e207 (bvneg ?e112))
+(let (?e208 (rotate_left[0] ?e64))
+(let (?e209 (bvcomp (sign_extend[6] ?e122) ?e34))
+(let (?e210 (bvor ?e39 ?e126))
+(let (?e211 (sign_extend[3] ?e96))
+(let (?e212 (bvnor (sign_extend[1] ?e166) ?e47))
+(let (?e213 (rotate_left[0] ?e117))
+(let (?e214 (ite (= (zero_extend[6] ?e199) ?e74) bv1[1] bv0[1]))
+(let (?e215 (concat ?e142 ?e160))
+(let (?e216 (bvor ?e54 (sign_extend[4] ?e17)))
+(let (?e217 (ite (distinct (sign_extend[6] ?e55) ?e41) bv1[1] bv0[1]))
+(let (?e218 (ite (distinct ?e206 ?e203) bv1[1] bv0[1]))
+(let (?e219 (ite (bvsle ?e207 ?e105) bv1[1] bv0[1]))
+(let (?e220 (ite (bvsle ?e139 ?e9) bv1[1] bv0[1]))
+(let (?e221 (bvneg ?e180))
+(let (?e222 (ite (bvslt (sign_extend[5] ?e155) ?e141) bv1[1] bv0[1]))
+(let (?e223 (ite (bvult ?e179 (zero_extend[6] ?e218)) bv1[1] bv0[1]))
+(let (?e224 (ite (bvugt ?e180 ?e83) bv1[1] bv0[1]))
+(let (?e225 (ite (bvsge ?e150 (zero_extend[6] ?e70)) bv1[1] bv0[1]))
+(let (?e226 (repeat[1] ?e15))
+(let (?e227 (bvneg ?e67))
+(let (?e228 (ite (bvuge ?e177 ?e65) bv1[1] bv0[1]))
+(let (?e229 (ite (bvule ?e141 ?e101) bv1[1] bv0[1]))
+(let (?e230 (ite (= ?e140 (sign_extend[6] ?e125)) bv1[1] bv0[1]))
+(let (?e231 (bvor (zero_extend[6] ?e221) ?e104))
+(let (?e232 (zero_extend[1] ?e149))
+(let (?e233 (ite (bvult v0 (zero_extend[6] ?e10)) bv1[1] bv0[1]))
+(let (?e234 (bvadd ?e194 ?e7))
+(let (?e235 (bvmul (sign_extend[6] ?e164) ?e44))
+(let (?e236 (bvnor ?e147 (zero_extend[6] ?e223)))
+(let (?e237 (concat ?e40 ?e184))
+(let (?e238 (bvsub (sign_extend[2] ?e55) ?e167))
+(let (?e239 (ite (bvule (sign_extend[4] ?e138) ?e28) bv1[1] bv0[1]))
+(let (?e240 (bvashr ?e110 (zero_extend[6] ?e180)))
+(let (?e241 (ite (bvslt ?e163 (sign_extend[4] ?e197)) bv1[1] bv0[1]))
+(let (?e242 (bvadd (sign_extend[7] ?e123) ?e131))
+(let (?e243 (bvxor ?e126 (zero_extend[6] ?e83)))
+(let (?e244 (ite (bvuge ?e168 (sign_extend[5] ?e26)) bv1[1] bv0[1]))
+(let (?e245 (ite (distinct ?e143 (zero_extend[1] ?e205)) bv1[1] bv0[1]))
+(let (?e246 (bvsub ?e29 (sign_extend[6] ?e132)))
+(let (?e247 (bvashr ?e24 (sign_extend[6] ?e192)))
+(let (?e248 (bvxnor (zero_extend[6] ?e162) ?e140))
+(let (?e249 (bvnor ?e76 ?e10))
+(let (?e250 (bvnor ?e175 ?e214))
+(let (?e251 (bvnand (zero_extend[6] ?e40) ?e21))
+(let (?e252 (bvsub ?e121 (zero_extend[2] ?e80)))
+(let (?e253 (ite (bvsgt (zero_extend[3] ?e4) ?e139) bv1[1] bv0[1]))
+(flet ($e254 (bvsle ?e82 (zero_extend[2] ?e133)))
+(flet ($e255 (bvult ?e246 (sign_extend[2] ?e11)))
+(flet ($e256 (bvsgt ?e117 ?e94))
+(flet ($e257 (distinct (zero_extend[7] ?e132) ?e52))
+(flet ($e258 (= ?e83 ?e177))
+(flet ($e259 (bvugt ?e115 (sign_extend[6] ?e138)))
+(flet ($e260 (bvsle (zero_extend[6] ?e35) ?e179))
+(flet ($e261 (bvult ?e239 ?e208))
+(flet ($e262 (bvule ?e244 ?e219))
+(flet ($e263 (bvule ?e165 (zero_extend[1] ?e226)))
+(flet ($e264 (distinct ?e81 ?e57))
+(flet ($e265 (bvsgt ?e27 (sign_extend[4] ?e180)))
+(flet ($e266 (bvuge ?e147 (zero_extend[6] ?e76)))
+(flet ($e267 (bvsle ?e114 ?e147))
+(flet ($e268 (bvslt ?e143 (zero_extend[1] ?e141)))
+(flet ($e269 (bvsge (zero_extend[4] ?e4) ?e52))
+(flet ($e270 (bvsge ?e142 ?e223))
+(flet ($e271 (bvule (zero_extend[2] ?e27) ?e205))
+(flet ($e272 (bvult ?e235 (sign_extend[2] ?e56)))
+(flet ($e273 (bvule ?e189 (zero_extend[6] ?e92)))
+(flet ($e274 (bvsge ?e68 ?e42))
+(flet ($e275 (distinct ?e77 ?e228))
+(flet ($e276 (= ?e81 (sign_extend[5] ?e193)))
+(flet ($e277 (bvugt (sign_extend[4] ?e185) ?e117))
+(flet ($e278 (bvult v2 ?e84))
+(flet ($e279 (bvsle (zero_extend[6] ?e239) ?e140))
+(flet ($e280 (= ?e80 (zero_extend[4] ?e217)))
+(flet ($e281 (bvuge (sign_extend[1] ?e12) ?e61))
+(flet ($e282 (bvugt ?e48 (sign_extend[7] ?e7)))
+(flet ($e283 (bvult ?e68 ?e241))
+(flet ($e284 (bvsgt ?e235 (zero_extend[6] ?e203)))
+(flet ($e285 (distinct ?e147 (sign_extend[6] ?e102)))
+(flet ($e286 (= (sign_extend[1] ?e190) ?e174))
+(flet ($e287 (bvslt ?e21 ?e107))
+(flet ($e288 (bvugt ?e201 ?e122))
+(flet ($e289 (bvule (zero_extend[6] ?e92) ?e136))
+(flet ($e290 (bvult (zero_extend[6] ?e137) ?e176))
+(flet ($e291 (= (zero_extend[5] ?e212) ?e24))
+(flet ($e292 (distinct ?e157 ?e225))
+(flet ($e293 (= (sign_extend[5] ?e47) ?e252))
+(flet ($e294 (bvugt ?e50 (zero_extend[6] ?e130)))
+(flet ($e295 (= ?e158 ?e14))
+(flet ($e296 (bvsge (sign_extend[1] ?e138) ?e47))
+(flet ($e297 (bvsgt (sign_extend[3] ?e11) ?e188))
+(flet ($e298 (bvult ?e242 (sign_extend[1] ?e121)))
+(flet ($e299 (bvsge ?e94 ?e74))
+(flet ($e300 (bvsge ?e231 (zero_extend[6] ?e225)))
+(flet ($e301 (bvule (sign_extend[1] ?e152) ?e111))
+(flet ($e302 (bvsgt ?e155 (zero_extend[1] ?e160)))
+(flet ($e303 (distinct ?e140 (sign_extend[4] ?e82)))
+(flet ($e304 (bvugt ?e55 ?e158))
+(flet ($e305 (bvule ?e58 ?e180))
+(flet ($e306 (bvule ?e198 (sign_extend[4] ?e182)))
+(flet ($e307 (= ?e71 ?e36))
+(flet ($e308 (bvsle ?e235 ?e136))
+(flet ($e309 (bvugt ?e90 (sign_extend[6] ?e97)))
+(flet ($e310 (bvslt ?e201 ?e172))
+(flet ($e311 (= ?e6 (zero_extend[4] ?e177)))
+(flet ($e312 (bvslt ?e134 ?e186))
+(flet ($e313 (bvugt ?e205 (zero_extend[6] ?e249)))
+(flet ($e314 (bvsgt (sign_extend[6] ?e70) ?e205))
+(flet ($e315 (bvule ?e17 (zero_extend[2] ?e144)))
+(flet ($e316 (distinct (sign_extend[6] ?e161) v0))
+(flet ($e317 (bvule (zero_extend[6] ?e109) ?e252))
+(flet ($e318 (distinct ?e238 (sign_extend[2] ?e142)))
+(flet ($e319 (bvsgt ?e38 ?e137))
+(flet ($e320 (distinct (zero_extend[4] ?e202) ?e11))
+(flet ($e321 (bvsle ?e5 (sign_extend[2] ?e55)))
+(flet ($e322 (bvugt ?e154 ?e239))
+(flet ($e323 (bvule ?e147 ?e104))
+(flet ($e324 (bvuge ?e213 ?e146))
+(flet ($e325 (bvult ?e108 ?e189))
+(flet ($e326 (distinct ?e50 (sign_extend[6] ?e68)))
+(flet ($e327 (bvsge (zero_extend[1] ?e150) ?e61))
+(flet ($e328 (bvule ?e198 (zero_extend[4] ?e170)))
+(flet ($e329 (bvuge (sign_extend[6] ?e148) ?e79))
+(flet ($e330 (= ?e69 ?e49))
+(flet ($e331 (= (sign_extend[4] ?e167) ?e25))
+(flet ($e332 (distinct ?e190 (sign_extend[1] ?e46)))
+(flet ($e333 (bvsle (sign_extend[6] ?e118) ?e139))
+(flet ($e334 (bvugt ?e117 (sign_extend[6] ?e172)))
+(flet ($e335 (bvugt ?e138 ?e218))
+(flet ($e336 (bvsle ?e176 (zero_extend[6] ?e170)))
+(flet ($e337 (bvule ?e252 (sign_extend[6] ?e138)))
+(flet ($e338 (bvsle ?e194 ?e158))
+(flet ($e339 (bvsle (zero_extend[5] ?e111) ?e25))
+(flet ($e340 (bvslt ?e40 ?e220))
+(flet ($e341 (bvuge ?e79 ?e140))
+(flet ($e342 (bvugt ?e173 ?e72))
+(flet ($e343 (bvslt ?e156 ?e208))
+(flet ($e344 (bvugt ?e196 (zero_extend[6] ?e37)))
+(flet ($e345 (= (zero_extend[4] ?e130) ?e88))
+(flet ($e346 (= ?e41 ?e213))
+(flet ($e347 (bvule (sign_extend[4] ?e93) ?e13))
+(flet ($e348 (distinct ?e204 ?e29))
+(flet ($e349 (bvult (zero_extend[6] ?e165) ?e143))
+(flet ($e350 (bvult (sign_extend[6] ?e72) ?e204))
+(flet ($e351 (bvult ?e118 ?e144))
+(flet ($e352 (bvsle ?e138 ?e138))
+(flet ($e353 (distinct ?e145 ?e113))
+(flet ($e354 (bvugt (sign_extend[6] ?e157) ?e251))
+(flet ($e355 (bvule ?e227 ?e150))
+(flet ($e356 (= ?e25 (sign_extend[6] ?e42)))
+(flet ($e357 (bvsle (zero_extend[1] ?e146) ?e98))
+(flet ($e358 (distinct ?e215 (sign_extend[1] ?e158)))
+(flet ($e359 (= ?e55 ?e133))
+(flet ($e360 (= ?e19 (sign_extend[6] ?e175)))
+(flet ($e361 (distinct ?e125 ?e151))
+(flet ($e362 (bvuge ?e54 ?e24))
+(flet ($e363 (bvuge ?e249 ?e152))
+(flet ($e364 (bvsge (sign_extend[1] ?e190) ?e39))
+(flet ($e365 (bvsgt ?e27 (zero_extend[4] ?e214)))
+(flet ($e366 (= ?e19 (sign_extend[6] ?e73)))
+(flet ($e367 (distinct ?e210 ?e216))
+(flet ($e368 (distinct ?e19 (zero_extend[6] ?e68)))
+(flet ($e369 (bvsle ?e102 ?e51))
+(flet ($e370 (bvugt ?e205 (zero_extend[6] ?e119)))
+(flet ($e371 (bvslt ?e140 (zero_extend[6] ?e133)))
+(flet ($e372 (bvugt ?e91 (sign_extend[4] ?e209)))
+(flet ($e373 (bvslt ?e174 ?e127))
+(flet ($e374 (bvsgt ?e9 (zero_extend[2] ?e13)))
+(flet ($e375 (bvule (sign_extend[4] ?e241) ?e13))
+(flet ($e376 (bvsle (sign_extend[6] ?e160) ?e114))
+(flet ($e377 (distinct ?e236 ?e103))
+(flet ($e378 (bvsle ?e103 (zero_extend[2] ?e28)))
+(flet ($e379 (= (sign_extend[6] ?e96) ?e169))
+(flet ($e380 (bvule ?e68 ?e249))
+(flet ($e381 (bvuge ?e147 (zero_extend[6] ?e156)))
+(flet ($e382 (bvuge ?e187 ?e31))
+(flet ($e383 (bvsgt ?e118 ?e130))
+(flet ($e384 (bvsle (sign_extend[1] ?e165) ?e17))
+(flet ($e385 (bvuge (zero_extend[7] ?e118) ?e48))
+(flet ($e386 (bvult (sign_extend[6] ?e197) ?e124))
+(flet ($e387 (bvsgt ?e211 (zero_extend[3] ?e31)))
+(flet ($e388 (bvslt ?e52 (sign_extend[7] ?e8)))
+(flet ($e389 (bvsle (sign_extend[3] ?e211) ?e49))
+(flet ($e390 (bvsgt (sign_extend[2] ?e151) ?e82))
+(flet ($e391 (bvult ?e23 ?e228))
+(flet ($e392 (bvule (zero_extend[4] ?e17) ?e246))
+(flet ($e393 (bvugt ?e191 ?e191))
+(flet ($e394 (bvult ?e160 ?e92))
+(flet ($e395 (bvuge ?e51 ?e65))
+(flet ($e396 (bvuge (zero_extend[1] ?e190) ?e108))
+(flet ($e397 (bvuge ?e69 (sign_extend[6] ?e65)))
+(flet ($e398 (bvult ?e200 ?e123))
+(flet ($e399 (= (zero_extend[7] ?e76) ?e78))
+(flet ($e400 (bvsgt (zero_extend[2] ?e118) ?e5))
+(flet ($e401 (bvugt (zero_extend[4] ?e82) ?e248))
+(flet ($e402 (bvsle ?e227 ?e127))
+(flet ($e403 (= ?e213 ?e95))
+(flet ($e404 (bvugt ?e54 (zero_extend[6] ?e109)))
+(flet ($e405 (bvsge ?e25 ?e139))
+(flet ($e406 (bvule ?e98 (zero_extend[7] ?e192)))
+(flet ($e407 (bvugt (sign_extend[7] ?e26) ?e98))
+(flet ($e408 (bvsgt ?e140 ?e95))
+(flet ($e409 (bvugt ?e112 ?e221))
+(flet ($e410 (bvugt (sign_extend[2] ?e46) ?e189))
+(flet ($e411 (bvuge (sign_extend[6] ?e142) ?e184))
+(flet ($e412 (bvslt (zero_extend[6] ?e200) ?e63))
+(flet ($e413 (bvsge ?e72 ?e40))
+(flet ($e414 (bvule ?e152 ?e151))
+(flet ($e415 (bvsge ?e59 (zero_extend[2] ?e22)))
+(flet ($e416 (bvsge ?e188 (sign_extend[7] ?e173)))
+(flet ($e417 (bvsgt ?e98 (zero_extend[1] ?e63)))
+(flet ($e418 (bvult ?e29 (zero_extend[2] ?e80)))
+(flet ($e419 (bvsgt ?e59 (zero_extend[6] ?e87)))
+(flet ($e420 (bvuge (sign_extend[2] ?e156) ?e99))
+(flet ($e421 (bvsgt ?e77 ?e118))
+(flet ($e422 (bvugt ?e74 (sign_extend[5] ?e111)))
+(flet ($e423 (bvult ?e180 ?e181))
+(flet ($e424 (bvsle ?e90 (sign_extend[6] ?e148)))
+(flet ($e425 (distinct ?e160 ?e194))
+(flet ($e426 (bvsle ?e184 (sign_extend[6] ?e45)))
+(flet ($e427 (= ?e252 (sign_extend[2] ?e11)))
+(flet ($e428 (bvsge ?e24 (zero_extend[6] ?e134)))
+(flet ($e429 (bvsgt ?e160 ?e206))
+(flet ($e430 (bvugt (zero_extend[2] ?e22) ?e240))
+(flet ($e431 (bvsge ?e95 ?e19))
+(flet ($e432 (bvsge ?e201 ?e87))
+(flet ($e433 (bvsle ?e34 ?e145))
+(flet ($e434 (bvuge ?e117 (zero_extend[6] ?e51)))
+(flet ($e435 (bvule ?e216 ?e145))
+(flet ($e436 (bvslt ?e52 (zero_extend[7] ?e191)))
+(flet ($e437 (bvslt ?e16 ?e129))
+(flet ($e438 (bvsge (zero_extend[7] ?e249) ?e188))
+(flet ($e439 (bvsle ?e138 ?e33))
+(flet ($e440 (distinct ?e103 (sign_extend[6] ?e186)))
+(flet ($e441 (bvuge ?e145 (sign_extend[6] ?e118)))
+(flet ($e442 (bvsgt ?e183 ?e102))
+(flet ($e443 (bvuge (zero_extend[6] ?e233) ?e49))
+(flet ($e444 (= ?e105 ?e160))
+(flet ($e445 (bvsgt ?e145 ?e104))
+(flet ($e446 (bvslt (zero_extend[2] ?e185) ?e32))
+(flet ($e447 (bvugt ?e122 ?e162))
+(flet ($e448 (= (sign_extend[6] ?e156) ?e240))
+(flet ($e449 (bvsge ?e83 ?e197))
+(flet ($e450 (bvsgt ?e89 (zero_extend[4] ?e70)))
+(flet ($e451 (bvsle (zero_extend[6] ?e202) ?e251))
+(flet ($e452 (bvslt ?e203 ?e229))
+(flet ($e453 (bvsge (sign_extend[6] ?e201) ?e63))
+(flet ($e454 (bvslt ?e33 ?e70))
+(flet ($e455 (bvuge ?e119 ?e173))
+(flet ($e456 (distinct ?e205 ?e210))
+(flet ($e457 (bvslt ?e230 ?e38))
+(flet ($e458 (bvsgt ?e45 ?e159))
+(flet ($e459 (bvuge ?e231 ?e115))
+(flet ($e460 (bvslt (sign_extend[5] ?e16) ?e81))
+(flet ($e461 (bvugt (sign_extend[6] ?e15) ?e126))
+(flet ($e462 (bvsgt ?e108 ?e106))
+(flet ($e463 (bvsgt ?e41 ?e252))
+(flet ($e464 (bvsge ?e56 (sign_extend[4] ?e233)))
+(flet ($e465 (bvult ?e76 ?e23))
+(flet ($e466 (bvuge ?e20 ?e126))
+(flet ($e467 (bvslt ?e85 ?e86))
+(flet ($e468 (bvuge ?e11 (zero_extend[4] ?e70)))
+(flet ($e469 (bvsgt (sign_extend[7] ?e87) ?e188))
+(flet ($e470 (bvsge (zero_extend[5] ?e199) ?e190))
+(flet ($e471 (= ?e146 ?e205))
+(flet ($e472 (distinct (sign_extend[4] ?e75) ?e32))
+(flet ($e473 (bvult (zero_extend[6] ?e222) ?e54))
+(flet ($e474 (bvult (zero_extend[6] ?e162) ?e149))
+(flet ($e475 (bvsge ?e50 (sign_extend[4] ?e99)))
+(flet ($e476 (bvult (sign_extend[1] ?e217) ?e165))
+(flet ($e477 (= ?e36 ?e117))
+(flet ($e478 (bvuge ?e80 (zero_extend[4] ?e87)))
+(flet ($e479 (= (sign_extend[6] ?e161) ?e204))
+(flet ($e480 (bvuge ?e227 (sign_extend[2] ?e89)))
+(flet ($e481 (bvslt (zero_extend[5] ?e5) ?e128))
+(flet ($e482 (bvuge (sign_extend[4] ?e99) ?e213))
+(flet ($e483 (bvsle (sign_extend[3] ?e138) ?e4))
+(flet ($e484 (distinct (sign_extend[7] ?e105) ?e195))
+(flet ($e485 (bvult ?e189 (sign_extend[6] ?e65)))
+(flet ($e486 (bvugt (zero_extend[6] ?e66) ?e20))
+(flet ($e487 (bvslt ?e76 ?e26))
+(flet ($e488 (bvsle ?e109 ?e68))
+(flet ($e489 (bvuge ?e56 (zero_extend[4] ?e250)))
+(flet ($e490 (bvule ?e61 (zero_extend[7] ?e156)))
+(flet ($e491 (bvsle (sign_extend[6] ?e144) ?e18))
+(flet ($e492 (bvsle (zero_extend[6] ?e26) ?e139))
+(flet ($e493 (bvslt (zero_extend[4] ?e200) ?e32))
+(flet ($e494 (bvslt (sign_extend[6] ?e218) ?e94))
+(flet ($e495 (bvslt ?e104 (zero_extend[6] ?e239)))
+(flet ($e496 (= (sign_extend[4] ?e211) ?e116))
+(flet ($e497 (distinct (sign_extend[3] ?e97) ?e211))
+(flet ($e498 (= ?e50 ?e210))
+(flet ($e499 (distinct (zero_extend[6] ?e192) ?e205))
+(flet ($e500 (bvsle ?e84 (sign_extend[6] ?e250)))
+(flet ($e501 (bvslt (zero_extend[4] ?e222) ?e13))
+(flet ($e502 (bvule ?e124 (zero_extend[6] ?e112)))
+(flet ($e503 (= ?e8 ?e177))
+(flet ($e504 (bvuge ?e200 ?e158))
+(flet ($e505 (bvugt (zero_extend[6] ?e77) ?e126))
+(flet ($e506 (= ?e148 ?e60))
+(flet ($e507 (bvuge (zero_extend[6] ?e132) ?e121))
+(flet ($e508 (bvule (sign_extend[5] ?e148) ?e81))
+(flet ($e509 (bvsle (sign_extend[5] ?e38) ?e81))
+(flet ($e510 (bvsge (zero_extend[4] ?e238) ?e36))
+(flet ($e511 (bvuge ?e231 (sign_extend[4] ?e99)))
+(flet ($e512 (bvsgt ?e46 (sign_extend[4] ?e225)))
+(flet ($e513 (bvsgt ?e29 (sign_extend[6] ?e245)))
+(flet ($e514 (bvsle ?e116 (zero_extend[7] ?e199)))
+(flet ($e515 (= ?e207 ?e16))
+(flet ($e516 (distinct ?e211 (zero_extend[3] ?e177)))
+(flet ($e517 (bvsgt ?e78 (sign_extend[7] ?e229)))
+(flet ($e518 (bvsge ?e88 (zero_extend[4] ?e119)))
+(flet ($e519 (bvult ?e128 (zero_extend[7] ?e120)))
+(flet ($e520 (bvugt ?e118 ?e225))
+(flet ($e521 (bvuge (sign_extend[6] ?e181) ?e49))
+(flet ($e522 (bvugt ?e115 (zero_extend[6] ?e222)))
+(flet ($e523 (bvult (zero_extend[6] ?e250) ?e94))
+(flet ($e524 (bvsle ?e60 ?e120))
+(flet ($e525 (bvugt ?e146 ?e236))
+(flet ($e526 (distinct ?e16 ?e123))
+(flet ($e527 (bvugt ?e124 ?e248))
+(flet ($e528 (bvult ?e189 ?e29))
+(flet ($e529 (bvult ?e154 ?e118))
+(flet ($e530 (= (sign_extend[7] ?e154) ?e143))
+(flet ($e531 (bvugt (sign_extend[1] ?e34) ?e131))
+(flet ($e532 (bvule ?e115 (zero_extend[6] ?e199)))
+(flet ($e533 (bvuge (zero_extend[6] ?e132) ?e110))
+(flet ($e534 (bvsgt ?e240 ?e227))
+(flet ($e535 (bvsle ?e246 ?e19))
+(flet ($e536 (bvsle ?e55 ?e207))
+(flet ($e537 (bvsge (zero_extend[5] ?e164) ?e190))
+(flet ($e538 (distinct (sign_extend[6] ?e183) ?e71))
+(flet ($e539 (bvslt (zero_extend[7] ?e197) ?e195))
+(flet ($e540 (bvslt ?e14 ?e233))
+(flet ($e541 (bvugt (sign_extend[6] ?e239) ?e44))
+(flet ($e542 (bvugt (sign_extend[6] ?e220) ?e36))
+(flet ($e543 (= ?e41 ?e127))
+(flet ($e544 (bvsle ?e139 ?e127))
+(flet ($e545 (bvsle ?e28 (sign_extend[4] ?e129)))
+(flet ($e546 (bvugt ?e106 ?e18))
+(flet ($e547 (= ?e224 ?e96))
+(flet ($e548 (bvugt ?e237 (zero_extend[7] ?e223)))
+(flet ($e549 (bvslt (zero_extend[6] ?e202) ?e204))
+(flet ($e550 (distinct (sign_extend[1] ?e79) ?e78))
+(flet ($e551 (bvsgt (zero_extend[7] ?e160) ?e78))
+(flet ($e552 (bvsge (sign_extend[7] ?e137) ?e232))
+(flet ($e553 (bvsge (zero_extend[7] ?e193) ?e128))
+(flet ($e554 (bvsge (zero_extend[4] ?e76) ?e22))
+(flet ($e555 (bvsgt (zero_extend[6] ?e96) ?e150))
+(flet ($e556 (bvugt ?e204 (zero_extend[2] ?e89)))
+(flet ($e557 (bvule (zero_extend[6] ?e43) ?e149))
+(flet ($e558 (bvuge ?e59 (zero_extend[4] ?e100)))
+(flet ($e559 (distinct ?e37 ?e37))
+(flet ($e560 (distinct ?e43 ?e233))
+(flet ($e561 (bvsgt ?e220 ?e221))
+(flet ($e562 (bvsge (zero_extend[6] ?e125) ?e126))
+(flet ($e563 (bvslt ?e117 (sign_extend[6] ?e51)))
+(flet ($e564 (bvsge (sign_extend[2] ?e89) ?e149))
+(flet ($e565 (bvsle ?e93 ?e35))
+(flet ($e566 (bvugt ?e127 (zero_extend[6] ?e60)))
+(flet ($e567 (bvule ?e20 (sign_extend[6] ?e218)))
+(flet ($e568 (bvugt (zero_extend[4] ?e100) ?e94))
+(flet ($e569 (bvslt ?e39 (sign_extend[6] ?e73)))
+(flet ($e570 (distinct ?e136 (sign_extend[6] ?e60)))
+(flet ($e571 (distinct ?e230 ?e40))
+(flet ($e572 (bvslt ?e111 (sign_extend[1] ?e93)))
+(flet ($e573 (bvuge v2 ?e54))
+(flet ($e574 (bvsle ?e44 (sign_extend[6] ?e97)))
+(flet ($e575 (distinct ?e226 ?e250))
+(flet ($e576 (bvsgt ?e227 (sign_extend[1] ?e81)))
+(flet ($e577 (bvsge (sign_extend[2] ?e123) ?e17))
+(flet ($e578 (bvsle ?e71 ?e135))
+(flet ($e579 (distinct ?e161 ?e159))
+(flet ($e580 (bvsge (zero_extend[7] ?e226) ?e128))
+(flet ($e581 (= (zero_extend[2] ?e56) ?e19))
+(flet ($e582 (bvuge (zero_extend[6] ?e86) ?e196))
+(flet ($e583 (bvugt (sign_extend[6] ?e181) ?e49))
+(flet ($e584 (bvugt (sign_extend[4] ?e167) ?e141))
+(flet ($e585 (bvule ?e177 ?e175))
+(flet ($e586 (bvsgt (sign_extend[6] ?e155) ?e188))
+(flet ($e587 (bvult (sign_extend[1] ?e72) ?e155))
+(flet ($e588 (distinct ?e114 ?e41))
+(flet ($e589 (bvule ?e153 (sign_extend[6] ?e178)))
+(flet ($e590 (distinct ?e63 ?e54))
+(flet ($e591 (bvslt ?e237 (sign_extend[1] ?e115)))
+(flet ($e592 (bvugt (zero_extend[7] ?e217) ?e116))
+(flet ($e593 (bvule ?e176 ?e21))
+(flet ($e594 (bvugt ?e232 (sign_extend[1] ?e36)))
+(flet ($e595 (= ?e169 (zero_extend[6] ?e226)))
+(flet ($e596 (distinct ?e113 (sign_extend[6] ?e234)))
+(flet ($e597 (bvugt ?e146 ?e39))
+(flet ($e598 (= ?e212 (sign_extend[1] ?e109)))
+(flet ($e599 (distinct ?e173 ?e129))
+(flet ($e600 (distinct ?e175 ?e97))
+(flet ($e601 (bvule ?e107 ?e29))
+(flet ($e602 (bvugt ?e30 (sign_extend[3] ?e93)))
+(flet ($e603 (distinct ?e67 (sign_extend[6] ?e187)))
+(flet ($e604 (bvsle ?e203 ?e249))
+(flet ($e605 (bvult ?e228 ?e119))
+(flet ($e606 (bvugt ?e132 v1))
+(flet ($e607 (bvsge (zero_extend[6] ?e218) ?e117))
+(flet ($e608 (bvsgt ?e227 (sign_extend[6] ?e228)))
+(flet ($e609 (bvuge (sign_extend[6] ?e206) ?e204))
+(flet ($e610 (distinct ?e10 ?e157))
+(flet ($e611 (= ?e221 ?e86))
+(flet ($e612 (bvslt ?e92 ?e245))
+(flet ($e613 (bvule ?e29 (sign_extend[6] ?e180)))
+(flet ($e614 (bvsle ?e45 ?e93))
+(flet ($e615 (= ?e150 (sign_extend[2] ?e22)))
+(flet ($e616 (bvult ?e76 ?e180))
+(flet ($e617 (bvult ?e20 (sign_extend[6] ?e171)))
+(flet ($e618 (bvule ?e141 ?e146))
+(flet ($e619 (= (zero_extend[1] ?e227) ?e242))
+(flet ($e620 (distinct ?e213 ?e114))
+(flet ($e621 (distinct ?e216 (sign_extend[6] ?e160)))
+(flet ($e622 (bvsle ?e9 ?e121))
+(flet ($e623 (distinct (zero_extend[6] ?e229) ?e95))
+(flet ($e624 (bvslt (sign_extend[1] ?e135) ?e78))
+(flet ($e625 (bvslt v3 ?e56))
+(flet ($e626 (bvslt (sign_extend[4] ?e123) ?e89))
+(flet ($e627 (bvule ?e183 ?e92))
+(flet ($e628 (bvslt (zero_extend[4] ?e112) ?e91))
+(flet ($e629 (bvult (sign_extend[6] ?e53) ?e117))
+(flet ($e630 (bvsgt ?e58 ?e249))
+(flet ($e631 (= ?e169 (sign_extend[6] ?e87)))
+(flet ($e632 (= ?e19 ?e103))
+(flet ($e633 (bvsgt ?e82 (zero_extend[2] ?e86)))
+(flet ($e634 (bvslt ?e198 (sign_extend[4] ?e15)))
+(flet ($e635 (bvsle ?e225 ?e193))
+(flet ($e636 (bvsge (sign_extend[2] ?e27) ?e149))
+(flet ($e637 (bvsle ?e91 (sign_extend[4] ?e194)))
+(flet ($e638 (bvugt (sign_extend[6] ?e14) ?e140))
+(flet ($e639 (bvsle ?e132 ?e118))
+(flet ($e640 (bvugt ?e82 (zero_extend[2] ?e85)))
+(flet ($e641 (bvuge (zero_extend[2] ?e163) ?e169))
+(flet ($e642 (bvsge ?e21 (sign_extend[2] ?e32)))
+(flet ($e643 (bvsle ?e232 (sign_extend[1] ?e20)))
+(flet ($e644 (bvslt ?e141 (zero_extend[4] ?e82)))
+(flet ($e645 (bvsle ?e215 (zero_extend[1] ?e134)))
+(flet ($e646 (bvsge ?e130 ?e152))
+(flet ($e647 (bvugt (sign_extend[7] ?e129) ?e98))
+(flet ($e648 (bvsgt ?e59 (zero_extend[6] ?e148)))
+(flet ($e649 (= (zero_extend[7] ?e253) ?e128))
+(flet ($e650 (distinct ?e231 (zero_extend[6] ?e193)))
+(flet ($e651 (bvsle ?e180 ?e31))
+(flet ($e652 (bvuge ?e220 ?e193))
+(flet ($e653 (= ?e110 ?e227))
+(flet ($e654 (bvuge ?e162 ?e186))
+(flet ($e655 (= ?e80 (zero_extend[4] ?e201)))
+(flet ($e656 (= ?e239 ?e220))
+(flet ($e657 (distinct ?e58 ?e233))
+(flet ($e658 (bvsge ?e35 ?e14))
+(flet ($e659 (bvsgt ?e99 (sign_extend[2] ?e159)))
+(flet ($e660 (bvsle (zero_extend[6] ?e43) ?e251))
+(flet ($e661 (= ?e132 ?e45))
+(flet ($e662 (bvugt (zero_extend[6] ?e96) v2))
+(flet ($e663 (bvsgt ?e207 ?e77))
+(flet ($e664 (bvslt (zero_extend[6] ?e109) ?e54))
+(flet ($e665 (bvugt (sign_extend[6] ?e14) ?e136))
+(flet ($e666 (bvsle (sign_extend[6] ?e33) ?e74))
+(flet ($e667 (bvuge (sign_extend[6] ?e64) ?e54))
+(flet ($e668 (bvult (sign_extend[4] ?e172) ?e56))
+(flet ($e669 (bvslt (sign_extend[6] ?e234) ?e149))
+(flet ($e670 (bvule ?e75 ?e250))
+(flet ($e671 (bvugt ?e101 ?e231))
+(flet ($e672 (bvslt (sign_extend[7] ?e186) ?e143))
+(flet ($e673 (= ?e186 ?e187))
+(flet ($e674 (bvsgt ?e106 ?e12))
+(flet ($e675 (bvugt ?e62 (zero_extend[7] ?e166)))
+(flet ($e676 (bvuge ?e210 ?e216))
+(flet ($e677 (bvult ?e144 ?e64))
+(flet ($e678 (distinct ?e240 (sign_extend[6] ?e23)))
+(flet ($e679 (bvsge ?e237 (zero_extend[7] ?e7)))
+(flet ($e680 (distinct (zero_extend[5] ?e134) ?e168))
+(flet ($e681 (= (sign_extend[6] ?e241) ?e235))
+(flet ($e682 (bvslt ?e45 ?e43))
+(flet ($e683 (bvuge ?e193 ?e225))
+(flet ($e684 (bvslt (zero_extend[6] ?e207) ?e174))
+(flet ($e685 (bvugt (sign_extend[6] ?e42) ?e216))
+(flet ($e686 (distinct (sign_extend[6] ?e225) ?e145))
+(flet ($e687 (bvugt ?e144 ?e60))
+(flet ($e688 (bvslt ?e199 ?e10))
+(flet ($e689 (bvsgt ?e81 (zero_extend[5] ?e192)))
+(flet ($e690 (bvsge ?e213 (zero_extend[6] ?e8)))
+(flet ($e691 (= ?e98 ?e78))
+(flet ($e692 (bvuge ?e138 ?e130))
+(flet ($e693 (bvule ?e97 ?e239))
+(flet ($e694 (bvslt (sign_extend[1] ?e190) ?e44))
+(flet ($e695 (bvugt ?e62 (sign_extend[7] ?e193)))
+(flet ($e696 (bvule ?e167 (zero_extend[2] ?e230)))
+(flet ($e697 (bvsge ?e179 ?e69))
+(flet ($e698 (distinct ?e74 ?e84))
+(flet ($e699 (bvugt ?e227 (sign_extend[6] ?e119)))
+(flet ($e700 (= ?e111 (zero_extend[1] ?e85)))
+(flet ($e701 (= ?e133 ?e35))
+(flet ($e702 (bvult ?e217 ?e226))
+(flet ($e703 (bvslt ?e70 ?e160))
+(flet ($e704 (bvslt ?e127 ?e49))
+(flet ($e705 (bvsge ?e116 (zero_extend[2] ?e168)))
+(flet ($e706 (= ?e193 ?e10))
+(flet ($e707 (bvugt ?e216 (zero_extend[6] ?e65)))
+(flet ($e708 (bvugt ?e80 (sign_extend[4] ?e250)))
+(flet ($e709 (bvsle ?e108 (sign_extend[6] ?e55)))
+(flet ($e710 (= ?e13 (zero_extend[4] ?e217)))
+(flet ($e711 (bvugt ?e234 ?e58))
+(flet ($e712 (= ?e127 ?e49))
+(flet ($e713 (bvugt ?e147 (sign_extend[6] ?e83)))
+(flet ($e714 (distinct ?e4 (sign_extend[3] ?e245)))
+(flet ($e715 (bvslt (sign_extend[4] ?e82) ?e149))
+(flet ($e716 (bvult (sign_extend[2] ?e6) ?e240))
+(flet ($e717 (bvsgt ?e128 ?e78))
+(flet ($e718 (bvsge ?e189 (sign_extend[6] ?e134)))
+(flet ($e719 (bvugt ?e14 ?e239))
+(flet ($e720 (bvsgt (zero_extend[5] ?e212) ?e29))
+(flet ($e721 (bvsgt (zero_extend[6] ?e203) ?e106))
+(flet ($e722 (bvsle (sign_extend[6] ?e225) ?e213))
+(flet ($e723 (bvuge (zero_extend[6] ?e171) ?e117))
+(flet ($e724 (bvsge ?e124 ?e251))
+(flet ($e725 (= ?e140 ?e231))
+(flet ($e726 (bvsge ?e89 (zero_extend[4] ?e183)))
+(flet ($e727 (= (sign_extend[4] ?e171) ?e22))
+(flet ($e728 (= ?e94 (zero_extend[2] ?e80)))
+(flet ($e729 (bvsle (zero_extend[6] ?e175) ?e240))
+(flet ($e730 (bvult ?e13 (zero_extend[4] ?e191)))
+(flet ($e731 (bvsgt (sign_extend[2] ?e162) ?e185))
+(flet ($e732 (bvsle (sign_extend[6] ?e250) ?e213))
+(flet ($e733 (bvult ?e53 ?e200))
+(flet ($e734 (bvsle (zero_extend[2] ?e28) ?e101))
+(flet ($e735 (bvslt ?e175 ?e53))
+(flet ($e736 (bvult ?e120 ?e234))
+(flet ($e737 (bvuge ?e116 (sign_extend[7] ?e253)))
+(flet ($e738 (bvsgt ?e116 (sign_extend[7] ?e83)))
+(flet ($e739 (bvugt ?e76 ?e31))
+(flet ($e740 (bvugt (sign_extend[1] ?e193) ?e212))
+(flet ($e741 (bvult (sign_extend[5] ?e111) ?e251))
+(flet ($e742 (bvult (zero_extend[6] ?e191) ?e184))
+(flet ($e743 (= ?e235 (zero_extend[6] ?e156)))
+(flet ($e744 (distinct ?e178 ?e86))
+(flet ($e745 (bvsgt ?e252 (sign_extend[6] ?e77)))
+(flet ($e746 (bvule ?e122 ?e15))
+(flet ($e747 (bvslt ?e21 (sign_extend[6] ?e207)))
+(flet ($e748 (bvult (sign_extend[2] ?e93) ?e82))
+(flet ($e749 (distinct ?e90 ?e115))
+(flet ($e750 (bvugt ?e243 (sign_extend[2] ?e28)))
+(flet ($e751 (bvsgt ?e146 ?e71))
+(flet ($e752 (bvule ?e106 (sign_extend[6] ?e241)))
+(flet ($e753 (distinct ?e88 (sign_extend[4] ?e96)))
+(flet ($e754 (bvsle ?e23 ?e180))
+(flet ($e755 (bvule ?e27 (sign_extend[4] ?e123)))
+(flet ($e756 (= (zero_extend[7] ?e229) ?e61))
+(flet ($e757 (bvuge ?e210 (sign_extend[5] ?e212)))
+(flet ($e758 (bvsge ?e180 ?e96))
+(flet ($e759 (bvsle ?e247 (zero_extend[6] ?e31)))
+(flet ($e760 (bvsle (zero_extend[5] ?e16) ?e168))
+(flet ($e761 (bvsgt ?e138 ?e200))
+(flet ($e762 (bvsgt ?e239 ?e209))
+(flet ($e763 (bvslt ?e197 ?e197))
+(flet ($e764 (bvugt ?e34 ?e29))
+(flet ($e765 (= ?e26 ?e217))
+(flet ($e766 (bvule (zero_extend[6] ?e221) ?e25))
+(flet ($e767 (bvsge ?e189 (zero_extend[5] ?e215)))
+(flet ($e768 (bvult ?e78 (zero_extend[1] ?e67)))
+(flet ($e769 (bvuge (zero_extend[5] ?e215) ?e240))
+(flet ($e770 (= (sign_extend[6] ?e133) ?e235))
+(flet ($e771 (bvsgt ?e27 (zero_extend[4] ?e253)))
+(flet ($e772 (bvsgt ?e18 ?e248))
+(flet ($e773 (bvult ?e78 (sign_extend[7] ?e200)))
+(flet ($e774 (bvult (zero_extend[6] ?e134) ?e251))
+(flet ($e775 (bvule ?e48 (sign_extend[7] ?e68)))
+(flet ($e776 (bvugt ?e6 (zero_extend[4] ?e191)))
+(flet ($e777 (bvult ?e89 (sign_extend[4] ?e162)))
+(flet ($e778 (bvsle ?e39 (sign_extend[6] ?e120)))
+(flet ($e779 (bvule ?e106 (zero_extend[6] ?e194)))
+(flet ($e780 (distinct ?e101 ?e50))
+(flet ($e781 (bvslt ?e91 (sign_extend[4] ?e92)))
+(flet ($e782 (distinct ?e96 ?e16))
+(flet ($e783 (bvugt ?e159 ?e253))
+(flet ($e784 (bvult ?e218 ?e142))
+(flet ($e785 (= (zero_extend[6] ?e133) ?e115))
+(flet ($e786 (bvsgt ?e131 (zero_extend[7] ?e191)))
+(flet ($e787 (bvugt ?e200 ?e87))
+(flet ($e788 (bvugt ?e139 (sign_extend[6] ?e144)))
+(flet ($e789 (bvsgt (zero_extend[1] ?e243) ?e195))
+(flet ($e790 (bvsge ?e71 (sign_extend[2] ?e6)))
+(flet ($e791 (bvule (sign_extend[5] ?e72) ?e168))
+(flet ($e792 (bvsgt ?e21 (sign_extend[6] ?e43)))
+(flet ($e793 (= (zero_extend[1] ?e168) ?e136))
+(flet ($e794 (bvsgt ?e113 ?e153))
+(flet ($e795 (bvult (sign_extend[6] ?e233) ?e251))
+(flet ($e796 (bvugt ?e124 (zero_extend[6] ?e178)))
+(flet ($e797 (distinct ?e242 (zero_extend[1] ?e127)))
+(flet ($e798 (= (sign_extend[4] ?e43) ?e91))
+(flet ($e799 (bvule ?e241 ?e119))
+(flet ($e800 (distinct ?e127 ?e101))
+(flet ($e801 (= (sign_extend[6] ?e197) ?e20))
+(flet ($e802 (bvsgt (sign_extend[6] ?e244) ?e236))
+(flet ($e803 (= ?e61 (zero_extend[1] ?e107)))
+(flet ($e804 (bvsgt ?e227 (sign_extend[3] ?e4)))
+(flet ($e805 (bvuge (sign_extend[1] ?e172) ?e47))
+(flet ($e806 (bvuge ?e201 ?e83))
+(flet ($e807 (bvsge ?e227 ?e196))
+(flet ($e808 (bvsle ?e215 (zero_extend[1] ?e171)))
+(flet ($e809 (bvsgt ?e247 (zero_extend[4] ?e17)))
+(flet ($e810 (bvult ?e62 (sign_extend[7] ?e172)))
+(flet ($e811 (= ?e38 ?e87))
+(flet ($e812 (= ?e58 ?e144))
+(flet ($e813 (bvuge ?e234 ?e40))
+(flet ($e814 (bvsge ?e229 ?e249))
+(flet ($e815 (bvsge ?e134 ?e221))
+(flet ($e816 (bvugt (zero_extend[6] ?e38) ?e34))
+(flet ($e817 (bvsle ?e42 ?e64))
+(flet ($e818 (bvule ?e174 ?e243))
+(flet ($e819 (bvugt ?e115 (sign_extend[6] ?e241)))
+(flet ($e820 (bvslt (zero_extend[2] ?e28) ?e227))
+(flet ($e821 (bvult (sign_extend[6] ?e159) ?e29))
+(flet ($e822 (bvuge ?e62 (sign_extend[7] ?e186)))
+(flet ($e823 (bvult ?e224 ?e253))
+(flet ($e824 (bvule ?e170 ?e55))
+(flet ($e825 (bvsge ?e235 ?e121))
+(flet ($e826 (bvsgt (zero_extend[6] ?e31) ?e126))
+(flet ($e827 (bvslt ?e51 ?e183))
+(flet ($e828 (bvult (zero_extend[4] ?e219) ?e13))
+(flet ($e829 (bvsge ?e108 (zero_extend[6] ?e226)))
+(flet ($e830 (bvslt ?e104 ?e252))
+(flet ($e831 (bvsgt (zero_extend[2] ?e23) ?e5))
+(flet ($e832 (= ?e171 v1))
+(flet ($e833 (bvsgt (sign_extend[6] v1) ?e184))
+(flet ($e834 (distinct ?e192 ?e166))
+(flet ($e835 (distinct ?e110 (zero_extend[6] ?e172)))
+(flet ($e836 (bvugt ?e182 ?e228))
+(flet ($e837 (bvuge ?e28 (sign_extend[4] ?e187)))
+(flet ($e838 (bvsle ?e236 ?e135))
+(flet ($e839 (bvule ?e71 (sign_extend[4] ?e185)))
+(flet ($e840 (bvslt ?e82 (zero_extend[2] ?e148)))
+(flet ($e841 (= (sign_extend[6] ?e249) ?e54))
+(flet ($e842 (bvugt ?e209 ?e93))
+(flet ($e843 (bvuge ?e158 ?e177))
+(flet ($e844 (bvsle (sign_extend[4] ?e96) ?e27))
+(flet ($e845 (distinct ?e219 ?e214))
+(flet ($e846 (bvsge ?e141 (sign_extend[6] ?e161)))
+(flet ($e847 (bvugt ?e62 (zero_extend[7] ?e151)))
+(flet ($e848 (bvule ?e146 (sign_extend[6] ?e55)))
+(flet ($e849 (bvult ?e67 (sign_extend[6] ?e171)))
+(flet ($e850 (bvsle ?e60 ?e209))
+(flet ($e851 (bvugt ?e82 (zero_extend[2] ?e224)))
+(flet ($e852 (bvsgt ?e80 ?e11))
+(flet ($e853 (bvule (zero_extend[6] ?e193) ?e213))
+(flet ($e854 (bvslt ?e158 ?e154))
+(flet ($e855 (distinct (sign_extend[4] ?e167) ?e113))
+(flet ($e856 (bvsle ?e235 (zero_extend[6] ?e160)))
+(flet ($e857 (bvsgt ?e143 (zero_extend[1] ?e139)))
+(flet ($e858 (bvult ?e227 ?e210))
+(flet ($e859 (bvule ?e135 ?e216))
+(flet ($e860 (bvsge (sign_extend[1] ?e106) ?e48))
+(flet ($e861 (= ?e50 (sign_extend[6] ?e137)))
+(flet ($e862 (distinct ?e150 (zero_extend[6] ?e42)))
+(flet ($e863 (bvsge ?e124 (zero_extend[6] ?e23)))
+(flet ($e864 (= ?e194 ?e161))
+(flet ($e865 (bvuge ?e24 (sign_extend[6] ?e214)))
+(flet ($e866 (bvsle (sign_extend[6] ?e92) ?e179))
+(flet ($e867 (bvule ?e141 (sign_extend[6] ?e16)))
+(flet ($e868 (bvule ?e165 (zero_extend[1] ?e199)))
+(flet ($e869 (bvsle (zero_extend[6] ?e105) ?e19))
+(flet ($e870 (bvult ?e233 ?e166))
+(flet ($e871 (bvuge ?e10 ?e183))
+(flet ($e872 (distinct ?e228 ?e206))
+(flet ($e873 (bvult ?e184 (sign_extend[6] ?e33)))
+(flet ($e874 (bvsgt ?e108 (zero_extend[6] ?e51)))
+(flet ($e875 (bvsge ?e53 ?e96))
+(flet ($e876 (distinct (sign_extend[6] v1) ?e71))
+(flet ($e877 (bvslt ?e64 ?e105))
+(flet ($e878 (bvsgt ?e213 (sign_extend[2] ?e32)))
+(flet ($e879 (bvugt (sign_extend[6] v1) ?e69))
+(flet ($e880 (distinct ?e250 ?e225))
+(flet ($e881 (bvsle ?e92 ?e23))
+(flet ($e882 (= (sign_extend[4] ?e161) v3))
+(flet ($e883 (bvslt ?e46 ?e89))
+(flet ($e884 (bvuge (sign_extend[6] ?e23) ?e54))
+(flet ($e885 (bvsle ?e55 ?e60))
+(flet ($e886 (bvsgt ?e197 ?e102))
+(flet ($e887 (bvsle ?e101 ?e41))
+(flet ($e888 (bvule ?e41 (zero_extend[6] ?e138)))
+(flet ($e889 (= (zero_extend[1] ?e205) ?e242))
+(flet ($e890 (distinct ?e24 ?e246))
+(flet ($e891 (bvsge (zero_extend[7] ?e92) ?e131))
+(flet ($e892 (bvule ?e9 (sign_extend[6] ?e109)))
+(flet ($e893 (bvsle (sign_extend[6] ?e182) ?e108))
+(flet ($e894 (bvsge ?e186 ?e166))
+(flet ($e895 (bvuge ?e146 ?e71))
+(flet ($e896 (bvsge ?e121 (sign_extend[6] v1)))
+(flet ($e897 (bvslt (zero_extend[1] ?e69) ?e61))
+(flet ($e898 (bvugt (sign_extend[6] ?e119) ?e44))
+(flet ($e899 (bvsgt (zero_extend[6] ?e154) ?e216))
+(flet ($e900 (bvugt ?e156 ?e202))
+(flet ($e901 (bvugt ?e251 (zero_extend[6] ?e151)))
+(flet ($e902 (bvule ?e235 (zero_extend[6] ?e187)))
+(flet ($e903 (bvslt ?e44 ?e84))
+(flet ($e904 (distinct ?e152 ?e10))
+(flet ($e905 (bvsge (sign_extend[6] ?e142) ?e204))
+(flet ($e906 (bvslt ?e54 (zero_extend[6] ?e16)))
+(flet ($e907 (bvule (zero_extend[2] ?e6) ?e67))
+(flet ($e908 (bvuge ?e43 ?e217))
+(flet ($e909 (bvsgt ?e91 (zero_extend[1] ?e30)))
+(flet ($e910 (bvule ?e167 (zero_extend[2] ?e55)))
+(flet ($e911 (= (zero_extend[2] ?e203) ?e82))
+(flet ($e912 (bvult ?e20 (zero_extend[6] ?e7)))
+(flet ($e913 (bvslt ?e195 (zero_extend[7] ?e42)))
+(flet ($e914 (bvule ?e123 ?e37))
+(flet ($e915 (bvule ?e188 (zero_extend[7] ?e214)))
+(flet ($e916 (bvsgt ?e30 (zero_extend[3] ?e175)))
+(flet ($e917 (= (zero_extend[4] ?e142) ?e88))
+(flet ($e918 (bvsle ?e232 (sign_extend[7] ?e228)))
+(flet ($e919 (distinct ?e136 (sign_extend[6] ?e132)))
+(flet ($e920 (bvuge ?e143 (sign_extend[7] ?e122)))
+(flet ($e921 (bvslt ?e17 (zero_extend[2] ?e42)))
+(flet ($e922 (bvslt ?e116 (zero_extend[7] ?e73)))
+(flet ($e923 (bvsge ?e127 ?e227))
+(flet ($e924 (bvslt (zero_extend[6] ?e180) v0))
+(flet ($e925 (distinct ?e47 (zero_extend[1] ?e226)))
+(flet ($e926 (= ?e69 (zero_extend[6] ?e250)))
+(flet ($e927 (bvult ?e247 ?e29))
+(flet ($e928 (bvuge (sign_extend[5] ?e217) ?e81))
+(flet ($e929 (distinct ?e48 (zero_extend[1] ?e141)))
+(flet ($e930 (bvugt ?e95 (zero_extend[6] ?e217)))
+(flet ($e931 (bvsle ?e246 (zero_extend[6] ?e40)))
+(flet ($e932 (bvslt (sign_extend[2] ?e82) ?e91))
+(flet ($e933 (bvsge ?e238 (sign_extend[2] ?e191)))
+(flet ($e934 (bvuge ?e252 (sign_extend[6] ?e193)))
+(flet ($e935 (bvugt (sign_extend[6] ?e14) ?e216))
+(flet ($e936 (bvsle ?e15 ?e206))
+(flet ($e937 (distinct (sign_extend[1] v2) ?e61))
+(flet ($e938 (bvslt (zero_extend[1] ?e19) ?e232))
+(flet ($e939 (= ?e98 (sign_extend[4] ?e30)))
+(flet ($e940 (bvsgt ?e71 (zero_extend[1] ?e168)))
+(flet ($e941 (bvult (sign_extend[5] ?e155) ?e71))
+(flet ($e942 (bvsle (sign_extend[7] ?e60) ?e232))
+(flet ($e943 (bvsle ?e139 ?e59))
+(flet ($e944 (distinct (sign_extend[6] ?e86) ?e74))
+(flet ($e945 (distinct (sign_extend[6] ?e209) v2))
+(flet ($e946 (bvule (zero_extend[6] ?e122) ?e101))
+(flet ($e947 (bvsgt ?e124 (zero_extend[6] ?e10)))
+(flet ($e948 (bvult ?e48 (zero_extend[3] ?e198)))
+(flet ($e949 (bvule ?e57 (zero_extend[1] ?e56)))
+(flet ($e950 (bvsgt ?e48 (zero_extend[7] ?e250)))
+(flet ($e951 (bvsgt ?e153 (zero_extend[6] ?e162)))
+(flet ($e952 (bvsle ?e138 ?e193))
+(flet ($e953 (bvsgt ?e235 ?e63))
+(flet ($e954 (bvule ?e93 ?e45))
+(flet ($e955 (bvule ?e32 (sign_extend[4] ?e220)))
+(flet ($e956 (bvslt ?e227 ?e149))
+(flet ($e957 (bvule (zero_extend[6] ?e64) ?e252))
+(flet ($e958 (= ?e7 ?e222))
+(flet ($e959 (= ?e118 ?e125))
+(flet ($e960 (bvuge ?e164 ?e157))
+(flet ($e961 (bvsle ?e227 ?e41))
+(flet ($e962 (bvugt ?e188 (zero_extend[7] ?e75)))
+(flet ($e963 (bvugt ?e130 ?e164))
+(flet ($e964 (bvuge ?e244 ?e194))
+(flet ($e965 (bvslt (zero_extend[6] ?e202) ?e189))
+(flet ($e966 (bvslt ?e229 ?e53))
+(flet ($e967 (bvslt ?e185 (sign_extend[2] ?e86)))
+(flet ($e968 (bvuge ?e231 ?e39))
+(flet ($e969 (= ?e26 ?e134))
+(flet ($e970 (bvule (sign_extend[4] ?e211) ?e188))
+(flet ($e971 (bvuge (sign_extend[2] ?e56) ?e114))
+(flet ($e972 (distinct ?e170 ?e209))
+(flet ($e973 (bvule ?e61 (sign_extend[1] ?e110)))
+(flet ($e974 (bvsle ?e218 ?e239))
+(flet ($e975 (bvuge ?e158 ?e37))
+(flet ($e976 (bvsgt ?e206 ?e148))
+(flet ($e977 (distinct ?e18 (zero_extend[6] ?e26)))
+(flet ($e978 (distinct ?e117 (sign_extend[6] ?e239)))
+(flet ($e979 (bvuge ?e82 (zero_extend[2] ?e197)))
+(flet ($e980 (bvsle ?e55 ?e118))
+(flet ($e981 (= ?e181 ?e152))
+(flet ($e982 (bvugt (sign_extend[2] ?e151) ?e99))
+(flet ($e983 (bvult (zero_extend[3] ?e202) ?e4))
+(flet ($e984 (bvugt ?e224 ?e55))
+(flet ($e985 (distinct (sign_extend[6] ?e97) ?e71))
+(flet ($e986 (bvsge ?e108 ?e106))
+(flet ($e987 (bvsle ?e59 (zero_extend[6] ?e222)))
+(flet ($e988 (distinct ?e138 ?e148))
+(flet ($e989 (bvuge (zero_extend[5] ?e155) ?e174))
+(flet ($e990 (bvsle ?e48 (sign_extend[7] ?e175)))
+(flet ($e991 (bvult (zero_extend[2] ?e125) ?e82))
+(flet ($e992 (bvsle ?e141 (zero_extend[6] ?e234)))
+(flet ($e993 (bvsle ?e43 ?e178))
+(flet ($e994 (distinct (sign_extend[7] ?e118) ?e98))
+(flet ($e995 (bvugt ?e9 (sign_extend[1] ?e190)))
+(flet ($e996 (bvult ?e20 ?e104))
+(flet ($e997 (bvsgt (sign_extend[6] ?e60) ?e84))
+(flet ($e998 (bvsgt (zero_extend[6] ?e223) ?e79))
+(flet ($e999 (bvuge ?e41 (sign_extend[2] ?e11)))
+(flet ($e1000 (distinct (zero_extend[6] ?e183) ?e127))
+(flet ($e1001 (bvule ?e135 ?e205))
+(flet ($e1002 (bvule ?e129 ?e142))
+(flet ($e1003 (bvult ?e97 ?e209))
+(flet ($e1004 (distinct (sign_extend[6] ?e199) ?e196))
+(flet ($e1005 (bvsge (sign_extend[1] ?e166) ?e111))
+(flet ($e1006 (= ?e198 (zero_extend[4] ?e134)))
+(flet ($e1007 (bvult (zero_extend[6] ?e129) ?e36))
+(flet ($e1008 (bvsge ?e241 ?e202))
+(flet ($e1009 (bvuge (sign_extend[6] ?e186) ?e106))
+(flet ($e1010 (bvslt ?e118 ?e26))
+(flet ($e1011 (bvult ?e135 ?e115))
+(flet ($e1012 (bvule ?e88 (zero_extend[4] ?e217)))
+(flet ($e1013 (bvsle ?e14 ?e137))
+(flet ($e1014 (distinct (zero_extend[6] ?e223) ?e71))
+(flet ($e1015 (bvsgt (sign_extend[6] ?e166) ?e196))
+(flet ($e1016 (bvule (zero_extend[6] ?e224) ?e127))
+(flet ($e1017 (bvugt ?e21 v0))
+(flet ($e1018 (bvsgt ?e174 (sign_extend[6] ?e220)))
+(flet ($e1019 (bvsge ?e74 (zero_extend[6] ?e105)))
+(flet ($e1020 (bvsge ?e188 (sign_extend[7] ?e66)))
+(flet ($e1021 (bvuge (zero_extend[6] ?e191) ?e115))
+(flet ($e1022 (bvult v3 (zero_extend[4] ?e164)))
+(flet ($e1023 (= ?e225 ?e97))
+(flet ($e1024 (bvult ?e120 ?e224))
+(flet ($e1025 (bvugt (sign_extend[1] ?e236) ?e78))
+(flet ($e1026 (bvule (sign_extend[6] ?e7) ?e136))
+(flet ($e1027 (= ?e147 ?e127))
+(flet ($e1028 (distinct ?e169 (zero_extend[6] ?e85)))
+(flet ($e1029 (bvsle ?e113 (zero_extend[5] ?e165)))
+(flet ($e1030 (bvult (zero_extend[4] ?e185) ?e36))
+(flet ($e1031 (bvuge ?e69 ?e115))
+(flet ($e1032 (= ?e132 ?e233))
+(flet ($e1033 (bvugt ?e45 ?e201))
+(flet ($e1034 (bvult ?e16 ?e10))
+(flet ($e1035 (bvugt ?e175 ?e72))
+(flet ($e1036 (bvuge ?e19 (sign_extend[6] ?e16)))
+(flet ($e1037 (bvule ?e158 ?e173))
+(flet ($e1038 (bvuge (sign_extend[1] ?e93) ?e111))
+(flet ($e1039 (= ?e227 ?e41))
+(flet ($e1040 (bvugt ?e165 (zero_extend[1] ?e130)))
+(flet ($e1041 (bvuge (zero_extend[2] ?e53) ?e99))
+(flet ($e1042 (bvsgt ?e236 (zero_extend[6] ?e53)))
+(flet ($e1043 (bvsle ?e135 ?e110))
+(flet ($e1044 (distinct (sign_extend[2] ?e206) ?e185))
+(flet ($e1045 (bvsgt (sign_extend[6] ?e239) ?e9))
+(flet ($e1046 (bvslt ?e91 (zero_extend[4] ?e160)))
+(flet ($e1047 (bvule ?e171 ?e172))
+(flet ($e1048 (bvsle ?e102 ?e162))
+(flet ($e1049 (bvsle ?e116 (sign_extend[7] ?e10)))
+(flet ($e1050 (bvugt ?e27 (zero_extend[3] ?e165)))
+(flet ($e1051 (= ?e68 ?e214))
+(flet ($e1052 (bvule ?e106 ?e74))
+(flet ($e1053 (bvule ?e217 ?e175))
+(flet ($e1054 (= ?e231 (sign_extend[6] ?e118)))
+(flet ($e1055 (bvsge ?e143 (sign_extend[7] ?e102)))
+(flet ($e1056 (bvult (sign_extend[1] ?e158) ?e215))
+(flet ($e1057 (bvslt (zero_extend[6] ?e87) ?e136))
+(flet ($e1058 (distinct ?e110 ?e25))
+(flet ($e1059 (= ?e155 (sign_extend[1] ?e223)))
+(flet ($e1060 (bvsle ?e242 (zero_extend[7] ?e208)))
+(flet ($e1061 (bvsgt (zero_extend[7] ?e66) ?e128))
+(flet ($e1062 (bvsgt (sign_extend[7] ?e156) ?e48))
+(flet ($e1063 (bvule ?e36 (zero_extend[6] ?e42)))
+(flet ($e1064 (= ?e246 ?e59))
+(flet ($e1065 (bvugt ?e4 (sign_extend[3] ?e33)))
+(flet ($e1066 (bvult ?e26 ?e221))
+(flet ($e1067 (bvuge (sign_extend[6] ?e203) ?e216))
+(flet ($e1068 (bvsle ?e64 ?e244))
+(flet ($e1069 (bvsgt (zero_extend[2] ?e28) ?e49))
+(flet ($e1070 (bvult (sign_extend[6] ?e156) ?e145))
+(flet ($e1071 (bvule (sign_extend[4] ?e53) ?e28))
+(flet ($e1072 (bvsge ?e54 (zero_extend[6] ?e87)))
+(flet ($e1073 (bvslt ?e145 (sign_extend[6] ?e191)))
+(flet ($e1074 (= ?e62 (sign_extend[6] ?e212)))
+(flet ($e1075 (bvslt (sign_extend[4] ?e26) v3))
+(flet ($e1076 (bvsgt ?e136 ?e210))
+(flet ($e1077 (distinct ?e229 ?e68))
+(flet ($e1078 (bvsle (sign_extend[6] ?e249) ?e110))
+(flet ($e1079 (bvule (sign_extend[6] ?e177) ?e59))
+(flet ($e1080 (bvule ?e201 ?e183))
+(flet ($e1081 (bvuge ?e44 (zero_extend[6] ?e122)))
+(flet ($e1082 (bvsge (zero_extend[1] ?e81) ?e117))
+(flet ($e1083 (bvugt (zero_extend[5] ?e239) ?e57))
+(flet ($e1084 (distinct ?e101 (sign_extend[4] ?e5)))
+(flet ($e1085 (bvule (zero_extend[3] ?e212) ?e46))
+(flet ($e1086 (bvslt (sign_extend[6] ?e130) ?e231))
+(flet ($e1087 (bvsgt (zero_extend[6] ?e217) ?e50))
+(flet ($e1088 (bvslt ?e104 v0))
+(flet ($e1089 (bvugt ?e232 (zero_extend[7] ?e87)))
+(flet ($e1090 (bvsge ?e14 ?e132))
+(flet ($e1091 (bvugt (zero_extend[6] ?e214) ?e247))
+(flet ($e1092 (bvult ?e174 (zero_extend[6] ?e66)))
+(flet ($e1093 (bvslt ?e116 (zero_extend[7] ?e233)))
+(flet ($e1094 (bvsle ?e94 (zero_extend[6] ?e31)))
+(flet ($e1095 (bvsge (zero_extend[7] ?e86) ?e52))
+(flet ($e1096 (bvsge (zero_extend[1] v3) ?e168))
+(flet ($e1097 (bvult (zero_extend[6] ?e68) ?e136))
+(flet ($e1098 (bvslt ?e50 (zero_extend[4] ?e82)))
+(flet ($e1099 (bvsge ?e141 ?e126))
+(flet ($e1100 (bvsgt ?e227 (sign_extend[6] ?e180)))
+(flet ($e1101 (bvsle (sign_extend[6] ?e43) ?e12))
+(flet ($e1102 (bvslt ?e178 ?e148))
+(flet ($e1103 (bvuge ?e126 ?e176))
+(flet ($e1104 (distinct (sign_extend[5] ?e230) ?e190))
+(flet ($e1105 (bvslt ?e130 ?e162))
+(flet ($e1106 (bvsgt (sign_extend[7] ?e220) ?e131))
+(flet ($e1107 (bvule ?e205 (zero_extend[2] ?e27)))
+(flet ($e1108 (bvsgt (zero_extend[5] ?e212) ?e94))
+(flet ($e1109 (bvugt ?e198 ?e91))
+(flet ($e1110 (bvuge ?e135 (zero_extend[6] ?e234)))
+(flet ($e1111 (bvuge (zero_extend[3] ?e208) ?e30))
+(flet ($e1112 (bvult ?e179 ?e84))
+(flet ($e1113 (bvsgt (sign_extend[3] ?e28) ?e242))
+(flet ($e1114 (bvugt ?e123 ?e151))
+(flet ($e1115 (bvule ?e20 (zero_extend[6] ?e218)))
+(flet ($e1116 (bvult ?e35 ?e228))
+(flet ($e1117 (bvsgt ?e174 (zero_extend[6] ?e102)))
+(flet ($e1118 (bvule (zero_extend[4] ?e5) ?e24))
+(flet ($e1119 (bvsge ?e206 ?e102))
+(flet ($e1120 (bvsle (zero_extend[5] ?e187) ?e57))
+(flet ($e1121 (bvslt (sign_extend[3] ?e155) v3))
+(flet ($e1122 (bvugt (sign_extend[6] ?e142) ?e12))
+(flet ($e1123 (bvult ?e204 (zero_extend[4] ?e17)))
+(flet ($e1124 (bvule ?e14 ?e220))
+(flet ($e1125 (= ?e18 (zero_extend[6] ?e229)))
+(flet ($e1126 (bvsgt (zero_extend[5] ?e175) ?e168))
+(flet ($e1127 (bvugt ?e184 (zero_extend[6] ?e162)))
+(flet ($e1128 (bvslt (sign_extend[1] ?e166) ?e47))
+(flet ($e1129 (bvslt (zero_extend[6] ?e64) ?e54))
+(flet ($e1130 (bvslt ?e221 ?e186))
+(flet ($e1131 (bvugt (zero_extend[6] ?e133) ?e36))
+(flet ($e1132 (bvslt (sign_extend[6] ?e214) ?e12))
+(flet ($e1133 (bvuge ?e247 (sign_extend[6] ?e42)))
+(flet ($e1134 (bvslt (sign_extend[6] ?e75) v0))
+(flet ($e1135 (bvsgt (zero_extend[5] ?e154) ?e81))
+(flet ($e1136 (bvsle (sign_extend[4] ?e250) ?e46))
+(flet ($e1137 (bvult ?e164 ?e130))
+(flet ($e1138 (distinct (sign_extend[1] ?e57) ?e71))
+(flet ($e1139 (bvsle ?e18 ?e29))
+(flet ($e1140 (bvugt (sign_extend[1] ?e81) ?e140))
+(flet ($e1141 (bvsge ?e21 (sign_extend[6] ?e105)))
+(flet ($e1142 (bvsge (zero_extend[6] ?e138) ?e210))
+(flet ($e1143 (bvsgt ?e141 (zero_extend[2] ?e13)))
+(flet ($e1144 (bvsgt ?e179 (sign_extend[6] ?e102)))
+(flet ($e1145 (bvult (zero_extend[6] ?e51) ?e179))
+(flet ($e1146 (bvslt (sign_extend[6] ?e183) ?e9))
+(flet ($e1147 (bvuge (zero_extend[6] ?e187) ?e136))
+(flet ($e1148 (bvsgt (sign_extend[7] ?e77) ?e131))
+(flet ($e1149 (bvsge (sign_extend[6] ?e26) ?e41))
+(flet ($e1150 (bvuge (zero_extend[4] ?e219) ?e6))
+(flet ($e1151 (bvugt ?e70 ?e87))
+(flet ($e1152 (bvult ?e114 (zero_extend[6] ?e159)))
+(flet ($e1153 (bvsgt ?e216 (zero_extend[6] ?e158)))
+(flet ($e1154 (bvsge ?e41 (zero_extend[2] ?e13)))
+(flet ($e1155 (bvsge (zero_extend[6] ?e218) ?e141))
+(flet ($e1156 (bvsle ?e47 ?e212))
+(flet ($e1157 (bvule ?e104 (zero_extend[6] ?e134)))
+(flet ($e1158 (bvslt ?e33 ?e244))
+(flet ($e1159 (= (sign_extend[3] ?e212) ?e89))
+(flet ($e1160 (bvsgt (sign_extend[6] ?e162) ?e69))
+(flet ($e1161 (bvsge ?e90 (zero_extend[6] ?e234)))
+(flet ($e1162 (bvslt ?e81 (sign_extend[5] ?e245)))
+(flet ($e1163 (= ?e19 ?e25))
+(flet ($e1164 (bvuge ?e25 ?e153))
+(flet ($e1165 (= (zero_extend[6] ?e175) ?e145))
+(flet ($e1166 (bvule ?e139 (zero_extend[6] ?e178)))
+(flet ($e1167 (bvule ?e226 ?e120))
+(flet ($e1168 (bvsgt ?e5 (zero_extend[2] ?e245)))
+(flet ($e1169 (bvsgt ?e195 (zero_extend[7] ?e148)))
+(flet ($e1170 (= ?e114 (sign_extend[6] ?e175)))
+(flet ($e1171 (distinct ?e74 ?e141))
+(flet ($e1172 (bvuge (zero_extend[2] ?e93) ?e238))
+(flet ($e1173 (bvult ?e242 (sign_extend[7] ?e93)))
+(flet ($e1174 (bvslt (sign_extend[2] ?e183) ?e5))
+(flet ($e1175 (bvuge ?e175 ?e151))
+(flet ($e1176 (bvugt ?e32 (zero_extend[4] ?e201)))
+(flet ($e1177 (= ?e55 ?e221))
+(flet ($e1178 (bvugt ?e159 ?e197))
+(flet ($e1179 (bvsgt ?e164 ?e224))
+(flet ($e1180 (bvuge (zero_extend[2] ?e11) ?e49))
+(flet ($e1181 (bvult v0 (zero_extend[6] ?e183)))
+(flet ($e1182 (bvsgt (sign_extend[6] ?e45) ?e18))
+(flet ($e1183 (bvult (sign_extend[6] ?e250) ?e127))
+(flet ($e1184 (bvugt v0 (sign_extend[6] ?e230)))
+(flet ($e1185 (bvule ?e221 ?e96))
+(flet ($e1186 (bvult ?e97 ?e43))
+(flet ($e1187 (bvsge (sign_extend[2] ?e253) ?e185))
+(flet ($e1188 (bvult (sign_extend[6] ?e58) v0))
+(flet ($e1189 (= (zero_extend[6] ?e157) ?e54))
+(flet ($e1190 (bvslt ?e204 ?e74))
+(flet ($e1191 (bvuge ?e70 ?e166))
+(flet ($e1192 (distinct (sign_extend[6] ?e65) ?e140))
+(flet ($e1193 (= (sign_extend[5] ?e35) ?e81))
+(flet ($e1194 (bvule (zero_extend[2] ?e85) ?e17))
+(flet ($e1195 (distinct (sign_extend[1] ?e231) ?e52))
+(flet ($e1196 (bvuge ?e35 ?e8))
+(flet ($e1197 (bvsgt (sign_extend[4] ?e151) ?e91))
+(flet ($e1198 (bvugt ?e10 ?e159))
+(flet ($e1199 (bvult (zero_extend[6] ?e35) ?e21))
+(flet ($e1200 (bvsge ?e56 (sign_extend[4] ?e245)))
+(flet ($e1201 (= (sign_extend[6] ?e102) ?e174))
+(flet ($e1202 (bvule ?e83 ?e77))
+(flet ($e1203 (bvugt (zero_extend[6] ?e97) ?e34))
+(flet ($e1204 (bvsle ?e99 (sign_extend[2] ?e250)))
+(flet ($e1205 (bvslt ?e38 ?e33))
+(flet ($e1206 (distinct ?e242 (zero_extend[7] ?e119)))
+(flet ($e1207 (distinct ?e114 ?e216))
+(flet ($e1208 (bvsge (sign_extend[7] ?e87) ?e52))
+(flet ($e1209 (bvsge (zero_extend[6] ?e96) ?e94))
+(flet ($e1210 (distinct (zero_extend[6] ?e148) ?e25))
+(flet ($e1211 (bvuge ?e245 ?e60))
+(flet ($e1212 (bvslt (sign_extend[6] ?e86) ?e29))
+(flet ($e1213 (bvsle ?e197 ?e40))
+(flet ($e1214 (bvuge ?e32 (sign_extend[4] ?e160)))
+(flet ($e1215 (distinct (zero_extend[7] ?e154) ?e62))
+(flet ($e1216 (bvugt v3 (zero_extend[4] ?e31)))
+(flet ($e1217 (bvugt (sign_extend[2] ?e163) ?e9))
+(flet ($e1218 (not $e570))
+(flet ($e1219 (implies $e343 $e915))
+(flet ($e1220 (iff $e1109 $e928))
+(flet ($e1221 (xor $e318 $e1181))
+(flet ($e1222 (or $e386 $e386))
+(flet ($e1223 (if_then_else $e287 $e479 $e1132))
+(flet ($e1224 (iff $e546 $e1071))
+(flet ($e1225 (xor $e1138 $e640))
+(flet ($e1226 (or $e555 $e522))
+(flet ($e1227 (implies $e269 $e1033))
+(flet ($e1228 (if_then_else $e981 $e606 $e696))
+(flet ($e1229 (not $e796))
+(flet ($e1230 (implies $e332 $e1188))
+(flet ($e1231 (implies $e360 $e576))
+(flet ($e1232 (xor $e440 $e729))
+(flet ($e1233 (not $e540))
+(flet ($e1234 (implies $e1161 $e423))
+(flet ($e1235 (or $e309 $e963))
+(flet ($e1236 (iff $e357 $e602))
+(flet ($e1237 (and $e1108 $e516))
+(flet ($e1238 (implies $e453 $e842))
+(flet ($e1239 (not $e632))
+(flet ($e1240 (xor $e1115 $e272))
+(flet ($e1241 (not $e1153))
+(flet ($e1242 (or $e944 $e1035))
+(flet ($e1243 (iff $e740 $e398))
+(flet ($e1244 (iff $e674 $e652))
+(flet ($e1245 (and $e312 $e741))
+(flet ($e1246 (and $e584 $e1226))
+(flet ($e1247 (not $e715))
+(flet ($e1248 (not $e284))
+(flet ($e1249 (and $e1220 $e472))
+(flet ($e1250 (if_then_else $e388 $e1232 $e636))
+(flet ($e1251 (not $e411))
+(flet ($e1252 (if_then_else $e642 $e975 $e503))
+(flet ($e1253 (and $e1189 $e560))
+(flet ($e1254 (if_then_else $e1125 $e395 $e416))
+(flet ($e1255 (and $e1148 $e477))
+(flet ($e1256 (and $e840 $e488))
+(flet ($e1257 (or $e953 $e1074))
+(flet ($e1258 (xor $e268 $e389))
+(flet ($e1259 (xor $e1019 $e562))
+(flet ($e1260 (xor $e610 $e1195))
+(flet ($e1261 (if_then_else $e533 $e965 $e419))
+(flet ($e1262 (not $e1037))
+(flet ($e1263 (if_then_else $e1219 $e1257 $e649))
+(flet ($e1264 (xor $e836 $e368))
+(flet ($e1265 (implies $e539 $e713))
+(flet ($e1266 (xor $e364 $e710))
+(flet ($e1267 (xor $e671 $e255))
+(flet ($e1268 (and $e1081 $e1158))
+(flet ($e1269 (xor $e960 $e656))
+(flet ($e1270 (and $e918 $e1256))
+(flet ($e1271 (or $e1112 $e431))
+(flet ($e1272 (implies $e254 $e777))
+(flet ($e1273 (xor $e718 $e1116))
+(flet ($e1274 (not $e1000))
+(flet ($e1275 (not $e554))
+(flet ($e1276 (xor $e1090 $e509))
+(flet ($e1277 (implies $e393 $e1180))
+(flet ($e1278 (or $e443 $e489))
+(flet ($e1279 (iff $e280 $e820))
+(flet ($e1280 (not $e1207))
+(flet ($e1281 (not $e1171))
+(flet ($e1282 (if_then_else $e979 $e936 $e392))
+(flet ($e1283 (and $e525 $e899))
+(flet ($e1284 (xor $e947 $e959))
+(flet ($e1285 (xor $e1049 $e638))
+(flet ($e1286 (iff $e531 $e779))
+(flet ($e1287 (implies $e1229 $e912))
+(flet ($e1288 (implies $e946 $e987))
+(flet ($e1289 (if_then_else $e747 $e893 $e856))
+(flet ($e1290 (iff $e801 $e303))
+(flet ($e1291 (or $e1093 $e901))
+(flet ($e1292 (and $e728 $e646))
+(flet ($e1293 (and $e684 $e1099))
+(flet ($e1294 (or $e369 $e484))
+(flet ($e1295 (xor $e621 $e837))
+(flet ($e1296 (xor $e653 $e745))
+(flet ($e1297 (implies $e624 $e1296))
+(flet ($e1298 (xor $e1203 $e882))
+(flet ($e1299 (and $e1022 $e1103))
+(flet ($e1300 (implies $e306 $e524))
+(flet ($e1301 (xor $e1204 $e1227))
+(flet ($e1302 (or $e1216 $e978))
+(flet ($e1303 (implies $e1039 $e816))
+(flet ($e1304 (implies $e1102 $e698))
+(flet ($e1305 (xor $e607 $e945))
+(flet ($e1306 (iff $e1206 $e336))
+(flet ($e1307 (not $e1048))
+(flet ($e1308 (or $e574 $e1014))
+(flet ($e1309 (if_then_else $e870 $e276 $e857))
+(flet ($e1310 (if_then_else $e299 $e1185 $e697))
+(flet ($e1311 (or $e799 $e457))
+(flet ($e1312 (not $e1278))
+(flet ($e1313 (and $e1027 $e449))
+(flet ($e1314 (implies $e337 $e467))
+(flet ($e1315 (xor $e827 $e1058))
+(flet ($e1316 (xor $e1015 $e1222))
+(flet ($e1317 (not $e1178))
+(flet ($e1318 (or $e717 $e790))
+(flet ($e1319 (if_then_else $e473 $e871 $e474))
+(flet ($e1320 (and $e353 $e1133))
+(flet ($e1321 (not $e1287))
+(flet ($e1322 (iff $e1265 $e390))
+(flet ($e1323 (iff $e753 $e427))
+(flet ($e1324 (and $e365 $e660))
+(flet ($e1325 (if_then_else $e275 $e571 $e798))
+(flet ($e1326 (or $e345 $e803))
+(flet ($e1327 (and $e418 $e406))
+(flet ($e1328 (if_then_else $e1079 $e435 $e865))
+(flet ($e1329 (if_then_else $e608 $e685 $e704))
+(flet ($e1330 (xor $e1020 $e352))
+(flet ($e1331 (xor $e828 $e578))
+(flet ($e1332 (xor $e491 $e811))
+(flet ($e1333 (or $e669 $e680))
+(flet ($e1334 (iff $e1191 $e1053))
+(flet ($e1335 (not $e881))
+(flet ($e1336 (iff $e722 $e397))
+(flet ($e1337 (implies $e256 $e672))
+(flet ($e1338 (iff $e916 $e1248))
+(flet ($e1339 (if_then_else $e1122 $e1038 $e785))
+(flet ($e1340 (or $e1302 $e736))
+(flet ($e1341 (and $e512 $e1041))
+(flet ($e1342 (and $e1044 $e377))
+(flet ($e1343 (iff $e744 $e471))
+(flet ($e1344 (not $e1249))
+(flet ($e1345 (and $e405 $e616))
+(flet ($e1346 (iff $e767 $e756))
+(flet ($e1347 (and $e334 $e1241))
+(flet ($e1348 (not $e1131))
+(flet ($e1349 (implies $e623 $e339))
+(flet ($e1350 (xor $e310 $e812))
+(flet ($e1351 (or $e451 $e1314))
+(flet ($e1352 (if_then_else $e1082 $e986 $e600))
+(flet ($e1353 (iff $e663 $e1332))
+(flet ($e1354 (xor $e1344 $e895))
+(flet ($e1355 (iff $e705 $e629))
+(flet ($e1356 (implies $e1340 $e924))
+(flet ($e1357 (or $e1096 $e750))
+(flet ($e1358 (iff $e1231 $e743))
+(flet ($e1359 (iff $e317 $e805))
+(flet ($e1360 (iff $e782 $e373))
+(flet ($e1361 (not $e657))
+(flet ($e1362 (and $e541 $e586))
+(flet ($e1363 (implies $e1043 $e1312))
+(flet ($e1364 (not $e1061))
+(flet ($e1365 (if_then_else $e1168 $e590 $e791))
+(flet ($e1366 (not $e1127))
+(flet ($e1367 (xor $e935 $e943))
+(flet ($e1368 (if_then_else $e844 $e413 $e834))
+(flet ($e1369 (and $e458 $e402))
+(flet ($e1370 (if_then_else $e695 $e407 $e500))
+(flet ($e1371 (not $e832))
+(flet ($e1372 (and $e283 $e1085))
+(flet ($e1373 (or $e483 $e889))
+(flet ($e1374 (if_then_else $e641 $e581 $e1201))
+(flet ($e1375 (and $e282 $e880))
+(flet ($e1376 (xor $e650 $e1008))
+(flet ($e1377 (and $e1311 $e1253))
+(flet ($e1378 (if_then_else $e504 $e367 $e428))
+(flet ($e1379 (if_then_else $e1321 $e949 $e1199))
+(flet ($e1380 (xor $e1007 $e1259))
+(flet ($e1381 (iff $e1130 $e1349))
+(flet ($e1382 (if_then_else $e366 $e267 $e279))
+(flet ($e1383 (not $e838))
+(flet ($e1384 (not $e1087))
+(flet ($e1385 (or $e1380 $e922))
+(flet ($e1386 (implies $e618 $e1172))
+(flet ($e1387 (implies $e1306 $e1331))
+(flet ($e1388 (and $e1239 $e507))
+(flet ($e1389 (not $e931))
+(flet ($e1390 (or $e967 $e1075))
+(flet ($e1391 (or $e934 $e982))
+(flet ($e1392 (if_then_else $e725 $e1165 $e985))
+(flet ($e1393 (xor $e1145 $e464))
+(flet ($e1394 (if_then_else $e295 $e964 $e1293))
+(flet ($e1395 (not $e1062))
+(flet ($e1396 (and $e1264 $e1368))
+(flet ($e1397 (xor $e1258 $e813))
+(flet ($e1398 (not $e690))
+(flet ($e1399 (if_then_else $e1328 $e1078 $e528))
+(flet ($e1400 (iff $e1070 $e742))
+(flet ($e1401 (iff $e911 $e1144))
+(flet ($e1402 (or $e781 $e662))
+(flet ($e1403 (if_then_else $e1101 $e530 $e378))
+(flet ($e1404 (and $e788 $e593))
+(flet ($e1405 (implies $e738 $e1160))
+(flet ($e1406 (if_then_else $e591 $e456 $e439))
+(flet ($e1407 (or $e1313 $e622))
+(flet ($e1408 (xor $e892 $e1362))
+(flet ($e1409 (iff $e1288 $e682))
+(flet ($e1410 (or $e1031 $e321))
+(flet ($e1411 (not $e1281))
+(flet ($e1412 (and $e1263 $e387))
+(flet ($e1413 (or $e939 $e543))
+(flet ($e1414 (xor $e1012 $e886))
+(flet ($e1415 (not $e716))
+(flet ($e1416 (implies $e536 $e385))
+(flet ($e1417 (implies $e775 $e598))
+(flet ($e1418 (if_then_else $e534 $e519 $e454))
+(flet ($e1419 (and $e643 $e826))
+(flet ($e1420 (not $e1001))
+(flet ($e1421 (implies $e647 $e515))
+(flet ($e1422 (not $e1179))
+(flet ($e1423 (or $e1254 $e1234))
+(flet ($e1424 (if_then_else $e877 $e679 $e465))
+(flet ($e1425 (if_then_else $e940 $e1384 $e670))
+(flet ($e1426 (and $e914 $e401))
+(flet ($e1427 (not $e676))
+(flet ($e1428 (xor $e1119 $e764))
+(flet ($e1429 (xor $e634 $e1386))
+(flet ($e1430 (xor $e1324 $e549))
+(flet ($e1431 (implies $e999 $e347))
+(flet ($e1432 (if_then_else $e1426 $e495 $e761))
+(flet ($e1433 (xor $e1367 $e1224))
+(flet ($e1434 (and $e1414 $e1054))
+(flet ($e1435 (iff $e951 $e724))
+(flet ($e1436 (iff $e759 $e637))
+(flet ($e1437 (not $e561))
+(flet ($e1438 (not $e988))
+(flet ($e1439 (if_then_else $e1182 $e1366 $e1334))
+(flet ($e1440 (or $e869 $e448))
+(flet ($e1441 (xor $e375 $e1213))
+(flet ($e1442 (or $e830 $e1403))
+(flet ($e1443 (xor $e1299 $e1104))
+(flet ($e1444 (or $e355 $e383))
+(flet ($e1445 (xor $e1016 $e1357))
+(flet ($e1446 (and $e765 $e1040))
+(flet ($e1447 (or $e1396 $e329))
+(flet ($e1448 (xor $e497 $e1305))
+(flet ($e1449 (or $e731 $e547))
+(flet ($e1450 (if_then_else $e789 $e1301 $e579))
+(flet ($e1451 (iff $e1443 $e969))
+(flet ($e1452 (implies $e260 $e1200))
+(flet ($e1453 (not $e585))
+(flet ($e1454 (iff $e270 $e1294))
+(flet ($e1455 (if_then_else $e604 $e1167 $e308))
+(flet ($e1456 (and $e919 $e766))
+(flet ($e1457 (implies $e362 $e1142))
+(flet ($e1458 (if_then_else $e1450 $e1353 $e1091))
+(flet ($e1459 (not $e1084))
+(flet ($e1460 (xor $e535 $e1032))
+(flet ($e1461 (xor $e1237 $e681))
+(flet ($e1462 (xor $e661 $e1444))
+(flet ($e1463 (if_then_else $e859 $e445 $e1350))
+(flet ($e1464 (iff $e566 $e686))
+(flet ($e1465 (or $e1137 $e1273))
+(flet ($e1466 (xor $e396 $e923))
+(flet ($e1467 (iff $e890 $e437))
+(flet ($e1468 (and $e490 $e475))
+(flet ($e1469 (and $e297 $e1003))
+(flet ($e1470 (not $e1286))
+(flet ($e1471 (if_then_else $e1369 $e552 $e1415))
+(flet ($e1472 (if_then_else $e1373 $e699 $e1266))
+(flet ($e1473 (and $e1361 $e1251))
+(flet ($e1474 (or $e773 $e703))
+(flet ($e1475 (implies $e1410 $e1089))
+(flet ($e1476 (not $e417))
+(flet ($e1477 (if_then_else $e1392 $e330 $e1359))
+(flet ($e1478 (not $e833))
+(flet ($e1479 (xor $e917 $e1151))
+(flet ($e1480 (not $e447))
+(flet ($e1481 (not $e573))
+(flet ($e1482 (or $e301 $e596))
+(flet ($e1483 (implies $e927 $e887))
+(flet ($e1484 (and $e1342 $e867))
+(flet ($e1485 (and $e1280 $e952))
+(flet ($e1486 (implies $e1005 $e537))
+(flet ($e1487 (and $e776 $e1110))
+(flet ($e1488 (and $e442 $e902))
+(flet ($e1489 (and $e1470 $e433))
+(flet ($e1490 (if_then_else $e1069 $e499 $e1050))
+(flet ($e1491 (or $e854 $e1208))
+(flet ($e1492 (xor $e463 $e1437))
+(flet ($e1493 (not $e274))
+(flet ($e1494 (iff $e772 $e861))
+(flet ($e1495 (iff $e1404 $e313))
+(flet ($e1496 (implies $e1230 $e1467))
+(flet ($e1497 (iff $e992 $e817))
+(flet ($e1498 (xor $e1387 $e1047))
+(flet ($e1499 (or $e675 $e292))
+(flet ($e1500 (xor $e974 $e1250))
+(flet ($e1501 (implies $e1067 $e415))
+(flet ($e1502 (implies $e1282 $e627))
+(flet ($e1503 (or $e712 $e1336))
+(flet ($e1504 (if_then_else $e615 $e1445 $e1503))
+(flet ($e1505 (implies $e1135 $e494))
+(flet ($e1506 (xor $e1325 $e529))
+(flet ($e1507 (not $e1430))
+(flet ($e1508 (iff $e1462 $e980))
+(flet ($e1509 (implies $e461 $e1024))
+(flet ($e1510 (xor $e961 $e263))
+(flet ($e1511 (implies $e654 $e1128))
+(flet ($e1512 (xor $e644 $e1491))
+(flet ($e1513 (implies $e1184 $e469))
+(flet ($e1514 (and $e1059 $e391))
+(flet ($e1515 (if_then_else $e1326 $e734 $e719))
+(flet ($e1516 (and $e665 $e932))
+(flet ($e1517 (and $e422 $e1433))
+(flet ($e1518 (if_then_else $e325 $e1120 $e1272))
+(flet ($e1519 (implies $e829 $e1329))
+(flet ($e1520 (xor $e1086 $e1113))
+(flet ($e1521 (not $e701))
+(flet ($e1522 (or $e506 $e614))
+(flet ($e1523 (and $e976 $e1235))
+(flet ($e1524 (implies $e1238 $e814))
+(flet ($e1525 (implies $e408 $e1453))
+(flet ($e1526 (xor $e1522 $e1274))
+(flet ($e1527 (implies $e1341 $e956))
+(flet ($e1528 (xor $e430 $e847))
+(flet ($e1529 (implies $e1358 $e1117))
+(flet ($e1530 (and $e436 $e550))
+(flet ($e1531 (not $e1408))
+(flet ($e1532 (and $e1289 $e1337))
+(flet ($e1533 (xor $e487 $e906))
+(flet ($e1534 (implies $e315 $e1196))
+(flet ($e1535 (if_then_else $e635 $e1401 $e403))
+(flet ($e1536 (if_then_else $e1307 $e1402 $e286))
+(flet ($e1537 (xor $e1330 $e768))
+(flet ($e1538 (or $e1481 $e466))
+(flet ($e1539 (and $e1283 $e290))
+(flet ($e1540 (if_then_else $e333 $e770 $e1255))
+(flet ($e1541 (or $e808 $e800))
+(flet ($e1542 (xor $e806 $e1013))
+(flet ($e1543 (iff $e1379 $e1395))
+(flet ($e1544 (if_then_else $e1492 $e1460 $e958))
+(flet ($e1545 (iff $e692 $e481))
+(flet ($e1546 (iff $e1493 $e346))
+(flet ($e1547 (iff $e1418 $e802))
+(flet ($e1548 (and $e714 $e1532))
+(flet ($e1549 (or $e1215 $e1412))
+(flet ($e1550 (iff $e1487 $e327))
+(flet ($e1551 (and $e1002 $e941))
+(flet ($e1552 (or $e771 $e1405))
+(flet ($e1553 (not $e1194))
+(flet ($e1554 (not $e432))
+(flet ($e1555 (and $e1279 $e264))
+(flet ($e1556 (not $e1500))
+(flet ($e1557 (iff $e1545 $e883))
+(flet ($e1558 (not $e658))
+(flet ($e1559 (iff $e735 $e486))
+(flet ($e1560 (or $e1124 $e977))
+(flet ($e1561 (and $e1246 $e441))
+(flet ($e1562 (not $e1497))
+(flet ($e1563 (and $e1385 $e508))
+(flet ($e1564 (or $e1542 $e1536))
+(flet ($e1565 (if_then_else $e1169 $e774 $e612))
+(flet ($e1566 (if_then_else $e1454 $e314 $e730))
+(flet ($e1567 (xor $e1316 $e930))
+(flet ($e1568 (or $e1042 $e1221))
+(flet ($e1569 (and $e1187 $e720))
+(flet ($e1570 (and $e1440 $e628))
+(flet ($e1571 (if_then_else $e311 $e639 $e1018))
+(flet ($e1572 (if_then_else $e501 $e322 $e950))
+(flet ($e1573 (if_then_else $e1292 $e1017 $e620))
+(flet ($e1574 (if_then_else $e523 $e1088 $e532))
+(flet ($e1575 (implies $e1434 $e1538))
+(flet ($e1576 (not $e783))
+(flet ($e1577 (if_then_else $e1134 $e323 $e860))
+(flet ($e1578 (or $e693 $e594))
+(flet ($e1579 (if_then_else $e380 $e1546 $e973))
+(flet ($e1580 (implies $e444 $e1290))
+(flet ($e1581 (or $e1136 $e1508))
+(flet ($e1582 (iff $e645 $e462))
+(flet ($e1583 (implies $e625 $e762))
+(flet ($e1584 (if_then_else $e575 $e261 $e1198))
+(flet ($e1585 (or $e1557 $e1371))
+(flet ($e1586 (if_then_else $e809 $e909 $e592))
+(flet ($e1587 (iff $e1320 $e1252))
+(flet ($e1588 (implies $e277 $e896))
+(flet ($e1589 (xor $e340 $e687))
+(flet ($e1590 (if_then_else $e319 $e1173 $e913))
+(flet ($e1591 (implies $e1393 $e1461))
+(flet ($e1592 (implies $e1126 $e1092))
+(flet ($e1593 (xor $e298 $e831))
+(flet ($e1594 (not $e1076))
+(flet ($e1595 (xor $e850 $e438))
+(flet ($e1596 (xor $e1511 $e1389))
+(flet ($e1597 (xor $e804 $e737))
+(flet ($e1598 (iff $e1597 $e993))
+(flet ($e1599 (iff $e1343 $e1065))
+(flet ($e1600 (if_then_else $e1319 $e907 $e1559))
+(flet ($e1601 (iff $e631 $e709))
+(flet ($e1602 (if_then_else $e876 $e1190 $e721))
+(flet ($e1603 (implies $e1466 $e700))
+(flet ($e1604 (if_then_else $e822 $e1052 $e1025))
+(flet ($e1605 (xor $e410 $e376))
+(flet ($e1606 (iff $e583 $e746))
+(flet ($e1607 (or $e792 $e1095))
+(flet ($e1608 (if_then_else $e1009 $e707 $e1245))
+(flet ($e1609 (xor $e1267 $e455))
+(flet ($e1610 (iff $e673 $e259))
+(flet ($e1611 (not $e307))
+(flet ($e1612 (not $e1567))
+(flet ($e1613 (not $e1327))
+(flet ($e1614 (iff $e910 $e1428))
+(flet ($e1615 (and $e1217 $e1576))
+(flet ($e1616 (not $e258))
+(flet ($e1617 (iff $e1333 $e1562))
+(flet ($e1618 (not $e1543))
+(flet ($e1619 (not $e1479))
+(flet ($e1620 (iff $e1504 $e1399))
+(flet ($e1621 (xor $e835 $e1614))
+(flet ($e1622 (if_then_else $e1262 $e302 $e1247))
+(flet ($e1623 (xor $e1519 $e1583))
+(flet ($e1624 (iff $e450 $e1591))
+(flet ($e1625 (and $e399 $e412))
+(flet ($e1626 (not $e968))
+(flet ($e1627 (implies $e601 $e1464))
+(flet ($e1628 (or $e1377 $e1394))
+(flet ($e1629 (or $e1442 $e1147))
+(flet ($e1630 (not $e900))
+(flet ($e1631 (not $e884))
+(flet ($e1632 (not $e1587))
+(flet ($e1633 (or $e1534 $e502))
+(flet ($e1634 (implies $e1080 $e1620))
+(flet ($e1635 (if_then_else $e1550 $e1495 $e485))
+(flet ($e1636 (not $e358))
+(flet ($e1637 (or $e1554 $e1607))
+(flet ($e1638 (not $e1525))
+(flet ($e1639 (xor $e818 $e1436))
+(flet ($e1640 (or $e891 $e1605))
+(flet ($e1641 (xor $e1588 $e1465))
+(flet ($e1642 (not $e288))
+(flet ($e1643 (implies $e824 $e459))
+(flet ($e1644 (if_then_else $e404 $e879 $e1458))
+(flet ($e1645 (not $e1594))
+(flet ($e1646 (implies $e1291 $e513))
+(flet ($e1647 (iff $e1139 $e688))
+(flet ($e1648 (and $e1612 $e1193))
+(flet ($e1649 (implies $e1212 $e300))
+(flet ($e1650 (and $e424 $e858))
+(flet ($e1651 (not $e1593))
+(flet ($e1652 (implies $e1177 $e1480))
+(flet ($e1653 (and $e421 $e1407))
+(flet ($e1654 (xor $e1526 $e429))
+(flet ($e1655 (not $e1372))
+(flet ($e1656 (or $e1154 $e1322))
+(flet ($e1657 (xor $e1129 $e648))
+(flet ($e1658 (and $e553 $e1556))
+(flet ($e1659 (and $e1261 $e825))
+(flet ($e1660 (implies $e1308 $e666))
+(flet ($e1661 (if_then_else $e1610 $e784 $e493))
+(flet ($e1662 (iff $e470 $e897))
+(flet ($e1663 (and $e1218 $e1449))
+(flet ($e1664 (and $e1164 $e551))
+(flet ($e1665 (and $e1627 $e1244))
+(flet ($e1666 (iff $e1570 $e1516))
+(flet ($e1667 (xor $e1575 $e1174))
+(flet ($e1668 (implies $e1236 $e1309))
+(flet ($e1669 (not $e1658))
+(flet ($e1670 (if_then_else $e933 $e400 $e855))
+(flet ($e1671 (implies $e587 $e1537))
+(flet ($e1672 (if_then_else $e1030 $e1323 $e492))
+(flet ($e1673 (or $e1530 $e864))
+(flet ($e1674 (xor $e1060 $e874))
+(flet ($e1675 (xor $e1448 $e755))
+(flet ($e1676 (or $e1529 $e1586))
+(flet ($e1677 (implies $e1565 $e1675))
+(flet ($e1678 (and $e655 $e1417))
+(flet ($e1679 (iff $e281 $e1636))
+(flet ($e1680 (if_then_else $e1622 $e667 $e1618))
+(flet ($e1681 (not $e1513))
+(flet ($e1682 (xor $e925 $e350))
+(flet ($e1683 (not $e1469))
+(flet ($e1684 (or $e1370 $e971))
+(flet ($e1685 (implies $e733 $e1240))
+(flet ($e1686 (if_then_else $e599 $e955 $e296))
+(flet ($e1687 (iff $e1064 $e848))
+(flet ($e1688 (iff $e538 $e1637))
+(flet ($e1689 (or $e1411 $e1411))
+(flet ($e1690 (and $e1625 $e1100))
+(flet ($e1691 (xor $e1004 $e966))
+(flet ($e1692 (xor $e678 $e1652))
+(flet ($e1693 (or $e556 $e348))
+(flet ($e1694 (implies $e1360 $e1685))
+(flet ($e1695 (if_then_else $e1400 $e595 $e1564))
+(flet ($e1696 (iff $e468 $e1572))
+(flet ($e1697 (implies $e1315 $e460))
+(flet ($e1698 (iff $e521 $e316))
+(flet ($e1699 (xor $e1468 $e1592))
+(flet ($e1700 (iff $e1143 $e569))
+(flet ($e1701 (or $e823 $e1383))
+(flet ($e1702 (or $e995 $e1317))
+(flet ($e1703 (implies $e984 $e285))
+(flet ($e1704 (if_then_else $e1429 $e335 $e1141))
+(flet ($e1705 (not $e1549))
+(flet ($e1706 (not $e1640))
+(flet ($e1707 (xor $e1140 $e1435))
+(flet ($e1708 (not $e597))
+(flet ($e1709 (xor $e1621 $e1505))
+(flet ($e1710 (and $e1021 $e331))
+(flet ($e1711 (and $e1375 $e1056))
+(flet ($e1712 (and $e1023 $e1555))
+(flet ($e1713 (xor $e510 $e1531))
+(flet ($e1714 (not $e434))
+(flet ($e1715 (or $e1528 $e1077))
+(flet ($e1716 (and $e1676 $e1228))
+(flet ($e1717 (xor $e1496 $e603))
+(flet ($e1718 (iff $e1552 $e1541))
+(flet ($e1719 (if_then_else $e1527 $e557 $e1558))
+(flet ($e1720 (if_then_else $e1310 $e1600 $e994))
+(flet ($e1721 (or $e548 $e1391))
+(flet ($e1722 (and $e1684 $e787))
+(flet ($e1723 (iff $e1441 $e1582))
+(flet ($e1724 (not $e452))
+(flet ($e1725 (if_then_else $e359 $e278 $e1233))
+(flet ($e1726 (not $e749))
+(flet ($e1727 (xor $e1608 $e293))
+(flet ($e1728 (if_then_else $e1431 $e1205 $e514))
+(flet ($e1729 (xor $e1284 $e1716))
+(flet ($e1730 (not $e1721))
+(flet ($e1731 (or $e1714 $e1566))
+(flet ($e1732 (if_then_else $e1339 $e1682 $e1668))
+(flet ($e1733 (implies $e1390 $e381))
+(flet ($e1734 (implies $e1553 $e1374))
+(flet ($e1735 (or $e1705 $e1494))
+(flet ($e1736 (or $e1197 $e903))
+(flet ($e1737 (if_then_else $e875 $e1735 $e1482))
+(flet ($e1738 (or $e1506 $e1709))
+(flet ($e1739 (xor $e372 $e1698))
+(flet ($e1740 (not $e1691))
+(flet ($e1741 (if_then_else $e863 $e589 $e1298))
+(flet ($e1742 (if_then_else $e1540 $e1712 $e1560))
+(flet ($e1743 (implies $e1351 $e1724))
+(flet ($e1744 (if_then_else $e1738 $e819 $e1717))
+(flet ($e1745 (and $e1661 $e1509))
+(flet ($e1746 (or $e1711 $e505))
+(flet ($e1747 (if_then_else $e1548 $e265 $e257))
+(flet ($e1748 (or $e1746 $e1303))
+(flet ($e1749 (implies $e341 $e425))
+(flet ($e1750 (xor $e1577 $e1518))
+(flet ($e1751 (xor $e1269 $e1424))
+(flet ($e1752 (and $e1679 $e1363))
+(flet ($e1753 (implies $e1463 $e1271))
+(flet ($e1754 (xor $e1681 $e1159))
+(flet ($e1755 (if_then_else $e1670 $e852 $e1388))
+(flet ($e1756 (if_then_else $e795 $e1729 $e1146))
+(flet ($e1757 (not $e1423))
+(flet ($e1758 (and $e304 $e266))
+(flet ($e1759 (if_then_else $e1209 $e1632 $e1590))
+(flet ($e1760 (not $e1149))
+(flet ($e1761 (or $e780 $e1474))
+(flet ($e1762 (or $e1118 $e605))
+(flet ($e1763 (and $e1006 $e841))
+(flet ($e1764 (if_then_else $e1631 $e1581 $e1121))
+(flet ($e1765 (iff $e1150 $e1764))
+(flet ($e1766 (xor $e356 $e1753))
+(flet ($e1767 (if_then_else $e558 $e1364 $e1688))
+(flet ($e1768 (iff $e1097 $e1285))
+(flet ($e1769 (implies $e1606 $e1107))
+(flet ($e1770 (implies $e962 $e1690))
+(flet ($e1771 (and $e1707 $e545))
+(flet ($e1772 (not $e1485))
+(flet ($e1773 (and $e1381 $e1745))
+(flet ($e1774 (or $e1499 $e1752))
+(flet ($e1775 (implies $e1769 $e1268))
+(flet ($e1776 (and $e511 $e1276))
+(flet ($e1777 (and $e559 $e1578))
+(flet ($e1778 (xor $e1447 $e908))
+(flet ($e1779 (implies $e1352 $e972))
+(flet ($e1780 (if_then_else $e426 $e1520 $e1657))
+(flet ($e1781 (xor $e1699 $e1378))
+(flet ($e1782 (implies $e991 $e1662))
+(flet ($e1783 (or $e328 $e1775))
+(flet ($e1784 (or $e894 $e1446))
+(flet ($e1785 (iff $e1297 $e794))
+(flet ($e1786 (or $e1782 $e996))
+(flet ($e1787 (if_then_else $e1175 $e989 $e1783))
+(flet ($e1788 (xor $e294 $e1098))
+(flet ($e1789 (iff $e1629 $e1397))
+(flet ($e1790 (iff $e727 $e1626))
+(flet ($e1791 (or $e626 $e942))
+(flet ($e1792 (if_then_else $e990 $e1166 $e1028))
+(flet ($e1793 (and $e619 $e1398))
+(flet ($e1794 (iff $e1478 $e1515))
+(flet ($e1795 (and $e1596 $e1210))
+(flet ($e1796 (implies $e723 $e1768))
+(flet ($e1797 (implies $e1571 $e1490))
+(flet ($e1798 (if_then_else $e1521 $e1335 $e1643))
+(flet ($e1799 (iff $e1539 $e1451))
+(flet ($e1800 (implies $e1740 $e1762))
+(flet ($e1801 (iff $e1687 $e1152))
+(flet ($e1802 (and $e1354 $e1653))
+(flet ($e1803 (xor $e446 $e1585))
+(flet ($e1804 (iff $e394 $e1766))
+(flet ($e1805 (iff $e1801 $e846))
+(flet ($e1806 (implies $e1105 $e588))
+(flet ($e1807 (and $e1318 $e1045))
+(flet ($e1808 (or $e1771 $e1700))
+(flet ($e1809 (xor $e1476 $e1073))
+(flet ($e1810 (iff $e810 $e1727))
+(flet ($e1811 (iff $e1780 $e609))
+(flet ($e1812 (iff $e1438 $e1456))
+(flet ($e1813 (iff $e1533 $e1800))
+(flet ($e1814 (iff $e659 $e1595))
+(flet ($e1815 (implies $e1489 $e1654))
+(flet ($e1816 (implies $e1427 $e1755))
+(flet ($e1817 (if_then_else $e1615 $e1733 $e1811))
+(flet ($e1818 (or $e1066 $e1817))
+(flet ($e1819 (implies $e1584 $e1694))
+(flet ($e1820 (implies $e544 $e1759))
+(flet ($e1821 (xor $e1225 $e1345))
+(flet ($e1822 (and $e633 $e1544))
+(flet ($e1823 (iff $e1162 $e1680))
+(flet ($e1824 (if_then_else $e1416 $e754 $e1214))
+(flet ($e1825 (xor $e1779 $e815))
+(flet ($e1826 (if_then_else $e1765 $e1807 $e1517))
+(flet ($e1827 (implies $e1692 $e305))
+(flet ($e1828 (and $e1677 $e683))
+(flet ($e1829 (and $e1270 $e1589))
+(flet ($e1830 (implies $e920 $e711))
+(flet ($e1831 (iff $e542 $e898))
+(flet ($e1832 (or $e527 $e324))
+(flet ($e1833 (implies $e1823 $e878))
+(flet ($e1834 (iff $e518 $e568))
+(flet ($e1835 (implies $e1659 $e1617))
+(flet ($e1836 (and $e326 $e496))
+(flet ($e1837 (and $e617 $e1649))
+(flet ($e1838 (xor $e1641 $e853))
+(flet ($e1839 (not $e1580))
+(flet ($e1840 (iff $e1835 $e763))
+(flet ($e1841 (implies $e1211 $e1072))
+(flet ($e1842 (xor $e1106 $e409))
+(flet ($e1843 (and $e1439 $e1704))
+(flet ($e1844 (xor $e1192 $e1731))
+(flet ($e1845 (xor $e382 $e1036))
+(flet ($e1846 (and $e1660 $e1825))
+(flet ($e1847 (or $e1702 $e1624))
+(flet ($e1848 (or $e793 $e1794))
+(flet ($e1849 (xor $e1665 $e708))
+(flet ($e1850 (implies $e1455 $e739))
+(flet ($e1851 (and $e752 $e1356))
+(flet ($e1852 (implies $e291 $e1609))
+(flet ($e1853 (or $e1833 $e370))
+(flet ($e1854 (or $e1810 $e845))
+(flet ($e1855 (not $e1613))
+(flet ($e1856 (xor $e797 $e998))
+(flet ($e1857 (xor $e1535 $e1741))
+(flet ($e1858 (if_then_else $e1300 $e1365 $e1843))
+(flet ($e1859 (not $e374))
+(flet ($e1860 (iff $e1819 $e938))
+(flet ($e1861 (not $e1850))
+(flet ($e1862 (xor $e1382 $e1834))
+(flet ($e1863 (if_then_else $e1706 $e1802 $e1277))
+(flet ($e1864 (xor $e611 $e757))
+(flet ($e1865 (xor $e1406 $e1602))
+(flet ($e1866 (if_then_else $e1848 $e1421 $e1776))
+(flet ($e1867 (implies $e1788 $e1853))
+(flet ($e1868 (not $e1484))
+(flet ($e1869 (and $e1851 $e344))
+(flet ($e1870 (implies $e1726 $e371))
+(flet ($e1871 (and $e1673 $e748))
+(flet ($e1872 (and $e1355 $e1599))
+(flet ($e1873 (iff $e1774 $e769))
+(flet ($e1874 (if_then_else $e1547 $e1639 $e1695))
+(flet ($e1875 (xor $e1787 $e1822))
+(flet ($e1876 (or $e1473 $e1604))
+(flet ($e1877 (implies $e873 $e1655))
+(flet ($e1878 (not $e1483))
+(flet ($e1879 (if_then_else $e1763 $e1725 $e1816))
+(flet ($e1880 (iff $e1475 $e1840))
+(flet ($e1881 (xor $e1761 $e1758))
+(flet ($e1882 (and $e1242 $e1856))
+(flet ($e1883 (xor $e478 $e414))
+(flet ($e1884 (or $e1757 $e1701))
+(flet ($e1885 (implies $e1806 $e526))
+(flet ($e1886 (if_then_else $e1877 $e851 $e1818))
+(flet ($e1887 (if_then_else $e668 $e1409 $e1871))
+(flet ($e1888 (and $e582 $e577))
+(flet ($e1889 (if_then_else $e1686 $e1846 $e1498))
+(flet ($e1890 (not $e1422))
+(flet ($e1891 (not $e379))
+(flet ($e1892 (implies $e1874 $e349))
+(flet ($e1893 (and $e1719 $e1512))
+(flet ($e1894 (and $e1664 $e786))
+(flet ($e1895 (iff $e482 $e1894))
+(flet ($e1896 (not $e1630))
+(flet ($e1897 (if_then_else $e1892 $e1510 $e1646))
+(flet ($e1898 (or $e1814 $e983))
+(flet ($e1899 (or $e1884 $e1821))
+(flet ($e1900 (xor $e565 $e1888))
+(flet ($e1901 (and $e1472 $e694))
+(flet ($e1902 (xor $e970 $e1875))
+(flet ($e1903 (xor $e1029 $e706))
+(flet ($e1904 (xor $e1666 $e904))
+(flet ($e1905 (xor $e954 $e1703))
+(flet ($e1906 (if_then_else $e1900 $e1748 $e1760))
+(flet ($e1907 (not $e1638))
+(flet ($e1908 (if_then_else $e1157 $e1619 $e1804))
+(flet ($e1909 (xor $e1011 $e1663))
+(flet ($e1910 (or $e1488 $e1743))
+(flet ($e1911 (if_then_else $e726 $e1650 $e1831))
+(flet ($e1912 (xor $e1730 $e1857))
+(flet ($e1913 (and $e567 $e1459))
+(flet ($e1914 (iff $e1772 $e1770))
+(flet ($e1915 (or $e1671 $e1786))
+(flet ($e1916 (implies $e1865 $e778))
+(flet ($e1917 (if_then_else $e1346 $e1693 $e1163))
+(flet ($e1918 (iff $e1809 $e1912))
+(flet ($e1919 (and $e1905 $e1420))
+(flet ($e1920 (or $e1176 $e1849))
+(flet ($e1921 (or $e1906 $e1413))
+(flet ($e1922 (xor $e1457 $e1882))
+(flet ($e1923 (and $e862 $e1869))
+(flet ($e1924 (and $e1083 $e1858))
+(flet ($e1925 (xor $e1778 $e1803))
+(flet ($e1926 (not $e760))
+(flet ($e1927 (implies $e1904 $e1672))
+(flet ($e1928 (iff $e702 $e520))
+(flet ($e1929 (if_then_else $e677 $e1598 $e563))
+(flet ($e1930 (or $e1523 $e1295))
+(flet ($e1931 (or $e1304 $e1926))
+(flet ($e1932 (implies $e1574 $e1057))
+(flet ($e1933 (iff $e1911 $e1886))
+(flet ($e1934 (iff $e630 $e1756))
+(flet ($e1935 (iff $e1737 $e1914))
+(flet ($e1936 (or $e1603 $e1805))
+(flet ($e1937 (xor $e1713 $e1898))
+(flet ($e1938 (xor $e1452 $e1744))
+(flet ($e1939 (and $e1551 $e1915))
+(flet ($e1940 (and $e1501 $e262))
+(flet ($e1941 (or $e1929 $e1872))
+(flet ($e1942 (and $e1573 $e363))
+(flet ($e1943 (or $e1847 $e1642))
+(flet ($e1944 (or $e1941 $e1866))
+(flet ($e1945 (iff $e1094 $e613))
+(flet ($e1946 (xor $e1837 $e1524))
+(flet ($e1947 (or $e1635 $e1051))
+(flet ($e1948 (implies $e905 $e1747))
+(flet ($e1949 (iff $e751 $e1921))
+(flet ($e1950 (or $e1948 $e1916))
+(flet ($e1951 (if_then_else $e1656 $e1924 $e843))
+(flet ($e1952 (not $e1903))
+(flet ($e1953 (and $e384 $e1842))
+(flet ($e1954 (xor $e1678 $e1734))
+(flet ($e1955 (if_then_else $e1859 $e1944 $e1861))
+(flet ($e1956 (if_then_else $e1155 $e1867 $e1891))
+(flet ($e1957 (if_then_else $e1949 $e1860 $e1928))
+(flet ($e1958 (if_then_else $e1633 $e1909 $e1829))
+(flet ($e1959 (if_then_else $e1920 $e1471 $e1881))
+(flet ($e1960 (or $e1715 $e1732))
+(flet ($e1961 (or $e1939 $e476))
+(flet ($e1962 (or $e1879 $e1918))
+(flet ($e1963 (and $e1797 $e1844))
+(flet ($e1964 (and $e1243 $e1432))
+(flet ($e1965 (iff $e691 $e1784))
+(flet ($e1966 (and $e1937 $e1896))
+(flet ($e1967 (if_then_else $e1812 $e1736 $e732))
+(flet ($e1968 (not $e1568))
+(flet ($e1969 (and $e1789 $e1935))
+(flet ($e1970 (if_then_else $e1925 $e1795 $e1931))
+(flet ($e1971 (if_then_else $e929 $e1845 $e1739))
+(flet ($e1972 (or $e1616 $e273))
+(flet ($e1973 (iff $e1026 $e1962))
+(flet ($e1974 (if_then_else $e1964 $e1718 $e1922))
+(flet ($e1975 (or $e1971 $e1477))
+(flet ($e1976 (xor $e926 $e1799))
+(flet ($e1977 (and $e957 $e821))
+(flet ($e1978 (xor $e1669 $e1796))
+(flet ($e1979 (if_then_else $e1063 $e1936 $e1838))
+(flet ($e1980 (if_then_else $e1963 $e1338 $e1954))
+(flet ($e1981 (or $e1068 $e1697))
+(flet ($e1982 (xor $e1183 $e1824))
+(flet ($e1983 (not $e866))
+(flet ($e1984 (implies $e1956 $e354))
+(flet ($e1985 (implies $e1965 $e1579))
+(flet ($e1986 (iff $e580 $e1750))
+(flet ($e1987 (or $e1114 $e1897))
+(flet ($e1988 (if_then_else $e1919 $e1966 $e1275))
+(flet ($e1989 (if_then_else $e807 $e1899 $e1722))
+(flet ($e1990 (not $e1793))
+(flet ($e1991 (implies $e1961 $e1855))
+(flet ($e1992 (iff $e921 $e1773))
+(flet ($e1993 (xor $e1742 $e1696))
+(flet ($e1994 (iff $e689 $e937))
+(flet ($e1995 (iff $e1689 $e1947))
+(flet ($e1996 (xor $e1913 $e1815))
+(flet ($e1997 (iff $e1514 $e1628))
+(flet ($e1998 (implies $e1836 $e1123))
+(flet ($e1999 (or $e1930 $e1878))
+(flet ($e2000 (implies $e1889 $e1728))
+(flet ($e2001 (and $e1873 $e1202))
+(flet ($e2002 (and $e1973 $e1958))
+(flet ($e2003 (iff $e1993 $e1987))
+(flet ($e2004 (and $e872 $e1260))
+(flet ($e2005 (implies $e1880 $e1885))
+(flet ($e2006 (and $e1977 $e1985))
+(flet ($e2007 (iff $e1854 $e1723))
+(flet ($e2008 (or $e1901 $e1827))
+(flet ($e2009 (or $e2008 $e758))
+(flet ($e2010 (implies $e1997 $e1419))
+(flet ($e2011 (not $e1563))
+(flet ($e2012 (iff $e1647 $e1932))
+(flet ($e2013 (iff $e1798 $e1902))
+(flet ($e2014 (not $e564))
+(flet ($e2015 (iff $e1945 $e1938))
+(flet ($e2016 (if_then_else $e1852 $e1781 $e338))
+(flet ($e2017 (and $e1751 $e1507))
+(flet ($e2018 (not $e1170))
+(flet ($e2019 (implies $e1156 $e2000))
+(flet ($e2020 (xor $e1708 $e1634))
+(flet ($e2021 (or $e2009 $e1813))
+(flet ($e2022 (not $e1910))
+(flet ($e2023 (iff $e2010 $e1820))
+(flet ($e2024 (if_then_else $e1934 $e498 $e1983))
+(flet ($e2025 (not $e1785))
+(flet ($e2026 (xor $e1864 $e1791))
+(flet ($e2027 (or $e2011 $e572))
+(flet ($e2028 (implies $e997 $e1486))
+(flet ($e2029 (not $e1974))
+(flet ($e2030 (not $e342))
+(flet ($e2031 (if_then_else $e1988 $e1034 $e1890))
+(flet ($e2032 (or $e1876 $e2024))
+(flet ($e2033 (or $e2027 $e1868))
+(flet ($e2034 (not $e2019))
+(flet ($e2035 (not $e1348))
+(flet ($e2036 (not $e517))
+(flet ($e2037 (implies $e1976 $e2003))
+(flet ($e2038 (if_then_else $e2006 $e1645 $e1754))
+(flet ($e2039 (if_then_else $e1972 $e2013 $e1996))
+(flet ($e2040 (or $e1862 $e2022))
+(flet ($e2041 (xor $e1611 $e849))
+(flet ($e2042 (xor $e1883 $e1623))
+(flet ($e2043 (if_then_else $e1425 $e1951 $e1832))
+(flet ($e2044 (iff $e1957 $e885))
+(flet ($e2045 (or $e2004 $e2033))
+(flet ($e2046 (or $e289 $e1927))
+(flet ($e2047 (or $e868 $e2014))
+(flet ($e2048 (iff $e1839 $e2023))
+(flet ($e2049 (if_then_else $e351 $e1502 $e1790))
+(flet ($e2050 (implies $e1808 $e2015))
+(flet ($e2051 (not $e320))
+(flet ($e2052 (not $e2036))
+(flet ($e2053 (and $e1644 $e1569))
+(flet ($e2054 (if_then_else $e1970 $e2047 $e1942))
+(flet ($e2055 (xor $e1960 $e1992))
+(flet ($e2056 (or $e2035 $e1975))
+(flet ($e2057 (implies $e1830 $e1933))
+(flet ($e2058 (iff $e948 $e1991))
+(flet ($e2059 (iff $e1952 $e1953))
+(flet ($e2060 (and $e2057 $e1923))
+(flet ($e2061 (and $e2041 $e1989))
+(flet ($e2062 (or $e1978 $e1055))
+(flet ($e2063 (xor $e1347 $e2020))
+(flet ($e2064 (implies $e1887 $e2034))
+(flet ($e2065 (if_then_else $e1950 $e1946 $e1990))
+(flet ($e2066 (xor $e1601 $e888))
+(flet ($e2067 (iff $e1826 $e1674))
+(flet ($e2068 (if_then_else $e1986 $e1984 $e1981))
+(flet ($e2069 (if_then_else $e1940 $e2044 $e1907))
+(flet ($e2070 (or $e1968 $e2051))
+(flet ($e2071 (if_then_else $e2052 $e2029 $e2016))
+(flet ($e2072 (iff $e2031 $e1995))
+(flet ($e2073 (or $e2070 $e271))
+(flet ($e2074 (iff $e2017 $e2042))
+(flet ($e2075 (implies $e2065 $e2037))
+(flet ($e2076 (or $e1186 $e1998))
+(flet ($e2077 (not $e2026))
+(flet ($e2078 (xor $e2040 $e1767))
+(flet ($e2079 (and $e1893 $e1749))
+(flet ($e2080 (or $e2075 $e1982))
+(flet ($e2081 (or $e2001 $e1828))
+(flet ($e2082 (and $e2056 $e1046))
+(flet ($e2083 (not $e2043))
+(flet ($e2084 (not $e839))
+(flet ($e2085 (and $e1967 $e2066))
+(flet ($e2086 (not $e2067))
+(flet ($e2087 (if_then_else $e2064 $e1908 $e1980))
+(flet ($e2088 (if_then_else $e2087 $e2071 $e1010))
+(flet ($e2089 (not $e1999))
+(flet ($e2090 (not $e2045))
+(flet ($e2091 (xor $e361 $e2088))
+(flet ($e2092 (implies $e1777 $e1955))
+(flet ($e2093 (if_then_else $e2091 $e2062 $e2032))
+(flet ($e2094 (not $e2073))
+(flet ($e2095 (not $e1863))
+(flet ($e2096 (implies $e1895 $e2039))
+(flet ($e2097 (if_then_else $e1917 $e1792 $e1870))
+(flet ($e2098 (xor $e1651 $e2061))
+(flet ($e2099 (if_then_else $e2081 $e2081 $e2089))
+(flet ($e2100 (if_then_else $e2097 $e2049 $e2092))
+(flet ($e2101 (implies $e1667 $e480))
+(flet ($e2102 (if_then_else $e2077 $e1223 $e2072))
+(flet ($e2103 (xor $e2055 $e2025))
+(flet ($e2104 (not $e2086))
+(flet ($e2105 (and $e2103 $e2005))
+(flet ($e2106 (iff $e2060 $e2079))
+(flet ($e2107 (and $e2058 $e2053))
+(flet ($e2108 (not $e1979))
+(flet ($e2109 (and $e2046 $e1648))
+(flet ($e2110 (xor $e2105 $e664))
+(flet ($e2111 (if_then_else $e2021 $e2095 $e420))
+(flet ($e2112 (iff $e2101 $e2012))
+(flet ($e2113 (or $e2100 $e1943))
+(flet ($e2114 (xor $e2038 $e2107))
+(flet ($e2115 (if_then_else $e2002 $e2074 $e1376))
+(flet ($e2116 (xor $e2098 $e2094))
+(flet ($e2117 (iff $e2050 $e2059))
+(flet ($e2118 (or $e2104 $e2090))
+(flet ($e2119 (xor $e2063 $e1959))
+(flet ($e2120 (and $e2110 $e1841))
+(flet ($e2121 (implies $e2068 $e2114))
+(flet ($e2122 (xor $e2007 $e2082))
+(flet ($e2123 (or $e2096 $e2108))
+(flet ($e2124 (implies $e2084 $e2076))
+(flet ($e2125 (implies $e2085 $e2099))
+(flet ($e2126 (iff $e2117 $e2120))
+(flet ($e2127 (or $e2028 $e2030))
+(flet ($e2128 (iff $e2121 $e1561))
+(flet ($e2129 (xor $e2048 $e2116))
+(flet ($e2130 (and $e2118 $e2126))
+(flet ($e2131 (iff $e2054 $e2080))
+(flet ($e2132 (xor $e2129 $e1683))
+(flet ($e2133 (implies $e2106 $e2122))
+(flet ($e2134 (not $e2119))
+(flet ($e2135 (if_then_else $e1969 $e651 $e2083))
+(flet ($e2136 (if_then_else $e1994 $e2133 $e2134))
+(flet ($e2137 (iff $e2132 $e2132))
+(flet ($e2138 (or $e1720 $e1111))
+(flet ($e2139 (and $e2078 $e2128))
+(flet ($e2140 (iff $e1710 $e2093))
+(flet ($e2141 (or $e2124 $e2130))
+(flet ($e2142 (not $e2131))
+(flet ($e2143 (if_then_else $e2111 $e2018 $e2069))
+(flet ($e2144 (iff $e2125 $e2143))
+(flet ($e2145 (implies $e2137 $e2127))
+(flet ($e2146 (xor $e2123 $e2112))
+(flet ($e2147 (not $e2135))
+(flet ($e2148 (or $e2136 $e2102))
+(flet ($e2149 (or $e2115 $e2141))
+(flet ($e2150 (or $e2148 $e2145))
+(flet ($e2151 (not $e2113))
+(flet ($e2152 (and $e2149 $e2149))
+(flet ($e2153 (if_then_else $e2140 $e2150 $e2140))
+(flet ($e2154 (not $e2153))
+(flet ($e2155 (or $e2138 $e2152))
+(flet ($e2156 (and $e2139 $e2154))
+(flet ($e2157 (and $e2144 $e2146))
+(flet ($e2158 (xor $e2156 $e2147))
+(flet ($e2159 (and $e2157 $e2142))
+(flet ($e2160 (implies $e2109 $e2159))
+(flet ($e2161 (not $e2158))
+(flet ($e2162 (if_then_else $e2151 $e2160 $e2151))
+(flet ($e2163 (or $e2161 $e2162))
+(flet ($e2164 (iff $e2163 $e2163))
+(flet ($e2165 (and $e2164 $e2164))
+(flet ($e2166 (or $e2165 $e2165))
+(flet ($e2167 (not $e2166))
+(flet ($e2168 (iff $e2167 $e2155))
+$e2168
+))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
+
check_cmdline="$check_cmdline --check-models"
fi
if $check_proofs; then
- check_cmdline="$check_cmdline --check-proofs"
+ # taking: Make the extra flags part of --check-proofs.
+ check_cmdline="$check_cmdline --check-proofs --no-bv-eq --no-bv-ineq --no-bv-algebraic"
fi
if $check_unsat_cores; then
check_cmdline="$check_cmdline --check-unsat-cores"
return d_nextVar++;
}
- void addClause(SatClause& c, bool lemma, uint64_t) {
+ ClauseId addClause(SatClause& c, bool lemma) {
d_addClauseCalled = true;
+ return ClauseIdUndef;
}
void reset() {
return true;
}
+ bool ok() const { return true; }
+
};/* class FakeSatSolver */
class CnfStreamWhite : public CxxTest::TestSuite {
using namespace std;
class FakeOutputChannel : public OutputChannel {
- void conflict(TNode n) throw(AssertionException) {
+ void conflict(TNode n, Proof* pf = NULL) throw(AssertionException) {
Unimplemented();
}
bool propagate(TNode n) throw(AssertionException) {
void propagateAsDecision(TNode n) throw(AssertionException) {
Unimplemented();
}
- LemmaStatus lemma(TNode n, bool removable, bool preprocess, bool sendAtoms) throw(AssertionException) {
+ LemmaStatus lemma(TNode n, ProofRule rule,
+ bool removable,
+ bool preprocess,
+ bool sendAtoms) throw(AssertionException) {
Unimplemented();
}
void requirePhase(TNode, bool) throw(AssertionException) {
**/
#include <cxxtest/TestSuite.h>
+#include <vector>
-#include "theory/theory.h"
-#include "theory/theory_engine.h"
+// taking: Add include for Proof*.
+#include "context/context.h"
#include "expr/node.h"
#include "expr/node_manager.h"
-#include "context/context.h"
#include "smt/smt_engine.h"
#include "smt/smt_engine_scope.h"
+#include "theory/theory.h"
+#include "theory/theory_engine.h"
-#include <vector>
using namespace CVC4;
using namespace CVC4::theory;
throw(Interrupted, UnsafeInterruptException, AssertionException)
{}
- void conflict(TNode n)
+ void conflict(TNode n, Proof* pf = NULL)
throw(AssertionException) {
push(CONFLICT, n);
}
// ignore
}
- LemmaStatus lemma(TNode n, bool removable = false, bool preprocess = false, bool sendAtoms = false)
+ LemmaStatus lemma(TNode n, ProofRule rule,
+ bool removable = false,
+ bool preprocess = false,
+ bool sendAtoms = false)
throw(AssertionException) {
push(LEMMA, n);
return LemmaStatus(Node::null(), 0);
void testOutputChannel() {
Node n = atom0.orNode(atom1);
- d_outputChannel.lemma(n);
+ d_outputChannel.lemma(n, RULE_INVALID);
d_outputChannel.split(atom0);
Node s = atom0.orNode(atom0.notNode());
TS_ASSERT_EQUALS(d_outputChannel.d_callHistory.size(), 2u);
projects / cvc5.git / commitdiff