How to encode a fixed number of true variables? - z3

Question

I have say 10 boolean variables. I want the model to be satisfiable if exactly 3 of them are true.
How would I encode this as a SAT problem? One way would to create the all the possible combinations and then or them together. Is there a better or more concise way to express this?

Answer 1

If your application allows, I would suggest using a different encoding (e.g., bitvectors or ints), as this makes things much easier and avoids the permutation part at the encoding level. For example, use ints and restrict the values to be 0 or 1, then assert their sum is 3.
Here's an encoding (rise4fun link: http://rise4fun.com/Z3/wswe ):
(declare-fun b0 () Int)
(declare-fun b1 () Int)
(declare-fun b2 () Int)
(declare-fun b3 () Int)
(declare-fun b4 () Int)
(declare-fun b5 () Int)
(declare-fun b6 () Int)
(declare-fun b7 () Int)
(declare-fun b8 () Int)
(declare-fun b9 () Int)
(assert (= (+ b0 b1 b2 b3 b4 b5 b6 b7 b8 b9) 3))
(assert (or (= b0 0) (= b0 1)))
(assert (or (= b1 0) (= b1 1)))
(assert (or (= b2 0) (= b2 1)))
(assert (or (= b3 0) (= b3 1)))
(assert (or (= b4 0) (= b4 1)))
(assert (or (= b5 0) (= b5 1)))
(assert (or (= b6 0) (= b6 1)))
(assert (or (= b7 0) (= b7 1)))
(assert (or (= b8 0) (= b8 1)))
(assert (or (= b9 0) (= b9 1)))
(check-sat)
(get-model)
Result is:
sat
(model
(define-fun b6 () Int
0)
(define-fun b5 () Int
0)
(define-fun b9 () Int
1)
(define-fun b3 () Int
0)
(define-fun b2 () Int
0)
(define-fun b7 () Int
0)
(define-fun b1 () Int
0)
(define-fun b8 () Int
1)
(define-fun b4 () Int
0)
(define-fun b0 () Int
1)
)
EDIT: added bitvector example for completeness, can be improved by doing padding so we can compare bitvectors of different sizes (rise4fun link: http://rise4fun.com/Z3/UsldZ ):
(declare-fun b0 () (_ BitVec 3))
(declare-fun b1 () (_ BitVec 3))
(declare-fun b2 () (_ BitVec 3))
(declare-fun b3 () (_ BitVec 3))
(declare-fun b4 () (_ BitVec 3))
(declare-fun b5 () (_ BitVec 3))
(declare-fun b6 () (_ BitVec 3))
(declare-fun b7 () (_ BitVec 3))
(declare-fun b8 () (_ BitVec 3))
(declare-fun b9 () (_ BitVec 3))
(assert (= (bvadd b0 b1 b2 b3 b4 b5 b6 b7 b8 b9) #b011))
; can probably avoid the next by using a length 1 bitvector and padding, but not sure how to do padding
(assert (or (= b0 #b000) (= b0 #b001)))
(assert (or (= b1 #b000) (= b1 #b001)))
(assert (or (= b2 #b000) (= b2 #b001)))
(assert (or (= b3 #b000) (= b3 #b001)))
(assert (or (= b4 #b000) (= b4 #b001)))
(assert (or (= b5 #b000) (= b5 #b001)))
(assert (or (= b6 #b000) (= b6 #b001)))
(assert (or (= b7 #b000) (= b7 #b001)))
(assert (or (= b8 #b000) (= b8 #b001)))
(assert (or (= b9 #b000) (= b9 #b001)))
(check-sat)
(get-model)
Result is:
sat
(model
(define-fun b6 () (_ BitVec 3)
#b000)
(define-fun b5 () (_ BitVec 3)
#b000)
(define-fun b9 () (_ BitVec 3)
#b001)
(define-fun b3 () (_ BitVec 3)
#b000)
(define-fun b0 () (_ BitVec 3)
#b001)
(define-fun b2 () (_ BitVec 3)
#b000)
(define-fun b7 () (_ BitVec 3)
#b000)
(define-fun b1 () (_ BitVec 3)
#b001)
(define-fun b8 () (_ BitVec 3)
#b000)
(define-fun b4 () (_ BitVec 3)
#b000)
)