Set membership relation in z3 - c++

Question

I wanted to define a membership relation in Z3 with C++ APIs. I thought of doing it in the following way:
z3::context C;
z3::sort I = C.int_sort();
z3::sort B = C.bool_sort();
z3::func_decl InSet = C.function("f", I, B);
z3::expr e1 = InSet(C.int_val(2)) == C.bool_val(true);
z3::expr e2 = InSet(C.int_val(3)) == C.bool_val(true);
z3::expr ite = to_expr(C, Z3_mk_ite(C, e1, C.bool_val(true),
Z3_mk_ite(C,e2,C.bool_val(true),C.bool_val(false))));
errs() << Z3_ast_to_string(C,ite);
In this example the set is composed by the integer 2 and 3. I am sure there is a better way to define a relation, in particular a set membership relation, but I am really a Z3 rookie. Does anyone know the best one?

Answer 1

In Z3, sets are usually encoded using predicates (as you did) or arrays of Boolean. In the Z3 C API, there are several functions for creating set expressions: Z3_mk_set_sort, Z3_mk_empty_set, Z3_mk_set_union, ... Actually, these functions are creating array expressions. They represent a set of T as an array from T to Boolean. They use the encoding described in this article.
Remarks: in Z3, InSet(C.int_val(2)) == C.bool_val(true) is equivalent to InSet(C.int_val(2)). The InSet function is a predicate. We can write std::cout << ite instead of std::cout << Z3_ast_to_string(C, ite).
In the approach based on predicates, we usually need to use quantifiers.
In your example, you are saying that 2 and 3 are elements of the set, but to say that nothing else is an element, we need a quantifier. We also need quantifiers to state properties such as: set A is equal to the union of sets B and C.The approach based on quantifiers is more flexible, we can say for example that A is a set containing all elements between 1 and n.
The drawback is that it is really easy to create formulas that are not in decidable fragments that Z3 can handle. The Z3 tutorial describes some of these fragments. Here is an example from the tutorial.
;; A, B, C and D are sets of Int
(declare-fun A (Int) Bool)
(declare-fun B (Int) Bool)
(declare-fun C (Int) Bool)
(declare-fun D (Int) Bool)
;; A union B is a subset of C
(assert (forall ((x Int)) (=> (or (A x) (B x)) (C x))))
;; B minus A is not empty
;; That is, there exists an integer e that is B but not in A
(declare-const e Int)
(assert (and (B e) (not (A e))))
;; D is equal to C
(assert (forall ((x Int)) (iff (D x) (C x))))
;; 0, 1 and 2 are in B
(assert (B 0))
(assert (B 1))
(assert (B 2))
(check-sat)
(get-model)
(echo "Is e an element of D?")
(eval (D e))
(echo "Now proving that A is a strict subset of D")
;; This is true if the negation is unsatisfiable
(push)
(assert (not (and
;; A is a subset of D
(forall ((x Int)) (=> (A x) (D x)))
;; but, D has an element that is not in A.
(exists ((x Int)) (and (D x) (not (A x)))))))
(check-sat)
(pop)