Term B = slv.mkConst(set, "B");
Term C = slv.mkConst(set, "C");
- Term unionAB = slv.mkTerm(UNION, A, B);
- Term lhs = slv.mkTerm(INTERSECTION, unionAB, C);
+ Term unionAB = slv.mkTerm(SET_UNION, A, B);
+ Term lhs = slv.mkTerm(SET_INTERSECTION, unionAB, C);
- Term intersectionAC = slv.mkTerm(INTERSECTION, A, C);
- Term intersectionBC = slv.mkTerm(INTERSECTION, B, C);
- Term rhs = slv.mkTerm(UNION, intersectionAC, intersectionBC);
+ Term intersectionAC = slv.mkTerm(SET_INTERSECTION, A, C);
+ Term intersectionBC = slv.mkTerm(SET_INTERSECTION, B, C);
+ Term rhs = slv.mkTerm(SET_UNION, intersectionAC, intersectionBC);
Term theorem = slv.mkTerm(EQUAL, lhs, rhs);
Term A = slv.mkConst(set, "A");
Term emptyset = slv.mkEmptySet(set);
- Term theorem = slv.mkTerm(SUBSET, emptyset, A);
+ Term theorem = slv.mkTerm(SET_SUBSET, emptyset, A);
cout << "cvc5 reports: " << theorem << " is " << slv.checkEntailed(theorem)
<< "." << endl;
Term two = slv.mkInteger(2);
Term three = slv.mkInteger(3);
- Term singleton_one = slv.mkTerm(SINGLETON, one);
- Term singleton_two = slv.mkTerm(SINGLETON, two);
- Term singleton_three = slv.mkTerm(SINGLETON, three);
- Term one_two = slv.mkTerm(UNION, singleton_one, singleton_two);
- Term two_three = slv.mkTerm(UNION, singleton_two, singleton_three);
- Term intersection = slv.mkTerm(INTERSECTION, one_two, two_three);
+ Term singleton_one = slv.mkTerm(SET_SINGLETON, one);
+ Term singleton_two = slv.mkTerm(SET_SINGLETON, two);
+ Term singleton_three = slv.mkTerm(SET_SINGLETON, three);
+ Term one_two = slv.mkTerm(SET_UNION, singleton_one, singleton_two);
+ Term two_three = slv.mkTerm(SET_UNION, singleton_two, singleton_three);
+ Term intersection = slv.mkTerm(SET_INTERSECTION, one_two, two_three);
Term x = slv.mkConst(integer, "x");
- Term e = slv.mkTerm(MEMBER, x, intersection);
+ Term e = slv.mkTerm(SET_MEMBER, x, intersection);
Result result = slv.checkSatAssuming(e);
cout << "cvc5 reports: " << e << " is " << result << "." << endl;
B = slv.mkConst(set_, "B")
C = slv.mkConst(set_, "C")
- unionAB = slv.mkTerm(kinds.Union, A, B)
- lhs = slv.mkTerm(kinds.Intersection, unionAB, C)
+ unionAB = slv.mkTerm(kinds.SetUnion, A, B)
+ lhs = slv.mkTerm(kinds.SetIntersection, unionAB, C)
- intersectionAC = slv.mkTerm(kinds.Intersection, A, C)
- intersectionBC = slv.mkTerm(kinds.Intersection, B, C)
- rhs = slv.mkTerm(kinds.Union, intersectionAC, intersectionBC)
+ intersectionAC = slv.mkTerm(kinds.SetIntersection, A, C)
+ intersectionBC = slv.mkTerm(kinds.SetIntersection, B, C)
+ rhs = slv.mkTerm(kinds.SetUnion, intersectionAC, intersectionBC)
theorem = slv.mkTerm(kinds.Equal, lhs, rhs)
A = slv.mkConst(set_, "A")
emptyset = slv.mkEmptySet(set_)
- theorem = slv.mkTerm(kinds.Subset, emptyset, A)
+ theorem = slv.mkTerm(kinds.SetSubset, emptyset, A)
print("cvc5 reports: {} is {}".format(theorem,
slv.checkEntailed(theorem)))
two = slv.mkInteger(2)
three = slv.mkInteger(3)
- singleton_one = slv.mkTerm(kinds.Singleton, one)
- singleton_two = slv.mkTerm(kinds.Singleton, two)
- singleton_three = slv.mkTerm(kinds.Singleton, three)
- one_two = slv.mkTerm(kinds.Union, singleton_one, singleton_two)
- two_three = slv.mkTerm(kinds.Union, singleton_two, singleton_three)
- intersection = slv.mkTerm(kinds.Intersection, one_two, two_three)
+ singleton_one = slv.mkTerm(kinds.SetSingleton, one)
+ singleton_two = slv.mkTerm(kinds.SetSingleton, two)
+ singleton_three = slv.mkTerm(kinds.SetSingleton, three)
+ one_two = slv.mkTerm(kinds.SetUnion, singleton_one, singleton_two)
+ two_three = slv.mkTerm(kinds.SetUnion, singleton_two, singleton_three)
+ intersection = slv.mkTerm(kinds.SetIntersection, one_two, two_three)
x = slv.mkConst(integer, "x")
- e = slv.mkTerm(kinds.Member, x, intersection)
+ e = slv.mkTerm(kinds.SetMember, x, intersection)
result = slv.checkSatAssuming(e)
(declare-fun b2 () Atom)
(assert (forall ((b Atom)) (or
-(member v (k t0 b))
-(member v (k t1 b))
+(set.member v (k t0 b))
+(set.member v (k t1 b))
) ))
-(assert (not (member v (k t2 b2))))
+(assert (not (set.member v (k t2 b2))))
(check-sat)
<< " ()"
<< " " << name
<< " ( (as const " << name << ") false ) )" << endl;
- setoperators[ make_pair(t, kind::EMPTYSET) ] =
- em->mkVar( std::string("emptyset") + elementTypeAsString,
- t);
+ setoperators[make_pair(t, kind::SET_EMPTY)] =
+ em->mkVar(std::string("emptyset") + elementTypeAsString, t);
if(!enableAxioms)
sout << "(define-fun singleton" << elementTypeAsString << " "
<< " ( (x " << elementType << ") )"
<< " " << name << ""
<< " (store emptyset" << elementTypeAsString << " x true) )" << endl;
- setoperators[ make_pair(t, kind::SINGLETON) ] =
- em->mkVar( std::string("singleton") + elementTypeAsString,
- em->mkFunctionType( elementType, t ) );
+ setoperators[make_pair(t, kind::SET_SINGLETON)] =
+ em->mkVar(std::string("singleton") + elementTypeAsString,
+ em->mkFunctionType(elementType, t));
if(!enableAxioms)
sout << "(define-fun union" << elementTypeAsString << " "
<< " ( (s1 " << name << ") (s2 " << name << ") )"
<< " " << name << ""
<< " ((_ map or) s1 s2))" << endl;
- setoperators[ make_pair(t, kind::UNION) ] =
- em->mkVar( std::string("union") + elementTypeAsString,
- em->mkFunctionType( t_t, t ) );
+ setoperators[make_pair(t, kind::SET_UNION)] =
+ em->mkVar(std::string("union") + elementTypeAsString,
+ em->mkFunctionType(t_t, t));
if(!enableAxioms)
sout << "(define-fun intersection" << elementTypeAsString << ""
<< " ( (s1 " << name << ") (s2 " << name << ") )"
<< " " << name << ""
<< " ((_ map and) s1 s2))" << endl;
- setoperators[ make_pair(t, kind::INTERSECTION) ] =
- em->mkVar( std::string("intersection") + elementTypeAsString,
- em->mkFunctionType( t_t, t ) );
+ setoperators[make_pair(t, kind::SET_INTERSECTION)] =
+ em->mkVar(std::string("intersection") + elementTypeAsString,
+ em->mkFunctionType(t_t, t));
if(!enableAxioms)
sout << "(define-fun setminus" << elementTypeAsString << " "
<< " ( (s1 " << name << ") (s2 " << name << ") )"
<< " " << name << ""
<< " (intersection" << elementTypeAsString << " s1 ((_ map not) s2)))" << endl;
- setoperators[ make_pair(t, kind::SETMINUS) ] =
- em->mkVar( std::string("setminus") + elementTypeAsString,
- em->mkFunctionType( t_t, t ) );
+ setoperators[make_pair(t, kind::SET_MINUS)] =
+ em->mkVar(std::string("setminus") + elementTypeAsString,
+ em->mkFunctionType(t_t, t));
if(!enableAxioms)
sout << "(define-fun member" << elementTypeAsString << " "
<< " ( (x " << elementType << ")" << " (s " << name << "))"
<< " Bool"
<< " (select s x) )" << endl;
- setoperators[ make_pair(t, kind::MEMBER) ] =
- em->mkVar( std::string("member") + elementTypeAsString,
- em->mkPredicateType( elet_t ) );
+ setoperators[make_pair(t, kind::SET_MEMBER)] =
+ em->mkVar(std::string("member") + elementTypeAsString,
+ em->mkPredicateType(elet_t));
if(!enableAxioms)
sout << "(define-fun subset" << elementTypeAsString << " "
<< " ( (s1 " << name << ") (s2 " << name << ") )"
<< " Bool"
<<" (= emptyset" << elementTypeAsString << " (setminus" << elementTypeAsString << " s1 s2)) )" << endl;
- setoperators[ make_pair(t, kind::SUBSET) ] =
- em->mkVar( std::string("subset") + elementTypeAsString,
- em->mkPredicateType( t_t ) );
+ setoperators[make_pair(t, kind::SET_SUBSET)] =
+ em->mkVar(std::string("subset") + elementTypeAsString,
+ em->mkPredicateType(t_t));
if(enableAxioms) {
int N = sizeof(setaxioms) / sizeof(setaxioms[0]);
}
Expr ret;
- if(e.getKind() == kind::EMPTYSET) {
+ if (e.getKind() == kind::SET_EMPTY)
+ {
ret = setoperators[ make_pair(t, e.getKind()) ];
- } else {
+ }
+ else
+ {
vector<Expr> children = e.getChildren();
children.insert(children.begin(), setoperators[ make_pair(t, e.getKind()) ]);
ret = em->mkExpr(kind::APPLY_UF, children);
{SEP_STAR, cvc5::Kind::SEP_STAR},
{SEP_WAND, cvc5::Kind::SEP_WAND},
/* Sets ---------------------------------------------------------------- */
- {EMPTYSET, cvc5::Kind::EMPTYSET},
- {UNION, cvc5::Kind::UNION},
- {INTERSECTION, cvc5::Kind::INTERSECTION},
- {SETMINUS, cvc5::Kind::SETMINUS},
- {SUBSET, cvc5::Kind::SUBSET},
- {MEMBER, cvc5::Kind::MEMBER},
- {SINGLETON, cvc5::Kind::SINGLETON},
- {INSERT, cvc5::Kind::INSERT},
- {CARD, cvc5::Kind::CARD},
- {COMPLEMENT, cvc5::Kind::COMPLEMENT},
- {UNIVERSE_SET, cvc5::Kind::UNIVERSE_SET},
- {JOIN, cvc5::Kind::JOIN},
- {PRODUCT, cvc5::Kind::PRODUCT},
- {TRANSPOSE, cvc5::Kind::TRANSPOSE},
- {TCLOSURE, cvc5::Kind::TCLOSURE},
- {JOIN_IMAGE, cvc5::Kind::JOIN_IMAGE},
- {IDEN, cvc5::Kind::IDEN},
- {COMPREHENSION, cvc5::Kind::COMPREHENSION},
- {CHOOSE, cvc5::Kind::CHOOSE},
- {IS_SINGLETON, cvc5::Kind::IS_SINGLETON},
+ {SET_EMPTY, cvc5::Kind::SET_EMPTY},
+ {SET_UNION, cvc5::Kind::SET_UNION},
+ {SET_INTERSECTION, cvc5::Kind::SET_INTERSECTION},
+ {SET_MINUS, cvc5::Kind::SET_MINUS},
+ {SET_SUBSET, cvc5::Kind::SET_SUBSET},
+ {SET_MEMBER, cvc5::Kind::SET_MEMBER},
+ {SET_SINGLETON, cvc5::Kind::SET_SINGLETON},
+ {SET_INSERT, cvc5::Kind::SET_INSERT},
+ {SET_CARD, cvc5::Kind::SET_CARD},
+ {SET_COMPLEMENT, cvc5::Kind::SET_COMPLEMENT},
+ {SET_UNIVERSE, cvc5::Kind::SET_UNIVERSE},
+ {SET_COMPREHENSION, cvc5::Kind::SET_COMPREHENSION},
+ {SET_CHOOSE, cvc5::Kind::SET_CHOOSE},
+ {SET_IS_SINGLETON, cvc5::Kind::SET_IS_SINGLETON},
+ /* Relations ----------------------------------------------------------- */
+ {RELATION_JOIN, cvc5::Kind::RELATION_JOIN},
+ {RELATION_PRODUCT, cvc5::Kind::RELATION_PRODUCT},
+ {RELATION_TRANSPOSE, cvc5::Kind::RELATION_TRANSPOSE},
+ {RELATION_TCLOSURE, cvc5::Kind::RELATION_TCLOSURE},
+ {RELATION_JOIN_IMAGE, cvc5::Kind::RELATION_JOIN_IMAGE},
+ {RELATION_IDEN, cvc5::Kind::RELATION_IDEN},
/* Bags ---------------------------------------------------------------- */
{UNION_MAX, cvc5::Kind::UNION_MAX},
{UNION_DISJOINT, cvc5::Kind::UNION_DISJOINT},
{cvc5::Kind::SEP_STAR, SEP_STAR},
{cvc5::Kind::SEP_WAND, SEP_WAND},
/* Sets ------------------------------------------------------------ */
- {cvc5::Kind::EMPTYSET, EMPTYSET},
- {cvc5::Kind::UNION, UNION},
- {cvc5::Kind::INTERSECTION, INTERSECTION},
- {cvc5::Kind::SETMINUS, SETMINUS},
- {cvc5::Kind::SUBSET, SUBSET},
- {cvc5::Kind::MEMBER, MEMBER},
- {cvc5::Kind::SINGLETON, SINGLETON},
- {cvc5::Kind::INSERT, INSERT},
- {cvc5::Kind::CARD, CARD},
- {cvc5::Kind::COMPLEMENT, COMPLEMENT},
- {cvc5::Kind::UNIVERSE_SET, UNIVERSE_SET},
- {cvc5::Kind::JOIN, JOIN},
- {cvc5::Kind::PRODUCT, PRODUCT},
- {cvc5::Kind::TRANSPOSE, TRANSPOSE},
- {cvc5::Kind::TCLOSURE, TCLOSURE},
- {cvc5::Kind::JOIN_IMAGE, JOIN_IMAGE},
- {cvc5::Kind::IDEN, IDEN},
- {cvc5::Kind::COMPREHENSION, COMPREHENSION},
- {cvc5::Kind::CHOOSE, CHOOSE},
- {cvc5::Kind::IS_SINGLETON, IS_SINGLETON},
+ {cvc5::Kind::SET_EMPTY, SET_EMPTY},
+ {cvc5::Kind::SET_UNION, SET_UNION},
+ {cvc5::Kind::SET_INTERSECTION, SET_INTERSECTION},
+ {cvc5::Kind::SET_MINUS, SET_MINUS},
+ {cvc5::Kind::SET_SUBSET, SET_SUBSET},
+ {cvc5::Kind::SET_MEMBER, SET_MEMBER},
+ {cvc5::Kind::SET_SINGLETON, SET_SINGLETON},
+ {cvc5::Kind::SET_INSERT, SET_INSERT},
+ {cvc5::Kind::SET_CARD, SET_CARD},
+ {cvc5::Kind::SET_COMPLEMENT, SET_COMPLEMENT},
+ {cvc5::Kind::SET_UNIVERSE, SET_UNIVERSE},
+ {cvc5::Kind::SET_COMPREHENSION, SET_COMPREHENSION},
+ {cvc5::Kind::SET_CHOOSE, SET_CHOOSE},
+ {cvc5::Kind::SET_IS_SINGLETON, SET_IS_SINGLETON},
+ /* Relations ------------------------------------------------------- */
+ {cvc5::Kind::RELATION_JOIN, RELATION_JOIN},
+ {cvc5::Kind::RELATION_PRODUCT, RELATION_PRODUCT},
+ {cvc5::Kind::RELATION_TRANSPOSE, RELATION_TRANSPOSE},
+ {cvc5::Kind::RELATION_TCLOSURE, RELATION_TCLOSURE},
+ {cvc5::Kind::RELATION_JOIN_IMAGE, RELATION_JOIN_IMAGE},
+ {cvc5::Kind::RELATION_IDEN, RELATION_IDEN},
/* Bags ------------------------------------------------------------ */
{cvc5::Kind::UNION_MAX, UNION_MAX},
{cvc5::Kind::UNION_DISJOINT, UNION_DISJOINT},
{cvc5::Kind::BAG_IS_SINGLETON, BAG_IS_SINGLETON},
{cvc5::Kind::BAG_FROM_SET, BAG_FROM_SET},
{cvc5::Kind::BAG_TO_SET, BAG_TO_SET},
- {cvc5::Kind::BAG_MAP,BAG_MAP},
+ {cvc5::Kind::BAG_MAP, BAG_MAP},
/* Strings --------------------------------------------------------- */
{cvc5::Kind::STRING_CONCAT, STRING_CONCAT},
{cvc5::Kind::STRING_IN_REGEXP, STRING_IN_REGEXP},
const Solver* slv)
{
// We asserted that node has a set type, and node.isConst()
- // Thus, node only contains of EMPTYSET, UNION and SINGLETON.
+ // Thus, node only contains of SET_EMPTY, SET_UNION and SET_SINGLETON.
switch (node.getKind())
{
- case cvc5::Kind::EMPTYSET: break;
- case cvc5::Kind::SINGLETON: set.emplace(Term(slv, node[0])); break;
- case cvc5::Kind::UNION:
+ case cvc5::Kind::SET_EMPTY: break;
+ case cvc5::Kind::SET_SINGLETON: set.emplace(Term(slv, node[0])); break;
+ case cvc5::Kind::SET_UNION:
{
for (const auto& sub : node)
{
{
// default case, same as above
checkMkTerm(kind, children.size());
- if (kind == api::SINGLETON)
+ if (kind == api::SET_SINGLETON)
{
// the type of the term is the same as the type of the internal node
// see Term::getSort()
//////// all checks before this line
Node res = getNodeManager()->mkNullaryOperator(*sort.d_type,
- cvc5::kind::UNIVERSE_SET);
+ cvc5::kind::SET_UNIVERSE);
// TODO(#2771): Reenable?
// (void)res->getType(true); /* kick off type checking */
return Term(this, res);
* where `c1 ... cn` are values ordered by id such that `c1 > ... > cn` (see
* also @ref Term::operator>(const Term&) const).
*
- * Note that a universe set term (kind UNIVERSE_SET) is not considered to be
+ * Note that a universe set term (kind SET_UNIVERSE) is not considered to be
* a set value.
*/
bool isSetValue() const;
* Create with:
* - `Solver::mkEmptySet(const Sort& sort) const`
*/
- EMPTYSET,
+ SET_EMPTY,
/**
* Set union.
*
* - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
* - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
*/
- UNION,
+ SET_UNION,
/**
* Set intersection.
*
* - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
* - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
*/
- INTERSECTION,
+ SET_INTERSECTION,
/**
* Set subtraction.
*
* - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
* - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
*/
- SETMINUS,
+ SET_MINUS,
/**
* Subset predicate.
*
* - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
* - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
*/
- SUBSET,
+ SET_SUBSET,
/**
* Set membership predicate.
*
* - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
* - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
*/
- MEMBER,
+ SET_MEMBER,
/**
* Construct a singleton set from an element given as a parameter.
* The returned set has same type of the element.
* Create with:
* - `Solver::mkTerm(Kind kind, const Term& child) const`
*/
- SINGLETON,
+ SET_SINGLETON,
/**
* The set obtained by inserting elements;
*
* - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2, const Term& child3) const`
* - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
*/
- INSERT,
+ SET_INSERT,
/**
* Set cardinality.
*
* Create with:
* - `Solver::mkTerm(Kind kind, const Term& child) const`
*/
- CARD,
+ SET_CARD,
/**
* Set complement with respect to finite universe.
*
* Create with:
* - `Solver::mkTerm(Kind kind, const Term& child) const`
*/
- COMPLEMENT,
+ SET_COMPLEMENT,
/**
* Finite universe set.
* All set variables must be interpreted as subsets of it.
*
- * Note that UNIVERSE_SET is considered a special symbol of the theory of
+ * Note that SET_UNIVERSE is considered a special symbol of the theory of
* sets and is not considered as a set value,
* i.e., `Term::isSetValue() const` will return false.
*
* Create with:
* - `Solver::mkUniverseSet(const Sort& sort) const`
*/
- UNIVERSE_SET,
+ SET_UNIVERSE,
/**
- * Set join.
+ * Set comprehension
+ * A set comprehension is specified by a bound variable list x1 ... xn,
+ * a predicate P[x1...xn], and a term t[x1...xn]. A comprehension C with the
+ * above form has members given by the following semantics:
+ * @f[
+ * \forall y. ( \exists x_1...x_n. P[x_1...x_n] \hat{} t[x_1...x_n] = y )
+ * \Leftrightarrow (member y C)
+ * @f]
+ * where y ranges over the element type of the (set) type of the
+ * comprehension. If @f$ t[x_1..x_n] @f$ is not provided, it is equivalent to
+ * y in the above formula.
*
* Parameters:
- * - 1..2: Terms of set sort
+ * - 1: Term BOUND_VAR_LIST
+ * - 2: Term denoting the predicate of the comprehension
+ * - 3: (optional) a Term denoting the generator for the comprehension
*
* Create with:
* - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
+ * - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2, const Term& child3) const`
* - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
*/
- JOIN,
+ SET_COMPREHENSION,
/**
- * Set cartesian product.
+ * Returns an element from a given set.
+ * If a set A = {x}, then the term (choose A) is equivalent to the term x.
+ * If the set is empty, then (choose A) is an arbitrary value.
+ * If the set has cardinality > 1, then (choose A) will deterministically
+ * return an element in A.
*
* Parameters:
- * - 1..2: Terms of set sort
+ * - 1: Term of set sort
*
* Create with:
- * - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
- * - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
+ * - `Solver::mkTerm(Kind kind, const Term& child) const`
*/
- PRODUCT,
+ SET_CHOOSE,
/**
- * Set transpose.
+ * Set is_singleton predicate.
*
* Parameters:
- * - 1: Term of set sort
+ * - 1: Term of set sort, is [1] a singleton set?
*
* Create with:
* - `Solver::mkTerm(Kind kind, const Term& child) const`
*/
- TRANSPOSE,
+ SET_IS_SINGLETON,
+
+ /* Relations ------------------------------------------------------------- */
+
/**
- * Set transitive closure.
+ * Set join.
*
* Parameters:
- * - 1: Term of set sort
+ * - 1..2: Terms of set sort
*
* Create with:
- * - `Solver::mkTerm(Kind kind, const Term& child) const`
+ * - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
+ * - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
*/
- TCLOSURE,
+ RELATION_JOIN,
/**
- * Set join image.
+ * Set cartesian product.
*
* Parameters:
* - 1..2: Terms of set sort
* - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
* - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
*/
- JOIN_IMAGE,
+ RELATION_PRODUCT,
/**
- * Set identity.
+ * Set transpose.
*
* Parameters:
* - 1: Term of set sort
* Create with:
* - `Solver::mkTerm(Kind kind, const Term& child) const`
*/
- IDEN,
+ RELATION_TRANSPOSE,
/**
- * Set comprehension
- * A set comprehension is specified by a bound variable list x1 ... xn,
- * a predicate P[x1...xn], and a term t[x1...xn]. A comprehension C with the
- * above form has members given by the following semantics:
- * @f[
- * \forall y. ( \exists x_1...x_n. P[x_1...x_n] \hat{} t[x_1...x_n] = y )
- * \Leftrightarrow (member y C)
- * @f]
- * where y ranges over the element type of the (set) type of the
- * comprehension. If @f$ t[x_1..x_n] @f$ is not provided, it is equivalent to
- * y in the above formula.
+ * Set transitive closure.
*
* Parameters:
- * - 1: Term BOUND_VAR_LIST
- * - 2: Term denoting the predicate of the comprehension
- * - 3: (optional) a Term denoting the generator for the comprehension
+ * - 1: Term of set sort
*
* Create with:
- * - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
- * - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2, const Term& child3) const`
- * - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
+ * - `Solver::mkTerm(Kind kind, const Term& child) const`
*/
- COMPREHENSION,
+ RELATION_TCLOSURE,
/**
- * Returns an element from a given set.
- * If a set A = {x}, then the term (choose A) is equivalent to the term x.
- * If the set is empty, then (choose A) is an arbitrary value.
- * If the set has cardinality > 1, then (choose A) will deterministically
- * return an element in A.
+ * Set join image.
*
* Parameters:
- * - 1: Term of set sort
+ * - 1..2: Terms of set sort
*
* Create with:
- * - `Solver::mkTerm(Kind kind, const Term& child) const`
+ * - `Solver::mkTerm(Kind kind, const Term& child1, const Term& child2) const`
+ * - `Solver::mkTerm(Kind kind, const std::vector<Term>& children) const`
*/
- CHOOSE,
+ RELATION_JOIN_IMAGE,
/**
- * Set is_singleton predicate.
+ * Set identity.
*
* Parameters:
- * - 1: Term of set sort, is [1] a singleton set?
+ * - 1: Term of set sort
*
* Create with:
* - `Solver::mkTerm(Kind kind, const Term& child) const`
*/
- IS_SINGLETON,
+ RELATION_IDEN,
+
/* Bags ------------------------------------------------------------------ */
+
/**
* Empty bag constant.
*
BITVECTOR_ADD --> BVAdd
APPLY_SELECTOR --> ApplySelector
FLOATINGPOINT_ISNAN --> FPIsNan
- SETMINUS --> Setminus
+ SET_MINUS --> Setminus
See the generated .pxi file for an explicit mapping
'''
assertTNodeNotExpired();
return getKind() == kind::LAMBDA || getKind() == kind::FORALL
|| getKind() == kind::EXISTS || getKind() == kind::WITNESS
- || getKind() == kind::COMPREHENSION
+ || getKind() == kind::SET_COMPREHENSION
|| getKind() == kind::MATCH_BIND_CASE;
}
<< "Invalid operands for mkSingleton. The type '" << n.getType()
<< "' of node '" << n << "' is not a subtype of '" << t << "'."
<< std::endl;
- Node op = mkConst(SingletonOp(t));
- Node singleton = mkNode(kind::SINGLETON, op, n);
+ Node op = mkConst(SetSingletonOp(t));
+ Node singleton = mkNode(kind::SET_SINGLETON, op, n);
return singleton;
}
api::Term Parser::applyTypeAscription(api::Term t, api::Sort s)
{
api::Kind k = t.getKind();
- if (k == api::EMPTYSET)
+ if (k == api::SET_EMPTY)
{
t = d_solver->mkEmptySet(s);
}
}
t = d_solver->mkEmptySequence(s.getSequenceElementSort());
}
- else if (k == api::UNIVERSE_SET)
+ else if (k == api::SET_UNIVERSE)
{
t = d_solver->mkUniverseSet(s);
}
*
* Return term t with a type ascription applied to it. This is used for
* syntax like (as t T) in smt2 and t::T in the CVC language. This includes:
- * - (as emptyset (Set T))
+ * - (as set.empty (Set T))
* - (as emptybag (Bag T))
* - (as univset (Set T))
* - (as sep.nil T)
*
* Notice that method is not necessarily a cast. In actuality, the above terms
* should be understood as symbols indexed by types. However, SMT-LIB does not
- * permit types as indices, so we must use, e.g. (as emptyset (Set T))
- * instead of (_ emptyset (Set T)).
+ * permit types as indices, so we must use, e.g. (as set.empty (Set T))
+ * instead of (_ set.empty (Set T)).
*
* @param t The term to ascribe a type
* @param s The sort to ascribe
}
expr = MK_TERM(kind, args);
}
- | LPAREN_TOK COMPREHENSION_TOK
+ | LPAREN_TOK SET_COMPREHENSION_TOK
{ PARSER_STATE->pushScope(); }
boundVarList[bvl]
{
term[f, f2] { args.push_back(f); }
term[f, f2] {
args.push_back(f);
- expr = MK_TERM(api::COMPREHENSION, args);
+ expr = MK_TERM(api::SET_COMPREHENSION, args);
}
RPAREN_TOK
| LPAREN_TOK qualIdentifier[p]
* as (3).
* - Overloaded non-parametric constructors (as C T) return the appropriate
* expression, analogous to the parametric cases above.
- * - For other ascripted nullary constants like (as emptyset (Set T)),
+ * - For other ascripted nullary constants like (as set.empty (Set T)),
* (as sep.nil T), we return the appropriate expression (3).
* - For array constant specifications (as const (Array T1 T2)), we return (1)
* and (4), where kind is set to STORE_ALL and type is set to (Array T1 T2),
DECLARE_CODATATYPES_2_5_TOK : { !( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) }?'declare-codatatypes';
DECLARE_CODATATYPES_TOK : { PARSER_STATE->v2_6() || PARSER_STATE->sygus() }?'declare-codatatypes';
PAR_TOK : { PARSER_STATE->v2_6() || PARSER_STATE->sygus() }?'par';
-COMPREHENSION_TOK : { PARSER_STATE->isTheoryEnabled(theory::THEORY_SETS) }?'comprehension';
+SET_COMPREHENSION_TOK : { PARSER_STATE->isTheoryEnabled(theory::THEORY_SETS) }?'set.comprehension';
TESTER_TOK : { ( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) && PARSER_STATE->isTheoryEnabled(theory::THEORY_DATATYPES) }?'is';
UPDATE_TOK : { ( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) && PARSER_STATE->isTheoryEnabled(theory::THEORY_DATATYPES) }?'update';
MATCH_TOK : { ( PARSER_STATE->v2_6() || PARSER_STATE->sygus() ) && PARSER_STATE->isTheoryEnabled(theory::THEORY_DATATYPES) }?'match';
}
if(d_logic.isTheoryEnabled(theory::THEORY_SETS)) {
- defineVar("emptyset", d_solver->mkEmptySet(d_solver->getNullSort()));
+ defineVar("set.empty", d_solver->mkEmptySet(d_solver->getNullSort()));
// the Boolean sort is a placeholder here since we don't have type info
// without type annotation
- defineVar("univset", d_solver->mkUniverseSet(d_solver->getBooleanSort()));
-
- addOperator(api::UNION, "union");
- addOperator(api::INTERSECTION, "intersection");
- addOperator(api::SETMINUS, "setminus");
- addOperator(api::SUBSET, "subset");
- addOperator(api::MEMBER, "member");
- addOperator(api::SINGLETON, "singleton");
- addOperator(api::INSERT, "insert");
- addOperator(api::CARD, "card");
- addOperator(api::COMPLEMENT, "complement");
- addOperator(api::CHOOSE, "choose");
- addOperator(api::IS_SINGLETON, "is_singleton");
- addOperator(api::JOIN, "join");
- addOperator(api::PRODUCT, "product");
- addOperator(api::TRANSPOSE, "transpose");
- addOperator(api::TCLOSURE, "tclosure");
- addOperator(api::JOIN_IMAGE, "join_image");
- addOperator(api::IDEN, "iden");
+ defineVar("set.universe",
+ d_solver->mkUniverseSet(d_solver->getBooleanSort()));
+
+ addOperator(api::SET_UNION, "set.union");
+ addOperator(api::SET_INTERSECTION, "set.intersection");
+ addOperator(api::SET_MINUS, "set.minus");
+ addOperator(api::SET_SUBSET, "set.subset");
+ addOperator(api::SET_MEMBER, "set.member");
+ addOperator(api::SET_SINGLETON, "set.singleton");
+ addOperator(api::SET_INSERT, "set.insert");
+ addOperator(api::SET_CARD, "set.card");
+ addOperator(api::SET_COMPLEMENT, "set.complement");
+ addOperator(api::SET_CHOOSE, "set.choose");
+ addOperator(api::SET_IS_SINGLETON, "set.is_singleton");
+ addOperator(api::RELATION_JOIN, "rel.join");
+ addOperator(api::RELATION_PRODUCT, "rel.product");
+ addOperator(api::RELATION_TRANSPOSE, "rel.transpose");
+ addOperator(api::RELATION_TCLOSURE, "rel.tclosure");
+ addOperator(api::RELATION_JOIN_IMAGE, "rel.join_image");
+ addOperator(api::RELATION_IDEN, "rel.iden");
}
if (d_logic.isTheoryEnabled(theory::THEORY_BAGS))
Debug("parser") << "applyParseOp: return uminus " << ret << std::endl;
return ret;
}
- if (kind == api::SINGLETON && args.size() == 1)
+ if (kind == api::SET_SINGLETON && args.size() == 1)
{
- api::Term ret = d_solver->mkTerm(api::SINGLETON, args[0]);
- Debug("parser") << "applyParseOp: return singleton " << ret << std::endl;
+ api::Term ret = d_solver->mkTerm(api::SET_SINGLETON, args[0]);
+ Debug("parser") << "applyParseOp: return set.singleton " << ret
+ << std::endl;
return ret;
}
else if (kind == api::CARDINALITY_CONSTRAINT)
out << ss.str();
break;
}
- case kind::EMPTYSET:
- out << "(as emptyset ";
+ case kind::SET_EMPTY:
+ out << "(as set.empty ";
toStreamType(out, n.getConst<EmptySet>().getType());
out << ")";
break;
break;
// sets
- case kind::SINGLETON:
+ case kind::SET_SINGLETON:
{
out << smtKindString(k, d_variant) << " ";
TypeNode elemType = n.getType().getSetElementType();
return;
}
break;
- case kind::UNIVERSE_SET:out << "(as univset " << n.getType() << ")";break;
+ case kind::SET_UNIVERSE: out << "(as set.universe " << n.getType() << ")"; break;
// bags
case kind::MK_BAG:
case kind::APPLY_UPDATER: return "update";
// set theory
- case kind::UNION: return "union";
- case kind::INTERSECTION: return "intersection";
- case kind::SETMINUS: return "setminus";
- case kind::SUBSET: return "subset";
- case kind::MEMBER: return "member";
+ case kind::SET_UNION: return "set.union";
+ case kind::SET_INTERSECTION: return "set.intersection";
+ case kind::SET_MINUS: return "set.minus";
+ case kind::SET_SUBSET: return "set.subset";
+ case kind::SET_MEMBER: return "set.member";
case kind::SET_TYPE: return "Set";
- case kind::SINGLETON: return "singleton";
- case kind::INSERT: return "insert";
- case kind::COMPLEMENT: return "complement";
- case kind::CARD: return "card";
- case kind::COMPREHENSION: return "comprehension";
- case kind::CHOOSE: return "choose";
- case kind::IS_SINGLETON: return "is_singleton";
- case kind::JOIN: return "join";
- case kind::PRODUCT: return "product";
- case kind::TRANSPOSE: return "transpose";
- case kind::TCLOSURE: return "tclosure";
- case kind::IDEN: return "iden";
- case kind::JOIN_IMAGE: return "join_image";
+ case kind::SET_SINGLETON: return "set.singleton";
+ case kind::SET_INSERT: return "set.insert";
+ case kind::SET_COMPLEMENT: return "set.complement";
+ case kind::SET_CARD: return "set.card";
+ case kind::SET_COMPREHENSION: return "set.comprehension";
+ case kind::SET_CHOOSE: return "set.choose";
+ case kind::SET_IS_SINGLETON: return "set.is_singleton";
+ case kind::RELATION_JOIN: return "rel.join";
+ case kind::RELATION_PRODUCT: return "rel.product";
+ case kind::RELATION_TRANSPOSE: return "rel.transpose";
+ case kind::RELATION_TCLOSURE: return "rel.tclosure";
+ case kind::RELATION_IDEN: return "rel.iden";
+ case kind::RELATION_JOIN_IMAGE: return "rel.join_image";
// bag theory
case kind::BAG_TYPE: return "Bag";
vrule = AletheRule::DIV_SIMPLIFY;
break;
}
- case kind::PRODUCT:
+ case kind::RELATION_PRODUCT:
{
vrule = AletheRule::PROD_SIMPLIFY;
break;
children.insert(children.end(), n.begin(), n.end());
return nm->mkNode(APPLY_UF, children);
}
- else if (k == EMPTYSET || k == UNIVERSE_SET || k == EMPTYBAG)
+ else if (k == SET_EMPTY || k == SET_UNIVERSE || k == EMPTYBAG)
{
Node t = typeAsNode(convertType(tn));
TypeNode etype = nm->mkFunctionType(d_sortType, tn);
Node ef = getSymbolInternal(
k,
etype,
- k == EMPTYSET ? "emptyset"
- : (k == UNIVERSE_SET ? "univset" : "emptybag"));
+ k == SET_EMPTY ? "set.empty"
+ : (k == SET_UNIVERSE ? "set.universe" : "emptybag"));
return nm->mkNode(APPLY_UF, ef, t);
}
else if (n.isClosure())
ret = maybeMkSkolemFun(op, macroApply);
Assert(!ret.isNull());
}
- else if (k == SINGLETON || k == MK_BAG)
+ else if (k == SET_SINGLETON || k == MK_BAG)
{
if (!macroApply)
{
BagsRewriteResponse BagsRewriter::rewriteFromSet(const TNode& n) const
{
Assert(n.getKind() == BAG_FROM_SET);
- if (n[0].getKind() == SINGLETON)
+ if (n[0].getKind() == SET_SINGLETON)
{
- // (bag.from_set (singleton (singleton_op Int) x)) = (mkBag x 1)
+ // (bag.from_set (set.singleton (singleton_op Int) x)) = (mkBag x 1)
TypeNode type = n[0].getType().getSetElementType();
Node bag = d_nm->mkBag(type, n[0][0], d_one);
return BagsRewriteResponse(bag, Rewrite::FROM_SINGLETON);
// Examples
// --------
- // - (bag.from_set (emptyset String)) = (emptybag String)
+ // - (bag.from_set (set.empty String)) = (emptybag String)
// - (bag.from_set (singleton "x")) = (mkBag "x" 1)
// - (bag.from_set (union (singleton "x") (singleton "y"))) =
// (disjoint_union (mkBag "x" 1) (mkBag "y" 1))
// Examples
// --------
- // - (bag.to_set (emptybag String)) = (emptyset String)
+ // - (bag.to_set (emptybag String)) = (set.empty String)
// - (bag.to_set (mkBag "x" 4)) = (singleton "x")
// - (bag.to_set (disjoint_union (mkBag "x" 3) (mkBag "y" 5)) =
// (union (singleton "x") (singleton "y")))
if (!bagType.isBag())
{
throw TypeCheckingExceptionPrivate(
- n, "CHOOSE operator expects a bag, a non-bag is found");
+ n, "BAG_CHOOSE operator expects a bag, a non-bag is found");
}
}
return bagType.getBagElementType();
// where these two things require those kinds respectively.
return k == APPLY_UF || k == SELECT || k == STORE || k == APPLY_CONSTRUCTOR
|| k == APPLY_SELECTOR || k == APPLY_SELECTOR_TOTAL
- || k == APPLY_TESTER || k == UNION || k == INTERSECTION || k == SUBSET
- || k == SETMINUS || k == MEMBER || k == SINGLETON || k == SEP_PTO
- || k == BITVECTOR_TO_NAT || k == INT_TO_BITVECTOR || k == HO_APPLY
- || k == STRING_LENGTH || k == SEQ_NTH;
+ || k == APPLY_TESTER || k == SET_UNION || k == SET_INTERSECTION
+ || k == SET_SUBSET || k == SET_MINUS || k == SET_MEMBER
+ || k == SET_SINGLETON || k == SEP_PTO || k == BITVECTOR_TO_NAT
+ || k == INT_TO_BITVECTOR || k == HO_APPLY || k == STRING_LENGTH
+ || k == SEQ_NTH;
}
bool TriggerTermInfo::isRelationalTrigger(Node n)
}
}
}
- }else if( n.getKind()==MEMBER ){
+ }
+ else if (n.getKind() == SET_MEMBER)
+ {
if( !pol && !hasNonBoundVar( q, n[1] ) ){
std::vector< Node > bound_vars;
std::map< Node, bool > visited;
bound_lit_pol_map[2][v] = pol;
}
}
- }else{
+ }
+ else
+ {
Assert(n.getKind() != LEQ && n.getKind() != LT && n.getKind() != GT);
}
}
setBoundVar = true;
d_setm_range[f][v] = bound_lit_map[2][v][1];
d_setm_range_lit[f][v] = bound_lit_map[2][v];
- d_range[f][v] = nm->mkNode(CARD, d_setm_range[f][v]);
+ d_range[f][v] = nm->mkNode(SET_CARD, d_setm_range[f][v]);
Trace("bound-int") << "Variable " << v
<< " is bound because of set membership literal "
<< bound_lit_map[2][v] << std::endl;
return Node::null();
}
Trace("bound-int-rsi") << "Value is " << sr << std::endl;
- if (sr.getKind() == EMPTYSET)
+ if (sr.getKind() == SET_EMPTY)
{
return sr;
}
// we can use choice functions for canonical symbolic instantiations
unsigned srCard = 0;
- while (sr.getKind() == UNION)
+ while (sr.getKind() == SET_UNION)
{
srCard++;
sr = sr[0];
}
- Assert(sr.getKind() == SINGLETON);
+ Assert(sr.getKind() == SET_SINGLETON);
srCard++;
// choices[i] stores the canonical symbolic representation of the (i+1)^th
// element of sro
std::vector<Node> choices;
- Node srCardN = nm->mkNode(CARD, sro);
+ Node srCardN = nm->mkNode(SET_CARD, sro);
Node choice_i;
for (unsigned i = 0; i < srCard; i++)
{
{
choice_i = nm->mkBoundVar(tne);
choices.push_back(choice_i);
- Node cBody = nm->mkNode(MEMBER, choice_i, sro);
+ Node cBody = nm->mkNode(SET_MEMBER, choice_i, sro);
if (choices.size() > 1)
{
cBody = nm->mkNode(AND, cBody, nm->mkNode(DISTINCT, choices));
}
else
{
- nsr = nm->mkNode(UNION, nsr, sChoiceI);
+ nsr = nm->mkNode(SET_UNION, nsr, sChoiceI);
}
}
// turns the concrete model value of sro into a canonical representation
return false;
}else{
Trace("bound-int-rsi") << "Bounded by set membership : " << srv << std::endl;
- if( srv.getKind()!=EMPTYSET ){
+ if (srv.getKind() != SET_EMPTY)
+ {
//collect the elements
- while( srv.getKind()==UNION ){
- Assert(srv[1].getKind() == kind::SINGLETON);
+ while (srv.getKind() == SET_UNION)
+ {
+ Assert(srv[1].getKind() == kind::SET_SINGLETON);
elements.push_back( srv[1][0] );
srv = srv[0];
}
- Assert(srv.getKind() == kind::SINGLETON);
+ Assert(srv.getKind() == kind::SET_SINGLETON);
elements.push_back( srv[0] );
//check if we need to do matching, for literals like ( tuple( v ) in S )
Node t = d_setm_range_lit[q][v][0];
sdts[i].addConstructor(lambda, "singleton", cargsSingleton);
// add for union, difference, intersection
- std::vector<Kind> bin_kinds = {UNION, INTERSECTION, SETMINUS};
+ std::vector<Kind> bin_kinds = {SET_UNION, SET_INTERSECTION, SET_MINUS};
std::vector<TypeNode> cargsBinary;
cargsBinary.push_back(unres_t);
cargsBinary.push_back(unres_t);
std::vector<TypeNode> cargsMember;
cargsMember.push_back(unresElemType);
cargsMember.push_back(unres_types[iuse]);
- Trace("sygus-grammar-def") << "...for MEMBER" << std::endl;
- sdtBool.addConstructor(MEMBER, cargsMember);
+ Trace("sygus-grammar-def") << "...for SET_MEMBER" << std::endl;
+ sdtBool.addConstructor(SET_MEMBER, cargsMember);
}
}
// add Boolean connectives, if not in a degenerate case of (recursively)
Node TermDb::getMatchOperator( Node n ) {
Kind k = n.getKind();
//datatype operators may be parametric, always assume they are
- if (k == SELECT || k == STORE || k == UNION || k == INTERSECTION
- || k == SUBSET || k == SETMINUS || k == MEMBER || k == SINGLETON
- || k == APPLY_SELECTOR_TOTAL || k == APPLY_SELECTOR || k == APPLY_TESTER
- || k == SEP_PTO || k == HO_APPLY || k == SEQ_NTH || k == STRING_LENGTH)
+ if (k == SELECT || k == STORE || k == SET_UNION || k == SET_INTERSECTION
+ || k == SET_SUBSET || k == SET_MINUS || k == SET_MEMBER
+ || k == SET_SINGLETON || k == APPLY_SELECTOR_TOTAL || k == APPLY_SELECTOR
+ || k == APPLY_TESTER || k == SEP_PTO || k == HO_APPLY || k == SEQ_NTH
+ || k == STRING_LENGTH)
{
//since it is parametric, use a particular one as op
TypeNode tn = n[0].getType();
{
if (reqNAry)
{
- if (k == UNION || k == INTERSECTION)
+ if (k == SET_UNION || k == SET_INTERSECTION)
{
return false;
}
|| k == XOR || k == BITVECTOR_ADD || k == BITVECTOR_MULT
|| k == BITVECTOR_AND || k == BITVECTOR_OR || k == BITVECTOR_XOR
|| k == BITVECTOR_XNOR || k == BITVECTOR_CONCAT || k == STRING_CONCAT
- || k == UNION || k == INTERSECTION || k == JOIN || k == PRODUCT
- || k == SEP_STAR;
+ || k == SET_UNION || k == SET_INTERSECTION || k == RELATION_JOIN
+ || k == RELATION_PRODUCT || k == SEP_STAR;
}
bool TermUtil::isComm(Kind k, bool reqNAry)
{
if (reqNAry)
{
- if (k == UNION || k == INTERSECTION)
+ if (k == SET_UNION || k == SET_INTERSECTION)
{
return false;
}
return k == EQUAL || k == PLUS || k == MULT || k == NONLINEAR_MULT || k == AND
|| k == OR || k == XOR || k == BITVECTOR_ADD || k == BITVECTOR_MULT
|| k == BITVECTOR_AND || k == BITVECTOR_OR || k == BITVECTOR_XOR
- || k == BITVECTOR_XNOR || k == UNION || k == INTERSECTION
+ || k == BITVECTOR_XNOR || k == SET_UNION || k == SET_INTERSECTION
|| k == SEP_STAR;
}
}else{
for( unsigned j=0; j<d_label_model[it->second].d_heap_locs_model.size(); j++ ){
Assert(d_label_model[it->second].d_heap_locs_model[j].getKind()
- == kind::SINGLETON);
+ == kind::SET_SINGLETON);
std::vector< Node > pto_children;
Node l = d_label_model[it->second].d_heap_locs_model[j][0];
Assert(l.isConst());
TypeNode tn = getReferenceType();
if (d_reference_bound_max.find(tn) != d_reference_bound_max.end())
{
- c_lems.push_back(nm->mkNode(SUBSET, slbl, d_reference_bound_max[tn]));
+ c_lems.push_back(
+ nm->mkNode(SET_SUBSET, slbl, d_reference_bound_max[tn]));
}
std::vector<Node> labels;
getLabelChildren(satom, slbl, children, labels);
if (satom.getKind() == SEP_STAR)
{
// reduction for heap : union, pairwise disjoint
- Node ulem = nm->mkNode(UNION, labels[0], labels[1]);
+ Node ulem = nm->mkNode(SET_UNION, labels[0], labels[1]);
size_t lsize = labels.size();
for (size_t i = 2; i < lsize; i++)
{
- ulem = nm->mkNode(UNION, ulem, labels[i]);
+ ulem = nm->mkNode(SET_UNION, ulem, labels[i]);
}
ulem = slbl.eqNode(ulem);
Trace("sep-lemma-debug")
{
for (size_t j = (i + 1); j < lsize; j++)
{
- Node s = nm->mkNode(INTERSECTION, labels[i], labels[j]);
+ Node s = nm->mkNode(SET_INTERSECTION, labels[i], labels[j]);
Node ilem = s.eqNode(empSet);
Trace("sep-lemma-debug")
<< "Sep::Lemma : star reduction, disjoint : " << ilem
}
else
{
- Node ulem = nm->mkNode(UNION, slbl, labels[0]);
+ Node ulem = nm->mkNode(SET_UNION, slbl, labels[0]);
ulem = ulem.eqNode(labels[1]);
Trace("sep-lemma-debug")
<< "Sep::Lemma : wand reduction, union : " << ulem << std::endl;
c_lems.push_back(ulem);
- Node s = nm->mkNode(INTERSECTION, slbl, labels[0]);
+ Node s = nm->mkNode(SET_INTERSECTION, slbl, labels[0]);
Node ilem = s.eqNode(empSet);
Trace("sep-lemma-debug")
<< "Sep::Lemma : wand reduction, disjoint : " << ilem << std::endl;
c_lems.push_back(ilem);
// nil does not occur in labels[0]
Node nr = getNilRef(tn);
- Node nrlem = nm->mkNode(MEMBER, nr, labels[0]).negate();
+ Node nrlem = nm->mkNode(SET_MEMBER, nr, labels[0]).negate();
Trace("sep-lemma")
<< "Sep::Lemma: sep.nil not in wand antecedant heap : " << nrlem
<< std::endl;
std::vector<Node>& hlmodel = d_label_model[it->second].d_heap_locs_model;
for (size_t j = 0, hsize = hlmodel.size(); j < hsize; j++)
{
- Assert(hlmodel[j].getKind() == SINGLETON);
+ Assert(hlmodel[j].getKind() == SET_SINGLETON);
Node l = hlmodel[j][0];
Trace("sep-process-debug") << " location : " << l << std::endl;
if (!d_pto_model[l].isNull())
// if location is in the heap, then something must point to it
Node lem = nm->mkNode(
IMPLIES,
- nm->mkNode(MEMBER, ll, it->second),
+ nm->mkNode(SET_MEMBER, ll, it->second),
nm->mkNode(SEP_STAR, nm->mkNode(SEP_PTO, ll, dsk), d_true));
Trace("sep-lemma") << "Sep::Lemma : witness finite data-pto : " << lem
<< std::endl;
d_reference_bound_max[tn] = mkUnion( tn, d_type_references_all[tn] );
Trace("sep-bound") << "overall bound for " << d_base_label[tn] << " : " << d_reference_bound_max[tn] << std::endl;
- Node slem = NodeManager::currentNM()->mkNode( kind::SUBSET, d_base_label[tn], d_reference_bound_max[tn] );
+ Node slem = NodeManager::currentNM()->mkNode(
+ kind::SET_SUBSET, d_base_label[tn], d_reference_bound_max[tn]);
Trace("sep-lemma") << "Sep::Lemma: reference bound for " << tn << " : " << slem << std::endl;
d_im.lemma(slem, InferenceId::SEP_REF_BOUND);
if( d_type_references_card[tn].size()>1 ){
std::map< unsigned, Node > lit_mem_map;
for( unsigned i=0; i<d_type_references_card[tn].size(); i++ ){
- lit_mem_map[i] = NodeManager::currentNM()->mkNode( kind::MEMBER, d_type_references_card[tn][i], d_reference_bound_max[tn]);
+ lit_mem_map[i] =
+ NodeManager::currentNM()->mkNode(kind::SET_MEMBER,
+ d_type_references_card[tn][i],
+ d_reference_bound_max[tn]);
}
for( unsigned i=0; i<(d_type_references_card[tn].size()-1); i++ ){
std::vector< Node > children;
//assert that nil ref is not in base label
Node nr = getNilRef( tn );
- Node nrlem = NodeManager::currentNM()->mkNode( kind::MEMBER, nr, n_lbl ).negate();
+ Node nrlem =
+ NodeManager::currentNM()->mkNode(kind::SET_MEMBER, nr, n_lbl).negate();
Trace("sep-lemma") << "Sep::Lemma: sep.nil not in base label " << tn << " : " << nrlem << std::endl;
d_im.lemma(nrlem, InferenceId::SEP_NIL_NOT_IN_HEAP);
if( u.isNull() ){
u = s;
}else{
- u = NodeManager::currentNM()->mkNode( kind::UNION, s, u );
+ u = NodeManager::currentNM()->mkNode(kind::SET_UNION, s, u);
}
}
return u;
Node sub_lbl_0 = d_label_map[n][lbl][0];
computeLabelModel( sub_lbl_0 );
Assert(d_label_model.find(sub_lbl_0) != d_label_model.end());
- lbl_mval = NodeManager::currentNM()->mkNode( kind::UNION, lbl, d_label_model[sub_lbl_0].getValue( rtn ) );
+ lbl_mval = NodeManager::currentNM()->mkNode(
+ kind::SET_UNION, lbl, d_label_model[sub_lbl_0].getValue(rtn));
}else{
computeLabelModel( sub_lbl );
Assert(d_label_model.find(sub_lbl) != d_label_model.end());
Node sub_lbl = itl->second;
Node lbl_mval = d_label_model[sub_lbl].getValue( rtn );
for( unsigned j=0; j<vs.size(); j++ ){
- bchildren.push_back( NodeManager::currentNM()->mkNode( kind::INTERSECTION, lbl_mval, vs[j] ).eqNode( empSet ) );
+ bchildren.push_back(
+ NodeManager::currentNM()
+ ->mkNode(kind::SET_INTERSECTION, lbl_mval, vs[j])
+ .eqNode(empSet));
}
vs.push_back( lbl_mval );
if( vsu.isNull() ){
vsu = lbl_mval;
}else{
- vsu = NodeManager::currentNM()->mkNode( kind::UNION, vsu, lbl_mval );
+ vsu = NodeManager::currentNM()->mkNode(
+ kind::SET_UNION, vsu, lbl_mval);
}
}
bchildren.push_back( vsu.eqNode( lbl ) );
for( unsigned i=0; i<children.size(); i++ ){
std::vector< Node > tchildren;
Node mval = mvals[i];
- tchildren.push_back(
- NodeManager::currentNM()->mkNode(kind::SUBSET, mval, lbl));
+ tchildren.push_back(NodeManager::currentNM()->mkNode(
+ kind::SET_SUBSET, mval, lbl));
tchildren.push_back( children[i] );
std::vector< Node > rem_children;
for( unsigned j=0; j<children.size(); j++ ){
}
std::map< Node, Node > rvisited;
Node rem = rem_children.size()==1 ? rem_children[0] : NodeManager::currentNM()->mkNode( kind::SEP_STAR, rem_children );
- rem = applyLabel( rem, NodeManager::currentNM()->mkNode( kind::SETMINUS, lbl, mval ), rvisited );
+ rem = applyLabel(
+ rem,
+ NodeManager::currentNM()->mkNode(kind::SET_MINUS, lbl, mval),
+ rvisited);
tchildren.push_back( rem );
conj.push_back( NodeManager::currentNM()->mkNode( kind::AND, tchildren ) );
}
//disjoint constraints
Node sub_lbl_0 = d_label_map[n][lbl][0];
Node lbl_mval_0 = d_label_model[sub_lbl_0].getValue( rtn );
- wchildren.push_back( NodeManager::currentNM()->mkNode( kind::INTERSECTION, lbl_mval_0, lbl ).eqNode( empSet ).negate() );
+ wchildren.push_back(
+ NodeManager::currentNM()
+ ->mkNode(kind::SET_INTERSECTION, lbl_mval_0, lbl)
+ .eqNode(empSet)
+ .negate());
//return the lemma
wchildren.push_back( children[0].negate() );
Trace("sep-inst-debug") << "Return " << ret << std::endl;
return ret;
}else if( n.getKind()==kind::SEP_EMP ){
- //return NodeManager::currentNM()->mkConst( lbl_v.getKind()==kind::EMPTYSET );
+ // return NodeManager::currentNM()->mkConst(
+ // lbl_v.getKind()==kind::SET_EMPTY );
return lbl_v.eqNode(
NodeManager::currentNM()->mkConst(EmptySet(lbl_v.getType())));
}else{
//Assert(...); TODO
Node v_val = d_valuation.getModel()->getRepresentative( lbl );
Trace("sep-process") << "Model value (from valuation) for " << lbl << " : " << v_val << std::endl;
- if( v_val.getKind()!=kind::EMPTYSET ){
- while( v_val.getKind()==kind::UNION ){
- Assert(v_val[0].getKind() == kind::SINGLETON);
+ if (v_val.getKind() != kind::SET_EMPTY)
+ {
+ while (v_val.getKind() == kind::SET_UNION)
+ {
+ Assert(v_val[0].getKind() == kind::SET_SINGLETON);
d_label_model[lbl].d_heap_locs_model.push_back(v_val[0]);
v_val = v_val[1];
}
- if( v_val.getKind()==kind::SINGLETON ){
+ if (v_val.getKind() == kind::SET_SINGLETON)
+ {
d_label_model[lbl].d_heap_locs_model.push_back( v_val );
- }else{
+ }
+ else
+ {
throw Exception("Could not establish value of heap in model.");
Assert(false);
}
}
for( unsigned j=0; j<d_label_model[lbl].d_heap_locs_model.size(); j++ ){
Node u = d_label_model[lbl].d_heap_locs_model[j];
- Assert(u.getKind() == kind::SINGLETON);
+ Assert(u.getKind() == kind::SET_SINGLETON);
u = u[0];
Node tt;
std::map< Node, Node >::iterator itm = d_tmodel.find( u );
Assert(areEqual(pb[1], p[1]));
std::vector< Node > exp;
if( pb[1]!=p[1] ){
- //if( pb[1].getKind()==kind::SINGLETON && p[1].getKind()==kind::SINGLETON ){
+ // if( pb[1].getKind()==kind::SET_SINGLETON &&
+ // p[1].getKind()==kind::SET_SINGLETON ){
// exp.push_back( pb[1][0].eqNode( p[1][0] ) );
//}else{
exp.push_back( pb[1].eqNode( p[1] ) );
Node curr = d_heap_locs[0];
for (unsigned j = 1; j < d_heap_locs.size(); j++)
{
- curr = NodeManager::currentNM()->mkNode(kind::UNION, d_heap_locs[j], curr);
+ curr =
+ NodeManager::currentNM()->mkNode(kind::SET_UNION, d_heap_locs[j], curr);
}
return curr;
}
void CardinalityExtension::registerTerm(Node n)
{
Trace("sets-card-debug") << "Register term : " << n << std::endl;
- Assert(n.getKind() == CARD);
+ Assert(n.getKind() == SET_CARD);
TypeNode tnc = n[0].getType().getSetElementType();
d_t_card_enabled[tnc] = true;
Node r = d_state.getRepresentative(n[0]);
if (finiteType)
{
Node typeCardinality = nm->mkConst(Rational(card.getFiniteCardinality()));
- Node cardUniv = nm->mkNode(kind::CARD, proxy);
+ Node cardUniv = nm->mkNode(kind::SET_CARD, proxy);
Node leq = nm->mkNode(kind::LEQ, cardUniv, typeCardinality);
// (=> true (<= (card (as univset t)) cardUniv)
}
// (=> true (subset representative (as univset t))
- Node subset = nm->mkNode(kind::SUBSET, variable, proxy);
+ Node subset = nm->mkNode(kind::SET_SUBSET, variable, proxy);
// subset terms are rewritten as union terms: (subset A B) implies (=
// (union A B) B)
subset = rewrite(subset);
for (const auto& negativeMember : negativeMembers)
{
- Node member = nm->mkNode(MEMBER, negativeMember.first, univ);
+ Node member = nm->mkNode(SET_MEMBER, negativeMember.first, univ);
// negativeMember.second is the reason for the negative membership and
- // has kind MEMBER. So we specify the negation as the reason for the
+ // has kind SET_MEMBER. So we specify the negation as the reason for the
// negative membership lemma
Node notMember = nm->mkNode(NOT, negativeMember.second);
// (=>
if (!d_state.isCongruent(n))
{
// if setminus, do for intersection instead
- if (n.getKind() == SETMINUS)
+ if (n.getKind() == SET_MINUS)
{
- n = rewrite(nm->mkNode(INTERSECTION, n[0], n[1]));
+ n = rewrite(nm->mkNode(SET_INTERSECTION, n[0], n[1]));
}
registerCardinalityTerm(n);
}
NodeManager* nm = NodeManager::currentNM();
Trace("sets-card") << "Cardinality lemmas for " << n << " : " << std::endl;
std::vector<Node> cterms;
- if (n.getKind() == INTERSECTION)
+ if (n.getKind() == SET_INTERSECTION)
{
for (unsigned e = 0; e < 2; e++)
{
- Node s = nm->mkNode(SETMINUS, n[e], n[1 - e]);
+ Node s = nm->mkNode(SET_MINUS, n[e], n[1 - e]);
cterms.push_back(s);
}
- Node pos_lem = nm->mkNode(GEQ, nm->mkNode(CARD, n), d_zero);
+ Node pos_lem = nm->mkNode(GEQ, nm->mkNode(SET_CARD, n), d_zero);
d_im.assertInference(
pos_lem, InferenceId::SETS_CARD_POSITIVE, d_emp_exp, 1);
}
{
Node nn = cterms[k];
Node nk = d_treg.getProxy(nn);
- Node pos_lem = nm->mkNode(GEQ, nm->mkNode(CARD, nk), d_zero);
+ Node pos_lem = nm->mkNode(GEQ, nm->mkNode(SET_CARD, nk), d_zero);
d_im.assertInference(
pos_lem, InferenceId::SETS_CARD_POSITIVE, d_emp_exp, 1);
if (nn != nk)
{
- Node lem = nm->mkNode(EQUAL, nm->mkNode(CARD, nk), nm->mkNode(CARD, nn));
+ Node lem =
+ nm->mkNode(EQUAL, nm->mkNode(SET_CARD, nk), nm->mkNode(SET_CARD, nn));
lem = rewrite(lem);
Trace("sets-card") << " " << k << " : " << lem << std::endl;
d_im.assertInference(lem, InferenceId::SETS_CARD_EQUAL, d_emp_exp, 1);
for (const Node& n : nvsets)
{
Kind nk = n.getKind();
- if (nk != INTERSECTION && nk != SETMINUS)
+ if (nk != SET_INTERSECTION && nk != SET_MINUS)
{
continue;
}
<< std::endl;
std::vector<Node> sib;
unsigned true_sib = 0;
- if (n.getKind() == INTERSECTION)
+ if (n.getKind() == SET_INTERSECTION)
{
d_localBase[n] = n;
for (unsigned e = 0; e < 2; e++)
{
- Node sm = rewrite(nm->mkNode(SETMINUS, n[e], n[1 - e]));
+ Node sm = rewrite(nm->mkNode(SET_MINUS, n[e], n[1 - e]));
sib.push_back(sm);
}
true_sib = 2;
}
else
{
- Node si = rewrite(nm->mkNode(INTERSECTION, n[0], n[1]));
+ Node si = rewrite(nm->mkNode(SET_INTERSECTION, n[0], n[1]));
sib.push_back(si);
d_localBase[n] = si;
- Node osm = rewrite(nm->mkNode(SETMINUS, n[1], n[0]));
+ Node osm = rewrite(nm->mkNode(SET_MINUS, n[1], n[0]));
sib.push_back(osm);
true_sib = 1;
}
- Node u = rewrite(nm->mkNode(UNION, n[0], n[1]));
+ Node u = rewrite(nm->mkNode(SET_UNION, n[0], n[1]));
if (!d_state.hasTerm(u))
{
u = Node::null();
<< "Sibling " << sib[si] << " is already empty." << std::endl;
}
}
- if (!is_union && nk == INTERSECTION && !u.isNull())
+ if (!is_union && nk == SET_INTERSECTION && !u.isNull())
{
// union is equal to other parent
if (!d_state.areEqual(u, n[1 - e]))
<< " are equal, ids = " << card_parent_ids[l]
<< " " << card_parent_ids[k] << std::endl;
dup = true;
- if (n.getKind() != INTERSECTION)
+ if (n.getKind() != SET_INTERSECTION)
{
continue;
}
Node r1 = e == 0 ? o0 : o1;
Node r2 = e == 0 ? o1 : o0;
// check if their intersection exists modulo equality
- Node r1r2i = d_state.getBinaryOpTerm(INTERSECTION, r1, r2);
+ Node r1r2i = d_state.getBinaryOpTerm(SET_INTERSECTION, r1, r2);
if (!r1r2i.isNull())
{
Trace("sets-nf-debug")
Assert(o0 != o1);
Node kca = d_treg.getProxy(o0);
Node kcb = d_treg.getProxy(o1);
- Node intro = rewrite(nm->mkNode(INTERSECTION, kca, kcb));
+ Node intro = rewrite(nm->mkNode(SET_INTERSECTION, kca, kcb));
Trace("sets-nf") << " Intro split : " << o0 << " against " << o1
<< ", term is " << intro << std::endl;
intro_sets.push_back(intro);
}
else
{
- cardTerm = nm->mkNode(CARD, eqc);
+ cardTerm = nm->mkNode(SET_CARD, eqc);
}
for (const std::pair<const Node, Node>& itmm : pmemsE)
{
members.push_back(itmm.first);
- exp.push_back(nm->mkNode(MEMBER, itmm.first, cardTerm[0]));
+ exp.push_back(nm->mkNode(SET_MEMBER, itmm.first, cardTerm[0]));
}
if (members.size() > 1)
{
* This class implements a variant of the procedure from Bansal et al, IJCAR
* 2016. It is used during a full effort check in the following way:
* reset(); { registerTerm(n,lemmas); | n in CardTerms } check();
- * where CardTerms is the set of all applications of CARD in the current
+ * where CardTerms is the set of all applications of SET_CARD in the current
* context.
*
* The remaining public methods are used during model construction, i.e.
/** register term
*
* Register that the term n exists in the current context, where n is an
- * application of CARD.
+ * application of SET_CARD.
*/
void registerTerm(Node n);
/** check
return false;
}
// things we can assert to equality engine
- if (atom.getKind() == MEMBER
+ if (atom.getKind() == SET_MEMBER
|| (atom.getKind() == EQUAL && atom[0].getType().isSet()))
{
// send to equality engine
properties check presolve
# constants
-constant EMPTYSET \
+constant SET_EMPTY\
class \
EmptySet \
::cvc5::EmptySetHashFunction \
"theory/sets/theory_sets_type_enumerator.h"
# operators
-operator UNION 2 "set union"
-operator INTERSECTION 2 "set intersection"
-operator SETMINUS 2 "set subtraction"
-operator SUBSET 2 "subset predicate; first parameter a subset of second"
-operator MEMBER 2 "set membership predicate; first parameter a member of second"
+operator SET_UNION 2 "set union"
+operator SET_INTERSECTION 2 "set intersection"
+operator SET_MINUS 2 "set subtraction"
+operator SET_SUBSET 2 "subset predicate; first parameter a subset of second"
+operator SET_MEMBER 2 "set membership predicate; first parameter a member of second"
-constant SINGLETON_OP \
+constant SET_SINGLETON_OP \
class \
- SingletonOp \
- ::cvc5::SingletonOpHashFunction \
+ SetSingletonOp \
+ ::cvc5::SetSingletonOpHashFunction \
"theory/sets/singleton_op.h" \
"operator for singletons; payload is an instance of the cvc5::SingletonOp class"
-parameterized SINGLETON SINGLETON_OP 1 \
+parameterized SET_SINGLETON SET_SINGLETON_OP 1 \
"constructs a set of a single element. First parameter is a SingletonOp. Second is a term"
-operator INSERT 2: "set obtained by inserting elements (first N-1 parameters) into a set (the last parameter)"
-operator CARD 1 "set cardinality operator"
-operator COMPLEMENT 1 "set COMPLEMENT (with respect to finite universe)"
-nullaryoperator UNIVERSE_SET "(finite) universe set, all set variables must be interpreted as subsets of it."
+operator SET_INSERT 2: "set obtained by inserting elements (first N-1 parameters) into a set (the last parameter)"
+operator SET_CARD 1 "set cardinality operator"
+operator SET_COMPLEMENT 1 "set complement (with respect to finite universe)"
+nullaryoperator SET_UNIVERSE "(finite) universe set, all set variables must be interpreted as subsets of it."
# A set comprehension is specified by:
# (1) a bound variable list x1 ... xn,
# that there are infinitely many y that satisfy the left hand side of the
# equivalence above. The same limitation occurs more generally when combining
# finite sets with quantified formulas.
-operator COMPREHENSION 3 "set comprehension specified by a bound variable list, a predicate, and a term."
+operator SET_COMPREHENSION 3 "set comprehension specified by a bound variable list, a predicate, and a term."
# The operator choose returns an element from a given set.
# If set A = {x}, then the term (choose A) is equivalent to the term x.
# If the set is empty, then (choose A) is an arbitrary value.
# If the set has cardinality > 1, then (choose A) will deterministically return an element in A.
-operator CHOOSE 1 "return an element in the set given as a parameter"
+operator SET_CHOOSE 1 "return an element in the set given as a parameter"
# The operator is_singleton returns whether the given set is a singleton
-operator IS_SINGLETON 1 "return whether the given set is a singleton"
+operator SET_IS_SINGLETON 1 "return whether the given set is a singleton"
-operator JOIN 2 "set join"
-operator PRODUCT 2 "set cartesian product"
-operator TRANSPOSE 1 "set transpose"
-operator TCLOSURE 1 "set transitive closure"
-operator JOIN_IMAGE 2 "set join image"
-operator IDEN 1 "set identity"
+operator RELATION_JOIN 2 "relation join"
+operator RELATION_PRODUCT 2 "relation cartesian product"
+operator RELATION_TRANSPOSE 1 "relation transpose"
+operator RELATION_TCLOSURE 1 "relation transitive closure"
+operator RELATION_JOIN_IMAGE 2 "relation join image"
+operator RELATION_IDEN 1 "relation identity"
-typerule UNION ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
-typerule INTERSECTION ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
-typerule SETMINUS ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
-typerule SUBSET ::cvc5::theory::sets::SubsetTypeRule
-typerule MEMBER ::cvc5::theory::sets::MemberTypeRule
-typerule SINGLETON_OP "SimpleTypeRule<RBuiltinOperator>"
-typerule SINGLETON ::cvc5::theory::sets::SingletonTypeRule
-typerule EMPTYSET ::cvc5::theory::sets::EmptySetTypeRule
-typerule INSERT ::cvc5::theory::sets::InsertTypeRule
-typerule CARD ::cvc5::theory::sets::CardTypeRule
-typerule COMPLEMENT ::cvc5::theory::sets::ComplementTypeRule
-typerule UNIVERSE_SET ::cvc5::theory::sets::UniverseSetTypeRule
-typerule COMPREHENSION ::cvc5::theory::sets::ComprehensionTypeRule
-typerule CHOOSE ::cvc5::theory::sets::ChooseTypeRule
-typerule IS_SINGLETON ::cvc5::theory::sets::IsSingletonTypeRule
+typerule SET_UNION ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
+typerule SET_INTERSECTION ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
+typerule SET_MINUS ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
+typerule SET_SUBSET ::cvc5::theory::sets::SubsetTypeRule
+typerule SET_MEMBER ::cvc5::theory::sets::MemberTypeRule
+typerule SET_SINGLETON_OP "SimpleTypeRule<RBuiltinOperator>"
+typerule SET_SINGLETON ::cvc5::theory::sets::SingletonTypeRule
+typerule SET_EMPTY ::cvc5::theory::sets::EmptySetTypeRule
+typerule SET_INSERT ::cvc5::theory::sets::InsertTypeRule
+typerule SET_CARD ::cvc5::theory::sets::CardTypeRule
+typerule SET_COMPLEMENT ::cvc5::theory::sets::ComplementTypeRule
+typerule SET_UNIVERSE ::cvc5::theory::sets::UniverseSetTypeRule
+typerule SET_COMPREHENSION ::cvc5::theory::sets::ComprehensionTypeRule
+typerule SET_CHOOSE ::cvc5::theory::sets::ChooseTypeRule
+typerule SET_IS_SINGLETON ::cvc5::theory::sets::IsSingletonTypeRule
-typerule JOIN ::cvc5::theory::sets::RelBinaryOperatorTypeRule
-typerule PRODUCT ::cvc5::theory::sets::RelBinaryOperatorTypeRule
-typerule TRANSPOSE ::cvc5::theory::sets::RelTransposeTypeRule
-typerule TCLOSURE ::cvc5::theory::sets::RelTransClosureTypeRule
-typerule JOIN_IMAGE ::cvc5::theory::sets::JoinImageTypeRule
-typerule IDEN ::cvc5::theory::sets::RelIdenTypeRule
+typerule RELATION_JOIN ::cvc5::theory::sets::RelBinaryOperatorTypeRule
+typerule RELATION_PRODUCT ::cvc5::theory::sets::RelBinaryOperatorTypeRule
+typerule RELATION_TRANSPOSE ::cvc5::theory::sets::RelTransposeTypeRule
+typerule RELATION_TCLOSURE ::cvc5::theory::sets::RelTransClosureTypeRule
+typerule RELATION_JOIN_IMAGE ::cvc5::theory::sets::JoinImageTypeRule
+typerule RELATION_IDEN ::cvc5::theory::sets::RelIdenTypeRule
-construle UNION ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
-construle SINGLETON ::cvc5::theory::sets::SingletonTypeRule
+construle SET_UNION ::cvc5::theory::sets::SetsBinaryOperatorTypeRule
+construle SET_SINGLETON ::cvc5::theory::sets::SingletonTypeRule
endtheory
while (++it != elements.end())
{
Node singleton = nm->mkSingleton(elementType, *it);
- cur = nm->mkNode(kind::UNION, singleton, cur);
+ cur = nm->mkNode(kind::SET_UNION, singleton, cur);
}
return cur;
}
static bool checkNormalConstant(TNode n) {
Debug("sets-checknormal") << "[sets-checknormal] checkNormal " << n << " :"
<< std::endl;
- if (n.getKind() == kind::EMPTYSET) {
+ if (n.getKind() == kind::SET_EMPTY)
+ {
return true;
- } else if (n.getKind() == kind::SINGLETON) {
+ }
+ else if (n.getKind() == kind::SET_SINGLETON)
+ {
return n[0].isConst();
- } else if (n.getKind() == kind::UNION) {
+ }
+ else if (n.getKind() == kind::SET_UNION)
+ {
// assuming (union {SmallestNodeID} ... (union {BiggerNodeId} ...
Node orig = n;
TNode prvs;
// check intermediate nodes
- while (n.getKind() == kind::UNION)
+ while (n.getKind() == kind::SET_UNION)
{
- if (n[0].getKind() != kind::SINGLETON || !n[0][0].isConst())
+ if (n[0].getKind() != kind::SET_SINGLETON || !n[0][0].isConst())
{
// not a constant
Trace("sets-isconst") << "sets::isConst: " << orig << " not due to "
}
// check SmallestNodeID is smallest
- if (n.getKind() != kind::SINGLETON || !n[0].isConst())
+ if (n.getKind() != kind::SET_SINGLETON || !n[0].isConst())
{
Trace("sets-isconst") << "sets::isConst: " << orig
<< " not due to final " << n << std::endl;
static std::set<Node> getElementsFromNormalConstant(TNode n) {
Assert(n.isConst());
std::set<Node> ret;
- if (n.getKind() == kind::EMPTYSET) {
+ if (n.getKind() == kind::SET_EMPTY)
+ {
return ret;
}
- while (n.getKind() == kind::UNION) {
- Assert(n[0].getKind() == kind::SINGLETON);
+ while (n.getKind() == kind::SET_UNION)
+ {
+ Assert(n[0].getKind() == kind::SET_SINGLETON);
ret.insert(ret.begin(), n[0][0]);
n = n[1];
}
- Assert(n.getKind() == kind::SINGLETON);
+ Assert(n.getKind() == kind::SET_SINGLETON);
ret.insert(n[0]);
return ret;
}
namespace cvc5 {
-std::ostream& operator<<(std::ostream& out, const SingletonOp& op)
+std::ostream& operator<<(std::ostream& out, const SetSingletonOp& op)
{
return out << "(singleton_op " << op.getType() << ')';
}
-size_t SingletonOpHashFunction::operator()(const SingletonOp& op) const
+size_t SetSingletonOpHashFunction::operator()(const SetSingletonOp& op) const
{
return std::hash<TypeNode>()(op.getType());
}
-SingletonOp::SingletonOp(const TypeNode& elementType)
+SetSingletonOp::SetSingletonOp(const TypeNode& elementType)
: d_type(new TypeNode(elementType))
{
}
-SingletonOp::SingletonOp(const SingletonOp& op)
+SetSingletonOp::SetSingletonOp(const SetSingletonOp& op)
: d_type(new TypeNode(op.getType()))
{
}
-const TypeNode& SingletonOp::getType() const { return *d_type; }
+const TypeNode& SetSingletonOp::getType() const { return *d_type; }
-bool SingletonOp::operator==(const SingletonOp& op) const
+bool SetSingletonOp::operator==(const SetSingletonOp& op) const
{
return getType() == op.getType();
}
class TypeNode;
/**
- * The class is an operator for kind SINGLETON used to construct singleton sets.
- * It specifies the type of the single element especially when it is a constant.
- * e.g. the type of rational 1 is Int, however
- * (singleton (singleton_op Real) 1) is of type (Set Real), not (Set Int).
- * Note that the type passed to the constructor is the element's type, not the
- * set type.
+ * The class is an operator for kind SET_SINGLETON used to construct singleton
+ * sets. It specifies the type of the single element especially when it is a
+ * constant. e.g. the type of rational 1 is Int, however (singleton
+ * (singleton_op Real) 1) is of type (Set Real), not (Set Int). Note that the
+ * type passed to the constructor is the element's type, not the set type.
*/
-class SingletonOp
+class SetSingletonOp
{
public:
- SingletonOp(const TypeNode& elementType);
- SingletonOp(const SingletonOp& op);
+ SetSingletonOp(const TypeNode& elementType);
+ SetSingletonOp(const SetSingletonOp& op);
/** return the type of the current object */
const TypeNode& getType() const;
- bool operator==(const SingletonOp& op) const;
+ bool operator==(const SetSingletonOp& op) const;
private:
- SingletonOp();
+ SetSingletonOp();
/** a pointer to the type of the singleton element */
std::unique_ptr<TypeNode> d_type;
-}; /* class Singleton */
+}; /* class SetSingletonOp */
-std::ostream& operator<<(std::ostream& out, const SingletonOp& op);
+std::ostream& operator<<(std::ostream& out, const SetSingletonOp& op);
/**
* Hash function for the SingletonHashFunction objects.
*/
-struct SingletonOpHashFunction
+struct SetSingletonOpHashFunction
{
- size_t operator()(const SingletonOp& op) const;
-}; /* struct SingletonOpHashFunction */
+ size_t operator()(const SetSingletonOp& op) const;
+}; /* struct SetSingletonOpHashFunction */
} // namespace cvc5
void SolverState::registerTerm(Node r, TypeNode tnn, Node n)
{
Kind nk = n.getKind();
- if (nk == MEMBER)
+ if (nk == SET_MEMBER)
{
if (r.isConst())
{
if (d_members_index[s].find(x) == d_members_index[s].end())
{
d_members_index[s][x] = n;
- d_op_list[MEMBER].push_back(n);
+ d_op_list[SET_MEMBER].push_back(n);
}
}
else
}
}
}
- else if (nk == SINGLETON || nk == UNION || nk == INTERSECTION
- || nk == SETMINUS || nk == EMPTYSET || nk == UNIVERSE_SET)
+ else if (nk == SET_SINGLETON || nk == SET_UNION || nk == SET_INTERSECTION
+ || nk == SET_MINUS || nk == SET_EMPTY || nk == SET_UNIVERSE)
{
- if (nk == SINGLETON)
+ if (nk == SET_SINGLETON)
{
Node re = d_ee->getRepresentative(n[0]);
if (d_singleton_index.find(re) == d_singleton_index.end())
{
d_singleton_index[re] = n;
d_eqc_singleton[r] = n;
- d_op_list[SINGLETON].push_back(n);
+ d_op_list[SET_SINGLETON].push_back(n);
}
else
{
d_congruent[n] = d_singleton_index[re];
}
}
- else if (nk == EMPTYSET)
+ else if (nk == SET_EMPTY)
{
d_eqc_emptyset[tnn] = r;
}
- else if (nk == UNIVERSE_SET)
+ else if (nk == SET_UNIVERSE)
{
Assert(options().sets.setsExt);
d_eqc_univset[tnn] = r;
d_nvar_sets[r].push_back(n);
Trace("sets-debug2") << "Non-var-set[" << r << "] : " << n << std::endl;
}
- else if (nk == COMPREHENSION)
+ else if (nk == SET_COMPREHENSION)
{
d_compSets[r].push_back(n);
d_allCompSets.push_back(n);
}
return areDisequal(n[0], n[1]);
}
- else if (n.getKind() == MEMBER)
+ else if (n.getKind() == SET_MEMBER)
{
if (areEqual(n, polarity ? d_true : d_false))
{
for (size_t i = 0, nmem2 = (*mem_i2).second; i < nmem2; i++)
{
Assert(i < d_members_data[t2].size()
- && d_members_data[t2][i].getKind() == MEMBER);
+ && d_members_data[t2][i].getKind() == SET_MEMBER);
Node m2 = d_members_data[t2][i];
// check if redundant
bool add = true;
for (size_t j = 0; j < n_members; j++)
{
Assert(j < d_members_data[t1].size()
- && d_members_data[t1][j].getKind() == MEMBER);
+ && d_members_data[t1][j].getKind() == SET_MEMBER);
if (areEqual(m2[0], d_members_data[t1][j][0]))
{
add = false;
NodeManager* nm = NodeManager::currentNM();
Assert(areEqual(m2[1], cset));
Node exp = nm->mkNode(AND, m2[1].eqNode(cset), m2);
- if (cset.getKind() == SINGLETON)
+ if (cset.getKind() == SET_SINGLETON)
{
if (cset[0] != m2[0])
{
bool hasMembers(Node r) const;
/** Get binary operator index
*
- * This returns a mapping from binary operator kinds (INTERSECT, SETMINUS,
- * UNION) to index of terms of that kind. Each kind k maps to a map whose
+ * This returns a mapping from binary operator kinds (INTERSECT, SET_MINUS,
+ * SET_UNION) to index of terms of that kind. Each kind k maps to a map whose
* entries are of the form [r1 -> r2 -> t], where t is a term in the current
* context, and t is of the form <k>(t1,t2) where t1=r1 and t2=r2 hold in the
* current context. The term t is the representative of its congruence class.
*/
std::map<Node, std::map<Node, Node> > d_pol_mems[2];
// -------------------------------- term indices
- /** Term index for MEMBER
+ /** Term index for SET_MEMBER
*
* A term index maps equivalence class representatives to the representative
* of their congruence class.
* class, and r1=t1 and r2=t2 hold in the current context.
*/
std::map<Node, std::map<Node, Node> > d_members_index;
- /** Term index for SINGLETON */
+ /** Term index for SET_SINGLETON */
std::map<Node, Node> d_singleton_index;
- /** Indices for the binary kinds INTERSECT, SETMINUS and UNION. */
+ /** Indices for the binary kinds INTERSECT, SET_MINUS and SET_UNION. */
std::map<Kind, std::map<Node, std::map<Node, Node> > > d_bop_index;
/** A list of comprehension sets */
std::vector<Node> d_allCompSets;
Node TermRegistry::getProxy(Node n)
{
Kind nk = n.getKind();
- if (nk != EMPTYSET && nk != SINGLETON && nk != INTERSECTION && nk != SETMINUS
- && nk != UNION && nk != UNIVERSE_SET)
+ if (nk != SET_EMPTY && nk != SET_SINGLETON && nk != SET_INTERSECTION
+ && nk != SET_MINUS && nk != SET_UNION && nk != SET_UNIVERSE)
{
return n;
}
d_proxy_to_term[k] = n;
Node eq = k.eqNode(n);
sendSimpleLemmaInternal(eq, InferenceId::SETS_PROXY);
- if (nk == SINGLETON)
+ if (nk == SET_SINGLETON)
{
- Node slem = nm->mkNode(MEMBER, n[0], k);
+ Node slem = nm->mkNode(SET_MEMBER, n[0], k);
sendSimpleLemmaInternal(slem, InferenceId::SETS_PROXY_SINGLETON);
}
return k;
return it->second;
}
NodeManager* nm = NodeManager::currentNM();
- Node n = nm->mkNullaryOperator(tn, UNIVERSE_SET);
+ Node n = nm->mkNullaryOperator(tn, SET_UNIVERSE);
for (it = d_univset.begin(); it != d_univset.end(); ++it)
{
Node n1;
}
if (!n1.isNull())
{
- Node ulem = nm->mkNode(SUBSET, n1, n2);
+ Node ulem = nm->mkNode(SET_SUBSET, n1, n2);
Trace("sets-lemma") << "Sets::Lemma : " << ulem << " by univ-type"
<< std::endl;
d_im.lemma(ulem, InferenceId::SETS_UNIV_TYPE);
{
Assert(d_equalityEngine != nullptr);
- d_valuation.setUnevaluatedKind(COMPREHENSION);
+ d_valuation.setUnevaluatedKind(SET_COMPREHENSION);
// choice is used to eliminate witness
d_valuation.setUnevaluatedKind(WITNESS);
// Universe set is not evaluated. This is moreover important for ensuring that
// we do not eliminate terms whose value involves the universe set.
- d_valuation.setUnevaluatedKind(UNIVERSE_SET);
+ d_valuation.setUnevaluatedKind(SET_UNIVERSE);
// functions we are doing congruence over
- d_equalityEngine->addFunctionKind(SINGLETON);
- d_equalityEngine->addFunctionKind(UNION);
- d_equalityEngine->addFunctionKind(INTERSECTION);
- d_equalityEngine->addFunctionKind(SETMINUS);
- d_equalityEngine->addFunctionKind(MEMBER);
- d_equalityEngine->addFunctionKind(SUBSET);
+ d_equalityEngine->addFunctionKind(SET_SINGLETON);
+ d_equalityEngine->addFunctionKind(SET_UNION);
+ d_equalityEngine->addFunctionKind(SET_INTERSECTION);
+ d_equalityEngine->addFunctionKind(SET_MINUS);
+ d_equalityEngine->addFunctionKind(SET_MEMBER);
+ d_equalityEngine->addFunctionKind(SET_SUBSET);
// relation operators
- d_equalityEngine->addFunctionKind(PRODUCT);
- d_equalityEngine->addFunctionKind(JOIN);
- d_equalityEngine->addFunctionKind(TRANSPOSE);
- d_equalityEngine->addFunctionKind(TCLOSURE);
- d_equalityEngine->addFunctionKind(JOIN_IMAGE);
- d_equalityEngine->addFunctionKind(IDEN);
+ d_equalityEngine->addFunctionKind(RELATION_PRODUCT);
+ d_equalityEngine->addFunctionKind(RELATION_JOIN);
+ d_equalityEngine->addFunctionKind(RELATION_TRANSPOSE);
+ d_equalityEngine->addFunctionKind(RELATION_TCLOSURE);
+ d_equalityEngine->addFunctionKind(RELATION_JOIN_IMAGE);
+ d_equalityEngine->addFunctionKind(RELATION_IDEN);
d_equalityEngine->addFunctionKind(APPLY_CONSTRUCTOR);
// we do congruence over cardinality
- d_equalityEngine->addFunctionKind(CARD);
+ d_equalityEngine->addFunctionKind(SET_CARD);
// finish initialization internally
d_internal->finishInit();
TrustNode TheorySets::ppRewrite(TNode n, std::vector<SkolemLemma>& lems)
{
Kind nk = n.getKind();
- if (nk == UNIVERSE_SET || nk == COMPLEMENT || nk == JOIN_IMAGE
- || nk == COMPREHENSION)
+ if (nk == SET_UNIVERSE || nk == SET_COMPLEMENT || nk == RELATION_JOIN_IMAGE
+ || nk == SET_COMPREHENSION)
{
if (!options().sets.setsExt)
{
throw LogicException(ss.str());
}
}
- if (nk == COMPREHENSION)
+ if (nk == SET_COMPREHENSION)
{
// set comprehension is an implicit quantifier, require it in the logic
if (!logicInfo().isQuantified())
void TheorySetsPrivate::eqNotifyNewClass(TNode t)
{
- if (t.getKind() == kind::SINGLETON || t.getKind() == kind::EMPTYSET)
+ if (t.getKind() == kind::SET_SINGLETON || t.getKind() == kind::SET_EMPTY)
{
EqcInfo* e = getOrMakeEqcInfo(t, true);
e->d_singleton = t;
// register it with the state
d_state.registerTerm(eqc, tnn, n);
Kind nk = n.getKind();
- if (nk == kind::SINGLETON)
+ if (nk == kind::SET_SINGLETON)
{
// ensure the proxy has been introduced
d_treg.getProxy(n);
}
- else if (nk == kind::CARD)
+ else if (nk == kind::SET_CARD)
{
d_card_enabled = true;
// register it with the cardinality solver
if (!options().sets.setsProxyLemmas)
{
Node nmem = NodeManager::currentNM()->mkNode(
- kind::MEMBER, mem[0], eq_set);
+ kind::SET_MEMBER, mem[0], eq_set);
nmem = rewrite(nmem);
std::vector<Node> exp;
exp.push_back(mem);
{
// use proxy set
Node k = d_treg.getProxy(eq_set);
- Node pmem =
- NodeManager::currentNM()->mkNode(kind::MEMBER, mem[0], k);
+ Node pmem = NodeManager::currentNM()->mkNode(
+ kind::SET_MEMBER, mem[0], k);
Node nmem = NodeManager::currentNM()->mkNode(
- kind::MEMBER, mem[0], eq_set);
+ kind::SET_MEMBER, mem[0], eq_set);
nmem = rewrite(nmem);
std::vector<Node> exp;
if (d_state.areEqual(mem, pmem))
Node r1 = it.first;
// see if there are members in first argument r1
const std::map<Node, Node>& r1mem = d_state.getMembers(r1);
- if (!r1mem.empty() || k == kind::UNION)
+ if (!r1mem.empty() || k == kind::SET_UNION)
{
for (const std::pair<const Node, Node>& it2 : it.second)
{
// see if there are members in second argument
const std::map<Node, Node>& r2mem = d_state.getMembers(r2);
const std::map<Node, Node>& r2nmem = d_state.getNegativeMembers(r2);
- if (!r2mem.empty() || k != kind::INTERSECTION)
+ if (!r2mem.empty() || k != kind::SET_INTERSECTION)
{
Trace("sets-debug")
<< "Checking " << term << ", members = " << (!r1mem.empty())
d_state.addEqualityToExp(term[0], itm1m.second[1], exp);
bool valid = false;
int inferType = 0;
- if (k == kind::UNION)
+ if (k == kind::SET_UNION)
{
valid = true;
}
- else if (k == kind::INTERSECTION)
+ else if (k == kind::SET_INTERSECTION)
{
// conclude x is in term
// if also existing in members of r2
// unknown, split
if (r2nmem.find(xr) == r2nmem.end())
{
- exp.push_back(nm->mkNode(kind::MEMBER, x, term[1]));
+ exp.push_back(nm->mkNode(kind::SET_MEMBER, x, term[1]));
valid = true;
inferType = 1;
}
}
else
{
- Assert(k == kind::SETMINUS);
+ Assert(k == kind::SET_MINUS);
std::map<Node, Node>::const_iterator itm = r2mem.find(xr);
if (itm == r2mem.end())
{
// must add lemma for set minus since non-membership in this
// case is not explained
exp.push_back(
- nm->mkNode(kind::MEMBER, x, term[1]).negate());
+ nm->mkNode(kind::SET_MEMBER, x, term[1]).negate());
valid = true;
inferType = 1;
}
if (!d_state.isMember(x, rr))
{
Node kk = d_treg.getProxy(term);
- Node fact = nm->mkNode(kind::MEMBER, x, kk);
+ Node fact = nm->mkNode(kind::SET_MEMBER, x, kk);
d_im.assertInference(
fact, InferenceId::SETS_UP_CLOSURE, exp, inferType);
if (d_state.isInConflict())
<< itm1m.second << std::endl;
}
}
- if (k == kind::UNION)
+ if (k == kind::SET_UNION)
{
if (!r2mem.empty())
{
exp.push_back(itm2m.second);
d_state.addEqualityToExp(term[1], itm2m.second[1], exp);
Node r = d_treg.getProxy(term);
- Node fact = nm->mkNode(kind::MEMBER, x, r);
+ Node fact = nm->mkNode(kind::SET_MEMBER, x, r);
d_im.assertInference(fact, InferenceId::SETS_UP_CLOSURE_2, exp);
if (d_state.isInConflict())
{
}
if (!u.isNull())
{
- Assert(it2.second.getKind() == kind::MEMBER);
+ Assert(it2.second.getKind() == kind::SET_MEMBER);
std::vector<Node> exp;
exp.push_back(it2.second);
if (v != it2.second[1])
{
exp.push_back(v.eqNode(it2.second[1]));
}
- Node fact = nm->mkNode(kind::MEMBER, it2.second[0], u);
+ Node fact = nm->mkNode(kind::SET_MEMBER, it2.second[0], u);
d_im.assertInference(fact, InferenceId::SETS_UP_UNIV, exp);
if (d_state.isInConflict())
{
TypeNode elementType = deq[0].getType().getSetElementType();
Node x = d_skCache.mkTypedSkolemCached(
elementType, deq[0], deq[1], SkolemCache::SK_DISEQUAL, "sde");
- Node mem1 = nm->mkNode(MEMBER, x, deq[0]);
- Node mem2 = nm->mkNode(MEMBER, x, deq[1]);
+ Node mem1 = nm->mkNode(SET_MEMBER, x, deq[0]);
+ Node mem2 = nm->mkNode(SET_MEMBER, x, deq[1]);
Node lem = nm->mkNode(OR, deq, nm->mkNode(EQUAL, mem1, mem2).negate());
lem = rewrite(lem);
d_im.assertInference(lem, InferenceId::SETS_DEQ, d_true, 1);
body = body.substitute(vars.begin(), vars.end(), subs.begin(), subs.end());
Node bvl = nm->mkNode(BOUND_VAR_LIST, subs);
body = nm->mkNode(EXISTS, bvl, body);
- Node mem = nm->mkNode(MEMBER, v, n);
+ Node mem = nm->mkNode(SET_MEMBER, v, n);
Node lem =
nm->mkNode(FORALL, nm->mkNode(BOUND_VAR_LIST, v), body.eqNode(mem));
Trace("sets-comprehension")
{
return;
}
- if (atom.getKind() == kind::MEMBER && polarity)
+ if (atom.getKind() == kind::SET_MEMBER && polarity)
{
// check if set has a value, if so, we can propagate
Node r = d_equalityEngine->getRepresentative(atom[1]);
{
Node pexp = NodeManager::currentNM()->mkNode(
kind::AND, atom, atom[1].eqNode(s));
- if (s.getKind() == kind::SINGLETON)
+ if (s.getKind() == kind::SET_SINGLETON)
{
if (s[0] != atom[0])
{
// not for the shared variables x, y in the care graph.
// However, this does not apply to the membership operator since the
// equality or disequality between members affects the number of elements
- // in a set. Therefore we need to split on (= x y) for kind MEMBER.
+ // in a set. Therefore we need to split on (= x y) for kind SET_MEMBER.
// Example:
// Suppose (= (member x S) member( y, S)) is true and there are
// no other members in S. We would get S = {x} if (= x y) is true.
// Otherwise we would get S = {x, y}.
- if (f1.getKind() == MEMBER || !d_state.areEqual(f1, f2))
+ if (f1.getKind() == SET_MEMBER || !d_state.areEqual(f1, f2))
{
Trace("sets-cg") << "Check " << f1 << " and " << f2 << std::endl;
vector<pair<TNode, TNode> > currentPairs;
for (const std::pair<const Kind, std::vector<Node> >& it : ol)
{
Kind k = it.first;
- if (k == kind::SINGLETON || k == kind::MEMBER)
+ if (k == kind::SET_SINGLETON || k == kind::SET_MEMBER)
{
unsigned n_pairs = 0;
Trace("sets-cg-summary") << "Compute graph for sets, op=" << k << "..."
// break into index based on operator, and the type of the element
// type of the proper set, which notice must be safe wrt subtyping.
TypeNode tn;
- if (k == kind::SINGLETON)
+ if (k == kind::SET_SINGLETON)
{
// get the type of the singleton set (not the type of its element)
tn = f1.getType().getSetElementType();
}
else
{
- Assert (k == kind::MEMBER);
+ Assert(k == kind::SET_MEMBER);
// get the element type of the set (not the type of the element)
tn = f1[1].getType().getSetElementType();
}
{
return true;
}
- else if ((n.getKind() == kind::MEMBER || n.getKind() == kind::SINGLETON)
+ else if ((n.getKind() == kind::SET_MEMBER
+ || n.getKind() == kind::SET_SINGLETON)
&& a == 0 && n[0].getType().isSet())
{
return true;
void traceSetElementsRecursively(stringstream& stream, const Node& set)
{
Assert(set.getType().isSet());
- if (set.getKind() == SINGLETON)
+ if (set.getKind() == SET_SINGLETON)
{
stream << set[0] << ", ";
}
- if (set.getKind() == UNION)
+ if (set.getKind() == SET_UNION)
{
traceSetElementsRecursively(stream, set[0]);
traceSetElementsRecursively(stream, set[1]);
d_cardSolver->mkModelValueElementsFor(val, eqc, els, mvals, m);
}
- Node rep = NormalForm::mkBop(kind::UNION, els, eqc.getType());
+ Node rep = NormalForm::mkBop(kind::SET_UNION, els, eqc.getType());
rep = rewrite(rep);
Trace("sets-model") << "* Assign representative of " << eqc << " to "
<< rep << std::endl;
{
d_equalityEngine->explainEquality(atom[0], atom[1], polarity, assumptions);
}
- else if (atom.getKind() == kind::MEMBER)
+ else if (atom.getKind() == kind::SET_MEMBER)
{
d_equalityEngine->explainPredicate(atom, polarity, assumptions);
}
switch (node.getKind())
{
case kind::EQUAL:
- case kind::MEMBER:
+ case kind::SET_MEMBER:
{
// add trigger predicate for equality and membership
d_equalityEngine->addTriggerPredicate(node);
}
break;
- case kind::JOIN_IMAGE:
+ case kind::RELATION_JOIN_IMAGE:
{
// these are logic exceptions, not type checking exceptions
if (node[1].getKind() != kind::CONST_RATIONAL)
switch (node.getKind())
{
- case kind::CHOOSE: return expandChooseOperator(node, lems);
- case kind::IS_SINGLETON: return expandIsSingletonOperator(node);
+ case kind::SET_CHOOSE: return expandChooseOperator(node, lems);
+ case kind::SET_IS_SINGLETON: return expandIsSingletonOperator(node);
default: return TrustNode::null();
}
}
TrustNode TheorySetsPrivate::expandChooseOperator(
const Node& node, std::vector<SkolemLemma>& lems)
{
- Assert(node.getKind() == CHOOSE);
+ Assert(node.getKind() == SET_CHOOSE);
// (choose A) is expanded as
// (witness ((x elementType))
Node equal = witnessVariable.eqNode(apply);
Node emptySet = nm->mkConst(EmptySet(setType));
Node isEmpty = set.eqNode(emptySet);
- Node member = nm->mkNode(MEMBER, witnessVariable, set);
+ Node member = nm->mkNode(SET_MEMBER, witnessVariable, set);
Node memberAndEqual = member.andNode(equal);
Node ite = nm->mkNode(ITE, isEmpty, equal, memberAndEqual);
SkolemManager* sm = nm->getSkolemManager();
TrustNode TheorySetsPrivate::expandIsSingletonOperator(const Node& node)
{
- Assert(node.getKind() == IS_SINGLETON);
+ Assert(node.getKind() == SET_IS_SINGLETON);
// we call the rewriter here to handle the pattern
// (is_singleton (singleton x)) because the rewriter is called after expansion
Node rewritten = rewrite(node);
- if (rewritten.getKind() != IS_SINGLETON)
+ if (rewritten.getKind() != SET_IS_SINGLETON)
{
return TrustNode::mkTrustRewrite(node, rewritten, nullptr);
}
void fullEffortReset();
/**
* This implements an inference schema based on the "downwards closure" of
- * set membership. This roughly corresponds to the rules UNION DOWN I and II,
- * INTER DOWN I and II from Bansal et al IJCAR 2016, as well as rules for set
- * difference.
+ * set membership. This roughly corresponds to the rules SET_UNION DOWN I and
+ * II, INTER DOWN I and II from Bansal et al IJCAR 2016, as well as rules for
+ * set difference.
*/
void checkDownwardsClosure();
/**
* This implements an inference schema based on the "upwards closure" of
- * set membership. This roughly corresponds to the rules UNION UP, INTER
+ * set membership. This roughly corresponds to the rules SET_UNION UP, INTER
* UP I and II from Bansal et al IJCAR 2016, as well as rules for set
* difference.
*/
std::map<kind::Kind_t, std::vector<Node> >& kind_terms =
d_terms_cache[rel_rep];
- if( kind_terms.find(kind::TRANSPOSE) != kind_terms.end() ) {
- std::vector<Node>& tp_terms = kind_terms[TRANSPOSE];
+ if (kind_terms.find(kind::RELATION_TRANSPOSE) != kind_terms.end())
+ {
+ std::vector<Node>& tp_terms = kind_terms[RELATION_TRANSPOSE];
if( tp_terms.size() > 0 ) {
applyTransposeRule( tp_terms );
applyTransposeRule( tp_terms[0], rel_rep, exp );
}
}
- if( kind_terms.find(kind::JOIN) != kind_terms.end() ) {
- std::vector<Node>& join_terms = kind_terms[JOIN];
+ if (kind_terms.find(kind::RELATION_JOIN) != kind_terms.end())
+ {
+ std::vector<Node>& join_terms = kind_terms[RELATION_JOIN];
for( unsigned int j = 0; j < join_terms.size(); j++ ) {
applyJoinRule( join_terms[j], rel_rep, exp );
}
}
- if( kind_terms.find(kind::PRODUCT) != kind_terms.end() ) {
- std::vector<Node>& product_terms = kind_terms[PRODUCT];
+ if (kind_terms.find(kind::RELATION_PRODUCT) != kind_terms.end())
+ {
+ std::vector<Node>& product_terms = kind_terms[RELATION_PRODUCT];
for( unsigned int j = 0; j < product_terms.size(); j++ ) {
applyProductRule( product_terms[j], rel_rep, exp );
}
}
- if( kind_terms.find(kind::TCLOSURE) != kind_terms.end() ) {
- std::vector<Node>& tc_terms = kind_terms[TCLOSURE];
+ if (kind_terms.find(kind::RELATION_TCLOSURE) != kind_terms.end())
+ {
+ std::vector<Node>& tc_terms = kind_terms[RELATION_TCLOSURE];
for( unsigned int j = 0; j < tc_terms.size(); j++ ) {
applyTCRule( mem, tc_terms[j], rel_rep, exp );
}
}
- if( kind_terms.find(kind::JOIN_IMAGE) != kind_terms.end() ) {
- std::vector<Node>& join_image_terms = kind_terms[JOIN_IMAGE];
+ if (kind_terms.find(kind::RELATION_JOIN_IMAGE) != kind_terms.end())
+ {
+ std::vector<Node>& join_image_terms = kind_terms[RELATION_JOIN_IMAGE];
for( unsigned int j = 0; j < join_image_terms.size(); j++ ) {
applyJoinImageRule( mem, join_image_terms[j], exp );
}
}
- if( kind_terms.find(kind::IDEN) != kind_terms.end() ) {
- std::vector<Node>& iden_terms = kind_terms[IDEN];
+ if (kind_terms.find(kind::RELATION_IDEN) != kind_terms.end())
+ {
+ std::vector<Node>& iden_terms = kind_terms[RELATION_IDEN];
for( unsigned int j = 0; j < iden_terms.size(); j++ ) {
applyIdenRule( mem, iden_terms[j], exp );
}
Trace("rels-debug") << "[sets-rels] Check " << k_t_it->second.size()
<< " terms of kind " << k_t_it->first << std::endl;
std::vector<Node>::iterator term_it = k_t_it->second.begin();
- if (k_t_it->first == kind::JOIN || k_t_it->first == kind::PRODUCT)
+ if (k_t_it->first == kind::RELATION_JOIN
+ || k_t_it->first == kind::RELATION_PRODUCT)
{
while (term_it != k_t_it->second.end())
{
++term_it;
}
}
- else if (k_t_it->first == kind::TRANSPOSE)
+ else if (k_t_it->first == kind::RELATION_TRANSPOSE)
{
while (term_it != k_t_it->second.end())
{
++term_it;
}
}
- else if (k_t_it->first == kind::TCLOSURE)
+ else if (k_t_it->first == kind::RELATION_TCLOSURE)
{
while (term_it != k_t_it->second.end())
{
++term_it;
}
}
- else if (k_t_it->first == kind::JOIN_IMAGE)
+ else if (k_t_it->first == kind::RELATION_JOIN_IMAGE)
{
while (term_it != k_t_it->second.end())
{
++term_it;
}
}
- else if (k_t_it->first == kind::IDEN)
+ else if (k_t_it->first == kind::RELATION_IDEN)
{
while (term_it != k_t_it->second.end())
{
if (erType.isBoolean() && eqc_rep.isConst())
{
// collect membership info
- if( eqc_node.getKind() == kind::MEMBER && eqc_node[1].getType().getSetElementType().isTuple()) {
+ if (eqc_node.getKind() == kind::SET_MEMBER
+ && eqc_node[1].getType().getSetElementType().isTuple())
+ {
Node tup_rep = getRepresentative( eqc_node[0] );
Node rel_rep = getRepresentative( eqc_node[1] );
}
else if (erType.isSet() && erType.getSetElementType().isTuple())
{
- if( eqc_node.getKind() == kind::TRANSPOSE || eqc_node.getKind() == kind::JOIN ||
- eqc_node.getKind() == kind::PRODUCT || eqc_node.getKind() == kind::TCLOSURE ||
- eqc_node.getKind() == kind::JOIN_IMAGE || eqc_node.getKind() == kind::IDEN ) {
+ if (eqc_node.getKind() == kind::RELATION_TRANSPOSE
+ || eqc_node.getKind() == kind::RELATION_JOIN
+ || eqc_node.getKind() == kind::RELATION_PRODUCT
+ || eqc_node.getKind() == kind::RELATION_TCLOSURE
+ || eqc_node.getKind() == kind::RELATION_JOIN_IMAGE
+ || eqc_node.getKind() == kind::RELATION_IDEN)
+ {
d_terms_cache[eqc_rep][eqc_node.getKind()].push_back(eqc_node);
}
// need to add all tuple elements as shared terms
Trace("rels-debug") << "[Theory::Rels] Done with collecting relational terms!" << std::endl;
}
- /* JOIN-IMAGE UP : (x, x1) IS_IN R, ..., (x, xn) IS_IN R (R JOIN_IMAGE n)
- * -------------------------------------------------------
- * x IS_IN (R JOIN_IMAGE n) || NOT DISTINCT(x1, ... , xn)
- *
- */
+ /* RELATION_JOIN-IMAGE UP:
+ * (x, x1) IS_IN R, ..., (x, xn) IS_IN R (R RELATION_JOIN_IMAGE n)
+ * ----------------------------------------------------------------
+ * x IS_IN (R RELATION_JOIN_IMAGE n) || NOT DISTINCT(x1, ... , xn)
+ */
void TheorySetsRels::computeMembersForJoinImageTerm( Node join_image_term ) {
Trace("rels-debug") << "\n[Theory::Rels] *********** Compute members for JoinImage Term = " << join_image_term << std::endl;
const DType& dt =
join_image_term.getType().getSetElementType().getDType();
Node new_membership = nm->mkNode(
- MEMBER,
+ SET_MEMBER,
nm->mkNode(APPLY_CONSTRUCTOR, dt[0].getConstructor(), fst_mem_rep),
join_image_term);
if (d_state.isEntailed(new_membership, true))
Trace("rels-debug") << "\n[Theory::Rels] *********** Done with computing members for JoinImage Term" << join_image_term << "*********** " << std::endl;
}
- /* JOIN-IMAGE DOWN : (x) IS_IN (R JOIN_IMAGE n)
- * -------------------------------------------------------
- * (x, x1) IS_IN R .... (x, xn) IS_IN R DISTINCT(x1, ...
- * , xn)
+ /* RELATION_JOIN-IMAGE DOWN:
+ * (x) IS_IN (R RELATION_JOIN_IMAGE n)
+ * ------------------------------------------------------------
+ * (x, x1) IS_IN R .... (x, xn) IS_IN R DISTINCT(x1, ... , xn)
*
*/
void TheorySetsRels::applyJoinImageRule( Node mem_rep, Node join_image_term, Node exp ) {
AND,
conclusion,
nm->mkNode(
- MEMBER,
+ SET_MEMBER,
RelsUtils::constructPair(join_image_rel, fst_mem_element, skolem),
join_image_rel));
}
Trace("rels-debug") << "\n[Theory::Rels] *********** Done with applyJoinImageRule ***********" << std::endl;
}
- /* IDENTITY-DOWN : (x, y) IS_IN IDEN(R)
- * -------------------------------------------------------
- * x = y, (x IS_IN R)
- *
- */
+ /* IDENTITY-DOWN : (x, y) IS_IN RELATION_IDEN(R)
+ * -------------------------------------------------------
+ * x = y, (x IS_IN R)
+ *
+ */
void TheorySetsRels::applyIdenRule( Node mem_rep, Node iden_term, Node exp) {
Trace("rels-debug") << "\n[Theory::Rels] *********** applyIdenRule on " << iden_term
Node snd_mem = RelsUtils::nthElementOfTuple( exp[0], 1 );
const DType& dt = iden_term[0].getType().getSetElementType().getDType();
Node fact = nm->mkNode(
- MEMBER,
+ SET_MEMBER,
nm->mkNode(APPLY_CONSTRUCTOR, dt[0].getConstructor(), fst_mem),
iden_term[0]);
Trace("rels-debug") << "\n[Theory::Rels] *********** Done with applyIdenRule on " << iden_term << std::endl;
}
- /* IDEN UP : (x) IS_IN R IDEN(R) IN T
- * --------------------------------
- * (x, x) IS_IN IDEN(R)
- *
- */
+ /* RELATION_IDEN UP : (x) IS_IN R RELATION_IDEN(R) IN T
+ * --------------------------------
+ * (x, x) IS_IN RELATION_IDEN(R)
+ *
+ */
void TheorySetsRels::computeMembersForIdenTerm( Node iden_term ) {
Trace("rels-debug") << "\n[Theory::Rels] *********** Compute members for Iden Term = " << iden_term << std::endl;
if( (*mem_rep_exp_it)[1] != iden_term_rel ) {
reason = NodeManager::currentNM()->mkNode( kind::AND, reason, NodeManager::currentNM()->mkNode( kind::EQUAL, (*mem_rep_exp_it)[1], iden_term_rel ) );
}
- sendInfer(
- nm->mkNode(MEMBER, new_mem, iden_term), InferenceId::SETS_RELS_IDENTITY_UP, reason);
+ sendInfer(nm->mkNode(SET_MEMBER, new_mem, iden_term),
+ InferenceId::SETS_RELS_IDENTITY_UP,
+ reason);
++mem_rep_exp_it;
}
Trace("rels-debug") << "\n[Theory::Rels] *********** Done with computing members for Iden Term = " << iden_term << std::endl;
*/
/*
- * TCLOSURE TCLOSURE(x) = x | x.x | x.x.x | ... (| is union)
+ * RELATION_TCLOSURE RELATION_TCLOSURE(x) = x | x.x | x.x.x | ... (| is union)
*
- * TCLOSURE-UP I: (a, b) IS_IN x TCLOSURE(x) in T
+ * RELATION_TCLOSURE-UP I: (a, b) IS_IN x RELATION_TCLOSURE(x) in
+ * T
* ---------------------------------------------
- * (a, b) IS_IN TCLOSURE(x)
+ * (a, b) IS_IN RELATION_TCLOSURE(x)
*
*
*
- * TCLOSURE-UP II : (a, b) IS_IN TCLOSURE(x) (b, c) IS_IN TCLOSURE(x)
+ * RELATION_TCLOSURE-UP II : (a, b) IS_IN RELATION_TCLOSURE(x) (b, c) IS_IN
+ * RELATION_TCLOSURE(x)
* -----------------------------------------------------------
- * (a, c) IS_IN TCLOSURE(x)
+ * (a, c) IS_IN RELATION_TCLOSURE(x)
*
*/
void TheorySetsRels::applyTCRule( Node mem_rep, Node tc_rel, Node tc_rel_rep, Node exp ) {
- Trace("rels-debug") << "[Theory::Rels] *********** Applying TCLOSURE rule on a tc term = " << tc_rel
- << ", its representative = " << tc_rel_rep
- << " with member rep = " << mem_rep << " and explanation = " << exp << std::endl;
+ Trace("rels-debug") << "[Theory::Rels] *********** Applying "
+ "RELATION_TCLOSURE rule on a tc term = "
+ << tc_rel << ", its representative = " << tc_rel_rep
+ << " with member rep = " << mem_rep
+ << " and explanation = " << exp << std::endl;
MEM_IT mem_it = d_rReps_memberReps_cache.find( tc_rel[0] );
if( mem_it != d_rReps_memberReps_cache.end() && d_rel_nodes.find( tc_rel ) == d_rel_nodes.end()
tc_rel[0],
SkolemCache::SK_TCLOSURE_DOWN2,
"stc2");
- Node mem_of_r = nm->mkNode(MEMBER, exp[0], tc_rel[0]);
+ Node mem_of_r = nm->mkNode(SET_MEMBER, exp[0], tc_rel[0]);
Node sk_eq = nm->mkNode(EQUAL, sk_1, sk_2);
Node reason = exp;
mem_of_r,
nm->mkNode(
AND,
- nm->mkNode(MEMBER,
+ nm->mkNode(SET_MEMBER,
RelsUtils::constructPair(tc_rel, fst_element, sk_1),
tc_rel[0]),
- nm->mkNode(MEMBER,
+ nm->mkNode(SET_MEMBER,
RelsUtils::constructPair(tc_rel, sk_2, snd_element),
tc_rel[0]),
nm->mkNode(OR,
sk_eq,
- nm->mkNode(MEMBER,
+ nm->mkNode(SET_MEMBER,
RelsUtils::constructPair(tc_rel, sk_1, sk_2),
tc_rel))));
all_reasons.push_back( NodeManager::currentNM()->mkNode(kind::EQUAL, tc_rel[0], reasons.back()[1]) );
}
if( all_reasons.size() > 1) {
- sendInfer(nm->mkNode(MEMBER, tc_mem, tc_rel),
+ sendInfer(nm->mkNode(SET_MEMBER, tc_mem, tc_rel),
InferenceId::SETS_RELS_TCLOSURE_FWD,
nm->mkNode(AND, all_reasons));
} else {
- sendInfer(nm->mkNode(MEMBER, tc_mem, tc_rel),
+ sendInfer(nm->mkNode(SET_MEMBER, tc_mem, tc_rel),
InferenceId::SETS_RELS_TCLOSURE_FWD,
all_reasons.front());
}
}
}
- /* product-split rule: (a, b) IS_IN (X PRODUCT Y)
- * ----------------------------------
- * a IS_IN X && b IS_IN Y
- *
- * product-compose rule: (a, b) IS_IN X (c, d) IS_IN Y
- * ---------------------------------
- * (a, b, c, d) IS_IN (X PRODUCT Y)
- */
-
+ /* product-split rule: (a, b) IS_IN (X RELATION_PRODUCT Y)
+ * ----------------------------------
+ * a IS_IN X && b IS_IN Y
+ *
+ * product-compose rule: (a, b) IS_IN X (c, d) IS_IN Y
+ * ---------------------------------
+ * (a, b, c, d) IS_IN (X RELATION_PRODUCT Y)
+ */
void TheorySetsRels::applyProductRule( Node pt_rel, Node pt_rel_rep, Node exp ) {
- Trace("rels-debug") << "\n[Theory::Rels] *********** Applying PRODUCT rule on producted term = " << pt_rel
- << ", its representative = " << pt_rel_rep
- << " with explanation = " << exp << std::endl;
+ Trace("rels-debug") << "\n[Theory::Rels] *********** Applying "
+ "RELATION_PRODUCT rule on producted term = "
+ << pt_rel << ", its representative = " << pt_rel_rep
+ << " with explanation = " << exp << std::endl;
if(d_rel_nodes.find( pt_rel ) == d_rel_nodes.end()) {
- Trace("rels-debug") << "\n[Theory::Rels] Apply PRODUCT-COMPOSE rule on term: " << pt_rel
- << " with explanation: " << exp << std::endl;
+ Trace("rels-debug")
+ << "\n[Theory::Rels] Apply RELATION_PRODUCT-COMPOSE rule on term: "
+ << pt_rel << " with explanation: " << exp << std::endl;
computeMembersForBinOpRel( pt_rel );
d_rel_nodes.insert( pt_rel );
Node reason = exp;
Node mem1 = NodeManager::currentNM()->mkNode(kind::APPLY_CONSTRUCTOR, r1_element);
Node mem2 = NodeManager::currentNM()->mkNode(kind::APPLY_CONSTRUCTOR, r2_element);
- Node fact_1 = NodeManager::currentNM()->mkNode(kind::MEMBER, mem1, pt_rel[0]);
- Node fact_2 = NodeManager::currentNM()->mkNode(kind::MEMBER, mem2, pt_rel[1]);
+ Node fact_1 =
+ NodeManager::currentNM()->mkNode(kind::SET_MEMBER, mem1, pt_rel[0]);
+ Node fact_2 =
+ NodeManager::currentNM()->mkNode(kind::SET_MEMBER, mem2, pt_rel[1]);
if( pt_rel != exp[1] ) {
reason = NodeManager::currentNM()->mkNode(kind::AND, exp, NodeManager::currentNM()->mkNode(kind::EQUAL, pt_rel, exp[1]));
sendInfer(fact_2, InferenceId::SETS_RELS_PRODUCT_SPLIT, reason);
}
- /* join-split rule: (a, b) IS_IN (X JOIN Y)
+ /* join-split rule: (a, b) IS_IN (X RELATION_JOIN Y)
* --------------------------------------------
* exists z | (a, z) IS_IN X && (z, b) IS_IN Y
*
*
- * join-compose rule: (a, b) IS_IN X (b, c) IS_IN Y NOT (t, u) IS_IN (X JOIN Y)
+ * join-compose rule: (a, b) IS_IN X (b, c) IS_IN Y NOT (t, u) IS_IN (X
+ * RELATION_JOIN Y)
* -------------------------------------------------------------
- * (a, c) IS_IN (X JOIN Y)
+ * (a, c) IS_IN (X RELATION_JOIN Y)
*/
void TheorySetsRels::applyJoinRule( Node join_rel, Node join_rel_rep, Node exp ) {
- Trace("rels-debug") << "\n[Theory::Rels] *********** Applying JOIN rule on joined term = " << join_rel
- << ", its representative = " << join_rel_rep
- << " with explanation = " << exp << std::endl;
+ Trace("rels-debug") << "\n[Theory::Rels] *********** Applying "
+ "RELATION_JOIN rule on joined term = "
+ << join_rel << ", its representative = " << join_rel_rep
+ << " with explanation = " << exp << std::endl;
if(d_rel_nodes.find( join_rel ) == d_rel_nodes.end()) {
- Trace("rels-debug") << "\n[Theory::Rels] Apply JOIN-COMPOSE rule on term: " << join_rel
- << " with explanation: " << exp << std::endl;
+ Trace("rels-debug")
+ << "\n[Theory::Rels] Apply RELATION_JOIN-COMPOSE rule on term: "
+ << join_rel << " with explanation: " << exp << std::endl;
computeMembersForBinOpRel( join_rel );
d_rel_nodes.insert( join_rel );
if( join_rel != exp[1] ) {
reason = NodeManager::currentNM()->mkNode(kind::AND, reason, NodeManager::currentNM()->mkNode(kind::EQUAL, join_rel, exp[1]));
}
- Node fact = NodeManager::currentNM()->mkNode(kind::MEMBER, mem1, join_rel[0]);
+ Node fact =
+ NodeManager::currentNM()->mkNode(kind::SET_MEMBER, mem1, join_rel[0]);
sendInfer(fact, InferenceId::SETS_RELS_JOIN_SPLIT_1, reason);
- fact = NodeManager::currentNM()->mkNode(kind::MEMBER, mem2, join_rel[1]);
+ fact =
+ NodeManager::currentNM()->mkNode(kind::SET_MEMBER, mem2, join_rel[1]);
sendInfer(fact, InferenceId::SETS_RELS_JOIN_SPLIT_2, reason);
makeSharedTerm(shared_x, shared_type);
}
/*
- * transpose-occur rule: (a, b) IS_IN X (TRANSPOSE X) in T
+ * transpose-occur rule: (a, b) IS_IN X (RELATION_TRANSPOSE X) in T
* ---------------------------------------
- * (b, a) IS_IN (TRANSPOSE X)
+ * (b, a) IS_IN (RELATION_TRANSPOSE X)
*
- * transpose-reverse rule: (a, b) IS_IN (TRANSPOSE X)
+ * transpose-reverse rule: (a, b) IS_IN (RELATION_TRANSPOSE X)
* ---------------------------------------
* (b, a) IS_IN X
*
}
NodeManager* nm = NodeManager::currentNM();
for( unsigned int i = 1; i < tp_terms.size(); i++ ) {
- Trace("rels-debug") << "\n[Theory::Rels] *********** Applying TRANSPOSE-Equal rule on transposed term = " << tp_terms[0] << " and " << tp_terms[i] << std::endl;
+ Trace("rels-debug")
+ << "\n[Theory::Rels] *********** Applying RELATION_TRANSPOSE-Equal "
+ "rule on transposed term = "
+ << tp_terms[0] << " and " << tp_terms[i] << std::endl;
sendInfer(nm->mkNode(EQUAL, tp_terms[0][0], tp_terms[i][0]),
InferenceId::SETS_RELS_TRANSPOSE_EQ,
nm->mkNode(EQUAL, tp_terms[0], tp_terms[i]));
}
void TheorySetsRels::applyTransposeRule( Node tp_rel, Node tp_rel_rep, Node exp ) {
- Trace("rels-debug") << "\n[Theory::Rels] *********** Applying TRANSPOSE rule on transposed term = " << tp_rel
- << ", its representative = " << tp_rel_rep
+ Trace("rels-debug") << "\n[Theory::Rels] *********** Applying "
+ "RELATION_TRANSPOSE rule on transposed term = "
+ << tp_rel << ", its representative = " << tp_rel_rep
<< " with explanation = " << exp << std::endl;
NodeManager* nm = NodeManager::currentNM();
if(d_rel_nodes.find( tp_rel ) == d_rel_nodes.end()) {
- Trace("rels-debug") << "\n[Theory::Rels] Apply TRANSPOSE-Compose rule on term: " << tp_rel
- << " with explanation: " << exp << std::endl;
+ Trace("rels-debug")
+ << "\n[Theory::Rels] Apply RELATION_TRANSPOSE-Compose rule on term: "
+ << tp_rel << " with explanation: " << exp << std::endl;
computeMembersForUnaryOpRel( tp_rel );
d_rel_nodes.insert( tp_rel );
if( tp_rel != exp[1] ) {
reason = NodeManager::currentNM()->mkNode(kind::AND, reason, NodeManager::currentNM()->mkNode(kind::EQUAL, tp_rel, exp[1]));
}
- sendInfer(nm->mkNode(MEMBER, reversed_mem, tp_rel[0]),
+ sendInfer(nm->mkNode(SET_MEMBER, reversed_mem, tp_rel[0]),
InferenceId::SETS_RELS_TRANSPOSE_REV,
reason);
}
Trace("rels-debug") << "\n[Theory::Rels] computeMembersForBinOpRel for relation " << rel << std::endl;
switch(rel[0].getKind()) {
- case kind::TRANSPOSE:
- case kind::TCLOSURE: {
+ case kind::RELATION_TRANSPOSE:
+ case kind::RELATION_TCLOSURE:
+ {
computeMembersForUnaryOpRel(rel[0]);
break;
}
- case kind::JOIN:
- case kind::PRODUCT: {
+ case kind::RELATION_JOIN:
+ case kind::RELATION_PRODUCT:
+ {
computeMembersForBinOpRel(rel[0]);
break;
}
break;
}
switch(rel[1].getKind()) {
- case kind::TRANSPOSE: {
+ case kind::RELATION_TRANSPOSE:
+ {
computeMembersForUnaryOpRel(rel[1]);
break;
}
- case kind::JOIN:
- case kind::PRODUCT: {
+ case kind::RELATION_JOIN:
+ case kind::RELATION_PRODUCT:
+ {
computeMembersForBinOpRel(rel[1]);
break;
}
Trace("rels-debug") << "\n[Theory::Rels] computeMembersForUnaryOpRel for relation " << rel << std::endl;
switch(rel[0].getKind()) {
- case kind::TRANSPOSE:
- case kind::TCLOSURE:
- computeMembersForUnaryOpRel(rel[0]);
- break;
- case kind::JOIN:
- case kind::PRODUCT:
- computeMembersForBinOpRel(rel[0]);
- break;
+ case kind::RELATION_TRANSPOSE:
+ case kind::RELATION_TCLOSURE: computeMembersForUnaryOpRel(rel[0]); break;
+ case kind::RELATION_JOIN:
+ case kind::RELATION_PRODUCT: computeMembersForBinOpRel(rel[0]); break;
default:
break;
}
Assert(members.size() == exps.size());
- if (rel.getKind() == kind::TRANSPOSE)
+ if (rel.getKind() == kind::RELATION_TRANSPOSE)
{
for (size_t i = 0, msize = members.size(); i < msize; i++)
{
reason = nm->mkNode(
kind::AND, reason, nm->mkNode(kind::EQUAL, rel[0], exps[i][1]));
}
- sendInfer(nm->mkNode(MEMBER, RelsUtils::reverseTuple(exps[i][0]), rel),
- InferenceId::SETS_RELS_TRANSPOSE_REV,
- reason);
+ sendInfer(
+ nm->mkNode(SET_MEMBER, RelsUtils::reverseTuple(exps[i][0]), rel),
+ InferenceId::SETS_RELS_TRANSPOSE_REV,
+ reason);
}
}
}
* Explicitly compose the join or product relations of r1 and r2. For example,
* consider the case that (a, b) in r1, (c, d) in r2.
*
- * For JOIN, we have three cases:
+ * For RELATION_JOIN, we have three cases:
* if b = c, we infer (a, d) in (join r1 r2)
* else, we mark b and c as shared terms; their equality will be split in
* theory combination if necessary.
*
- * For PRODUCT, we infer (a, b, c, d) in (product r1 r2).
+ * For RELATION_PRODUCT, we infer (a, b, c, d) in (product r1 r2).
*/
void TheorySetsRels::composeMembersForRels( Node rel ) {
Trace("rels-debug") << "[Theory::Rels] Start composing members for relation = " << rel << std::endl;
std::vector<Node> tuple_elements;
tuple_elements.push_back(tn.getDType()[0].getConstructor());
std::vector<Node> reasons;
- if (rk == kind::JOIN)
+ if (rk == kind::RELATION_JOIN)
{
Node r1_rmost =
RelsUtils::nthElementOfTuple(r1_rep_exps[i][0], r1_tuple_len - 1);
}
}
- if (rk == kind::PRODUCT || rk == kind::JOIN)
+ if (rk == kind::RELATION_PRODUCT || rk == kind::RELATION_JOIN)
{
- bool isProduct = rk == kind::PRODUCT;
+ bool isProduct = rk == kind::RELATION_PRODUCT;
unsigned int k = 0;
unsigned int l = 1;
Node composed_tuple =
nm->mkNode(kind::APPLY_CONSTRUCTOR, tuple_elements);
- Node fact = nm->mkNode(kind::MEMBER, composed_tuple, rel);
+ Node fact = nm->mkNode(kind::SET_MEMBER, composed_tuple, rel);
reasons.push_back( r1_rep_exps[i] );
reasons.push_back( r2_rep_exps[j] );
}
bool TheorySetsRels::isRelationKind( Kind k ) {
- return k == TRANSPOSE || k == PRODUCT || k == JOIN || k == TCLOSURE
- || k == IDEN || k == JOIN_IMAGE;
+ return k == RELATION_TRANSPOSE || k == RELATION_PRODUCT
+ || k == RELATION_JOIN || k == RELATION_TCLOSURE || k == RELATION_IDEN
+ || k == RELATION_JOIN_IMAGE;
}
Node TheorySetsRels::getRepresentative( Node t ) {
}
/*
- * For each tuple n, we store a mapping between n and a list of its elements representatives
- * in d_tuple_reps. This would later be used for applying JOIN operator.
+ * For each tuple n, we store a mapping between n and a list of its elements
+ * representatives in d_tuple_reps. This would later be used for applying
+ * RELATION_JOIN operator.
*/
void TheorySetsRels::computeTupleReps( Node n ) {
if( d_tuple_reps.find( n ) == d_tuple_reps.end() ){
tuple_elements.push_back(element);
}
Node tuple_reduct = NodeManager::currentNM()->mkNode(kind::APPLY_CONSTRUCTOR, tuple_elements);
- tuple_reduct = NodeManager::currentNM()->mkNode(kind::MEMBER,tuple_reduct, n[1]);
+ tuple_reduct = NodeManager::currentNM()->mkNode(
+ kind::SET_MEMBER, tuple_reduct, n[1]);
Node tuple_reduction_lemma = NodeManager::currentNM()->mkNode(kind::EQUAL, n, tuple_reduct);
sendInfer(tuple_reduction_lemma, InferenceId::SETS_RELS_TUPLE_REDUCTION, d_trueNode);
d_symbolic_tuples.insert(n);
* for handling quantifier-free constraints in the theory of relations.
*
* In cvc5, relations are represented as sets of tuples. The theory of
- * relations includes constraints over operators, e.g. TRANSPOSE, JOIN and so
- * on, which apply to sets of tuples.
+ * relations includes constraints over operators, e.g. RELATION_TRANSPOSE,
+ * RELATION_JOIN and so on, which apply to sets of tuples.
*
* Since relations are a special case of sets, this class is implemented as an
* extension of the theory of sets. That is, it shares many components of the
bool TheorySetsRewriter::checkConstantMembership(TNode elementTerm, TNode setTerm)
{
- if(setTerm.getKind() == kind::EMPTYSET) {
+ if (setTerm.getKind() == kind::SET_EMPTY)
+ {
return false;
}
- if(setTerm.getKind() == kind::SINGLETON) {
+ if (setTerm.getKind() == kind::SET_SINGLETON)
+ {
return elementTerm == setTerm[0];
}
- Assert(setTerm.getKind() == kind::UNION
- && setTerm[0].getKind() == kind::SINGLETON)
+ Assert(setTerm.getKind() == kind::SET_UNION
+ && setTerm[0].getKind() == kind::SET_SINGLETON)
<< "kind was " << setTerm.getKind() << ", term: " << setTerm;
return elementTerm == setTerm[0][0]
}
switch(kind) {
-
- case kind::MEMBER: {
- if(node[0].isConst() && node[1].isConst()) {
- // both are constants
- TNode S = preRewrite(node[1]).d_node;
- bool isMember = checkConstantMembership(node[0], S);
- return RewriteResponse(REWRITE_DONE, nm->mkConst(isMember));
- }else if( node[1].getKind()==kind::EMPTYSET ){
- return RewriteResponse(REWRITE_DONE, nm->mkConst(false));
- }else if( node[1].getKind()==kind::SINGLETON ){
- return RewriteResponse(REWRITE_AGAIN_FULL, nm->mkNode(kind::EQUAL, node[0], node[1][0] ) );
- }else if( node[1].getKind()==kind::UNION || node[1].getKind()==kind::INTERSECTION || node[1].getKind()==kind::SETMINUS ){
- std::vector< Node > children;
- for( unsigned i=0; i<node[1].getNumChildren(); i++ ){
- Node nc = nm->mkNode(kind::MEMBER, node[0], node[1][i] );
- if( node[1].getKind()==kind::SETMINUS && i==1 ){
- nc = nc.negate();
+ case kind::SET_MEMBER:
+ {
+ if (node[0].isConst() && node[1].isConst())
+ {
+ // both are constants
+ TNode S = preRewrite(node[1]).d_node;
+ bool isMember = checkConstantMembership(node[0], S);
+ return RewriteResponse(REWRITE_DONE, nm->mkConst(isMember));
+ }
+ else if (node[1].getKind() == kind::SET_EMPTY)
+ {
+ return RewriteResponse(REWRITE_DONE, nm->mkConst(false));
+ }
+ else if (node[1].getKind() == kind::SET_SINGLETON)
+ {
+ return RewriteResponse(REWRITE_AGAIN_FULL,
+ nm->mkNode(kind::EQUAL, node[0], node[1][0]));
+ }
+ else if (node[1].getKind() == kind::SET_UNION
+ || node[1].getKind() == kind::SET_INTERSECTION
+ || node[1].getKind() == kind::SET_MINUS)
+ {
+ std::vector<Node> children;
+ for (unsigned i = 0; i < node[1].getNumChildren(); i++)
+ {
+ Node nc = nm->mkNode(kind::SET_MEMBER, node[0], node[1][i]);
+ if (node[1].getKind() == kind::SET_MINUS && i == 1)
+ {
+ nc = nc.negate();
+ }
+ children.push_back(nc);
}
- children.push_back( nc );
+ return RewriteResponse(
+ REWRITE_AGAIN_FULL,
+ nm->mkNode(
+ node[1].getKind() == kind::SET_UNION ? kind::OR : kind::AND,
+ children));
}
- return RewriteResponse(REWRITE_AGAIN_FULL, nm->mkNode( node[1].getKind()==kind::UNION ? kind::OR : kind::AND, children ) );
- }
- break;
- }//kind::MEMBER
+ break;
+ } // kind::SET_MEMBER
- case kind::SUBSET: {
- Assert(false)
- << "TheorySets::postRrewrite(): Subset is handled in preRewrite.";
+ case kind::SET_SUBSET:
+ {
+ Assert(false)
+ << "TheorySets::postRrewrite(): Subset is handled in preRewrite.";
- // but in off-chance we do end up here, let us do our best
+ // but in off-chance we do end up here, let us do our best
- // rewrite (A subset-or-equal B) as (A union B = B)
- TNode A = node[0];
- TNode B = node[1];
- return RewriteResponse(REWRITE_AGAIN_FULL,
- nm->mkNode(kind::EQUAL,
- nm->mkNode(kind::UNION, A, B),
- B) );
- }//kind::SUBSET
+ // rewrite (A subset-or-equal B) as (A union B = B)
+ TNode A = node[0];
+ TNode B = node[1];
+ return RewriteResponse(
+ REWRITE_AGAIN_FULL,
+ nm->mkNode(kind::EQUAL, nm->mkNode(kind::SET_UNION, A, B), B));
+ } // kind::SET_SUBSET
case kind::EQUAL: {
//rewrite: t = t with true (t term)
break;
}
- case kind::SETMINUS:
+ case kind::SET_MINUS:
{
if (node[0] == node[1])
{
<< "Sets::postRewrite returning " << newNode << std::endl;
return RewriteResponse(REWRITE_DONE, newNode);
}
- else if (node[0].getKind() == kind::EMPTYSET
- || node[1].getKind() == kind::EMPTYSET)
+ else if (node[0].getKind() == kind::SET_EMPTY
+ || node[1].getKind() == kind::SET_EMPTY)
{
Trace("sets-postrewrite")
<< "Sets::postRewrite returning " << node[0] << std::endl;
return RewriteResponse(REWRITE_AGAIN, node[0]);
}
- else if (node[1].getKind() == kind::SETMINUS && node[1][0] == node[0])
+ else if (node[1].getKind() == kind::SET_MINUS && node[1][0] == node[0])
{
// (setminus A (setminus A B)) = (intersection A B)
- Node intersection = nm->mkNode(INTERSECTION, node[0], node[1][1]);
+ Node intersection = nm->mkNode(SET_INTERSECTION, node[0], node[1][1]);
return RewriteResponse(REWRITE_AGAIN, intersection);
}
- else if (node[1].getKind() == kind::UNIVERSE_SET)
+ else if (node[1].getKind() == kind::SET_UNIVERSE)
{
return RewriteResponse(
REWRITE_AGAIN,
return RewriteResponse(REWRITE_DONE, newNode);
}
break;
- } // kind::SETMINUS
+ } // kind::SET_MINUS
- case kind::INTERSECTION: {
+ case kind::SET_INTERSECTION:
+ {
if(node[0] == node[1]) {
Trace("sets-postrewrite") << "Sets::postRewrite returning " << node[0] << std::endl;
return RewriteResponse(REWRITE_AGAIN, node[0]);
- } else if(node[0].getKind() == kind::EMPTYSET || node[1].getKind() == kind::UNIVERSE_SET) {
+ }
+ else if (node[0].getKind() == kind::SET_EMPTY
+ || node[1].getKind() == kind::SET_UNIVERSE)
+ {
return RewriteResponse(REWRITE_AGAIN, node[0]);
- } else if(node[1].getKind() == kind::EMPTYSET || node[0].getKind() == kind::UNIVERSE_SET) {
+ }
+ else if (node[1].getKind() == kind::SET_EMPTY
+ || node[0].getKind() == kind::SET_UNIVERSE)
+ {
return RewriteResponse(REWRITE_AGAIN, node[1]);
- } else if(node[0].isConst() && node[1].isConst()) {
+ }
+ else if (node[0].isConst() && node[1].isConst())
+ {
std::set<Node> left = NormalForm::getElementsFromNormalConstant(node[0]);
std::set<Node> right = NormalForm::getElementsFromNormalConstant(node[1]);
std::set<Node> newSet;
}
// we don't merge non-constant intersections
break;
- }//kind::INTERSECION
+ } // kind::INTERSECION
- case kind::UNION: {
+ case kind::SET_UNION:
+ {
// NOTE: case where it is CONST is taken care of at the top
if(node[0] == node[1]) {
Trace("sets-postrewrite") << "Sets::postRewrite returning " << node[0] << std::endl;
return RewriteResponse(REWRITE_AGAIN, node[0]);
- } else if(node[0].getKind() == kind::EMPTYSET || node[1].getKind() == kind::UNIVERSE_SET) {
+ }
+ else if (node[0].getKind() == kind::SET_EMPTY
+ || node[1].getKind() == kind::SET_UNIVERSE)
+ {
return RewriteResponse(REWRITE_AGAIN, node[1]);
- } else if(node[1].getKind() == kind::EMPTYSET || node[0].getKind() == kind::UNIVERSE_SET) {
+ }
+ else if (node[1].getKind() == kind::SET_EMPTY
+ || node[0].getKind() == kind::SET_UNIVERSE)
+ {
return RewriteResponse(REWRITE_AGAIN, node[0]);
- } else if(node[0].isConst() && node[1].isConst()) {
+ }
+ else if (node[0].isConst() && node[1].isConst())
+ {
std::set<Node> left = NormalForm::getElementsFromNormalConstant(node[0]);
std::set<Node> right = NormalForm::getElementsFromNormalConstant(node[1]);
std::set<Node> newSet;
}
// we don't merge non-constant unions
break;
- }//kind::UNION
- case kind::COMPLEMENT:
+ } // kind::SET_UNION
+ case kind::SET_COMPLEMENT:
{
Node univ = NodeManager::currentNM()->mkNullaryOperator(node[0].getType(),
- kind::UNIVERSE_SET);
+ kind::SET_UNIVERSE);
return RewriteResponse(
REWRITE_AGAIN,
- NodeManager::currentNM()->mkNode(kind::SETMINUS, univ, node[0]));
+ NodeManager::currentNM()->mkNode(kind::SET_MINUS, univ, node[0]));
}
- case kind::CARD: {
+ case kind::SET_CARD:
+ {
if(node[0].isConst()) {
std::set<Node> elements = NormalForm::getElementsFromNormalConstant(node[0]);
return RewriteResponse(REWRITE_DONE, nm->mkConst(Rational(elements.size())));
- }else if( node[0].getKind()==kind::SINGLETON ){
+ }
+ else if (node[0].getKind() == kind::SET_SINGLETON)
+ {
return RewriteResponse(REWRITE_DONE, nm->mkConst(Rational(1)));
- }else if( node[0].getKind()==kind::UNION ){
- Node ret = NodeManager::currentNM()->mkNode( kind::MINUS,
- NodeManager::currentNM()->mkNode( kind::PLUS, NodeManager::currentNM()->mkNode( kind::CARD, node[0][0] ),
- NodeManager::currentNM()->mkNode( kind::CARD, node[0][1] ) ),
- NodeManager::currentNM()->mkNode( kind::CARD, NodeManager::currentNM()->mkNode( kind::INTERSECTION, node[0][0], node[0][1] ) ) );
+ }
+ else if (node[0].getKind() == kind::SET_UNION)
+ {
+ Node ret = NodeManager::currentNM()->mkNode(
+ kind::MINUS,
+ NodeManager::currentNM()->mkNode(
+ kind::PLUS,
+ NodeManager::currentNM()->mkNode(kind::SET_CARD, node[0][0]),
+ NodeManager::currentNM()->mkNode(kind::SET_CARD, node[0][1])),
+ NodeManager::currentNM()->mkNode(
+ kind::SET_CARD,
+ NodeManager::currentNM()->mkNode(
+ kind::SET_INTERSECTION, node[0][0], node[0][1])));
return RewriteResponse(REWRITE_DONE, ret );
- }else if( node[0].getKind()==kind::SETMINUS ){
- Node ret = NodeManager::currentNM()->mkNode( kind::MINUS,
- NodeManager::currentNM()->mkNode( kind::CARD, node[0][0] ),
- NodeManager::currentNM()->mkNode( kind::CARD, NodeManager::currentNM()->mkNode( kind::INTERSECTION, node[0][0], node[0][1] ) ) );
+ }
+ else if (node[0].getKind() == kind::SET_MINUS)
+ {
+ Node ret = NodeManager::currentNM()->mkNode(
+ kind::MINUS,
+ NodeManager::currentNM()->mkNode(kind::SET_CARD, node[0][0]),
+ NodeManager::currentNM()->mkNode(
+ kind::SET_CARD,
+ NodeManager::currentNM()->mkNode(
+ kind::SET_INTERSECTION, node[0][0], node[0][1])));
return RewriteResponse(REWRITE_DONE, ret );
}
break;
}
-
- case kind::CHOOSE:
+
+ case kind::SET_CHOOSE:
{
- if (node[0].getKind() == SINGLETON)
+ if (node[0].getKind() == SET_SINGLETON)
{
//(= (choose (singleton x)) x) is a tautology
// we return x for (choose (singleton x))
return RewriteResponse(REWRITE_AGAIN, node[0][0]);
}
break;
- } // kind::CHOOSE
- case kind::IS_SINGLETON:
+ } // kind::SET_CHOOSE
+ case kind::SET_IS_SINGLETON:
{
- if (node[0].getKind() == SINGLETON)
+ if (node[0].getKind() == SET_SINGLETON)
{
//(= (is_singleton (singleton x)) is a tautology
// we return true for (is_singleton (singleton x))
NodeManager::currentNM()->mkConst(true));
}
break;
- } // kind::IS_SINGLETON
+ } // kind::SET_IS_SINGLETON
- case kind::TRANSPOSE: {
- if(node[0].getKind() == kind::TRANSPOSE) {
+ case kind::RELATION_TRANSPOSE:
+ {
+ if (node[0].getKind() == kind::RELATION_TRANSPOSE)
+ {
return RewriteResponse(REWRITE_AGAIN, node[0][0]);
}
- if(node[0].getKind() == kind::EMPTYSET) {
+ if (node[0].getKind() == kind::SET_EMPTY)
+ {
return RewriteResponse(REWRITE_DONE,
nm->mkConst(EmptySet(node.getType())));
- } else if(node[0].isConst()) {
+ }
+ else if (node[0].isConst())
+ {
std::set<Node> new_tuple_set;
std::set<Node> tuple_set = NormalForm::getElementsFromNormalConstant(node[0]);
std::set<Node>::iterator tuple_it = tuple_set.begin();
Assert(new_node.isConst());
Trace("sets-postrewrite") << "Sets::postRewrite returning " << new_node << std::endl;
return RewriteResponse(REWRITE_DONE, new_node);
-
}
- if(node[0].getKind() != kind::TRANSPOSE) {
+ if (node[0].getKind() != kind::RELATION_TRANSPOSE)
+ {
Trace("sets-postrewrite") << "Sets::postRewrite returning " << node << std::endl;
return RewriteResponse(REWRITE_DONE, node);
}
break;
}
- case kind::PRODUCT: {
+ case kind::RELATION_PRODUCT:
+ {
Trace("sets-rels-postrewrite") << "Sets::postRewrite processing " << node << std::endl;
- if( node[0].getKind() == kind::EMPTYSET ||
- node[1].getKind() == kind::EMPTYSET) {
+ if (node[0].getKind() == kind::SET_EMPTY
+ || node[1].getKind() == kind::SET_EMPTY)
+ {
return RewriteResponse(REWRITE_DONE,
nm->mkConst(EmptySet(node.getType())));
- } else if( node[0].isConst() && node[1].isConst() ) {
+ }
+ else if (node[0].isConst() && node[1].isConst())
+ {
Trace("sets-rels-postrewrite") << "Sets::postRewrite processing **** " << node << std::endl;
std::set<Node> new_tuple_set;
std::set<Node> left = NormalForm::getElementsFromNormalConstant(node[0]);
break;
}
- case kind::JOIN: {
- if( node[0].getKind() == kind::EMPTYSET ||
- node[1].getKind() == kind::EMPTYSET) {
+ case kind::RELATION_JOIN:
+ {
+ if (node[0].getKind() == kind::SET_EMPTY
+ || node[1].getKind() == kind::SET_EMPTY)
+ {
return RewriteResponse(REWRITE_DONE,
nm->mkConst(EmptySet(node.getType())));
- } else if( node[0].isConst() && node[1].isConst() ) {
+ }
+ else if (node[0].isConst() && node[1].isConst())
+ {
Trace("sets-rels-postrewrite") << "Sets::postRewrite processing " << node << std::endl;
std::set<Node> new_tuple_set;
std::set<Node> left = NormalForm::getElementsFromNormalConstant(node[0]);
break;
}
- case kind::TCLOSURE: {
- if(node[0].getKind() == kind::EMPTYSET) {
+ case kind::RELATION_TCLOSURE:
+ {
+ if (node[0].getKind() == kind::SET_EMPTY)
+ {
return RewriteResponse(REWRITE_DONE,
nm->mkConst(EmptySet(node.getType())));
- } else if (node[0].isConst()) {
+ }
+ else if (node[0].isConst())
+ {
std::set<Node> rel_mems = NormalForm::getElementsFromNormalConstant(node[0]);
std::set<Node> tc_rel_mems = RelsUtils::computeTC(rel_mems, node);
Node new_node = NormalForm::elementsToSet(tc_rel_mems, node.getType());
Assert(new_node.isConst());
Trace("sets-postrewrite") << "Sets::postRewrite returning " << new_node << std::endl;
return RewriteResponse(REWRITE_DONE, new_node);
-
- } else if(node[0].getKind() == kind::TCLOSURE) {
+ }
+ else if (node[0].getKind() == kind::RELATION_TCLOSURE)
+ {
return RewriteResponse(REWRITE_AGAIN, node[0]);
- } else if(node[0].getKind() != kind::TCLOSURE) {
+ }
+ else if (node[0].getKind() != kind::RELATION_TCLOSURE)
+ {
Trace("sets-postrewrite") << "Sets::postRewrite returning " << node << std::endl;
return RewriteResponse(REWRITE_DONE, node);
}
break;
}
-
- case kind::IDEN: {
- if(node[0].getKind() == kind::EMPTYSET) {
+
+ case kind::RELATION_IDEN:
+ {
+ if (node[0].getKind() == kind::SET_EMPTY)
+ {
return RewriteResponse(REWRITE_DONE,
nm->mkConst(EmptySet(node.getType())));
- } else if (node[0].isConst()) {
+ }
+ else if (node[0].isConst())
+ {
std::set<Node> iden_rel_mems;
std::set<Node> rel_mems = NormalForm::getElementsFromNormalConstant(node[0]);
std::set<Node>::iterator rel_mems_it = rel_mems.begin();
Assert(new_node.isConst());
Trace("rels-postrewrite") << "Rels::postRewrite returning " << new_node << std::endl;
return RewriteResponse(REWRITE_DONE, new_node);
-
- } else {
+ }
+ else
+ {
Trace("rels-postrewrite") << "Rels::postRewrite miss to handle term " << node << std::endl;
}
break;
}
- case kind::JOIN_IMAGE: {
+ case kind::RELATION_JOIN_IMAGE:
+ {
unsigned int min_card = node[1].getConst<Rational>().getNumerator().getUnsignedInt();
Trace("rels-postrewrite") << "Rels::postRewrite " << node << " with min_card = " << min_card << std::endl;
if( min_card == 0) {
- return RewriteResponse(REWRITE_DONE, nm->mkNullaryOperator( node.getType(), kind::UNIVERSE_SET ));
- } else if(node[0].getKind() == kind::EMPTYSET) {
+ return RewriteResponse(
+ REWRITE_DONE,
+ nm->mkNullaryOperator(node.getType(), kind::SET_UNIVERSE));
+ }
+ else if (node[0].getKind() == kind::SET_EMPTY)
+ {
return RewriteResponse(REWRITE_DONE,
nm->mkConst(EmptySet(node.getType())));
- } else if (node[0].isConst()) {
+ }
+ else if (node[0].isConst())
+ {
std::set<Node> has_checked;
std::set<Node> join_img_mems;
std::set<Node> rel_mems = NormalForm::getElementsFromNormalConstant(node[0]);
Assert(new_node.isConst());
Trace("rels-postrewrite") << "Rels::postRewrite returning " << new_node << std::endl;
return RewriteResponse(REWRITE_DONE, new_node);
- } else {
+ }
+ else
+ {
Trace("rels-postrewrite") << "Rels::postRewrite miss to handle term " << node << std::endl;
}
break;
return RewriteResponse(REWRITE_DONE, nm->mkConst(true));
}
}
- else if (k == kind::INSERT)
+ else if (k == kind::SET_INSERT)
{
size_t setNodeIndex = node.getNumChildren()-1;
TypeNode elementType = node[setNodeIndex].getType().getSetElementType();
for (size_t i = 1; i < setNodeIndex; ++i)
{
Node singleton = nm->mkSingleton(elementType, node[i]);
- insertedElements = nm->mkNode(kind::UNION, insertedElements, singleton);
+ insertedElements =
+ nm->mkNode(kind::SET_UNION, insertedElements, singleton);
}
- return RewriteResponse(REWRITE_AGAIN,
- nm->mkNode(kind::UNION,
- insertedElements,
- node[setNodeIndex]));
+ return RewriteResponse(
+ REWRITE_AGAIN,
+ nm->mkNode(kind::SET_UNION, insertedElements, node[setNodeIndex]));
}
- else if (k == kind::SUBSET)
+ else if (k == kind::SET_SUBSET)
{
// rewrite (A subset-or-equal B) as (A union B = B)
- return RewriteResponse(REWRITE_AGAIN,
- nm->mkNode(kind::EQUAL,
- nm->mkNode(kind::UNION, node[0], node[1]),
- node[1]) );
+ return RewriteResponse(
+ REWRITE_AGAIN,
+ nm->mkNode(kind::EQUAL,
+ nm->mkNode(kind::SET_UNION, node[0], node[1]),
+ node[1]));
}
// could have an efficient normalizer for union here
TNode n,
bool check)
{
- Assert(n.getKind() == kind::UNION || n.getKind() == kind::INTERSECTION
- || n.getKind() == kind::SETMINUS);
+ Assert(n.getKind() == kind::SET_UNION || n.getKind() == kind::SET_INTERSECTION
+ || n.getKind() == kind::SET_MINUS);
TypeNode setType = n[0].getType(check);
if (check)
{
bool SetsBinaryOperatorTypeRule::computeIsConst(NodeManager* nodeManager,
TNode n)
{
- // only UNION has a const rule in kinds.
- // INTERSECTION and SETMINUS are not used in the canonical representation of
- // sets and therefore they do not have const rules in kinds
- Assert(n.getKind() == kind::UNION);
+ // only SET_UNION has a const rule in kinds.
+ // SET_INTERSECTION and SET_MINUS are not used in the canonical representation
+ // of sets and therefore they do not have const rules in kinds
+ Assert(n.getKind() == kind::SET_UNION);
return NormalForm::checkNormalConstant(n);
}
TNode n,
bool check)
{
- Assert(n.getKind() == kind::SUBSET);
+ Assert(n.getKind() == kind::SET_SUBSET);
TypeNode setType = n[0].getType(check);
if (check)
{
TNode n,
bool check)
{
- Assert(n.getKind() == kind::MEMBER);
+ Assert(n.getKind() == kind::SET_MEMBER);
TypeNode setType = n[1].getType(check);
if (check)
{
TNode n,
bool check)
{
- Assert(n.getKind() == kind::SINGLETON && n.hasOperator()
- && n.getOperator().getKind() == kind::SINGLETON_OP);
+ Assert(n.getKind() == kind::SET_SINGLETON && n.hasOperator()
+ && n.getOperator().getKind() == kind::SET_SINGLETON_OP);
- SingletonOp op = n.getOperator().getConst<SingletonOp>();
+ SetSingletonOp op = n.getOperator().getConst<SetSingletonOp>();
TypeNode type1 = op.getType();
if (check)
{
bool SingletonTypeRule::computeIsConst(NodeManager* nodeManager, TNode n)
{
- Assert(n.getKind() == kind::SINGLETON);
+ Assert(n.getKind() == kind::SET_SINGLETON);
return n[0].isConst();
}
TNode n,
bool check)
{
- Assert(n.getKind() == kind::EMPTYSET);
+ Assert(n.getKind() == kind::SET_EMPTY);
EmptySet emptySet = n.getConst<EmptySet>();
return emptySet.getType();
}
TNode n,
bool check)
{
- Assert(n.getKind() == kind::CARD);
+ Assert(n.getKind() == kind::SET_CARD);
TypeNode setType = n[0].getType(check);
if (check)
{
TNode n,
bool check)
{
- Assert(n.getKind() == kind::COMPLEMENT);
+ Assert(n.getKind() == kind::SET_COMPLEMENT);
TypeNode setType = n[0].getType(check);
if (check)
{
if (!setType.isSet())
{
throw TypeCheckingExceptionPrivate(
- n, "COMPLEMENT operates on a set, non-set object found");
+ n, "SET_COMPLEMENT operates on a set, non-set object found");
}
}
return setType;
TNode n,
bool check)
{
- Assert(n.getKind() == kind::UNIVERSE_SET);
+ Assert(n.getKind() == kind::SET_UNIVERSE);
// for nullary operators, we only computeType for check=true, since they are
// given TypeAttr() on creation
Assert(check);
TNode n,
bool check)
{
- Assert(n.getKind() == kind::COMPREHENSION);
+ Assert(n.getKind() == kind::SET_COMPREHENSION);
if (check)
{
if (n[0].getType(check) != nodeManager->boundVarListType())
TNode n,
bool check)
{
- Assert(n.getKind() == kind::CHOOSE);
+ Assert(n.getKind() == kind::SET_CHOOSE);
TypeNode setType = n[0].getType(check);
if (check)
{
if (!setType.isSet())
{
throw TypeCheckingExceptionPrivate(
- n, "CHOOSE operator expects a set, a non-set is found");
+ n, "SET_CHOOSE operator expects a set, a non-set is found");
}
}
return setType.getSetElementType();
TNode n,
bool check)
{
- Assert(n.getKind() == kind::IS_SINGLETON);
+ Assert(n.getKind() == kind::SET_IS_SINGLETON);
TypeNode setType = n[0].getType(check);
if (check)
{
if (!setType.isSet())
{
throw TypeCheckingExceptionPrivate(
- n, "IS_SINGLETON operator expects a set, a non-set is found");
+ n, "SET_IS_SINGLETON operator expects a set, a non-set is found");
}
}
return nodeManager->booleanType();
TNode n,
bool check)
{
- Assert(n.getKind() == kind::INSERT);
+ Assert(n.getKind() == kind::SET_INSERT);
size_t numChildren = n.getNumChildren();
Assert(numChildren >= 2);
TypeNode setType = n[numChildren - 1].getType(check);
TNode n,
bool check)
{
- Assert(n.getKind() == kind::PRODUCT || n.getKind() == kind::JOIN);
+ Assert(n.getKind() == kind::RELATION_PRODUCT
+ || n.getKind() == kind::RELATION_JOIN);
TypeNode firstRelType = n[0].getType(check);
TypeNode secondRelType = n[1].getType(check);
std::vector<TypeNode> firstTupleTypes = firstRelType[0].getTupleTypes();
std::vector<TypeNode> secondTupleTypes = secondRelType[0].getTupleTypes();
- // JOIN is not allowed to apply on two unary sets
- if (n.getKind() == kind::JOIN)
+ // RELATION_JOIN is not allowed to apply on two unary sets
+ if (n.getKind() == kind::RELATION_JOIN)
{
if ((firstTupleTypes.size() == 1) && (secondTupleTypes.size() == 1))
{
secondTupleTypes.begin() + 1,
secondTupleTypes.end());
}
- else if (n.getKind() == kind::PRODUCT)
+ else if (n.getKind() == kind::RELATION_PRODUCT)
{
newTupleTypes.insert(
newTupleTypes.end(), firstTupleTypes.begin(), firstTupleTypes.end());
TNode n,
bool check)
{
- Assert(n.getKind() == kind::TRANSPOSE);
+ Assert(n.getKind() == kind::RELATION_TRANSPOSE);
TypeNode setType = n[0].getType(check);
if (check && (!setType.isSet() || !setType.getSetElementType().isTuple()))
{
TNode n,
bool check)
{
- Assert(n.getKind() == kind::TCLOSURE);
+ Assert(n.getKind() == kind::RELATION_TCLOSURE);
TypeNode setType = n[0].getType(check);
if (check)
{
TNode n,
bool check)
{
- Assert(n.getKind() == kind::JOIN_IMAGE);
+ Assert(n.getKind() == kind::RELATION_JOIN_IMAGE);
TypeNode firstRelType = n[0].getType(check);
TNode n,
bool check)
{
- Assert(n.getKind() == kind::IDEN);
+ Assert(n.getKind() == kind::RELATION_IDEN);
TypeNode setType = n[0].getType(check);
if (check)
{
* kind k in getModelValue. We distinguish four categories of kinds:
*
* [1] "Evaluated"
- * This includes (standard) interpreted symbols like NOT, PLUS, UNION, etc.
- * These operators can be characterized by the invariant that they are
+ * This includes (standard) interpreted symbols like NOT, PLUS, SET_UNION,
+ * etc. These operators can be characterized by the invariant that they are
* "evaluatable". That is, if they are applied to only constants, the rewriter
* is guaranteed to rewrite the application to a constant. When getting
* the model value of <k>( t1...tn ) where k is a kind of this category, we
i2 = solver.mkInteger(7)
s1 = solver.mkEmptySet(s)
- s2 = solver.mkTerm(kinds.Singleton, i1)
- s3 = solver.mkTerm(kinds.Singleton, i1)
- s4 = solver.mkTerm(kinds.Singleton, i2)
- s5 = solver.mkTerm(kinds.Union, s2, solver.mkTerm(kinds.Union, s3, s4))
+ s2 = solver.mkTerm(kinds.SetSingleton, i1)
+ s3 = solver.mkTerm(kinds.SetSingleton, i1)
+ s4 = solver.mkTerm(kinds.SetSingleton, i2)
+ s5 = solver.mkTerm(
+ kinds.SetUnion, s2, solver.mkTerm(kinds.SetUnion, s3, s4))
assert s1.isSetValue()
assert s2.isSetValue()
(declare-fun emptyRoleSet () (Set role))
-(assert (= emptyRoleSet (as emptyset (Set role))))
+(assert (= emptyRoleSet (as set.empty (Set role))))
(declare-fun d () (Array role |__cvc5_record_pos_(Set role)_neg_(Set role)|))
-(assert (= (pos (select d r3)) (singleton r1)))
-(assert (= (pos (select d r2)) (union (singleton r2) (singleton r3))))
-(assert (= (neg (select d r2)) (singleton r1)))
+(assert (= (pos (select d r3)) (set.singleton r1)))
+(assert (= (pos (select d r2)) (set.union (set.singleton r2) (set.singleton r3))))
+(assert (= (neg (select d r2)) (set.singleton r1)))
(check-sat)
(declare-fun a () (Array Int |__cvc5_record_s_f____cvc5_record_base____cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)__|))
(define-fun p1 () __cvc5_record_longitude_Int_latitude_Int (__cvc5_record_longitude_Int_latitude_Int_ctor 0 0))
-(define-fun s1 () |__cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)| (|__cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)_ctor| (singleton (__cvc5_record_longitude_Int_latitude_Int_ctor 0 0))))
-(define-fun f0 () |__cvc5_record_base____cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)_| (|__cvc5_record_base____cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)__ctor| (|__cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)_ctor| (singleton (__cvc5_record_longitude_Int_latitude_Int_ctor 0 0)))))
+(define-fun s1 () |__cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)| (|__cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)_ctor| (set.singleton (__cvc5_record_longitude_Int_latitude_Int_ctor 0 0))))
+(define-fun f0 () |__cvc5_record_base____cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)_| (|__cvc5_record_base____cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)__ctor| (|__cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)_ctor| (set.singleton (__cvc5_record_longitude_Int_latitude_Int_ctor 0 0)))))
(define-fun init ((v (Array Int |__cvc5_record_s_f____cvc5_record_base____cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)__|)) (i Int) (f |__cvc5_record_base____cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)_|)) Bool (= (s_f (select v 0)) f))
-(assert (init a 2 (|__cvc5_record_base____cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)__ctor| (|__cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)_ctor| (singleton (__cvc5_record_longitude_Int_latitude_Int_ctor 0 0))))))
+(assert (init a 2 (|__cvc5_record_base____cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)__ctor| (|__cvc5_record_geoLoc_(Set __cvc5_record_longitude_Int_latitude_Int)_ctor| (set.singleton (__cvc5_record_longitude_Int_latitude_Int_ctor 0 0))))))
(push 1)
(assert true)
(declare-fun st4 () (Set Int))
(declare-fun st9 () (Set Int))
(declare-const v6 Bool)
-(assert (! (forall ((q12 Int) (q13 Bool)) (xor false true true false true true v6 (<= 5 i5 93 417 i2) true (subset st2 st4) true)) :named IP_4))
+(assert (! (forall ((q12 Int) (q13 Bool)) (xor false true true false true true v6 (<= 5 i5 93 417 i2) true (set.subset st2 st4) true)) :named IP_4))
(declare-const i11 Int)
-(assert (< (card st9) i11))
+(assert (< (set.card st9) i11))
(assert (! (not (<= 5 i5 93 417 i2)) :named IP_46))
(check-sat)
(check-sat-assuming ((! (or v6 v6 v6) :named IP_12) (! (or false v6 v6) :named IP_56)))
\ No newline at end of file
(declare-fun isTip!5 (ConQ!6) Bool)
-(assert (=> start!13 (and (not (isTip!5 (evalLazyConQ2!7 lt!14))) (member lt!14 st!3))))
+(assert (=> start!13 (and (not (isTip!5 (evalLazyConQ2!7 lt!14))) (set.member lt!14 st!3))))
(assert (=> start!13 (= lt!14 e!42)))
-(assert (=> start!13 (= b!40 (member l!2 st!3))))
+(assert (=> start!13 (= b!40 (set.member l!2 st!3))))
(assert (=> start!13 (or (not b!40) (not b!42))))
(set-logic ALL)
(set-info :status sat)
(declare-datatypes ((IntList 0)) (
-((empty) (insert ( head Int ) ( tail IntList ) ))
+((empty) (set.insert ( head Int ) ( tail IntList ) ))
))
(declare-fun x () IntList)
(set-info :status sat)
(declare-datatypes ( ( Tree 0) ( TreeList 0) ) (
( ( node ( value Int ) ( children TreeList) ))
-( ( empty ) ( insert ( head Tree) ( tail TreeList)) )
+( ( empty ) ( set.insert ( head Tree) ( tail TreeList)) )
))
(declare-fun t () TreeList)
-(assert (<= 100 (match t ((empty (- 1)) ((insert x1 x2) (value x1))))))
+(assert (<= 100 (match t ((empty (- 1)) ((set.insert x1 x2) (value x1))))))
(declare-datatypes ( ( PTree 1) ( PTreeList 1) ) (
(set-info :status sat)
(declare-datatypes ( (Tree 1) (TreeList 1) ) (
(par ( X ) ( ( node ( value X ) ( children ( TreeList X )) )))
-(par ( Y ) ( ( empty ) ( insert ( head ( Tree Y )) ( tail ( TreeList Y ))) ))
+(par ( Y ) ( ( empty ) ( set.insert ( head ( Tree Y )) ( tail ( TreeList Y ))) ))
))
(assert (distinct x y z))
(assert (= (value x) 5))
-(assert ((_ is insert) (children y)))
+(assert ((_ is set.insert) (children y)))
(assert (= (value (head (children y))) 7))
(declare-sort U 0)
(assert (distinct a b c))
-(assert ((_ is insert) (children a)))
+(assert ((_ is set.insert) (children a)))
(declare-fun d () (Tree (Tree Int)))
(set-logic ALL)
(set-info :status unsat)
(declare-datatypes ((IntList 0)) (
-((empty) (insert ( head Int ) ( tail IntList ) ))
+((empty) (set.insert ( head Int ) ( tail IntList ) ))
))
(declare-fun x () IntList)
(assert (distinct x y z))
-(assert (not ((_ is insert) x)))
-(assert (not ((_ is insert) y)))
+(assert (not ((_ is set.insert) x)))
+(assert (not ((_ is set.insert) y)))
(check-sat)
(declare-datatype ty0 ((Emp) (Container (v2 (Set ty0)))))
(declare-fun v1 () ty0)
(assert (not ((_ is Emp) v1)))
-(assert (= (v2 v1) (singleton v1)))
+(assert (= (v2 v1) (set.singleton v1)))
(check-sat)
(declare-fun S () (Set Int))
(declare-fun P (Int) Bool)
(declare-fun a () Int)
-(assert (member a S))
-(assert (forall ((y Int)) (=> (member y S) (P y))))
+(assert (set.member a S))
+(assert (forall ((y Int)) (=> (set.member y S) (P y))))
(declare-fun T () (Set Int))
(declare-fun b () Int)
-(assert (member b T))
-(assert (forall ((y Int)) (=> (member y T) (not (P y)))))
+(assert (set.member b T))
+(assert (forall ((y Int)) (=> (set.member y T) (not (P y)))))
(check-sat)
(declare-fun f (U) U)
(assert (forall ((x Int) (z U))
-(=> (member x (S (f z)))
+(=> (set.member x (S (f z)))
(P x z))))
; need model of U size 2 to satisfy these
(declare-fun a () U)
-(assert (member 77 (S a)))
+(assert (set.member 77 (S a)))
(assert (not (P 77 a)))
; unsat
(declare-sort Atom 0)
(declare-fun REAL_UNIVERSE () (Set (Tuple Real)))
(declare-fun ATOM_UNIVERSE () (Set (Tuple Atom)))
-(assert (= REAL_UNIVERSE (as univset (Set (Tuple Real)))))
-(assert (= ATOM_UNIVERSE (as univset (Set (Tuple Atom)))))
+(assert (= REAL_UNIVERSE (as set.universe (Set (Tuple Real)))))
+(assert (= ATOM_UNIVERSE (as set.universe (Set (Tuple Atom)))))
(declare-fun levelVal () (Set (Tuple Atom Real)))
-(assert (forall ((s Atom) (v1 Real) (v2 Real)) (=> (and (and (member (tuple s) ATOM_UNIVERSE) (member (tuple v1) REAL_UNIVERSE)) (member (tuple v2) REAL_UNIVERSE)) (=> (and (member (tuple s v1) levelVal) (member (tuple s v2) levelVal)) (= v1 v2)))))
+(assert (forall ((s Atom) (v1 Real) (v2 Real)) (=> (and (and (set.member (tuple s) ATOM_UNIVERSE) (set.member (tuple v1) REAL_UNIVERSE)) (set.member (tuple v2) REAL_UNIVERSE)) (=> (and (set.member (tuple s v1) levelVal) (set.member (tuple s v2) levelVal)) (= v1 v2)))))
(check-sat)
(declare-fun minus$ (Complex$ Complex$) Complex$)
(declare-fun norm$a (Real) Real)
(declare-fun zero$a () Nat$)
-(declare-fun member$ (Real Real_set$) Bool)
+(declare-fun set.member$ (Real Real_set$) Bool)
(declare-fun minus$a (Nat$ Nat$) Nat$)
(declare-fun thesis$ () Bool)
(declare-fun collect$ ((-> Real Bool)) Real_set$)
(set-logic QF_UF)
(declare-sort T 0)
(declare-fun union () T)
-(declare-fun emptyset () T)
-(assert (= union emptyset))
+(declare-fun set.empty () T)
+(assert (= union set.empty))
(check-sat)
(declare-fun b1 () Atom)
(declare-fun b1_tup () (Tuple Atom))
(assert (= b1_tup (tuple b1)))
-(assert (member b1_tup Book))
+(assert (set.member b1_tup Book))
(declare-fun b2 () Atom)
(declare-fun b2_tup () (Tuple Atom))
(assert (= b2_tup (tuple b2)))
-(assert (member b2_tup Book))
+(assert (set.member b2_tup Book))
(declare-fun b3 () Atom)
(declare-fun b3_tup () (Tuple Atom))
(assert (= b3_tup (tuple b3)))
-(assert (member b3_tup Book))
+(assert (set.member b3_tup Book))
(declare-fun n () Atom)
(declare-fun n_tup () (Tuple Atom))
(assert (= n_tup (tuple n)))
-(assert (member n_tup Name))
+(assert (set.member n_tup Name))
(declare-fun t () Atom)
(declare-fun t_tup () (Tuple Atom))
(assert (= t_tup (tuple t)))
-(assert (member t_tup Target))
-(assert (subset (join (join Book addr) Target) Name))
-(assert (subset (join Book names) Name))
-(assert (= (intersection Name Addr) (as emptyset (Set (Tuple Atom)))))
-(assert (= (join (singleton n_tup) (join (singleton b1_tup) addr)) (as emptyset (Set (Tuple Atom)))))
-(assert (let ((_let_1 (singleton n_tup))) (= (join _let_1 (join (singleton b2_tup) addr)) (union (join _let_1 (join (singleton b1_tup) addr)) (singleton t_tup)))))
-(assert (let ((_let_1 (singleton n_tup))) (= (join _let_1 (join (singleton b3_tup) addr)) (setminus (join _let_1 (join (singleton b2_tup) addr)) (singleton t_tup)))))
-(assert (let ((_let_1 (singleton n_tup))) (not (= (join _let_1 (join (singleton b1_tup) addr)) (join _let_1 (join (singleton b3_tup) addr))))))
+(assert (set.member t_tup Target))
+(assert (set.subset (rel.join (rel.join Book addr) Target) Name))
+(assert (set.subset (rel.join Book names) Name))
+(assert (= (set.intersection Name Addr) (as set.empty (Set (Tuple Atom)))))
+(assert (= (rel.join (set.singleton n_tup) (rel.join (set.singleton b1_tup) addr)) (as set.empty (Set (Tuple Atom)))))
+(assert (let ((_let_1 (set.singleton n_tup))) (= (rel.join _let_1 (rel.join (set.singleton b2_tup) addr)) (set.union (rel.join _let_1 (rel.join (set.singleton b1_tup) addr)) (set.singleton t_tup)))))
+(assert (let ((_let_1 (set.singleton n_tup))) (= (rel.join _let_1 (rel.join (set.singleton b3_tup) addr)) (set.minus (rel.join _let_1 (rel.join (set.singleton b2_tup) addr)) (set.singleton t_tup)))))
+(assert (let ((_let_1 (set.singleton n_tup))) (not (= (rel.join _let_1 (rel.join (set.singleton b1_tup) addr)) (rel.join _let_1 (rel.join (set.singleton b3_tup) addr))))))
(check-sat)
(declare-fun x () Atom)
(declare-fun y () Atom)
(assert (not (= x y)))
-(assert (member (tuple y) a))
-(assert (member (tuple x y) b))
-(assert (= (as univset (Set (Tuple Atom Atom))) (product (as univset (Set (Tuple Atom))) (as univset (Set (Tuple Atom))))))
+(assert (set.member (tuple y) a))
+(assert (set.member (tuple x y) b))
+(assert (= (as set.universe (Set (Tuple Atom Atom))) (rel.product (as set.universe (Set (Tuple Atom))) (as set.universe (Set (Tuple Atom))))))
(declare-fun u () (Set (Tuple Atom Atom)))
-(assert (= u (as univset (Set (Tuple Atom Atom)))))
-(assert (not (member (tuple x y) u)))
+(assert (= u (as set.universe (Set (Tuple Atom Atom)))))
+(assert (not (set.member (tuple x y) u)))
(check-sat)
(set-logic ALL)
(declare-fun x () (Set (Tuple Int Int)))
-(assert (> (card (transpose x)) 0))
+(assert (> (set.card (rel.transpose x)) 0))
(check-sat)
(assert (= v (tuple 1 1)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
-(assert (member (tuple 1) t))
-(assert (member (tuple 2) t))
-(assert (member z x))
-(assert (member zt x))
-(assert (member v x))
-(assert (member a x))
-(assert (= id (iden t)))
-(assert (not (member (tuple 1 1) (intersection id x))))
+(assert (set.member (tuple 1) t))
+(assert (set.member (tuple 2) t))
+(assert (set.member z x))
+(assert (set.member zt x))
+(assert (set.member v x))
+(assert (set.member a x))
+(assert (= id (rel.iden t)))
+(assert (not (set.member (tuple 1 1) (set.intersection id x))))
(check-sat)
(declare-fun b () Atom)
(declare-fun c () Atom)
(declare-fun d () Atom)
-(assert (= univ (as univset (Set (Tuple Atom)))))
-(assert (member (tuple a b) x))
-(assert (member (tuple c d) x))
+(assert (= univ (as set.universe (Set (Tuple Atom)))))
+(assert (set.member (tuple a b) x))
+(assert (set.member (tuple c d) x))
(assert (not (= a b)))
-(assert (= (iden (join x univ)) x))
+(assert (= (rel.iden (rel.join x univ)) x))
(check-sat)
(declare-fun w () (Set (Tuple Int unit)))
(declare-fun z () (Set (Tuple unit Int)))
-(assert (= (join x y) (join w z)))
-(assert (member (tuple 0 1) (join x y)))
-(assert (member (tuple 0 u) w))
+(assert (= (rel.join x y) (rel.join w z)))
+(assert (set.member (tuple 0 1) (rel.join x y)))
+(assert (set.member (tuple 0 u) w))
(declare-fun t () Int)
(assert (and (> t 0) (< t 3)))
-(assert (not (member (tuple u t) z)))
+(assert (not (set.member (tuple u t) z)))
(check-sat)
(declare-fun w () (Set (Tuple Int unit)))
(declare-fun z () (Set (Tuple unit Int)))
-(assert (= (join x y) (join w z)))
-(assert (member (tuple 0 1) (join x y)))
-(assert (member (tuple 0 u) w))
+(assert (= (rel.join x y) (rel.join w z)))
+(assert (set.member (tuple 0 1) (rel.join x y)))
+(assert (set.member (tuple 0 u) w))
(declare-fun t () Int)
(assert (and (> t 0) (< t 2)))
-(assert (not (member (tuple u t) z)))
+(assert (not (set.member (tuple u t) z)))
(check-sat)
(assert (= v (tuple 1 1)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
-(assert (member (tuple 1 7) x))
-(assert (member z x))
-(assert (member (tuple 7 5) y))
-(assert (= t (join_image x 2)))
-(assert (member (tuple 3) (join_image x 2)))
-(assert (not (member (tuple 1) (join_image x 2))))
-(assert (member (tuple 4) (join_image x 2)))
-(assert (member (tuple 1) (join_image x 1)))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member z x))
+(assert (set.member (tuple 7 5) y))
+(assert (= t (rel.join_image x 2)))
+(assert (set.member (tuple 3) (rel.join_image x 2)))
+(assert (not (set.member (tuple 1) (rel.join_image x 2))))
+(assert (set.member (tuple 4) (rel.join_image x 2)))
+(assert (set.member (tuple 1) (rel.join_image x 1)))
(check-sat)
(declare-fun c () Atom)
(declare-fun J ((Set (Tuple Atom)) (Set (Tuple Atom Atom))) (Set (Tuple Atom)))
(declare-fun T ((Set (Tuple Atom Atom))) (Set (Tuple Atom Atom)))
-(assert (let ((_let_1 (singleton (tuple a)))) (= (join _let_1 t) (J _let_1 t))))
-(assert (let ((_let_1 (singleton (tuple c)))) (not (= (join _let_1 (tclosure t)) _let_1))))
+(assert (let ((_let_1 (set.singleton (tuple a)))) (= (rel.join _let_1 t) (J _let_1 t))))
+(assert (let ((_let_1 (set.singleton (tuple c)))) (not (= (rel.join _let_1 (rel.tclosure t)) _let_1))))
(check-sat)
(set-logic ALL)
(set-info :status sat)
(declare-fun d () (Tuple Int Int))
-(assert (= (as emptyset (Set (Tuple Int Int))) (join (singleton (tuple 1 0)) (singleton d))))
+(assert (= (as set.empty (Set (Tuple Int Int))) (rel.join (set.singleton (tuple 1 0)) (set.singleton d))))
(check-sat)
(declare-fun b () (Set (Tuple Int Int)))
(declare-fun c () Int)
(declare-fun d () (Tuple Int Int))
-(assert (and (= b (singleton (tuple 1 0))) (= a (join b (transpose a))) (= a (join b (tclosure a))) (= a (join b (singleton d)))))
+(assert (and (= b (set.singleton (tuple 1 0))) (= a (rel.join b (rel.transpose a))) (= a (rel.join b (rel.tclosure a))) (= a (rel.join b (set.singleton d)))))
(check-sat)
(declare-fun z () (Set (Tuple Int)))
(declare-fun b () (Tuple Int Int))
(assert (= b (tuple 2 1)))
-(assert (member b x))
+(assert (set.member b x))
(declare-fun a () (Tuple Int))
(assert (= a (tuple 1)))
-(assert (member a y))
+(assert (set.member a y))
(declare-fun c () (Tuple Int))
(assert (= c (tuple 2)))
-(assert (= z (join x y)))
-(assert (not (member c z)))
+(assert (= z (rel.join x y)))
+(assert (not (set.member c z)))
(check-sat)
(declare-fun g () Int)
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 4 f)))
-(assert (member e x))
+(assert (set.member e x))
(declare-fun d () (Tuple Int Int))
(assert (= d (tuple g 3)))
-(assert (member d y))
-(assert (= z (union (singleton f) (singleton g))))
+(assert (set.member d y))
+(assert (= z (set.union (set.singleton f) (set.singleton g))))
(assert (= 0 (- f g)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 4 3)))
-(assert (= r (join x y)))
-(assert (not (member a r)))
+(assert (= r (rel.join x y)))
+(assert (not (set.member a r)))
(check-sat)
(declare-fun r2 () (Set (Tuple Int Int)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 3 1)))
-(assert (member a x))
+(assert (set.member a x))
(declare-fun d () (Tuple Int Int))
(assert (= d (tuple 1 3)))
-(assert (member d y))
+(assert (set.member d y))
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 4 3)))
-(assert (= r (join x y)))
-(assert (member (tuple 1) w))
-(assert (member (tuple 2) z))
-(assert (= r2 (product w z)))
-(assert (not (member e r)))
-(assert (subset r r2))
-(assert (not (member (tuple 3 3) r2)))
+(assert (= r (rel.join x y)))
+(assert (set.member (tuple 1) w))
+(assert (set.member (tuple 2) z))
+(assert (= r2 (rel.product w z)))
+(assert (not (set.member e r)))
+(assert (set.subset r r2))
+(assert (not (set.member (tuple 3 3) r2)))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 4 4)))
-(assert (member e x))
-(assert (not (member (tuple 4 4) x)))
+(assert (set.member e x))
+(assert (not (set.member (tuple 4 4) x)))
(check-sat)
(assert (= v (tuple 1 1)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
-(assert (member (tuple 1 7) x))
-(assert (member (tuple 7 5) y))
-(assert (member z x))
-(assert (member zt y))
-(assert (not (member a (join x y))))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member (tuple 7 5) y))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (not (set.member a (rel.join x y))))
(check-sat)
(assert (= v (tuple 1 1)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
-(assert (member (tuple 1 7) x))
-(assert (member (tuple 4 3) x))
-(assert (member (tuple 7 5) y))
-(assert (member z x))
-(assert (member zt y))
-(assert (member a (join x y)))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member (tuple 4 3) x))
+(assert (set.member (tuple 7 5) y))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (set.member a (rel.join x y)))
(check-sat)
(assert (= v (tuple 1 1)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
-(assert (member (tuple 1 7) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 3 4) x))
-(assert (member (tuple 7 5) y))
-(assert (member (tuple 7 3) y))
-(assert (member (tuple 4 7) y))
-(assert (member z x))
-(assert (member zt y))
-(assert (not (member a (join x y))))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 3 4) x))
+(assert (set.member (tuple 7 5) y))
+(assert (set.member (tuple 7 3) y))
+(assert (set.member (tuple 4 7) y))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (not (set.member a (rel.join x y))))
(check-sat)
(assert (= v (tuple 1 1)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
-(assert (member (tuple 1 7) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 3 4) x))
-(assert (member (tuple 7 5) y))
-(assert (member (tuple 7 3) y))
-(assert (member (tuple 4 7) y))
-(assert (member z x))
-(assert (member zt y))
-(assert (= r (join x y)))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 3 4) x))
+(assert (set.member (tuple 7 5) y))
+(assert (set.member (tuple 7 3) y))
+(assert (set.member (tuple 4 7) y))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (= r (rel.join x y)))
(check-sat)
(assert (= zt (tuple 2 1 3)))
(declare-fun a () (Tuple Int Int Int))
(assert (= a (tuple 1 1 3)))
-(assert (member z x))
-(assert (member zt y))
-(assert (not (member a (join x y))))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (not (set.member a (rel.join x y))))
(check-sat)
(assert (= zt (tuple 2 1 3)))
(declare-fun a () (Tuple Int Int Int))
(assert (= a (tuple 1 1 3)))
-(assert (member z x))
-(assert (member zt y))
-(assert (member a (join x y)))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (set.member a (rel.join x y)))
(check-sat)
(assert (= v (tuple 1 1)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
-(assert (member (tuple 1 7) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 3 4) x))
-(assert (member (tuple 7 5) y))
-(assert (member (tuple 7 3) y))
-(assert (member (tuple 4 7) y))
-(assert (= r (join x y)))
-(assert (member z x))
-(assert (member zt y))
-(assert (not (member a r)))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 3 4) x))
+(assert (set.member (tuple 7 5) y))
+(assert (set.member (tuple 7 3) y))
+(assert (set.member (tuple 4 7) y))
+(assert (= r (rel.join x y)))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (not (set.member a r)))
(check-sat)
(assert (= v (tuple 1 1)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
-(assert (member (tuple 1 7) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 3 4) x))
-(assert (member (tuple 7 5) y))
-(assert (member (tuple 7 3) y))
-(assert (member (tuple 4 7) y))
-(assert (= r (join x y)))
-(assert (member z x))
-(assert (member zt y))
-(assert (member a r))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 3 4) x))
+(assert (set.member (tuple 7 5) y))
+(assert (set.member (tuple 7 3) y))
+(assert (set.member (tuple 4 7) y))
+(assert (= r (rel.join x y)))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (set.member a r))
(check-sat)
(assert (= a (tuple 1 5)))
(declare-fun b () (Tuple Int Int))
(assert (= b (tuple 7 5)))
-(assert (member (tuple 1 7) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 3 4) x))
-(assert (member b y))
-(assert (member (tuple 7 3) y))
-(assert (member (tuple 4 7) y))
-(assert (= r (join x y)))
-(assert (member z x))
-(assert (member zt y))
-(assert (not (member a r)))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 3 4) x))
+(assert (set.member b y))
+(assert (set.member (tuple 7 3) y))
+(assert (set.member (tuple 4 7) y))
+(assert (= r (rel.join x y)))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (not (set.member a r)))
(check-sat)
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int)))
(declare-fun r () (Set (Tuple Int Int)))
-(assert (member (tuple 7 1) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 7 3) y))
-(assert (member (tuple 4 7) y))
-(assert (member (tuple 3 4) z))
+(assert (set.member (tuple 7 1) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 7 3) y))
+(assert (set.member (tuple 4 7) y))
+(assert (set.member (tuple 3 4) z))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 4)))
-(assert (= r (join (join (transpose x) y) z)))
-(assert (not (member a r)))
+(assert (= r (rel.join (rel.join (rel.transpose x) y) z)))
+(assert (not (set.member a r)))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun r () (Set (Tuple Int Int)))
-(assert (= x (union (singleton (tuple 1 2)) (singleton (tuple 3 4)))))
-(assert (= y (join x (union (singleton (tuple 2 1)) (singleton (tuple 4 3))))))
-(assert (not (member (tuple 1 1) y)))
+(assert (= x (set.union (set.singleton (tuple 1 2)) (set.singleton (tuple 3 4)))))
+(assert (= y (rel.join x (set.union (set.singleton (tuple 2 1)) (set.singleton (tuple 4 3))))))
+(assert (not (set.member (tuple 1 1) y)))
(check-sat)
(assert (= v (tuple 1 1)))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
-(assert (member (tuple 1 7) x))
-(assert (member (tuple 7 5) y))
-(assert (member z x))
-(assert (member zt y))
-(assert (= w (union r (join x y))))
-(assert (not (member a w)))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member (tuple 7 5) y))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (= w (set.union r (rel.join x y))))
+(assert (not (set.member a w)))
(check-sat)
(assert (= zt (tuple 2 1)))
(declare-fun v () (Tuple Int Int Int Int))
(assert (= v (tuple 1 2 2 1)))
-(assert (member z x))
-(assert (member zt y))
-(assert (not (member v (product x y))))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (not (set.member v (rel.product x y))))
(check-sat)
(assert (= zt (tuple 2 1)))
(declare-fun v () (Tuple Int Int Int Int))
(assert (= v (tuple 1 2 2 1)))
-(assert (member z x))
-(assert (member zt y))
-(assert (member v (product x y)))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (set.member v (rel.product x y)))
(check-sat)
(assert (= zt (tuple 3 2 1)))
(declare-fun v () (Tuple Int Int Int Int Int Int))
(assert (= v (tuple 1 2 3 3 2 1)))
-(assert (member z x))
-(assert (member zt y))
-(assert (not (member v (product x y))))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (not (set.member v (rel.product x y))))
(check-sat)
(assert (= z (tuple 1 2 3)))
(declare-fun zt () (Tuple Int Int Int))
(assert (= zt (tuple 3 2 1)))
-(assert (member z x))
-(assert (member zt y))
-(assert (member (tuple 1 1 1 1 1 1) r))
-(assert (= r (product x y)))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (set.member (tuple 1 1 1 1 1 1) r))
+(assert (= r (rel.product x y)))
(check-sat)
(declare-fun f () Int)
(declare-fun d () (Tuple Int Int))
(assert (= d (tuple f 3)))
-(assert (member d y))
+(assert (set.member d y))
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 4 f)))
-(assert (member e x))
+(assert (set.member e x))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 4 3)))
-(assert (= r (join x y)))
-(assert (not (member a r)))
+(assert (= r (rel.join x y)))
+(assert (not (set.member a r)))
(check-sat)
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun r () (Set (Tuple Int Int)))
(declare-fun d () (Tuple Int Int))
-(assert (member d y))
+(assert (set.member d y))
(declare-fun a () (Tuple Int Int))
-(assert (member a x))
+(assert (set.member a x))
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 4 3)))
-(assert (= r (join x y)))
-(assert (not (member e r)))
+(assert (= r (rel.join x y)))
+(assert (not (set.member e r)))
(check-sat)
(declare-fun r () (Set (Tuple Int Int)))
(declare-fun d () (Tuple Int Int))
(assert (= d (tuple 1 3)))
-(assert (member (tuple 1 3) y))
+(assert (set.member (tuple 1 3) y))
(declare-fun a () (Tuple Int Int))
-(assert (member a x))
+(assert (set.member a x))
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 4 3)))
-(assert (= r (join x y)))
-(assert (not (member e r)))
+(assert (= r (rel.join x y)))
+(assert (not (set.member e r)))
(check-sat)
(declare-fun r () (Set (Tuple Int Int)))
(declare-fun f () Int)
(declare-fun d () (Tuple Int Int))
-(assert (member d y))
+(assert (set.member d y))
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 4 f)))
-(assert (member e x))
+(assert (set.member e x))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 4 3)))
-(assert (= r (join x y)))
-(assert (not (member a r)))
+(assert (= r (rel.join x y)))
+(assert (not (set.member a r)))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int Int Int)))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 5 3) x))
-(assert (member (tuple 3 9) x))
-(assert (= z (product x y)))
-(assert (member (tuple 1 2 3 4) z))
-(assert (not (member (tuple 5 9) x)))
-(assert (member (tuple 3 8) y))
-(assert (= y (tclosure x)))
-(assert (not (member (tuple 1 2) y)))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 5 3) x))
+(assert (set.member (tuple 3 9) x))
+(assert (= z (rel.product x y)))
+(assert (set.member (tuple 1 2 3 4) z))
+(assert (not (set.member (tuple 5 9) x)))
+(assert (set.member (tuple 3 8) y))
+(assert (= y (rel.tclosure x)))
+(assert (not (set.member (tuple 1 2) y)))
(check-sat)
(assert (= a (tuple 1 e)))
(declare-fun d () (Tuple Int Int))
(assert (= d (tuple e 5)))
-(assert (member a x))
-(assert (member d x))
-(assert (not (member (tuple 1 1) x)))
-(assert (not (member (tuple 1 2) x)))
-(assert (not (member (tuple 1 3) x)))
-(assert (not (member (tuple 1 4) x)))
-(assert (not (member (tuple 1 5) x)))
-(assert (not (member (tuple 1 6) x)))
-(assert (not (member (tuple 1 7) x)))
-(assert (= y (tclosure x)))
-(assert (member (tuple 1 5) y))
+(assert (set.member a x))
+(assert (set.member d x))
+(assert (not (set.member (tuple 1 1) x)))
+(assert (not (set.member (tuple 1 2) x)))
+(assert (not (set.member (tuple 1 3) x)))
+(assert (not (set.member (tuple 1 4) x)))
+(assert (not (set.member (tuple 1 5) x)))
+(assert (not (set.member (tuple 1 6) x)))
+(assert (not (set.member (tuple 1 7) x)))
+(assert (= y (rel.tclosure x)))
+(assert (set.member (tuple 1 5) y))
(check-sat)
(declare-fun b () Int)
(declare-fun c () Int)
(declare-fun d () Int)
-(assert (member (tuple 1 a) x))
-(assert (member (tuple 1 c) x))
-(assert (member (tuple 1 d) x))
-(assert (member (tuple b 1) x))
+(assert (set.member (tuple 1 a) x))
+(assert (set.member (tuple 1 c) x))
+(assert (set.member (tuple 1 d) x))
+(assert (set.member (tuple b 1) x))
(assert (= b d))
(assert (> b (- d 1)))
(assert (< b (+ d 1)))
-(assert (= y (tclosure x)))
-(assert (not (member (tuple 1 1) y)))
+(assert (= y (rel.tclosure x)))
+(assert (not (set.member (tuple 1 1) y)))
(check-sat)
(declare-fun b () Int)
(declare-fun c () Int)
(declare-fun d () Int)
-(assert (member (tuple 1 a) x))
-(assert (member (tuple 1 c) x))
-(assert (member (tuple 1 d) x))
-(assert (member (tuple b 1) x))
+(assert (set.member (tuple 1 a) x))
+(assert (set.member (tuple 1 c) x))
+(assert (set.member (tuple 1 d) x))
+(assert (set.member (tuple b 1) x))
(assert (= b d))
-(assert (= y (tclosure x)))
+(assert (= y (rel.tclosure x)))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun y () (Set (Tuple Int Int)))
-(assert (= y (join (tclosure x) x)))
-(assert (member (tuple 1 2) (join (join x x) x)))
-(assert (not (subset y (tclosure x))))
+(assert (= y (rel.join (rel.tclosure x) x)))
+(assert (set.member (tuple 1 2) (rel.join (rel.join x x) x)))
+(assert (not (set.subset y (rel.tclosure x))))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun y () (Set (Tuple Int Int)))
-(assert (member (tuple 2 2) (tclosure x)))
-(assert (= x (as emptyset (Set (Tuple Int Int)))))
+(assert (set.member (tuple 2 2) (rel.tclosure x)))
+(assert (= x (as set.empty (Set (Tuple Int Int)))))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int)))
-(assert (member (tuple 1 3) x))
-(assert (or (member (tuple 2 3) z) (member (tuple 2 1) z)))
-(assert (= y (transpose x)))
-(assert (not (member (tuple 1 2) y)))
+(assert (set.member (tuple 1 3) x))
+(assert (or (set.member (tuple 2 3) z) (set.member (tuple 2 1) z)))
+(assert (= y (rel.transpose x)))
+(assert (not (set.member (tuple 1 2) y)))
(assert (= x z))
(check-sat)
(assert (= a (tuple 5 1)))
(declare-fun b () (Tuple Int Int))
(assert (= b (tuple 7 5)))
-(assert (member (tuple 1 7) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 3 4) x))
-(assert (member b y))
-(assert (member (tuple 7 3) y))
-(assert (member (tuple 4 7) y))
-(assert (= r (join x y)))
-(assert (member z x))
-(assert (member zt y))
-(assert (not (member a (transpose r))))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 3 4) x))
+(assert (set.member b y))
+(assert (set.member (tuple 7 3) y))
+(assert (set.member (tuple 4 7) y))
+(assert (= r (rel.join x y)))
+(assert (set.member z x))
+(assert (set.member zt y))
+(assert (not (set.member a (rel.transpose r))))
(check-sat)
(assert (= b (tuple 1 7)))
(declare-fun c () (Tuple Int Int))
(assert (= c (tuple 2 3)))
-(assert (member b x))
-(assert (member c x))
+(assert (set.member b x))
+(assert (set.member c x))
(declare-fun d () (Tuple Int Int))
(assert (= d (tuple 7 3)))
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 4 7)))
-(assert (member d y))
-(assert (member e y))
-(assert (member (tuple 3 4) z))
+(assert (set.member d y))
+(assert (set.member e y))
+(assert (set.member (tuple 3 4) z))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 4 1)))
-(assert (= r (join (join x y) z)))
-(assert (not (member a (transpose r))))
+(assert (= r (rel.join (rel.join x y) z)))
+(assert (not (set.member a (rel.transpose r))))
(check-sat)
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int)))
(declare-fun r () (Set (Tuple Int Int)))
-(assert (member (tuple 7 1) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 7 3) y))
-(assert (member (tuple 4 7) y))
-(assert (member (tuple 3 4) z))
+(assert (set.member (tuple 7 1) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 7 3) y))
+(assert (set.member (tuple 4 7) y))
+(assert (set.member (tuple 3 4) z))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 4 1)))
-(assert (= r (join (join (transpose x) y) z)))
-(assert (not (member a (transpose r))))
+(assert (= r (rel.join (rel.join (rel.transpose x) y) z)))
+(assert (not (set.member a (rel.transpose r))))
(check-sat)
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int)))
(declare-fun r () (Set (Tuple Int Int)))
-(assert (member (tuple 7 1) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 7 3) y))
-(assert (member (tuple 4 7) y))
-(assert (member (tuple 3 4) z))
-(assert (member (tuple 3 3) w))
+(assert (set.member (tuple 7 1) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 7 3) y))
+(assert (set.member (tuple 4 7) y))
+(assert (set.member (tuple 3 4) z))
+(assert (set.member (tuple 3 3) w))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 4 1)))
-(assert (not (member a (transpose r))))
+(assert (not (set.member a (rel.transpose r))))
(declare-fun zz () (Set (Tuple Int Int)))
-(assert (= zz (join (transpose x) y)))
-(assert (not (member (tuple 1 3) w)))
-(assert (not (member (tuple 1 3) (union w zz))))
+(assert (= zz (rel.join (rel.transpose x) y)))
+(assert (not (set.member (tuple 1 3) w)))
+(assert (not (set.member (tuple 1 3) (set.union w zz))))
(check-sat)
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int)))
(declare-fun r () (Set (Tuple Int Int)))
-(assert (= x (union (singleton (tuple 1 7)) (singleton (tuple 2 3)))))
+(assert (= x (set.union (set.singleton (tuple 1 7)) (set.singleton (tuple 2 3)))))
(declare-fun d () (Tuple Int Int))
(assert (= d (tuple 7 3)))
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 4 7)))
-(assert (member d y))
-(assert (member e y))
-(assert (member (tuple 3 4) z))
+(assert (set.member d y))
+(assert (set.member e y))
+(assert (set.member (tuple 3 4) z))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 4 1)))
-(assert (= r (join (join x y) z)))
-(assert (not (member a (transpose r))))
+(assert (= r (rel.join (rel.join x y) z)))
+(assert (not (set.member a (rel.transpose r))))
(check-sat)
(declare-fun u () Int)
(assert (and (< 4 t) (< t 6)))
(assert (and (< 4 u) (< u 6)))
-(assert (member (tuple 1 u) x))
-(assert (member (tuple t 3) y))
+(assert (set.member (tuple 1 u) x))
+(assert (set.member (tuple t 3) y))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 3)))
-(assert (not (member a (join x y))))
+(assert (not (set.member a (rel.join x y))))
(check-sat)
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int)))
(declare-fun r () (Set (Tuple Int Int Int Int)))
-(assert (member (tuple 2 1) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 2 2) y))
-(assert (member (tuple 4 7) y))
-(assert (member (tuple 3 4) z))
+(assert (set.member (tuple 2 1) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 2 2) y))
+(assert (set.member (tuple 4 7) y))
+(assert (set.member (tuple 3 4) z))
(declare-fun v () (Tuple Int Int Int Int))
(assert (= v (tuple 4 3 2 1)))
-(assert (= r (product (join (transpose x) y) z)))
-(assert (not (member v (transpose r))))
+(assert (= r (rel.product (rel.join (rel.transpose x) y) z)))
+(assert (not (set.member v (rel.transpose r))))
(check-sat)
(declare-fun u () Int)
(assert (and (< 4 t) (< t 6)))
(assert (and (< 4 u) (< u 6)))
-(assert (member (tuple 1 t) x))
-(assert (member (tuple u 3) y))
+(assert (set.member (tuple 1 t) x))
+(assert (set.member (tuple u 3) y))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 3)))
-(assert (not (member a (join x y))))
+(assert (not (set.member a (rel.join x y))))
(declare-fun st () (Set Int))
(declare-fun su () (Set Int))
-(assert (member t st))
-(assert (member u su))
+(assert (set.member t st))
+(assert (set.member u su))
(check-sat)
(assert (= z (tuple 1 2)))
(declare-fun zt () (Tuple Int Int))
(assert (= zt (tuple 2 1)))
-(assert (member z x))
-(assert (not (member zt (transpose x))))
-(assert (= y (transpose x)))
+(assert (set.member z x))
+(assert (not (set.member zt (rel.transpose x))))
+(assert (= y (rel.transpose x)))
(check-sat)
(assert (= z (tuple 1 2 3)))
(declare-fun zt () (Tuple Int Int Int))
(assert (= zt (tuple 3 2 1)))
-(assert (member z x))
-(assert (not (member zt (transpose x))))
+(assert (set.member z x))
+(assert (not (set.member zt (rel.transpose x))))
(check-sat)
(assert (= z (tuple 1 2 a)))
(declare-fun zt () (Tuple Int Int Int))
(assert (= zt (tuple 3 2 2)))
-(assert (member z x))
-(assert (member zt (transpose x)))
-(assert (= y (transpose x)))
+(assert (set.member z x))
+(assert (set.member zt (rel.transpose x)))
+(assert (= y (rel.transpose x)))
(check-sat)
(declare-fun zt () (Tuple Int Int))
(assert (= zt (tuple 2 1)))
(assert (= x y))
-(assert (member z x))
-(assert (not (member zt (transpose y))))
+(assert (set.member z x))
+(assert (not (set.member zt (rel.transpose y))))
(check-sat)
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Tuple Int Int))
(assert (= z (tuple 1 2)))
-(assert (member z x))
-(assert (not (member (tuple 2 1) (transpose x))))
+(assert (set.member z x))
+(assert (not (set.member (tuple 2 1) (rel.transpose x))))
(check-sat)
(assert (= z (tuple 1 2)))
(declare-fun zt () (Tuple Int Int))
(assert (= zt (tuple 2 1)))
-(assert (member zt y))
+(assert (set.member zt y))
(declare-fun w () (Tuple Int Int))
(assert (= w (tuple 2 2)))
-(assert (member w y))
-(assert (member z x))
-(assert (not (member zt (transpose (join x y)))))
+(assert (set.member w y))
+(assert (set.member z x))
+(assert (not (set.member zt (rel.transpose (rel.join x y)))))
(check-sat)
(assert (= z (tuple 1 2)))
(declare-fun zt () (Tuple Int Int))
(assert (= zt (tuple 2 1)))
-(assert (member z x))
-(assert (member (tuple 3 4) x))
-(assert (member (tuple 3 5) x))
-(assert (member (tuple 3 3) x))
-(assert (= x (transpose y)))
-(assert (not (member zt y)))
-(assert (member z y))
-(assert (not (member zt (transpose y))))
+(assert (set.member z x))
+(assert (set.member (tuple 3 4) x))
+(assert (set.member (tuple 3 5) x))
+(assert (set.member (tuple 3 3) x))
+(assert (= x (rel.transpose y)))
+(assert (not (set.member zt y)))
+(assert (set.member z y))
+(assert (not (set.member zt (rel.transpose y))))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun y () (Set (Tuple Int Int)))
(assert (= x y))
-(assert (not (= (transpose x) (transpose y))))
+(assert (not (= (rel.transpose x) (rel.transpose y))))
(check-sat)
(declare-fun lt2 () (Set (Tuple Int Int)))
(declare-fun i () Int)
-(assert (= r1 (insert (tuple "a" 1) (tuple "b" 2) (tuple "c" 3) (singleton (tuple "d" 4)))))
-(assert (= r2 (insert (tuple 1 "1") (tuple 2 "2") (tuple 3 "3") (singleton (tuple 17 "17")))))
-(assert (= r (join r1 r2)))
-(assert (= s (transpose r)))
-(assert (= t (product r1 r2)))
-(assert (= lt1 (insert (tuple 1 2) (tuple 2 3) (tuple 3 4) (singleton (tuple 4 5)))))
-(assert (= lt2 (tclosure lt1)))
-(assert (= i (card t)))
+(assert (= r1 (set.insert (tuple "a" 1) (tuple "b" 2) (tuple "c" 3) (set.singleton (tuple "d" 4)))))
+(assert (= r2 (set.insert (tuple 1 "1") (tuple 2 "2") (tuple 3 "3") (set.singleton (tuple 17 "17")))))
+(assert (= r (rel.join r1 r2)))
+(assert (= s (rel.transpose r)))
+(assert (= t (rel.product r1 r2)))
+(assert (= lt1 (set.insert (tuple 1 2) (tuple 2 3) (tuple 3 4) (set.singleton (tuple 4 5)))))
+(assert (= lt2 (rel.tclosure lt1)))
+(assert (= i (set.card t)))
(check-sat)
(declare-fun z () (Set (Tuple Int Int)))
(declare-fun x () Int)
(declare-fun y () Int)
-(assert (member (tuple 1 x) w))
-(assert (member (tuple y 2) z))
-(assert (not (member (tuple 1 2) (join w z))))
+(assert (set.member (tuple 1 x) w))
+(assert (set.member (tuple y 2) z))
+(assert (not (set.member (tuple 1 2) (rel.join w z))))
(check-sat)
(declare-fun b2 () Atom)
(assert (forall ((b Atom)) (or
-(member v (k t0 b))
-(member v (k t1 b))
+(set.member v (k t0 b))
+(set.member v (k t1 b))
) ))
-(assert (not (member v (k t2 b2))))
+(assert (not (set.member v (k t2 b2))))
(check-sat)
(declare-fun kk (Atom (Set Atom)) (Set Atom))
(declare-fun n () (Set Atom))
-(assert (forall ((b Atom)) (= (as emptyset (Set Atom)) (kk (j (singleton b)) n))))
+(assert (forall ((b Atom)) (= (as set.empty (Set Atom)) (kk (j (set.singleton b)) n))))
(check-sat)
(assert (forall ((b Atom) (c Atom))
(or
-(member v (k (singleton n) (j (singleton b) a)))
-(= (as emptyset (Set Atom)) (d (j (singleton b) a) (singleton n)))
+(set.member v (k (set.singleton n) (j (set.singleton b) a)))
+(= (as set.empty (Set Atom)) (d (j (set.singleton b) a) (set.singleton n)))
)
)
)
(declare-fun s () (Set E))
(declare-fun t () (Set E))
(declare-fun u () (Set E))
-(assert (>= (card s) 5))
-(assert (>= (card t) 5))
-(assert (<= (card u) 6))
-(assert (= u (union s t)))
+(assert (>= (set.card s) 5))
+(assert (>= (set.card t) 5))
+(assert (<= (set.card u) 6))
+(assert (= u (set.union s t)))
(check-sat)
(declare-fun x () (Set Int))
(declare-fun y () (Set Int))
(declare-fun z () (Set Int))
-(assert (let ((_let_1 (card y))) (and (> (card x) _let_1) (> _let_1 (card z)))))
+(assert (let ((_let_1 (set.card y))) (and (> (set.card x) _let_1) (> _let_1 (set.card z)))))
(check-sat)
(declare-sort E 0)
(declare-fun s () (Set E))
(declare-fun t () (Set E))
-(assert (>= (card s) 5))
-(assert (>= (card t) 5))
-(assert (<= (card (union s t)) 4))
+(assert (>= (set.card s) 5))
+(assert (>= (set.card t) 5))
+(assert (<= (set.card (set.union s t)) 4))
(check-sat)
(set-logic ALL)
(set-info :status sat)
(declare-fun S () (Set Int))
-(assert (>= (card S) 3))
-(assert (not (member 1 S)))
+(assert (>= (set.card S) 3))
+(assert (not (set.member 1 S)))
(check-sat)
(declare-fun x () (Set U))
-(assert (subset x (comprehension ((z U)) (not (= z a)) z)))
+(assert (set.subset x (set.comprehension ((z U)) (not (= z a)) z)))
(check-sat)
(declare-sort Atom 0)
(declare-fun a () (Set (Tuple Atom)))
(declare-fun b () (Set (Tuple Atom)))
-(assert (= a (complement b)))
+(assert (= a (set.complement b)))
(check-sat)
(declare-fun a () (Set Atom))
(declare-fun b () (Set Atom))
(declare-fun c () Atom)
-(assert (= a (complement a)))
-(assert (member c a))
+(assert (= a (set.complement a)))
+(assert (set.member c a))
(check-sat)
(declare-fun C4 () (Set (Tuple Atom)))
(declare-fun ATOM_UNIV () (Set (Tuple Atom)))
(declare-fun V1 () Atom)
-(assert (= C32 (intersection (complement C2) (complement C4))))
-(assert (member (tuple V1) (complement C32)))
-(assert (= ATOM_UNIV (as univset (Set (Tuple Atom)))))
-(assert (member (tuple V1) ATOM_UNIV))
-(assert (member (tuple V1) (complement C2)))
+(assert (= C32 (set.intersection (set.complement C2) (set.complement C4))))
+(assert (set.member (tuple V1) (set.complement C32)))
+(assert (= ATOM_UNIV (as set.universe (Set (Tuple Atom)))))
+(assert (set.member (tuple V1) ATOM_UNIV))
+(assert (set.member (tuple V1) (set.complement C2)))
(check-sat)
(declare-fun b () (Set Int))
(declare-fun c () (Set Int))
(declare-fun e () Int)
-(assert (= a (singleton 5)))
-(assert (= c (union a b)))
-(assert (not (= c (intersection a b))))
-(assert (= c (setminus a b)))
-(assert (subset a b))
-(assert (member e c))
-(assert (member e a))
-(assert (member e (intersection a b)))
+(assert (= a (set.singleton 5)))
+(assert (= c (set.union a b)))
+(assert (not (= c (set.intersection a b))))
+(assert (= c (set.minus a b)))
+(assert (set.subset a b))
+(assert (set.member e c))
+(assert (set.member e a))
+(assert (set.member e (set.intersection a b)))
(push 1)
(assert true)
(pop 1)
(push 1)
(assert (= x y))
-(assert (not (= (union x z) (union y z))))
+(assert (not (= (set.union x z) (set.union y z))))
(push 1)
(assert true)
(push 1)
(assert (= x y))
(assert (= e1 e2))
-(assert (member e1 x))
-(assert (not (member e2 y)))
+(assert (set.member e1 x))
+(assert (not (set.member e2 y)))
(push 1)
(assert true)
(push 1)
(assert (= x y))
(assert (= e1 e2))
-(assert (member e1 (union x z)))
-(assert (not (member e2 (union y z))))
+(assert (set.member e1 (set.union x z)))
+(assert (not (set.member e2 (set.union y z))))
(push 1)
(assert true)
(pop 1)
(push 1)
-(assert (member 5 (union (union (union (union (singleton 1) (singleton 2)) (singleton 3)) (singleton 4)) (singleton 5))))
-(assert (member 5 (union (union (union (union (singleton 1) (singleton 2)) (singleton 3)) (singleton 4)) (as emptyset (Set Int)))))
+(assert (set.member 5 (set.union (set.union (set.union (set.union (set.singleton 1) (set.singleton 2)) (set.singleton 3)) (set.singleton 4)) (set.singleton 5))))
+(assert (set.member 5 (set.union (set.union (set.union (set.union (set.singleton 1) (set.singleton 2)) (set.singleton 3)) (set.singleton 4)) (as set.empty (Set Int)))))
(push 1)
(assert true)
(pop 1)
(pop 1)
-(check-sat-assuming ( (not (let ((_let_1 (member e1 z))) (and _let_1 (not _let_1)))) ))
+(check-sat-assuming ( (not (let ((_let_1 (set.member e1 z))) (and _let_1 (not _let_1)))) ))
(declare-fun x1 () D)
(declare-fun S () (Set D))
(declare-fun P (D) Bool)
-(assert (member x1 S))
-(assert (=> (member (A 0) S) (P x1)))
+(assert (set.member x1 S))
+(assert (=> (set.member (A 0) S) (P x1)))
(check-sat)
(set-logic ALL)
(set-info :status unsat)
-(assert (member 5 (as emptyset (Set Int) )))
+(assert (set.member 5 (as set.empty (Set Int) )))
(check-sat)
(declare-fun H () (Set Int) )
(declare-fun I () (Set Int) )
(declare-fun x () Int)
-(assert (member x (intersection (union A B) C)))
-(assert (not (member x G)))
-(assert (= (union A B) D))
-(assert (= C (intersection E F)))
+(assert (set.member x (set.intersection (set.union A B) C)))
+(assert (not (set.member x G)))
+(assert (= (set.union A B) D))
+(assert (= C (set.intersection E F)))
(assert (and (= F H) (= G H) (= H I)))
(check-sat)
(declare-fun E () (Set Int))
(set-info :status sat)
-(assert (= A (union D C)))
-(assert (not (= A (union E A))))
+(assert (= A (set.union D C)))
+(assert (not (= A (set.union E A))))
(check-sat)
(set-logic QF_ALL)
(set-info :status unsat)
-(assert (= (as emptyset (Set Int)) (singleton 5)))
+(assert (= (as set.empty (Set Int)) (set.singleton 5)))
(check-sat)
(set-logic QF_UFLIAFS)
(set-info :status sat)
(declare-fun X () (Set Int))
-(assert (= X (insert 1 2 (singleton 3))))
+(assert (= X (set.insert 1 2 (set.singleton 3))))
(check-sat)
;(get-model)
(declare-fun x () Real)
-(assert (= (as univset (Set Real)) (as univset (Set Real))))
+(assert (= (as set.universe (Set Real)) (as set.universe (Set Real))))
-(assert (member x a))
+(assert (set.member x a))
(assert (and (<= 5.5 x) (< x 5.8)))
(declare-fun x () Real)
-(assert (= (as univset (Set Real)) (as univset (Set Real))))
+(assert (= (as set.universe (Set Real)) (as set.universe (Set Real))))
-(assert (member x a))
+(assert (set.member x a))
(assert (and (<= 5.5 x) (< x 6.1)))
(set-info :status unsat)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3v58 () Int)
(declare-fun z3v59 () Int)
(assert (distinct z3v58 z3v59))
(declare-fun S () (Set Int))
(declare-fun T () (Set Int))
-(assert (member x S))
+(assert (set.member x S))
-(assert (= S (union T (singleton y))))
+(assert (= S (set.union T (set.singleton y))))
(assert (not (= x y)))
-(assert (not (member x T)))
+(assert (not (set.member x T)))
(check-sat)
(set-info :status unsat)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
(declare-fun S () (Set Int))
(declare-fun T () (Set Int))
(assert (not (= S T)))
-(assert (= T (union smt_set_emp S)))
+(assert (= T (set.union smt_set_emp S)))
(check-sat)
; What was the bug?
(set-info :status unsat)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2)))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3v54 () Int)
(declare-fun z3f55 (Int) Int)
(declare-fun z3v56 () Int)
(declare-fun T () mySet)
(assert (= (f x)
- (union S T)))
+ (set.union S T)))
(assert (= (f x)
- (union T (f y))))
+ (set.union T (f y))))
(assert (not (= (f y)
- (union T (f y)))))
+ (set.union T (f y)))))
(check-sat)
;
; What was going on?
;
-; The solver was unable to reason that (emptyset) cannot equal
-; (singleton 0). There were no membership predicates anywhere, just
+; The solver was unable to reason that (set.empty) cannot equal
+; (set.singleton 0). There were no membership predicates anywhere, just
; equalities.
;
; Fix
;
-; Add the propagation rule: (true) => (member x (singleton x))
+; Add the propagation rule: (true) => (set.member x (set.singleton x))
(declare-fun z3f70 (Int) (Set Int))
(declare-fun z3v85 () Int)
(declare-fun z3v87 () Int)
(declare-fun z3v90 () Int)
-(assert (= (z3f70 z3v90) (union (z3f70 z3v85) (union (as emptyset (Set Int)) (singleton z3v86)))))
+(assert (= (z3f70 z3v90) (set.union (z3f70 z3v85) (set.union (as set.empty (Set Int)) (set.singleton z3v86)))))
(assert (= (z3f70 z3v90) (z3f70 z3v87)))
-(assert (= (as emptyset (Set Int)) (z3f70 z3v87)))
+(assert (= (as set.empty (Set Int)) (z3f70 z3v87)))
(check-sat)
(define-sort Elt () Int)
(define-sort mySet ()
(Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
(declare-fun S () (Set Int))
(declare-fun T () (Set Int))
(declare-fun x () Int)
-(assert (or (not (= S smt_set_emp)) (member x T)))
+(assert (or (not (= S smt_set_emp)) (set.member x T)))
(assert (= smt_set_emp
- (ite (member x T)
- (union (union smt_set_emp (singleton x)) S)
+ (ite (set.member x T)
+ (set.union (set.union smt_set_emp (set.singleton x)) S)
S)))
(check-sat)
(declare-fun b () Int)
(declare-fun x () (Set Int))
(declare-fun y () (Set Int))
-(assert (= x (singleton a)))
-(assert (= y (singleton b)))
+(assert (= x (set.singleton a)))
+(assert (= y (set.singleton b)))
(assert (not (= x y)))
(assert (and (< 1 a) (< a 3) (< 1 b) (< b 3)))
(check-sat)
(declare-fun z () Int)
(declare-fun a () (Set Int))
(declare-fun b () (Set Int))
-(assert (member x (union a b)))
-(assert (not (member y a)))
-(assert (not (member z b)))
+(assert (set.member x (set.union a b)))
+(assert (not (set.member y a)))
+(assert (not (set.member z b)))
(assert (= z y))
(assert (= x y))
(check-sat)
(declare-fun y () Int)
(declare-fun a () (Set Int))
(declare-fun b () (Set Int))
-(assert (member x (union a b)))
-(assert (not (member y a)))
+(assert (set.member x (set.union a b)))
+(assert (not (set.member y a)))
(assert (= x y))
(check-sat)
(declare-fun P ((Set Int)) Bool)
(assert (P x))
-(assert (not (P (singleton 0))))
-(assert (member 1 x))
-(assert (not (member 0 (as univset (Set Int)))))
+(assert (not (P (set.singleton 0))))
+(assert (set.member 1 x))
+(assert (not (set.member 0 (as set.universe (Set Int)))))
(check-sat)
(set-info :status unsat)
(declare-fun x () (Set Int))
-(assert (= x (union (singleton 0) (singleton 1))))
+(assert (= x (set.union (set.singleton 0) (set.singleton 1))))
-(assert (not (member 0 (as univset (Set Int)))))
+(assert (not (set.member 0 (as set.universe (Set Int)))))
(check-sat)
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 curr$0 l1 null$0)
- (member l1 (lseg_domain$0 next$0 curr$0 null$0))
+ (set.member l1 (lseg_domain$0 next$0 curr$0 null$0))
(not (= l1 null$0)))
(and (or (= l1 null$0) (not (Btwn$0 next$0 curr$0 l1 null$0)))
- (not (member l1 (lseg_domain$0 next$0 curr$0 null$0))))))
+ (not (set.member l1 (lseg_domain$0 next$0 curr$0 null$0))))))
:named lseg_footprint_14))
-(assert (! (not (member tmp_1$0 Alloc$0)) :named new_42_10))
+(assert (! (not (set.member tmp_1$0 Alloc$0)) :named new_42_10))
-(assert (! (not (member null$0 Alloc$0))
+(assert (! (not (set.member null$0 Alloc$0))
:named initial_footprint_of_rec_copy_loop_34_11_4))
(assert (! (not (= curr$0 null$0)) :named if_else_37_6))
(assert (! (= sk_?X_36$0 FP$0) :named precondition_of_rec_copy_loop_34_11_18))
-(assert (! (= (as emptyset SetLoc) (intersection sk_?X_38$0 sk_?X_37$0))
+(assert (! (= (as set.empty SetLoc) (set.intersection sk_?X_38$0 sk_?X_37$0))
:named precondition_of_rec_copy_loop_34_11_19))
(assert (! (= old_cp_2$0 cp$0) :named assign_41_4))
-(assert (! (= FP_Caller_2$0 (setminus FP_Caller$0 FP$0)) :named assign_37_2_2))
+(assert (! (= FP_Caller_2$0 (set.minus FP_Caller$0 FP$0)) :named assign_37_2_2))
-(assert (! (= Alloc_2$0 (union Alloc$0 (singleton tmp_1$0))) :named assign_42_10))
+(assert (! (= Alloc_2$0 (set.union Alloc$0 (set.singleton tmp_1$0))) :named assign_42_10))
(assert (! (or (Btwn$0 next$0 cp$0 null$0 null$0)
(not (lseg_struct$0 sk_?X_38$0 next$0 cp$0 null$0)))
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 cp$0 l1 null$0)
- (member l1 (lseg_domain$0 next$0 cp$0 null$0))
+ (set.member l1 (lseg_domain$0 next$0 cp$0 null$0))
(not (= l1 null$0)))
(and (or (= l1 null$0) (not (Btwn$0 next$0 cp$0 l1 null$0)))
- (not (member l1 (lseg_domain$0 next$0 cp$0 null$0))))))
+ (not (set.member l1 (lseg_domain$0 next$0 cp$0 null$0))))))
:named lseg_footprint_15))
-(assert (! (not (member cp_1$0 FP_3$0)) :named check_heap_access_43_4))
+(assert (! (not (set.member cp_1$0 FP_3$0)) :named check_heap_access_43_4))
(assert (! (not (= tmp_1$0 null$0)) :named new_42_10_1))
(assert (! (lseg_struct$0 sk_?X_38$0 next$0 cp$0 null$0)
:named precondition_of_rec_copy_loop_34_11_20))
-(assert (! (= FP_Caller$0 (union FP$0 FP_Caller$0))
+(assert (! (= FP_Caller$0 (set.union FP$0 FP_Caller$0))
:named precondition_of_rec_copy_loop_34_11_21))
(assert (! (= sk_?X_37$0 (lseg_domain$0 next$0 curr$0 null$0))
:named precondition_of_rec_copy_loop_34_11_22))
-(assert (! (= sk_?X_36$0 (union sk_?X_37$0 sk_?X_38$0))
+(assert (! (= sk_?X_36$0 (set.union sk_?X_37$0 sk_?X_38$0))
:named precondition_of_rec_copy_loop_34_11_23))
-(assert (! (= Alloc$0 (union FP_Caller$0 Alloc$0))
+(assert (! (= Alloc$0 (set.union FP_Caller$0 Alloc$0))
:named initial_footprint_of_rec_copy_loop_34_11_5))
(assert (! (= cp_1$0 tmp_1$0) :named assign_42_4))
-(assert (! (= FP_3$0 (union FP$0 (singleton tmp_1$0))) :named assign_42_10_1))
+(assert (! (= FP_3$0 (set.union FP$0 (set.singleton tmp_1$0))) :named assign_42_10_1))
(assert (! (or (Btwn$0 next$0 curr$0 null$0 null$0)
(not (lseg_struct$0 sk_?X_37$0 next$0 curr$0 null$0)))
(declare-fun T () (Set Int))
(declare-fun x () Int)
(declare-fun y () Int)
-(assert (member y S))
-(assert (not (member x (union S T))))
+(assert (set.member y S))
+(assert (not (set.member x (set.union S T))))
(assert (= x y))
(check-sat)
(set-logic ALL)
(set-info :status sat)
(declare-fun S () (Set (_ BitVec 1)))
-(assert (not (= S (as emptyset (Set (_ BitVec 1))))))
+(assert (not (= S (as set.empty (Set (_ BitVec 1))))))
(check-sat)
(assert (= x y))
(declare-fun a () (Set Int))
(declare-fun b () (Set Int))
-(assert (not (member x a)))
-(assert (member y (union a b)))
+(assert (not (set.member x a)))
+(assert (set.member y (set.union a b)))
(assert (= x z))
-(assert (not (member z a)))
+(assert (not (set.member z a)))
(assert (= a b))
(check-sat)
(declare-fun S () (Set Atom))
-(assert (= S (union (singleton a) (union (singleton c) (singleton b)))))
+(assert (= S (set.union (set.singleton a) (set.union (set.singleton c) (set.singleton b)))))
(check-sat)
(declare-fun a () (Set Int))
(declare-fun b () (Set Int))
(declare-fun x () Int)
-;(assert (not (member x a)))
-(assert (member x (intersection a b)))
-(assert (not (member x b)))
+;(assert (not (set.member x a)))
+(assert (set.member x (set.intersection a b)))
+(assert (not (set.member x b)))
(check-sat)
(exit)
(declare-fun A () SetInt)
(declare-fun B () SetInt)
(declare-fun x () Int)
-(assert (member x (union A B)))
+(assert (set.member x (set.union A B)))
-(assert (not (member x (intersection A B))))
-(assert (not (member x (setminus A B))))
-;(assert (not (member x (setminus B A))))
-;(assert (member x B))
+(assert (not (set.member x (set.intersection A B))))
+(assert (not (set.member x (set.minus A B))))
+;(assert (not (set.member x (set.minus B A))))
+;(assert (set.member x B))
(check-sat)
(declare-fun x () (Set Real))
(declare-fun y () (Set Real))
-(assert (member 0.5 y))
-(assert (member y s))
-(assert (or (= s t) (= s (singleton (singleton 1.0))) (= s (singleton (singleton 0.0)))))
+(assert (set.member 0.5 y))
+(assert (set.member y s))
+(assert (or (= s t) (= s (set.singleton (set.singleton 1.0))) (= s (set.singleton (set.singleton 0.0)))))
(check-sat)
(declare-fun r1 () (Set Real))
(declare-fun r2 () (Set Real))
(declare-fun r3 () (Set Real))
-(assert (and (member 1.5 s) (member 0.0 s)))
-(assert (= t1 (union s (singleton 2.5))))
-(assert (= t2 (union s (singleton 2.0))))
-(assert (= t3 (union r3 (singleton 2.5))))
-(assert (= (intersection r1 r2) (intersection s (singleton 0.0))))
-(assert (not (= r1 (as emptyset (Set Real)))))
+(assert (and (set.member 1.5 s) (set.member 0.0 s)))
+(assert (= t1 (set.union s (set.singleton 2.5))))
+(assert (= t2 (set.union s (set.singleton 2.0))))
+(assert (= t3 (set.union r3 (set.singleton 2.5))))
+(assert (= (set.intersection r1 r2) (set.intersection s (set.singleton 0.0))))
+(assert (not (= r1 (as set.empty (Set Real)))))
(check-sat)
(declare-fun t () (Set Real))
(declare-fun r () (Set Real))
(declare-fun u () (Set Real))
-(assert (member 1.5 t))
-(assert (member 2.5 r))
-(assert (member 3.5 u))
+(assert (set.member 1.5 t))
+(assert (set.member 2.5 r))
+(assert (set.member 3.5 u))
(assert (or (= s t) (= s r) (= s u)))
(check-sat)
(declare-fun b () (Set Int))
(declare-fun c () (Set Int))
(declare-fun e () Int)
-(assert (= a (singleton 5)))
-(assert (= c (union a b) ))
-(assert (not (= c (intersection a b) )))
-(assert (= c (setminus a b) ))
-(assert (subset a b))
-(assert (member e c))
-(assert (member e a))
-(assert (member e (intersection a b)))
+(assert (= a (set.singleton 5)))
+(assert (= c (set.union a b) ))
+(assert (not (= c (set.intersection a b) )))
+(assert (= c (set.minus a b) ))
+(assert (set.subset a b))
+(assert (set.member e c))
+(assert (set.member e a))
+(assert (set.member e (set.intersection a b)))
(check-sat)
(pop 1)
-; UF can tell that this is UNSAT (union)
+; UF can tell that this is UNSAT (set.union)
(push 1)
(declare-fun x () (Set Int))
(declare-fun y () (Set Int))
(declare-fun z () (Set Int))
(assert (= x y))
-(assert (not (= (union x z) (union y z))))
+(assert (not (= (set.union x z) (set.union y z))))
(check-sat)
(pop 1)
(declare-fun e2 () Int)
(assert (= x y))
(assert (= e1 e2))
-(assert (member e1 x))
-(assert (not (member e2 y)))
+(assert (set.member e1 x))
+(assert (not (set.member e2 y)))
(check-sat)
(pop 1)
-; UF can tell that this is UNSAT (merge union + containment examples)
+; UF can tell that this is UNSAT (merge set.union + containment examples)
(push 1)
(declare-fun x () (Set Int))
(declare-fun y () (Set Int))
(declare-fun e2 () Int)
(assert (= x y))
(assert (= e1 e2))
-(assert (member e1 (union x z)))
-(assert (not (member e2 (union y z))))
+(assert (set.member e1 (set.union x z)))
+(assert (not (set.member e2 (set.union y z))))
(check-sat)
(pop 1)
; test all the other kinds for completeness
(push 1)
-(assert (member 5 (insert 1 2 3 4 (singleton 5))))
-(assert (member 5 (insert 1 2 3 4 (as emptyset (Set Int)))))
+(assert (set.member 5 (set.insert 1 2 3 4 (set.singleton 5))))
+(assert (set.member 5 (set.insert 1 2 3 4 (as set.empty (Set Int)))))
(check-sat)
(exit)
(declare-fun S () (Set Int))
(declare-fun x () Int)
-(assert (member (+ 5 x) S))
-(assert (not (member 9 S)))
+(assert (set.member (+ 5 x) S))
+(assert (not (set.member 9 S)))
(assert (= x 4))
(check-sat)
(declare-fun a () (Set Int))
(declare-fun b () (Set Int))
(declare-fun x () Int)
-(assert (not (member x a)))
-(assert (member x (union a b)))
+(assert (not (set.member x a)))
+(assert (set.member x (set.union a b)))
(check-sat)
;(get-model)
-(assert (not (member x b)))
+(assert (not (set.member x b)))
(check-sat)
(exit)
(declare-fun C () (Set Int))
(declare-fun D () (Set Int))
-(assert (member x A))
-(assert (member y B))
-(assert (or (= C (intersection A B)) (= D (intersection A B))))
+(assert (set.member x A))
+(assert (set.member y B))
+(assert (or (= C (set.intersection A B)) (= D (set.intersection A B))))
(check-sat)
(declare-fun A () (Set Int))
(declare-fun B () (Set Int))
(declare-fun x () Int)
-(assert (member x A))
+(assert (set.member x A))
(push 1)
-(assert (not (member x (union A B))))
+(assert (not (set.member x (set.union A B))))
(check-sat)
(pop 1)
(check-sat)
(declare-fun A () (Set Int))
(declare-fun B () (Set Int))
(declare-fun x () Int)
-(assert (not (member x (union A B))))
+(assert (not (set.member x (set.union A B))))
(push 1)
-(assert (member x A))
+(assert (set.member x A))
(check-sat)
(pop 1)
(check-sat)
(declare-fun A () (Set Int))
(declare-fun B () (Set Int))
(declare-fun x () Int)
-(assert (member x B))
+(assert (set.member x B))
(push 1)
-(assert (not (member x (union A B))))
+(assert (not (set.member x (set.union A B))))
(check-sat)
(pop 1)
(check-sat)
(declare-fun A () (Set Int))
(declare-fun B () (Set Int))
(declare-fun x () Int)
-(assert (not (member x (union A B))))
+(assert (not (set.member x (set.union A B))))
(push 1)
-(assert (member x B))
+(assert (set.member x B))
(check-sat)
(pop 1)
(check-sat)
(declare-fun B () (Set Int))
(declare-fun x () Int)
(declare-fun y () Int)
-(assert (member x (union A B)))
-(assert (not (member y A)))
-(assert (not (member y B)))
+(assert (set.member x (set.union A B)))
+(assert (not (set.member y A)))
+(assert (not (set.member y B)))
(check-sat)
(declare-fun x () Int)
-(assert (not (member 0 a)))
-(assert (member 0 b))
-(assert (not (member 1 c)))
-(assert (member 2 d))
-(assert (= e (as univset (Set Int))))
-(assert (= f (complement d)))
-(assert (not (member x (as univset (Set Int)))))
+(assert (not (set.member 0 a)))
+(assert (set.member 0 b))
+(assert (not (set.member 1 c)))
+(assert (set.member 2 d))
+(assert (= e (as set.universe (Set Int))))
+(assert (= f (set.complement d)))
+(assert (not (set.member x (as set.universe (Set Int)))))
(check-sat)
% Maximal clause size : 1 ( 1 average)
% Number of predicates : 1 ( 0 propositional; 2-2 arity)
% Number of functors : 5 ( 2 constant; 0-2 arity)
-% Number of variables : 14 ( 0 singleton)
+% Number of variables : 14 ( 0 set.singleton)
% Maximal term depth : 3 ( 2 average)
% SPC :
% ( 0 <~>; 0 ~|; 0 ~&)
% Number of predicates : 3 ( 3 propositional; 0-0 arity)
% Number of functors : 0 ( 0 constant; --- arity)
-% Number of variables : 0 ( 0 singleton; 0 !; 0 ?)
+% Number of variables : 0 ( 0 set.singleton; 0 !; 0 ?)
% Maximal term depth : 0 ( 0 average)
% SPC :
% Maximal clause size : 1 ( 1 average)
% Number of predicates : 3 ( 3 propositional; 0-0 arity)
% Number of functors : 0 ( 0 constant; --- arity)
-% Number of variables : 0 ( 0 singleton)
+% Number of variables : 0 ( 0 set.singleton)
% Maximal term depth : 0 ( 0 average)
% SPC :
% Maximal clause size : 1 ( 1 average)
% Number of predicates : 1 ( 0 propositional; 2-2 arity)
% Number of functors : 6 ( 3 constant; 0-2 arity)
-% Number of variables : 14 ( 0 singleton)
+% Number of variables : 14 ( 0 set.singleton)
% Maximal term depth : 3 ( 2 average)
% SPC : CNF_UNS_RFO_PEQ_UEQ
% Maximal clause size : 1 ( 1 average)
% Number of predicates : 1 ( 0 propositional; 2-2 arity)
% Number of functors : 5 ( 2 constant; 0-2 arity)
-% Number of variables : 10 ( 0 singleton)
+% Number of variables : 10 ( 0 set.singleton)
% Maximal term depth : 5 ( 3 average)
% SPC : CNF_SAT_RFO_PEQ_UEQ
% ( 0 <~>; 0 ~|; 0 ~&)
% Number of predicates : 6 ( 0 propositional; 1-2 arity)
% Number of functors : 0 ( 0 constant; --- arity)
-% Number of variables : 6 ( 0 singleton; 4 !; 2 ?)
+% Number of variables : 6 ( 0 set.singleton; 4 !; 2 ?)
% Maximal term depth : 1 ( 1 average)
% SPC : FOF_SAT_RFO_NEQ
% ( 0 <~>; 0 ~|; 0 ~&)
% Number of predicates : 11 ( 0 propositional; 1-2 arity)
% Number of functors : 7 ( 7 constant; 0-0 arity)
-% Number of variables : 37 ( 0 singleton; 36 !; 1 ?)
+% Number of variables : 37 ( 0 set.singleton; 36 !; 1 ?)
% Maximal term depth : 1 ( 1 average)
% SPC : FOF_UNS_RFO_SEQ
% ( 0 <~>; 0 ~|; 0 ~&)
% Number of predicates : 7 ( 0 propositional; 1-4 arity)
% Number of functors : 5 ( 2 constant; 0-2 arity)
-% Number of variables : 11 ( 0 singleton; 9 !; 2 ?)
+% Number of variables : 11 ( 0 set.singleton; 9 !; 2 ?)
% Maximal term depth : 2 ( 1 average)
% SPC : FOF_CSA_RFO_SEQ
% Maximal clause size : 5 ( 3 average)
% Number of predicates : 6 ( 0 propositional; 1-3 arity)
% Number of functors : 10 ( 6 constant; 0-2 arity)
-% Number of variables : 23 ( 0 singleton)
+% Number of variables : 23 ( 0 set.singleton)
% Maximal term depth : 3 ( 1 average)
% SPC : CNF_SAT_RFO_EQU_NUE
% Maximal clause size : 4 ( 2 average)
% Number of predicates : 6 ( 0 propositional; 1-3 arity)
% Number of functors : 4 ( 4 constant; 0-0 arity)
-% Number of variables : 8 ( 1 singleton)
+% Number of variables : 8 ( 1 set.singleton)
% Maximal term depth : 1 ( 1 average)
% SPC : CNF_UNS_EPR
% Maximal clause size : 18 ( 3 average)
% Number of predicates : 18 ( 1 propositional; 0-3 arity)
% Number of functors : 11 ( 11 constant; 0-0 arity)
-% Number of variables : 11 ( 0 singleton)
+% Number of variables : 11 ( 0 set.singleton)
% Maximal term depth : 1 ( 1 average)
% SPC : CNF_SAT_EPR
% Maximal clause size : 5 ( 2 average)
% Number of predicates : 16 ( 10 propositional; 0-3 arity)
% Number of functors : 8 ( 5 constant; 0-3 arity)
-% Number of variables : 11 ( 5 singleton)
+% Number of variables : 11 ( 5 set.singleton)
% Maximal term depth : 4 ( 2 average)
% SPC : CNF_UNS_RFO_SEQ_NHN
% ( 0 <~>; 0 ~|; 0 ~&)
% Number of predicates : 2 ( 0 propositional; 2-2 arity)
% Number of functors : 0 ( 0 constant; --- arity)
-% Number of variables : 8 ( 0 singleton; 4 !; 4 ?)
+% Number of variables : 8 ( 0 set.singleton; 4 !; 4 ?)
% Maximal term depth : 1 ( 1 average)
% SPC : FOF_THM_RFO_SEQ
% Maximal clause size : 4 ( 3 average)
% Number of predicates : 2 ( 0 propositional; 2-2 arity)
% Number of functors : 5 ( 2 constant; 0-2 arity)
-% Number of variables : 23 ( 2 singleton)
+% Number of variables : 23 ( 2 set.singleton)
% Maximal term depth : 2 ( 1 average)
% SPC : CNF_UNS_RFO_SEQ_NHN
(assert (forall ((l4 List0) (e1 Int)) (! (= (buggySortedIns e1 l4) (ite ((_ is Nil) l4) (Cons e1 Nil) (ite (<= (head0 l4) e1) (Cons (head0 l4) (buggySortedIns e1 (tail0 l4))) (Cons e1 l4)))) :pattern ((buggySortedIns e1 l4)))))
(assert (forall ((l3 List0) (e Int)) (! (= (sortedIns e l3) (ite ((_ is Nil) l3) (Cons e Nil) (ite (<= (head0 l3) e) (Cons (head0 l3) (sortedIns e (tail0 l3))) (Cons e l3)))) :pattern ((sortedIns e l3)))))
(assert (forall ((l5 List0)) (! (= (sort l5) (ite ((_ is Nil) l5) Nil (sortedIns (head0 l5) (sort (tail0 l5))))) :pattern ((sort l5)))))
-(assert (forall ((l1 List0)) (! (= (contents l1) (ite ((_ is Nil) l1) (as emptyset (Set Int)) (union (contents (tail0 l1)) (singleton (head0 l1))))) :pattern ((contents l1)))))
+(assert (forall ((l1 List0)) (! (= (contents l1) (ite ((_ is Nil) l1) (as set.empty (Set Int)) (set.union (contents (tail0 l1)) (set.singleton (head0 l1))))) :pattern ((contents l1)))))
(push)
(assert (forall ((l List0)) (not (let ((result (ite ((_ is Nil) l) 0 (+ 1 (size (tail0 l)))))) (>= result 0)))))
(pop)
(push)
-(assert (forall ((l4 List0) (e1 Int)) (not (let ((result2 (ite ((_ is Nil) l4) (Cons e1 Nil) (ite (<= (head0 l4) e1) (Cons (head0 l4) (buggySortedIns e1 (tail0 l4))) (Cons e1 l4))))) (and (= (contents result2) (union (contents l4) (singleton e1))) (isSorted result2) (= (size result2) (+ (size l4) 1)))))))
+(assert (forall ((l4 List0) (e1 Int)) (not (let ((result2 (ite ((_ is Nil) l4) (Cons e1 Nil) (ite (<= (head0 l4) e1) (Cons (head0 l4) (buggySortedIns e1 (tail0 l4))) (Cons e1 l4))))) (and (= (contents result2) (set.union (contents l4) (set.singleton e1))) (isSorted result2) (= (size result2) (+ (size l4) 1)))))))
(check-sat)
(pop)
))
(declare-fun a () T)
(assert (not ((_ is Emp) a)))
-(assert (= (s a) (singleton a)))
+(assert (= (s a) (set.singleton a)))
(check-sat)
(assert (forall ((mk_array_7_index node$type)) (= (select mk_array_7
mk_array_7_index) null_state)))
(define-fun null_state_set () state_set$type mk_array_7)
-(declare-fun choose (Values$t$type) value$type)
+(declare-fun set.choose (Values$t$type) value$type)
;choosen_value :
(assert (forall ((vals Values$t$type)) (or (= vals Values$empty) (= (Values$mem
- (choose
+ (set.choose
vals)
vals)
Truth))))
(declare-fun S () (Set list))
; can use simple unification to infer bounds on x and y
-(assert (forall ((x Int) (y list)) (=> (member (cons x y) S) (P x))))
+(assert (forall ((x Int) (y list)) (=> (set.member (cons x y) S) (P x))))
-(assert (member (cons 4 (cons 1 nil)) S))
-(assert (member (cons 2 nil) S))
+(assert (set.member (cons 4 (cons 1 nil)) S))
+(assert (set.member (cons 2 nil) S))
; should construct instantiation involving selectors for l
(declare-fun l () list)
(assert ((_ is cons) l))
-(assert (member l S))
+(assert (set.member l S))
; should not contribute to instantiations
-(assert (member nil S))
+(assert (set.member nil S))
(assert (not (P 1)))
(assert (not (P 0)))
(declare-fun h (U) Int)
-(assert (member 77 S))
+(assert (set.member 77 S))
(assert (>= (h (f 77)) 3))
(assert (>= (h (g 77)) 2))
(assert (not (= (g 77) (f 77))))
(assert (forall ((x Int) (z U)) (=>
(or (= z (f x)) (= z (g x)))
-(=> (member x S)
+(=> (set.member x S)
(P x 0 z)))))
(assert (forall ((x Int) (y Int) (z U)) (=>
(set-option :produce-models true)
(declare-fun X () (Set Int))
(declare-fun Y () (Set Int))
-(assert (forall ((x Int)) (=> (member x X) (> x 0))))
-(check-sat-assuming ( (=> (and (= (card X) 5) (= Y (union X (singleton 9)))) (<= (card Y) 4)) ))
+(assert (forall ((x Int)) (=> (set.member x X) (> x 0))))
+(check-sat-assuming ( (=> (and (= (set.card X) 5) (= Y (set.union X (set.singleton 9)))) (<= (set.card Y) 4)) ))
(declare-fun or2 () |__cvc5_record_O_MOPERATION_T_TEAR_TYPE_R_ORDER_A_ATOM_B_SDBLOCK_TYPE_M_(Set BINT)_V_VALUE_TYPE|)
(declare-fun v1 () VALUE_TYPE)
(declare-fun v2 () VALUE_TYPE)
-(assert (and (and (and (and (and (and (= (O ow1) W) (= (T ow1) TEAR_FALSE)) (= (RR ow1) U)) (= (A ow1) NA)) (= (B ow1) m1)) (= (M ow1) (singleton I0))) (= (V ow1) v1)))
-(assert (and (and (and (and (and (and (= (O or2) R) (= (T or2) TEAR_FALSE)) (= (RR or2) U)) (= (A or2) NA)) (= (B or2) m1)) (= (M or2) (singleton I0))) (= (V or2) v2)))
+(assert (and (and (and (and (and (and (= (O ow1) W) (= (T ow1) TEAR_FALSE)) (= (RR ow1) U)) (= (A ow1) NA)) (= (B ow1) m1)) (= (M ow1) (set.singleton I0))) (= (V ow1) v1)))
+(assert (and (and (and (and (and (and (= (O or2) R) (= (T or2) TEAR_FALSE)) (= (RR or2) U)) (= (A or2) NA)) (= (B or2) m1)) (= (M or2) (set.singleton I0))) (= (V or2) v2)))
(declare-fun ev_set () (Set |__cvc5_record_O_MOPERATION_T_TEAR_TYPE_R_ORDER_A_ATOM_B_SDBLOCK_TYPE_M_(Set BINT)_V_VALUE_TYPE|))
-(assert (= ev_set (union (singleton ow1) (singleton or2))))
+(assert (= ev_set (set.union (set.singleton ow1) (set.singleton or2))))
(declare-fun RF () (Set (Tuple |__cvc5_record_O_MOPERATION_T_TEAR_TYPE_R_ORDER_A_ATOM_B_SDBLOCK_TYPE_M_(Set BINT)_V_VALUE_TYPE| |__cvc5_record_O_MOPERATION_T_TEAR_TYPE_R_ORDER_A_ATOM_B_SDBLOCK_TYPE_M_(Set BINT)_V_VALUE_TYPE|)))
-(assert (forall ((r |__cvc5_record_O_MOPERATION_T_TEAR_TYPE_R_ORDER_A_ATOM_B_SDBLOCK_TYPE_M_(Set BINT)_V_VALUE_TYPE|) (w |__cvc5_record_O_MOPERATION_T_TEAR_TYPE_R_ORDER_A_ATOM_B_SDBLOCK_TYPE_M_(Set BINT)_V_VALUE_TYPE|)) (=> (and (member r ev_set) (member w ev_set)) (= (member (tuple r w) RF) (and (= (O r) R) (= (O w) W))))))
+(assert (forall ((r |__cvc5_record_O_MOPERATION_T_TEAR_TYPE_R_ORDER_A_ATOM_B_SDBLOCK_TYPE_M_(Set BINT)_V_VALUE_TYPE|) (w |__cvc5_record_O_MOPERATION_T_TEAR_TYPE_R_ORDER_A_ATOM_B_SDBLOCK_TYPE_M_(Set BINT)_V_VALUE_TYPE|)) (=> (and (set.member r ev_set) (set.member w ev_set)) (= (set.member (tuple r w) RF) (and (= (O r) R) (= (O w) W))))))
(check-sat)
(declare-const B (Set Int))
(define-fun F () Bool
- (exists ((i Int) (j Int)) (and (distinct i j) (member i A) (member j B)))
+ (exists ((i Int) (j Int)) (and (distinct i j) (set.member i A) (set.member j B)))
)
(define-fun G () Bool
- (and (>= (card (union A B)) 2) (>= (card A) 1) (>= (card B) 1))
+ (and (>= (set.card (set.union A B)) 2) (>= (set.card A) 1) (>= (set.card B) 1))
)
(assert (and G (not F)))
(declare-fun these$ (Pname_option_set$) Pname_set$)
(declare-fun while$ ((-> State$ Bool) Com$) Com$)
(declare-fun finite$ (Pname_set$) Bool)
-(declare-fun insert$ (State_triple$ State_triple_set$) State_triple_set$)
+(declare-fun set.insert$ (State_triple$ State_triple_set$) State_triple_set$)
(declare-fun map_le$ ((-> State_triple$ Com_option$) (-> State_triple$ Com_option$)) Bool)
-(declare-fun member$ (State_triple$ State_triple_set$) Bool)
+(declare-fun set.member$ (State_triple$ State_triple_set$) Bool)
(declare-fun minus$a (State_triple_option_set$ State_triple_option_set$) State_triple_option_set$)
(declare-fun minus$b (Com_option_set$ Com_option_set$) Com_option_set$)
(declare-fun minus$c (State_triple_set$ State_triple_set$) State_triple_set$)
(declare-fun collect$ ((-> Com$ Bool)) Com_set$)
(declare-fun fun_upd$ ((-> State_triple$ Com_option$) State_triple$ Com_option$) (-> State_triple$ Com_option$))
(declare-fun getlocs$ (State$) (-> Loc$ Nat$))
-(declare-fun insert$a (Com$ Com_set$) Com_set$)
-(declare-fun insert$b (Pname$ Pname_set$) Pname_set$)
-(declare-fun insert$c (State_triple_option$ State_triple_option_set$) State_triple_option_set$)
-(declare-fun insert$d (Com_option$ Com_option_set$) Com_option_set$)
-(declare-fun insert$e (Pname_option$ Pname_option_set$) Pname_option_set$)
-(declare-fun insert$f (State_triple_option_option$ State_triple_option_option_set$) State_triple_option_option_set$)
-(declare-fun insert$g (Com_option_option$ Com_option_option_set$) Com_option_option_set$)
+(declare-fun set.insert$a (Com$ Com_set$) Com_set$)
+(declare-fun set.insert$b (Pname$ Pname_set$) Pname_set$)
+(declare-fun set.insert$c (State_triple_option$ State_triple_option_set$) State_triple_option_set$)
+(declare-fun set.insert$d (Com_option$ Com_option_set$) Com_option_set$)
+(declare-fun set.insert$e (Pname_option$ Pname_option_set$) Pname_option_set$)
+(declare-fun set.insert$f (State_triple_option_option$ State_triple_option_option_set$) State_triple_option_option_set$)
+(declare-fun set.insert$g (Com_option_option$ Com_option_option_set$) Com_option_option_set$)
(declare-fun map_le$a ((-> Pname$ Com_option$) (-> Pname$ Com_option$)) Bool)
-(declare-fun member$a (Pname$ Pname_set$) Bool)
-(declare-fun member$b (Com$ Com_set$) Bool)
-(declare-fun member$c (State_triple_option$ State_triple_option_set$) Bool)
-(declare-fun member$d (Com_option$ Com_option_set$) Bool)
+(declare-fun set.member$a (Pname$ Pname_set$) Bool)
+(declare-fun set.member$b (Com$ Com_set$) Bool)
+(declare-fun set.member$c (State_triple_option$ State_triple_option_set$) Bool)
+(declare-fun set.member$d (Com_option$ Com_option_set$) Bool)
(declare-fun newlocs$ () (-> Loc$ Nat$))
(declare-fun setlocs$ (State$ (-> Loc$ Nat$)) State$)
(declare-fun collect$a ((-> State_triple$ Bool)) State_triple_set$)
(declare-fun restrict_map$i ((-> State_triple$ Com_option$) State_triple_set$) (-> State_triple$ Com_option$))
(declare-fun state_not_singleton$ () Bool)
(assert (! (forall ((?v0 Bool)) (! (= (uut$ ?v0) (not ?v0)) :pattern ((uut$ ?v0)))) :named a0))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$)) (! (= (uua$ ?v0 ?v1) (member$ ?v1 ?v0)) :pattern ((uua$ ?v0 ?v1)))) :named a1))
-(assert (! (forall ((?v0 Pname_set$) (?v1 Pname$)) (! (= (uub$ ?v0 ?v1) (member$a ?v1 ?v0)) :pattern ((uub$ ?v0 ?v1)))) :named a2))
-(assert (! (forall ((?v0 Com_set$) (?v1 Com$)) (! (= (uu$ ?v0 ?v1) (member$b ?v1 ?v0)) :pattern ((uu$ ?v0 ?v1)))) :named a3))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$)) (! (= (uua$ ?v0 ?v1) (set.member$ ?v1 ?v0)) :pattern ((uua$ ?v0 ?v1)))) :named a1))
+(assert (! (forall ((?v0 Pname_set$) (?v1 Pname$)) (! (= (uub$ ?v0 ?v1) (set.member$a ?v1 ?v0)) :pattern ((uub$ ?v0 ?v1)))) :named a2))
+(assert (! (forall ((?v0 Com_set$) (?v1 Com$)) (! (= (uu$ ?v0 ?v1) (set.member$b ?v1 ?v0)) :pattern ((uu$ ?v0 ?v1)))) :named a3))
(assert (! (forall ((?v0 State$) (?v1 State$)) (! (= (uuq$ ?v0 ?v1) (= ?v0 ?v1)) :pattern ((uuq$ ?v0 ?v1)))) :named a4))
(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (! (= (uvh$ ?v0 ?v1) (not (= (?v0 ?v1) none$))) :pattern ((uvh$ ?v0 ?v1)))) :named a5))
(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$)) (! (= (uvi$ ?v0 ?v1) (not (= (?v0 ?v1) none$a))) :pattern ((uvi$ ?v0 ?v1)))) :named a6))
(assert (! (forall ((?v0 Com$) (?v1 State$) (?v2 Nat$) (?v3 State$) (?v4 Com$) (?v5 State$)) (=> (and (evaln$ ?v0 ?v1 ?v2 ?v3) (evaln$ ?v4 ?v3 ?v2 ?v5)) (evaln$ (semi$ ?v0 ?v4) ?v1 ?v2 ?v5))) :named a76))
(assert (! (forall ((?v0 Com$) (?v1 Com$) (?v2 State$) (?v3 Nat$) (?v4 State$)) (=> (and (evaln$ (semi$ ?v0 ?v1) ?v2 ?v3 ?v4) (forall ((?v5 State$)) (=> (and (evaln$ ?v0 ?v2 ?v3 ?v5) (evaln$ ?v1 ?v5 ?v3 ?v4)) false))) false)) :named a77))
(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (not (= skip$ (ass$ ?v0 ?v1)))) :named a78))
-(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ Bool))) (= (member$b ?v0 (collect$ ?v1)) (?v1 ?v0))) :named a79))
-(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ Bool))) (= (member$ ?v0 (collect$a ?v1)) (?v1 ?v0))) :named a80))
-(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ Bool))) (= (member$a ?v0 (collect$b ?v1)) (?v1 ?v0))) :named a81))
+(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ Bool))) (= (set.member$b ?v0 (collect$ ?v1)) (?v1 ?v0))) :named a79))
+(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ Bool))) (= (set.member$ ?v0 (collect$a ?v1)) (?v1 ?v0))) :named a80))
+(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ Bool))) (= (set.member$a ?v0 (collect$b ?v1)) (?v1 ?v0))) :named a81))
(assert (! (forall ((?v0 Com_set$)) (= (collect$ (uu$ ?v0)) ?v0)) :named a82))
(assert (! (forall ((?v0 State_triple_set$)) (= (collect$a (uua$ ?v0)) ?v0)) :named a83))
(assert (! (forall ((?v0 Pname_set$)) (= (collect$b (uub$ ?v0)) ?v0)) :named a84))
(assert (! (forall ((?v0 Vname$)) (=> (and (forall ((?v1 Glb$)) (=> (= ?v0 (glb$ ?v1)) false)) (forall ((?v1 Loc$)) (=> (= ?v0 (loc$ ?v1)) false))) false)) :named a180))
(assert (! (forall ((?v0 Pname$) (?v1 Com$)) (=> (and wT_bodies$ (= (body$ ?v0) (some$ ?v1))) (wt$ ?v1))) :named a181))
(assert (! (forall ((?v0 Nat$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool)))) (= (triple_valid$ ?v0 (triple$ ?v1 (the$ (body$ ?v2)) ?v3)) (triple_valid$ (suc$ ?v0) (triple$ ?v1 (body$a ?v2) ?v3)))) :named a182))
-(assert (! (forall ((?v0 Pname_option$)) (=> (not (= ?v0 none$b)) (member$a (the$b ?v0) (set_option$ ?v0)))) :named a183))
-(assert (! (forall ((?v0 State_triple_option$)) (=> (not (= ?v0 none$a)) (member$ (the$a ?v0) (set_option$a ?v0)))) :named a184))
-(assert (! (forall ((?v0 Com_option$)) (=> (not (= ?v0 none$)) (member$b (the$ ?v0) (set_option$b ?v0)))) :named a185))
+(assert (! (forall ((?v0 Pname_option$)) (=> (not (= ?v0 none$b)) (set.member$a (the$b ?v0) (set_option$ ?v0)))) :named a183))
+(assert (! (forall ((?v0 State_triple_option$)) (=> (not (= ?v0 none$a)) (set.member$ (the$a ?v0) (set_option$a ?v0)))) :named a184))
+(assert (! (forall ((?v0 Com_option$)) (=> (not (= ?v0 none$)) (set.member$b (the$ ?v0) (set_option$b ?v0)))) :named a185))
(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple$ Com_option$))) (= (= (bind$ ?v0 ?v1) none$) (or (= ?v0 none$a) (= (?v1 (the$a ?v0)) none$)))) :named a186))
(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com$ State_triple_option$))) (= (= (bind$a ?v0 ?v1) none$a) (or (= ?v0 none$) (= (?v1 (the$ ?v0)) none$a)))) :named a187))
(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple$ State_triple_option$))) (= (= (bind$b ?v0 ?v1) none$a) (or (= ?v0 none$a) (= (?v1 (the$a ?v0)) none$a)))) :named a188))
(assert (! (forall ((?v0 Vname$) (?v1 (-> State$ Nat$))) (! (= (size$d (ass$ ?v0 ?v1)) zero$) :pattern ((ass$ ?v0 ?v1)))) :named a241))
(assert (! (= (size$d skip$) zero$) :named a242))
(assert (! (forall ((?v0 (-> State$ Bool)) (?v1 Com$)) (! (= (size$d (while$ ?v0 ?v1)) (plus$ (size$d ?v1) (suc$ zero$))) :pattern ((while$ ?v0 ?v1)))) :named a243))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool))) (?v4 State$) (?v5 Vname$) (?v6 (-> State$ Nat$))) (=> (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (body$a ?v2) (uuc$ ?v3 ?v4 ?v5)) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (uud$ ?v1 ?v4 ?v6) (call$ ?v5 ?v2 ?v6) ?v3) bot$d)))) :named a244))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool))) (?v4 State$) (?v5 Vname$) (?v6 (-> State$ Nat$))) (=> (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 (body$a ?v2) (uuc$ ?v3 ?v4 ?v5)) bot$d)) (hoare_derivs$ ?v0 (set.insert$ (triple$ (uud$ ?v1 ?v4 ?v6) (call$ ?v5 ?v2 ?v6) ?v3) bot$d)))) :named a244))
(assert (! (forall ((?v0 Com_option$)) (= (bind$c ?v0 uue$) none$)) :named a245))
(assert (! (forall ((?v0 Bool) (?v1 (-> State_triple$ Bool)) (?v2 State_triple_option$)) (=> (and (case_option$a ?v0 ?v1 ?v2) (and (=> (and (= ?v2 none$a) ?v0) false) (forall ((?v3 State_triple$)) (=> (and (= ?v2 (some$a ?v3)) (?v1 ?v3)) false)))) false)) :named a246))
(assert (! (forall ((?v0 Bool) (?v1 (-> Com$ Bool)) (?v2 Com_option$)) (=> (and (case_option$ ?v0 ?v1 ?v2) (and (=> (and (= ?v2 none$) ?v0) false) (forall ((?v3 Com$)) (=> (and (= ?v2 (some$ ?v3)) (?v1 ?v3)) false)))) false)) :named a247))
(assert (! (forall ((?v0 Com_option$)) (= (not (= ?v0 none$)) (case_option$ false uug$ ?v0))) :named a250))
(assert (! (forall ((?v0 State_triple_option$)) (= (= ?v0 none$a) (case_option$a true uuh$ ?v0))) :named a251))
(assert (! (forall ((?v0 Com_option$)) (= (= ?v0 none$) (case_option$ true uui$ ?v0))) :named a252))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (hoare_derivs$ ?v0 (insert$ ?v1 ?v2)) (and (hoare_derivs$ ?v0 (insert$ ?v1 bot$d)) (hoare_derivs$ ?v0 ?v2)))) :named a253))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (hoare_derivs$ ?v0 (set.insert$ ?v1 ?v2)) (and (hoare_derivs$ ?v0 (set.insert$ ?v1 bot$d)) (hoare_derivs$ ?v0 ?v2)))) :named a253))
(assert (! (forall ((?v0 State_triple_set$)) (hoare_derivs$ ?v0 bot$d)) :named a254))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (and (hoare_derivs$ ?v0 (insert$ ?v1 bot$d)) (hoare_derivs$ ?v0 ?v2)) (hoare_derivs$ ?v0 (insert$ ?v1 ?v2)))) :named a255))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 Loc$) (?v5 State$) (?v6 (-> State$ Nat$))) (=> (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 (uuj$ ?v3 ?v4 ?v5)) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (uuk$ ?v1 ?v4 ?v5 ?v6) (local$ ?v4 ?v6 ?v2) ?v3) bot$d)))) :named a256))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (hoare_derivs$ ?v0 (insert$ (triple$ (uul$ ?v1 ?v2) (while$ ?v2 ?v3) ?v1) bot$d))) :named a257))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 Com$) (?v5 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ ?v3 ?v4 ?v5) bot$d))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (semi$ ?v2 ?v4) ?v5) bot$d)))) :named a258))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool)))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 skip$ ?v1) bot$d))) :named a259))
-(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State_triple_set$) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (=> (forall ((?v4 State$) (?v5 State$)) (=> (?v0 ?v4 ?v5) (exists ((?v6 (-> State$ (-> State$ Bool))) (?v7 (-> State$ (-> State$ Bool)))) (and (hoare_derivs$ ?v1 (insert$ (triple$ ?v6 ?v2 ?v7) bot$d)) (forall ((?v8 State$)) (=> (forall ((?v9 State$)) (=> (?v6 ?v9 ?v5) (?v7 ?v9 ?v8))) (?v3 ?v4 ?v8))))))) (hoare_derivs$ ?v1 (insert$ (triple$ ?v0 ?v2 ?v3) bot$d)))) :named a260))
-(assert (! (forall ((?v0 Bool) (?v1 State_triple_set$) (?v2 (-> State$ (-> State$ Bool))) (?v3 Com$) (?v4 (-> State$ (-> State$ Bool)))) (=> (=> ?v0 (hoare_derivs$ ?v1 (insert$ (triple$ ?v2 ?v3 ?v4) bot$d))) (hoare_derivs$ ?v1 (insert$ (triple$ (uum$ ?v0 ?v2) ?v3 ?v4) bot$d)))) :named a261))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool))) (?v5 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v6 State$) (?v7 State$)) (=> (?v4 ?v6 ?v7) (forall ((?v8 State$)) (=> (forall ((?v9 State$)) (=> (?v1 ?v9 ?v7) (?v3 ?v9 ?v8))) (?v5 ?v6 ?v8)))))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v4 ?v2 ?v5) bot$d)))) :named a262))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v5 State$) (?v6 State$)) (=> (?v3 ?v5 ?v6) (?v4 ?v5 ?v6)))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v4) bot$d)))) :named a263))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v5 State$) (?v6 State$)) (=> (?v4 ?v5 ?v6) (?v1 ?v5 ?v6)))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v4 ?v2 ?v3) bot$d)))) :named a264))
-(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State_triple_set$) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (=> (forall ((?v4 State$) (?v5 State$)) (=> (?v0 ?v4 ?v5) (hoare_derivs$ ?v1 (insert$ (triple$ (uun$ ?v5) ?v2 (uuo$ ?v3 ?v4)) bot$d)))) (hoare_derivs$ ?v1 (insert$ (triple$ ?v0 ?v2 ?v3) bot$d)))) :named a265))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Vname$) (?v3 (-> State$ Nat$))) (hoare_derivs$ ?v0 (insert$ (triple$ (uup$ ?v1 ?v2 ?v3) (ass$ ?v2 ?v3) ?v1) bot$d))) :named a266))
-(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Pname$) (?v2 (-> State$ (-> State$ Bool))) (?v3 State_triple_set$)) (=> (hoare_derivs$ (insert$ (triple$ ?v0 (body$a ?v1) ?v2) ?v3) (insert$ (triple$ ?v0 (the$ (body$ ?v1)) ?v2) bot$d)) (hoare_derivs$ ?v3 (insert$ (triple$ ?v0 (body$a ?v1) ?v2) bot$d)))) :named a267))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool)))) (=> (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (the$ (body$ ?v2)) ?v3) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (body$a ?v2) ?v3) bot$d)))) :named a268))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (and (hoare_derivs$ ?v0 (set.insert$ ?v1 bot$d)) (hoare_derivs$ ?v0 ?v2)) (hoare_derivs$ ?v0 (set.insert$ ?v1 ?v2)))) :named a255))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 Loc$) (?v5 State$) (?v6 (-> State$ Nat$))) (=> (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 ?v2 (uuj$ ?v3 ?v4 ?v5)) bot$d)) (hoare_derivs$ ?v0 (set.insert$ (triple$ (uuk$ ?v1 ?v4 ?v5 ?v6) (local$ ?v4 ?v6 ?v2) ?v3) bot$d)))) :named a256))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (hoare_derivs$ ?v0 (set.insert$ (triple$ (uul$ ?v1 ?v2) (while$ ?v2 ?v3) ?v1) bot$d))) :named a257))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 Com$) (?v5 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v3 ?v4 ?v5) bot$d))) (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 (semi$ ?v2 ?v4) ?v5) bot$d)))) :named a258))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool)))) (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 skip$ ?v1) bot$d))) :named a259))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State_triple_set$) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (=> (forall ((?v4 State$) (?v5 State$)) (=> (?v0 ?v4 ?v5) (exists ((?v6 (-> State$ (-> State$ Bool))) (?v7 (-> State$ (-> State$ Bool)))) (and (hoare_derivs$ ?v1 (set.insert$ (triple$ ?v6 ?v2 ?v7) bot$d)) (forall ((?v8 State$)) (=> (forall ((?v9 State$)) (=> (?v6 ?v9 ?v5) (?v7 ?v9 ?v8))) (?v3 ?v4 ?v8))))))) (hoare_derivs$ ?v1 (set.insert$ (triple$ ?v0 ?v2 ?v3) bot$d)))) :named a260))
+(assert (! (forall ((?v0 Bool) (?v1 State_triple_set$) (?v2 (-> State$ (-> State$ Bool))) (?v3 Com$) (?v4 (-> State$ (-> State$ Bool)))) (=> (=> ?v0 (hoare_derivs$ ?v1 (set.insert$ (triple$ ?v2 ?v3 ?v4) bot$d))) (hoare_derivs$ ?v1 (set.insert$ (triple$ (uum$ ?v0 ?v2) ?v3 ?v4) bot$d)))) :named a261))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool))) (?v5 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v6 State$) (?v7 State$)) (=> (?v4 ?v6 ?v7) (forall ((?v8 State$)) (=> (forall ((?v9 State$)) (=> (?v1 ?v9 ?v7) (?v3 ?v9 ?v8))) (?v5 ?v6 ?v8)))))) (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v4 ?v2 ?v5) bot$d)))) :named a262))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v5 State$) (?v6 State$)) (=> (?v3 ?v5 ?v6) (?v4 ?v5 ?v6)))) (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 ?v2 ?v4) bot$d)))) :named a263))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool))) (?v4 (-> State$ (-> State$ Bool)))) (=> (and (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 ?v2 ?v3) bot$d)) (forall ((?v5 State$) (?v6 State$)) (=> (?v4 ?v5 ?v6) (?v1 ?v5 ?v6)))) (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v4 ?v2 ?v3) bot$d)))) :named a264))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 State_triple_set$) (?v2 Com$) (?v3 (-> State$ (-> State$ Bool)))) (=> (forall ((?v4 State$) (?v5 State$)) (=> (?v0 ?v4 ?v5) (hoare_derivs$ ?v1 (set.insert$ (triple$ (uun$ ?v5) ?v2 (uuo$ ?v3 ?v4)) bot$d)))) (hoare_derivs$ ?v1 (set.insert$ (triple$ ?v0 ?v2 ?v3) bot$d)))) :named a265))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Vname$) (?v3 (-> State$ Nat$))) (hoare_derivs$ ?v0 (set.insert$ (triple$ (uup$ ?v1 ?v2 ?v3) (ass$ ?v2 ?v3) ?v1) bot$d))) :named a266))
+(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 Pname$) (?v2 (-> State$ (-> State$ Bool))) (?v3 State_triple_set$)) (=> (hoare_derivs$ (set.insert$ (triple$ ?v0 (body$a ?v1) ?v2) ?v3) (set.insert$ (triple$ ?v0 (the$ (body$ ?v1)) ?v2) bot$d)) (hoare_derivs$ ?v3 (set.insert$ (triple$ ?v0 (body$a ?v1) ?v2) bot$d)))) :named a267))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 Pname$) (?v3 (-> State$ (-> State$ Bool)))) (=> (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 (the$ (body$ ?v2)) ?v3) bot$d)) (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 (body$a ?v2) ?v3) bot$d)))) :named a268))
(assert (! (forall ((?v0 Com$)) (! (= (mgt$ ?v0) (triple$ uuq$ ?v0 (evalc$ ?v0))) :pattern ((mgt$ ?v0)))) :named a269))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname_set$) (?v4 Pname$)) (=> (and (hoare_derivs$ (sup$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)) (image$ (uus$ ?v1 ?v2) ?v3)) (member$a ?v4 ?v3)) (hoare_derivs$ ?v0 (insert$ (triple$ (?v1 ?v4) (body$a ?v4) (?v2 ?v4)) bot$d)))) :named a270))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$) (?v4 (-> State$ (-> State$ Bool))) (?v5 Com$)) (=> (and (hoare_derivs$ ?v0 (insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v4) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (peek_and$ ?v1 (comp$ uut$ ?v2)) ?v5 ?v4) bot$d))) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (cond$ ?v2 ?v3 ?v5) ?v4) bot$d)))) :named a271))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname_set$) (?v4 Pname$)) (=> (and (hoare_derivs$ (sup$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)) (image$ (uus$ ?v1 ?v2) ?v3)) (set.member$a ?v4 ?v3)) (hoare_derivs$ ?v0 (set.insert$ (triple$ (?v1 ?v4) (body$a ?v4) (?v2 ?v4)) bot$d)))) :named a270))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$) (?v4 (-> State$ (-> State$ Bool))) (?v5 Com$)) (=> (and (hoare_derivs$ ?v0 (set.insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v4) bot$d)) (hoare_derivs$ ?v0 (set.insert$ (triple$ (peek_and$ ?v1 (comp$ uut$ ?v2)) ?v5 ?v4) bot$d))) (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 (cond$ ?v2 ?v3 ?v5) ?v4) bot$d)))) :named a271))
(assert (! (forall ((?v0 (-> State$ (-> State$ Bool))) (?v1 (-> State$ Bool)) (?v2 State$) (?v3 State$)) (! (= (peek_and$ ?v0 ?v1 ?v2 ?v3) (and (?v0 ?v2 ?v3) (?v1 ?v3))) :pattern ((peek_and$ ?v0 ?v1 ?v2 ?v3)))) :named a272))
(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname_set$)) (=> (hoare_derivs$ (sup$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)) (image$ (uus$ ?v1 ?v2) ?v3)) (hoare_derivs$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)))) :named a273))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (=> (hoare_derivs$ ?v0 (insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v1) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ ?v1 (while$ ?v2 ?v3) (peek_and$ ?v1 (comp$ uut$ ?v2))) bot$d)))) :named a274))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (=> (hoare_derivs$ ?v0 (set.insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v1) bot$d)) (hoare_derivs$ ?v0 (set.insert$ (triple$ ?v1 (while$ ?v2 ?v3) (peek_and$ ?v1 (comp$ uut$ ?v2))) bot$d)))) :named a274))
(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 Pname_set$)) (=> (hoare_valids$ (sup$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)) (image$ (uus$ ?v1 ?v2) ?v3)) (hoare_valids$ ?v0 (image$ (uur$ ?v1 ?v2) ?v3)))) :named a275))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (=> (hoare_valids$ ?v0 (insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v1) bot$d)) (hoare_valids$ ?v0 (insert$ (triple$ ?v1 (while$ ?v2 ?v3) (peek_and$ ?v1 (comp$ uut$ ?v2))) bot$d)))) :named a276))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 (-> State$ (-> State$ Bool))) (?v2 (-> State$ Bool)) (?v3 Com$)) (=> (hoare_valids$ ?v0 (set.insert$ (triple$ (peek_and$ ?v1 ?v2) ?v3 ?v1) bot$d)) (hoare_valids$ ?v0 (set.insert$ (triple$ ?v1 (while$ ?v2 ?v3) (peek_and$ ?v1 (comp$ uut$ ?v2))) bot$d)))) :named a276))
(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple_set$)) (=> (hoare_derivs$ ?v0 ?v1) (hoare_valids$ ?v0 ?v1))) :named a277))
-(assert (! (forall ((?v0 Pname_set$) (?v1 State_triple_set$) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 (-> Pname$ Com$)) (?v4 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v5 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v6 (-> Pname$ (-> State$ (-> State$ Bool))))) (=> (and (finite$ ?v0) (and (forall ((?v7 Pname$)) (=> (hoare_derivs$ ?v1 (insert$ (triple$ (?v2 ?v7) (?v3 ?v7) (?v4 ?v7)) bot$d)) (hoare_derivs$ ?v1 (insert$ (triple$ (?v5 ?v7) (?v3 ?v7) (?v6 ?v7)) bot$d)))) (hoare_derivs$ ?v1 (image$ (uuu$ ?v2 ?v3 ?v4) ?v0)))) (hoare_derivs$ ?v1 (image$ (uuv$ ?v3 ?v5 ?v6) ?v0)))) :named a278))
-(assert (! (forall ((?v0 State_triple_set$) (?v1 Com$)) (=> (hoare_derivs$ ?v0 (insert$ (mgt$ ?v1) bot$d)) (hoare_derivs$ ?v0 (insert$ (triple$ (uuw$ ?v1) ?v1 uuq$) bot$d)))) :named a279))
+(assert (! (forall ((?v0 Pname_set$) (?v1 State_triple_set$) (?v2 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v3 (-> Pname$ Com$)) (?v4 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v5 (-> Pname$ (-> State$ (-> State$ Bool)))) (?v6 (-> Pname$ (-> State$ (-> State$ Bool))))) (=> (and (finite$ ?v0) (and (forall ((?v7 Pname$)) (=> (hoare_derivs$ ?v1 (set.insert$ (triple$ (?v2 ?v7) (?v3 ?v7) (?v4 ?v7)) bot$d)) (hoare_derivs$ ?v1 (set.insert$ (triple$ (?v5 ?v7) (?v3 ?v7) (?v6 ?v7)) bot$d)))) (hoare_derivs$ ?v1 (image$ (uuu$ ?v2 ?v3 ?v4) ?v0)))) (hoare_derivs$ ?v1 (image$ (uuv$ ?v3 ?v5 ?v6) ?v0)))) :named a278))
+(assert (! (forall ((?v0 State_triple_set$) (?v1 Com$)) (=> (hoare_derivs$ ?v0 (set.insert$ (mgt$ ?v1) bot$d)) (hoare_derivs$ ?v0 (set.insert$ (triple$ (uuw$ ?v1) ?v1 uuq$) bot$d)))) :named a279))
(assert (! (forall ((?v0 Nat$) (?v1 State_triple$)) (= (triple_valid$ ?v0 ?v1) (case_triple$ (uux$ ?v0) ?v1))) :named a280))
-(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com$)) (=> (= (?v0 ?v1) none$) (= (ran$ (fun_upd$ ?v0 ?v1 (some$ ?v2))) (insert$a ?v2 (ran$ ?v0))))) :named a281))
-(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com$)) (=> (= (?v0 ?v1) none$) (= (ran$a (fun_upd$a ?v0 ?v1 (some$ ?v2))) (insert$a ?v2 (ran$a ?v0))))) :named a282))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com$)) (=> (= (?v0 ?v1) none$) (= (ran$ (fun_upd$ ?v0 ?v1 (some$ ?v2))) (set.insert$a ?v2 (ran$ ?v0))))) :named a281))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com$)) (=> (= (?v0 ?v1) none$) (= (ran$a (fun_upd$a ?v0 ?v1 (some$ ?v2))) (set.insert$a ?v2 (ran$a ?v0))))) :named a282))
(assert (! (forall ((?v0 State_triple$) (?v1 State_triple$)) (= (fun_upd$ uuy$ ?v0 none$ ?v1) none$)) :named a283))
(assert (! (forall ((?v0 Pname$) (?v1 Pname$)) (= (fun_upd$a uuz$ ?v0 none$ ?v1) none$)) :named a284))
(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com$)) (not (= (fun_upd$ ?v0 ?v1 (some$ ?v2)) uuy$))) :named a285))
(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com$)) (not (= (fun_upd$a ?v0 ?v1 (some$ ?v2)) uuz$))) :named a286))
-(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$)) (= (= (dom$ ?v0) (insert$ ?v1 bot$d)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$b uva$ ?v1 (some$a ?v2)))))) :named a287))
-(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com$)) (= (= (dom$a ?v0) (insert$a ?v1 bot$c)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$c uvb$ ?v1 (some$a ?v2)))))) :named a288))
-(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com$)) (= (= (dom$b ?v0) (insert$a ?v1 bot$c)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$d uue$ ?v1 (some$ ?v2)))))) :named a289))
-(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$)) (= (= (dom$c ?v0) (insert$b ?v1 bot$)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$e uvc$ ?v1 (some$a ?v2)))))) :named a290))
-(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$)) (= (= (dom$d ?v0) (insert$c ?v1 bot$a)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$f uvd$ ?v1 (some$a ?v2)))))) :named a291))
-(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$)) (= (= (dom$e ?v0) (insert$c ?v1 bot$a)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$g uve$ ?v1 (some$ ?v2)))))) :named a292))
-(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$)) (= (= (dom$f ?v0) (insert$d ?v1 bot$b)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$h uvf$ ?v1 (some$a ?v2)))))) :named a293))
-(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$)) (= (= (dom$g ?v0) (insert$d ?v1 bot$b)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$i uvg$ ?v1 (some$ ?v2)))))) :named a294))
-(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$)) (= (= (dom$h ?v0) (insert$b ?v1 bot$)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$a uuz$ ?v1 (some$ ?v2)))))) :named a295))
-(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (= (dom$i ?v0) (insert$ ?v1 bot$d)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$ uuy$ ?v1 (some$ ?v2)))))) :named a296))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$)) (= (= (dom$ ?v0) (set.insert$ ?v1 bot$d)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$b uva$ ?v1 (some$a ?v2)))))) :named a287))
+(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com$)) (= (= (dom$a ?v0) (set.insert$a ?v1 bot$c)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$c uvb$ ?v1 (some$a ?v2)))))) :named a288))
+(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com$)) (= (= (dom$b ?v0) (set.insert$a ?v1 bot$c)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$d uue$ ?v1 (some$ ?v2)))))) :named a289))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$)) (= (= (dom$c ?v0) (set.insert$b ?v1 bot$)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$e uvc$ ?v1 (some$a ?v2)))))) :named a290))
+(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$)) (= (= (dom$d ?v0) (set.insert$c ?v1 bot$a)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$f uvd$ ?v1 (some$a ?v2)))))) :named a291))
+(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$)) (= (= (dom$e ?v0) (set.insert$c ?v1 bot$a)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$g uve$ ?v1 (some$ ?v2)))))) :named a292))
+(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$)) (= (= (dom$f ?v0) (set.insert$d ?v1 bot$b)) (exists ((?v2 State_triple$)) (= ?v0 (fun_upd$h uvf$ ?v1 (some$a ?v2)))))) :named a293))
+(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$)) (= (= (dom$g ?v0) (set.insert$d ?v1 bot$b)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$i uvg$ ?v1 (some$ ?v2)))))) :named a294))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$)) (= (= (dom$h ?v0) (set.insert$b ?v1 bot$)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$a uuz$ ?v1 (some$ ?v2)))))) :named a295))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (= (dom$i ?v0) (set.insert$ ?v1 bot$d)) (exists ((?v2 Com$)) (= ?v0 (fun_upd$ uuy$ ?v1 (some$ ?v2)))))) :named a296))
(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 (-> State_triple$ Com_option$)) (?v2 State_triple$) (?v3 Com$)) (=> (map_le$ ?v0 ?v1) (map_le$ (fun_upd$ ?v0 ?v2 none$) (fun_upd$ ?v1 ?v2 (some$ ?v3))))) :named a297))
(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 (-> Pname$ Com_option$)) (?v2 Pname$) (?v3 Com$)) (=> (map_le$a ?v0 ?v1) (map_le$a (fun_upd$a ?v0 ?v2 none$) (fun_upd$a ?v1 ?v2 (some$ ?v3))))) :named a298))
(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$))) (= (= (dom$ ?v0) bot$d) (= ?v0 uva$))) :named a299))
(assert (! (= (dom$h uuz$) bot$) :named a317))
(assert (! (= (dom$i uuy$) bot$d) :named a318))
(assert (! (finite$ (dom$h body$)) :named a319))
-(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ Com_option$))) (= (member$b ?v0 (dom$b ?v1)) (not (= (?v1 ?v0) none$)))) :named a320))
-(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ Com_option$))) (= (member$ ?v0 (dom$i ?v1)) (not (= (?v1 ?v0) none$)))) :named a321))
-(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ State_triple_option$))) (= (member$b ?v0 (dom$a ?v1)) (not (= (?v1 ?v0) none$a)))) :named a322))
-(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ State_triple_option$))) (= (member$a ?v0 (dom$c ?v1)) (not (= (?v1 ?v0) none$a)))) :named a323))
-(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ State_triple_option$))) (= (member$ ?v0 (dom$ ?v1)) (not (= (?v1 ?v0) none$a)))) :named a324))
-(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ Com_option$))) (= (member$a ?v0 (dom$h ?v1)) (not (= (?v1 ?v0) none$)))) :named a325))
+(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ Com_option$))) (= (set.member$b ?v0 (dom$b ?v1)) (not (= (?v1 ?v0) none$)))) :named a320))
+(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ Com_option$))) (= (set.member$ ?v0 (dom$i ?v1)) (not (= (?v1 ?v0) none$)))) :named a321))
+(assert (! (forall ((?v0 Com$) (?v1 (-> Com$ State_triple_option$))) (= (set.member$b ?v0 (dom$a ?v1)) (not (= (?v1 ?v0) none$a)))) :named a322))
+(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ State_triple_option$))) (= (set.member$a ?v0 (dom$c ?v1)) (not (= (?v1 ?v0) none$a)))) :named a323))
+(assert (! (forall ((?v0 State_triple$) (?v1 (-> State_triple$ State_triple_option$))) (= (set.member$ ?v0 (dom$ ?v1)) (not (= (?v1 ?v0) none$a)))) :named a324))
+(assert (! (forall ((?v0 Pname$) (?v1 (-> Pname$ Com_option$))) (= (set.member$a ?v0 (dom$h ?v1)) (not (= (?v1 ?v0) none$)))) :named a325))
(assert (! (forall ((?v0 (-> State_triple$ Com_option$))) (= (dom$i ?v0) (collect$a (uvh$ ?v0)))) :named a326))
(assert (! (forall ((?v0 (-> Pname$ State_triple_option$))) (= (dom$c ?v0) (collect$b (uvi$ ?v0)))) :named a327))
(assert (! (forall ((?v0 (-> Pname$ Com_option$))) (= (dom$h ?v0) (collect$b (uvj$ ?v0)))) :named a328))
(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (map_le$ (fun_upd$ ?v0 ?v1 none$) ?v0)) :named a329))
(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$)) (map_le$a (fun_upd$a ?v0 ?v1 none$) ?v0)) :named a330))
-(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com$) (?v2 Com_option$)) (= (dom$b (fun_upd$d ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$ (dom$b ?v0) (insert$a ?v1 bot$c)) (insert$a ?v1 (dom$b ?v0))))) :named a331))
-(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com$) (?v2 State_triple_option$)) (= (dom$a (fun_upd$c ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$ (dom$a ?v0) (insert$a ?v1 bot$c)) (insert$a ?v1 (dom$a ?v0))))) :named a332))
-(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$) (?v2 Com_option$)) (= (dom$e (fun_upd$g ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$a (dom$e ?v0) (insert$c ?v1 bot$a)) (insert$c ?v1 (dom$e ?v0))))) :named a333))
-(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$) (?v2 State_triple_option$)) (= (dom$d (fun_upd$f ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$a (dom$d ?v0) (insert$c ?v1 bot$a)) (insert$c ?v1 (dom$d ?v0))))) :named a334))
-(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$) (?v2 Com_option$)) (= (dom$g (fun_upd$i ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$b (dom$g ?v0) (insert$d ?v1 bot$b)) (insert$d ?v1 (dom$g ?v0))))) :named a335))
-(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$) (?v2 State_triple_option$)) (= (dom$f (fun_upd$h ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$b (dom$f ?v0) (insert$d ?v1 bot$b)) (insert$d ?v1 (dom$f ?v0))))) :named a336))
-(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$) (?v2 State_triple_option$)) (= (dom$ (fun_upd$b ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$c (dom$ ?v0) (insert$ ?v1 bot$d)) (insert$ ?v1 (dom$ ?v0))))) :named a337))
-(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$) (?v2 State_triple_option$)) (= (dom$c (fun_upd$e ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$d (dom$c ?v0) (insert$b ?v1 bot$)) (insert$b ?v1 (dom$c ?v0))))) :named a338))
-(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com_option$)) (= (dom$h (fun_upd$a ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$d (dom$h ?v0) (insert$b ?v1 bot$)) (insert$b ?v1 (dom$h ?v0))))) :named a339))
-(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com_option$)) (= (dom$i (fun_upd$ ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$c (dom$i ?v0) (insert$ ?v1 bot$d)) (insert$ ?v1 (dom$i ?v0))))) :named a340))
+(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com$) (?v2 Com_option$)) (= (dom$b (fun_upd$d ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$ (dom$b ?v0) (set.insert$a ?v1 bot$c)) (set.insert$a ?v1 (dom$b ?v0))))) :named a331))
+(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com$) (?v2 State_triple_option$)) (= (dom$a (fun_upd$c ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$ (dom$a ?v0) (set.insert$a ?v1 bot$c)) (set.insert$a ?v1 (dom$a ?v0))))) :named a332))
+(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$) (?v2 Com_option$)) (= (dom$e (fun_upd$g ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$a (dom$e ?v0) (set.insert$c ?v1 bot$a)) (set.insert$c ?v1 (dom$e ?v0))))) :named a333))
+(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$) (?v2 State_triple_option$)) (= (dom$d (fun_upd$f ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$a (dom$d ?v0) (set.insert$c ?v1 bot$a)) (set.insert$c ?v1 (dom$d ?v0))))) :named a334))
+(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$) (?v2 Com_option$)) (= (dom$g (fun_upd$i ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$b (dom$g ?v0) (set.insert$d ?v1 bot$b)) (set.insert$d ?v1 (dom$g ?v0))))) :named a335))
+(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$) (?v2 State_triple_option$)) (= (dom$f (fun_upd$h ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$b (dom$f ?v0) (set.insert$d ?v1 bot$b)) (set.insert$d ?v1 (dom$f ?v0))))) :named a336))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$) (?v2 State_triple_option$)) (= (dom$ (fun_upd$b ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$c (dom$ ?v0) (set.insert$ ?v1 bot$d)) (set.insert$ ?v1 (dom$ ?v0))))) :named a337))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$) (?v2 State_triple_option$)) (= (dom$c (fun_upd$e ?v0 ?v1 ?v2)) (ite (= ?v2 none$a) (minus$d (dom$c ?v0) (set.insert$b ?v1 bot$)) (set.insert$b ?v1 (dom$c ?v0))))) :named a338))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Com_option$)) (= (dom$h (fun_upd$a ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$d (dom$h ?v0) (set.insert$b ?v1 bot$)) (set.insert$b ?v1 (dom$h ?v0))))) :named a339))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 Com_option$)) (= (dom$i (fun_upd$ ?v0 ?v1 ?v2)) (ite (= ?v2 none$) (minus$c (dom$i ?v0) (set.insert$ ?v1 bot$d)) (set.insert$ ?v1 (dom$i ?v0))))) :named a340))
(assert (! (forall ((?v0 (-> Com$ Com$)) (?v1 Com_option$)) (= (map_option$ ?v0 ?v1) (case_option$b none$ (uvk$ ?v0) ?v1))) :named a341))
(assert (! (forall ((?v0 (-> State_triple$ Com$)) (?v1 State_triple_option$)) (= (= (map_option$a ?v0 ?v1) none$) (= ?v1 none$a))) :named a342))
(assert (! (forall ((?v0 (-> Com$ State_triple$)) (?v1 Com_option$)) (= (= (map_option$b ?v0 ?v1) none$a) (= ?v1 none$))) :named a343))
(assert (! (forall ((?v0 (-> Com$ Com$))) (! (= (map_option$ ?v0 none$) none$) :pattern ((map_option$ ?v0)))) :named a357))
(assert (! (forall ((?v0 State_triple_option$) (?v1 (-> State_triple$ Com$))) (=> (not (= ?v0 none$a)) (= (the$ (map_option$a ?v1 ?v0)) (?v1 (the$a ?v0))))) :named a358))
(assert (! (forall ((?v0 Com_option$) (?v1 (-> Com$ Com$))) (=> (not (= ?v0 none$)) (= (the$ (map_option$ ?v1 ?v0)) (?v1 (the$ ?v0))))) :named a359))
-(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$) (?v2 State_triple_option_set$)) (=> (= (?v0 ?v1) none$) (= (minus$a (dom$e ?v0) (insert$c ?v1 ?v2)) (minus$a (dom$e ?v0) ?v2)))) :named a360))
-(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$) (?v2 Com_option_set$)) (=> (= (?v0 ?v1) none$) (= (minus$b (dom$g ?v0) (insert$d ?v1 ?v2)) (minus$b (dom$g ?v0) ?v2)))) :named a361))
-(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$) (?v2 State_triple_option_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$a (dom$d ?v0) (insert$c ?v1 ?v2)) (minus$a (dom$d ?v0) ?v2)))) :named a362))
-(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$) (?v2 Com_option_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$b (dom$f ?v0) (insert$d ?v1 ?v2)) (minus$b (dom$f ?v0) ?v2)))) :named a363))
-(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$c (dom$ ?v0) (insert$ ?v1 ?v2)) (minus$c (dom$ ?v0) ?v2)))) :named a364))
-(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$) (?v2 Pname_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$d (dom$c ?v0) (insert$b ?v1 ?v2)) (minus$d (dom$c ?v0) ?v2)))) :named a365))
-(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Pname_set$)) (=> (= (?v0 ?v1) none$) (= (minus$d (dom$h ?v0) (insert$b ?v1 ?v2)) (minus$d (dom$h ?v0) ?v2)))) :named a366))
-(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (= (?v0 ?v1) none$) (= (minus$c (dom$i ?v0) (insert$ ?v1 ?v2)) (minus$c (dom$i ?v0) ?v2)))) :named a367))
-(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com_set$) (?v2 Com$)) (= (fun_upd$d (restrict_map$ ?v0 ?v1) ?v2 none$) (ite (member$b ?v2 ?v1) (restrict_map$ ?v0 (minus$ ?v1 (insert$a ?v2 bot$c))) (restrict_map$ ?v0 ?v1)))) :named a368))
-(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com_set$) (?v2 Com$)) (= (fun_upd$c (restrict_map$a ?v0 ?v1) ?v2 none$a) (ite (member$b ?v2 ?v1) (restrict_map$a ?v0 (minus$ ?v1 (insert$a ?v2 bot$c))) (restrict_map$a ?v0 ?v1)))) :named a369))
-(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option_set$) (?v2 State_triple_option$)) (= (fun_upd$g (restrict_map$b ?v0 ?v1) ?v2 none$) (ite (member$c ?v2 ?v1) (restrict_map$b ?v0 (minus$a ?v1 (insert$c ?v2 bot$a))) (restrict_map$b ?v0 ?v1)))) :named a370))
-(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option_set$) (?v2 State_triple_option$)) (= (fun_upd$f (restrict_map$c ?v0 ?v1) ?v2 none$a) (ite (member$c ?v2 ?v1) (restrict_map$c ?v0 (minus$a ?v1 (insert$c ?v2 bot$a))) (restrict_map$c ?v0 ?v1)))) :named a371))
-(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option_set$) (?v2 Com_option$)) (= (fun_upd$i (restrict_map$d ?v0 ?v1) ?v2 none$) (ite (member$d ?v2 ?v1) (restrict_map$d ?v0 (minus$b ?v1 (insert$d ?v2 bot$b))) (restrict_map$d ?v0 ?v1)))) :named a372))
-(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option_set$) (?v2 Com_option$)) (= (fun_upd$h (restrict_map$e ?v0 ?v1) ?v2 none$a) (ite (member$d ?v2 ?v1) (restrict_map$e ?v0 (minus$b ?v1 (insert$d ?v2 bot$b))) (restrict_map$e ?v0 ?v1)))) :named a373))
-(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple_set$) (?v2 State_triple$)) (= (fun_upd$b (restrict_map$f ?v0 ?v1) ?v2 none$a) (ite (member$ ?v2 ?v1) (restrict_map$f ?v0 (minus$c ?v1 (insert$ ?v2 bot$d))) (restrict_map$f ?v0 ?v1)))) :named a374))
-(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname_set$) (?v2 Pname$)) (= (fun_upd$a (restrict_map$g ?v0 ?v1) ?v2 none$) (ite (member$a ?v2 ?v1) (restrict_map$g ?v0 (minus$d ?v1 (insert$b ?v2 bot$))) (restrict_map$g ?v0 ?v1)))) :named a375))
-(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname_set$) (?v2 Pname$)) (= (fun_upd$e (restrict_map$h ?v0 ?v1) ?v2 none$a) (ite (member$a ?v2 ?v1) (restrict_map$h ?v0 (minus$d ?v1 (insert$b ?v2 bot$))) (restrict_map$h ?v0 ?v1)))) :named a376))
-(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple_set$) (?v2 State_triple$)) (= (fun_upd$ (restrict_map$i ?v0 ?v1) ?v2 none$) (ite (member$ ?v2 ?v1) (restrict_map$i ?v0 (minus$c ?v1 (insert$ ?v2 bot$d))) (restrict_map$i ?v0 ?v1)))) :named a377))
-(assert (! (forall ((?v0 Pname_option_set$)) (= (not (= (these$ ?v0) bot$)) (and (not (= ?v0 bot$e)) (not (= ?v0 (insert$e none$b bot$e)))))) :named a378))
-(assert (! (forall ((?v0 State_triple_option_option_set$)) (= (not (= (these$a ?v0) bot$a)) (and (not (= ?v0 bot$f)) (not (= ?v0 (insert$f none$c bot$f)))))) :named a379))
-(assert (! (forall ((?v0 Com_option_option_set$)) (= (not (= (these$b ?v0) bot$b)) (and (not (= ?v0 bot$g)) (not (= ?v0 (insert$g none$d bot$g)))))) :named a380))
-(assert (! (forall ((?v0 Com_option_set$)) (= (not (= (these$c ?v0) bot$c)) (and (not (= ?v0 bot$b)) (not (= ?v0 (insert$d none$ bot$b)))))) :named a381))
-(assert (! (forall ((?v0 State_triple_option_set$)) (= (not (= (these$d ?v0) bot$d)) (and (not (= ?v0 bot$a)) (not (= ?v0 (insert$c none$a bot$a)))))) :named a382))
-(assert (! (forall ((?v0 Com$) (?v1 Com_set$) (?v2 (-> Com$ Com_option$))) (! (=> (not (member$b ?v0 ?v1)) (= (restrict_map$ ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$ ?v2 ?v1 ?v0)))) :named a383))
-(assert (! (forall ((?v0 Pname$) (?v1 Pname_set$) (?v2 (-> Pname$ Com_option$))) (! (=> (not (member$a ?v0 ?v1)) (= (restrict_map$g ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$g ?v2 ?v1 ?v0)))) :named a384))
-(assert (! (forall ((?v0 State_triple$) (?v1 State_triple_set$) (?v2 (-> State_triple$ Com_option$))) (! (=> (not (member$ ?v0 ?v1)) (= (restrict_map$i ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$i ?v2 ?v1 ?v0)))) :named a385))
-(assert (! (forall ((?v0 Com$) (?v1 Com_set$) (?v2 (-> Com$ State_triple_option$))) (! (=> (not (member$b ?v0 ?v1)) (= (restrict_map$a ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$a ?v2 ?v1 ?v0)))) :named a386))
-(assert (! (forall ((?v0 Pname$) (?v1 Pname_set$) (?v2 (-> Pname$ State_triple_option$))) (! (=> (not (member$a ?v0 ?v1)) (= (restrict_map$h ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$h ?v2 ?v1 ?v0)))) :named a387))
-(assert (! (forall ((?v0 State_triple$) (?v1 State_triple_set$) (?v2 (-> State_triple$ State_triple_option$))) (! (=> (not (member$ ?v0 ?v1)) (= (restrict_map$f ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$f ?v2 ?v1 ?v0)))) :named a388))
+(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option$) (?v2 State_triple_option_set$)) (=> (= (?v0 ?v1) none$) (= (minus$a (dom$e ?v0) (set.insert$c ?v1 ?v2)) (minus$a (dom$e ?v0) ?v2)))) :named a360))
+(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$) (?v2 Com_option_set$)) (=> (= (?v0 ?v1) none$) (= (minus$b (dom$g ?v0) (set.insert$d ?v1 ?v2)) (minus$b (dom$g ?v0) ?v2)))) :named a361))
+(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option$) (?v2 State_triple_option_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$a (dom$d ?v0) (set.insert$c ?v1 ?v2)) (minus$a (dom$d ?v0) ?v2)))) :named a362))
+(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$) (?v2 Com_option_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$b (dom$f ?v0) (set.insert$d ?v1 ?v2)) (minus$b (dom$f ?v0) ?v2)))) :named a363))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$c (dom$ ?v0) (set.insert$ ?v1 ?v2)) (minus$c (dom$ ?v0) ?v2)))) :named a364))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname$) (?v2 Pname_set$)) (=> (= (?v0 ?v1) none$a) (= (minus$d (dom$c ?v0) (set.insert$b ?v1 ?v2)) (minus$d (dom$c ?v0) ?v2)))) :named a365))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname$) (?v2 Pname_set$)) (=> (= (?v0 ?v1) none$) (= (minus$d (dom$h ?v0) (set.insert$b ?v1 ?v2)) (minus$d (dom$h ?v0) ?v2)))) :named a366))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$) (?v2 State_triple_set$)) (=> (= (?v0 ?v1) none$) (= (minus$c (dom$i ?v0) (set.insert$ ?v1 ?v2)) (minus$c (dom$i ?v0) ?v2)))) :named a367))
+(assert (! (forall ((?v0 (-> Com$ Com_option$)) (?v1 Com_set$) (?v2 Com$)) (= (fun_upd$d (restrict_map$ ?v0 ?v1) ?v2 none$) (ite (set.member$b ?v2 ?v1) (restrict_map$ ?v0 (minus$ ?v1 (set.insert$a ?v2 bot$c))) (restrict_map$ ?v0 ?v1)))) :named a368))
+(assert (! (forall ((?v0 (-> Com$ State_triple_option$)) (?v1 Com_set$) (?v2 Com$)) (= (fun_upd$c (restrict_map$a ?v0 ?v1) ?v2 none$a) (ite (set.member$b ?v2 ?v1) (restrict_map$a ?v0 (minus$ ?v1 (set.insert$a ?v2 bot$c))) (restrict_map$a ?v0 ?v1)))) :named a369))
+(assert (! (forall ((?v0 (-> State_triple_option$ Com_option$)) (?v1 State_triple_option_set$) (?v2 State_triple_option$)) (= (fun_upd$g (restrict_map$b ?v0 ?v1) ?v2 none$) (ite (set.member$c ?v2 ?v1) (restrict_map$b ?v0 (minus$a ?v1 (set.insert$c ?v2 bot$a))) (restrict_map$b ?v0 ?v1)))) :named a370))
+(assert (! (forall ((?v0 (-> State_triple_option$ State_triple_option$)) (?v1 State_triple_option_set$) (?v2 State_triple_option$)) (= (fun_upd$f (restrict_map$c ?v0 ?v1) ?v2 none$a) (ite (set.member$c ?v2 ?v1) (restrict_map$c ?v0 (minus$a ?v1 (set.insert$c ?v2 bot$a))) (restrict_map$c ?v0 ?v1)))) :named a371))
+(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option_set$) (?v2 Com_option$)) (= (fun_upd$i (restrict_map$d ?v0 ?v1) ?v2 none$) (ite (set.member$d ?v2 ?v1) (restrict_map$d ?v0 (minus$b ?v1 (set.insert$d ?v2 bot$b))) (restrict_map$d ?v0 ?v1)))) :named a372))
+(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option_set$) (?v2 Com_option$)) (= (fun_upd$h (restrict_map$e ?v0 ?v1) ?v2 none$a) (ite (set.member$d ?v2 ?v1) (restrict_map$e ?v0 (minus$b ?v1 (set.insert$d ?v2 bot$b))) (restrict_map$e ?v0 ?v1)))) :named a373))
+(assert (! (forall ((?v0 (-> State_triple$ State_triple_option$)) (?v1 State_triple_set$) (?v2 State_triple$)) (= (fun_upd$b (restrict_map$f ?v0 ?v1) ?v2 none$a) (ite (set.member$ ?v2 ?v1) (restrict_map$f ?v0 (minus$c ?v1 (set.insert$ ?v2 bot$d))) (restrict_map$f ?v0 ?v1)))) :named a374))
+(assert (! (forall ((?v0 (-> Pname$ Com_option$)) (?v1 Pname_set$) (?v2 Pname$)) (= (fun_upd$a (restrict_map$g ?v0 ?v1) ?v2 none$) (ite (set.member$a ?v2 ?v1) (restrict_map$g ?v0 (minus$d ?v1 (set.insert$b ?v2 bot$))) (restrict_map$g ?v0 ?v1)))) :named a375))
+(assert (! (forall ((?v0 (-> Pname$ State_triple_option$)) (?v1 Pname_set$) (?v2 Pname$)) (= (fun_upd$e (restrict_map$h ?v0 ?v1) ?v2 none$a) (ite (set.member$a ?v2 ?v1) (restrict_map$h ?v0 (minus$d ?v1 (set.insert$b ?v2 bot$))) (restrict_map$h ?v0 ?v1)))) :named a376))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple_set$) (?v2 State_triple$)) (= (fun_upd$ (restrict_map$i ?v0 ?v1) ?v2 none$) (ite (set.member$ ?v2 ?v1) (restrict_map$i ?v0 (minus$c ?v1 (set.insert$ ?v2 bot$d))) (restrict_map$i ?v0 ?v1)))) :named a377))
+(assert (! (forall ((?v0 Pname_option_set$)) (= (not (= (these$ ?v0) bot$)) (and (not (= ?v0 bot$e)) (not (= ?v0 (set.insert$e none$b bot$e)))))) :named a378))
+(assert (! (forall ((?v0 State_triple_option_option_set$)) (= (not (= (these$a ?v0) bot$a)) (and (not (= ?v0 bot$f)) (not (= ?v0 (set.insert$f none$c bot$f)))))) :named a379))
+(assert (! (forall ((?v0 Com_option_option_set$)) (= (not (= (these$b ?v0) bot$b)) (and (not (= ?v0 bot$g)) (not (= ?v0 (set.insert$g none$d bot$g)))))) :named a380))
+(assert (! (forall ((?v0 Com_option_set$)) (= (not (= (these$c ?v0) bot$c)) (and (not (= ?v0 bot$b)) (not (= ?v0 (set.insert$d none$ bot$b)))))) :named a381))
+(assert (! (forall ((?v0 State_triple_option_set$)) (= (not (= (these$d ?v0) bot$d)) (and (not (= ?v0 bot$a)) (not (= ?v0 (set.insert$c none$a bot$a)))))) :named a382))
+(assert (! (forall ((?v0 Com$) (?v1 Com_set$) (?v2 (-> Com$ Com_option$))) (! (=> (not (set.member$b ?v0 ?v1)) (= (restrict_map$ ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$ ?v2 ?v1 ?v0)))) :named a383))
+(assert (! (forall ((?v0 Pname$) (?v1 Pname_set$) (?v2 (-> Pname$ Com_option$))) (! (=> (not (set.member$a ?v0 ?v1)) (= (restrict_map$g ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$g ?v2 ?v1 ?v0)))) :named a384))
+(assert (! (forall ((?v0 State_triple$) (?v1 State_triple_set$) (?v2 (-> State_triple$ Com_option$))) (! (=> (not (set.member$ ?v0 ?v1)) (= (restrict_map$i ?v2 ?v1 ?v0) none$)) :pattern ((restrict_map$i ?v2 ?v1 ?v0)))) :named a385))
+(assert (! (forall ((?v0 Com$) (?v1 Com_set$) (?v2 (-> Com$ State_triple_option$))) (! (=> (not (set.member$b ?v0 ?v1)) (= (restrict_map$a ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$a ?v2 ?v1 ?v0)))) :named a386))
+(assert (! (forall ((?v0 Pname$) (?v1 Pname_set$) (?v2 (-> Pname$ State_triple_option$))) (! (=> (not (set.member$a ?v0 ?v1)) (= (restrict_map$h ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$h ?v2 ?v1 ?v0)))) :named a387))
+(assert (! (forall ((?v0 State_triple$) (?v1 State_triple_set$) (?v2 (-> State_triple$ State_triple_option$))) (! (=> (not (set.member$ ?v0 ?v1)) (= (restrict_map$f ?v2 ?v1 ?v0) none$a)) :pattern ((restrict_map$f ?v2 ?v1 ?v0)))) :named a388))
(assert (! (forall ((?v0 State_triple_set$) (?v1 State_triple$)) (= (restrict_map$i uuy$ ?v0 ?v1) none$)) :named a389))
(assert (! (forall ((?v0 (-> Com_option$ Com_option$)) (?v1 Com_option$)) (= (restrict_map$d ?v0 bot$b ?v1) none$)) :named a390))
(assert (! (forall ((?v0 (-> Com_option$ State_triple_option$)) (?v1 Com_option$)) (= (restrict_map$e ?v0 bot$b ?v1) none$a)) :named a391))
(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (restrict_map$i ?v0 bot$d ?v1) none$)) :named a392))
-(assert (! (forall ((?v0 Com_option_set$)) (= (these$c (insert$d none$ ?v0)) (these$c ?v0))) :named a393))
-(assert (! (forall ((?v0 Com_option_set$)) (= (= (these$c ?v0) bot$c) (or (= ?v0 bot$b) (= ?v0 (insert$d none$ bot$b))))) :named a394))
-(assert (! (forall ((?v0 State_triple_option_set$)) (= (= (these$d ?v0) bot$d) (or (= ?v0 bot$a) (= ?v0 (insert$c none$a bot$a))))) :named a395))
-(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (restrict_map$i ?v0 (uminus$ (insert$ ?v1 bot$d))) (fun_upd$ ?v0 ?v1 none$))) :named a396))
+(assert (! (forall ((?v0 Com_option_set$)) (= (these$c (set.insert$d none$ ?v0)) (these$c ?v0))) :named a393))
+(assert (! (forall ((?v0 Com_option_set$)) (= (= (these$c ?v0) bot$c) (or (= ?v0 bot$b) (= ?v0 (set.insert$d none$ bot$b))))) :named a394))
+(assert (! (forall ((?v0 State_triple_option_set$)) (= (= (these$d ?v0) bot$d) (or (= ?v0 bot$a) (= ?v0 (set.insert$c none$a bot$a))))) :named a395))
+(assert (! (forall ((?v0 (-> State_triple$ Com_option$)) (?v1 State_triple$)) (= (restrict_map$i ?v0 (uminus$ (set.insert$ ?v1 bot$d))) (fun_upd$ ?v0 ?v1 none$))) :named a396))
(check-sat)
;(get-proof)
(declare-fun comp$cj (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_fun_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_tree_a_b_fun_sum_fun_fun$)
(declare-fun convol$ (B_b_fun$ B_b_fun$) B_b_b_prod_fun$)
(declare-fun id_bnf$ (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$) B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)
-(declare-fun member$ (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) Bool)
+(declare-fun set.member$ (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$ B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) Bool)
(declare-fun convol$a (B_b_tree_fun$ B_b_fun$ B$) B_tree_b_prod$)
(declare-fun convol$b (B_tree_b_tree_fun$ B_tree_b_fun$) B_tree_b_tree_b_prod_fun$)
(declare-fun convol$c (B_tree_b_fun$ B_tree_b_fun$ B_tree$) B_b_prod$)
(declare-fun id_bnf$d (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)
(declare-fun id_bnf$e (B_tree_a_b_fun_sum$) B_tree_a_b_fun_sum$)
(declare-fun map_sum$ (A_tree_b_tree_fun$ B_b_fun$) A_tree_b_sum_b_tree_b_sum_fun$)
-(declare-fun member$a (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) Bool)
+(declare-fun set.member$a (B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$ B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) Bool)
(declare-fun uncurry$ (B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun_fun$) B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_b_prod_b_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_fun$)
(declare-fun case_sum$ (B_tree_b_tree_fun$) A_b_fun_b_tree_fun_b_tree_a_b_fun_sum_b_tree_fun_fun$)
(declare-fun ctor_rec$ (A_b_fun$) A_b_fun$)
(assert (forall ((?v0 B_tree$) (?v1 B_tree_b_tree_fun$)) (! (= (fun_app$y (uuw$ ?v0) ?v1) (fun_app$x ?v1 ?v0)) :pattern ((fun_app$y (uuw$ ?v0) ?v1)))))
(assert (forall ((?v0 B$) (?v1 B_b_fun$)) (! (= (fun_app$z (uuu$ ?v0) ?v1) (fun_app$aa ?v1 ?v0)) :pattern ((fun_app$z (uuu$ ?v0) ?v1)))))
(assert (forall ((?v0 A$) (?v1 A_b_fun$)) (! (= (fun_app$ab (uuo$ ?v0) ?v1) (fun_app$ac ?v1 ?v0)) :pattern ((fun_app$ab (uuo$ ?v0) ?v1)))))
-(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (! (= (fun_app$ad (fun_app$ae (uuz$ ?v0) ?v1) ?v2) (member$ (pair$b ?v1 ?v2) ?v0)) :pattern ((fun_app$ad (fun_app$ae (uuz$ ?v0) ?v1) ?v2)))))
-(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$af (fun_app$ag (uuy$ ?v0) ?v1) ?v2) (member$a (pair$c ?v1 ?v2) ?v0)) :pattern ((fun_app$af (fun_app$ag (uuy$ ?v0) ?v1) ?v2)))))
+(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum$)) (! (= (fun_app$ad (fun_app$ae (uuz$ ?v0) ?v1) ?v2) (set.member$ (pair$b ?v1 ?v2) ?v0)) :pattern ((fun_app$ad (fun_app$ae (uuz$ ?v0) ?v1) ?v2)))))
+(assert (forall ((?v0 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) (?v1 B$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (! (= (fun_app$af (fun_app$ag (uuy$ ?v0) ?v1) ?v2) (set.member$a (pair$c ?v1 ?v2) ?v0)) :pattern ((fun_app$af (fun_app$ag (uuy$ ?v0) ?v1) ?v2)))))
(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 B_tree_b_tree_fun$) (?v2 B_tree$)) (! (= (fun_app$x (fun_app$s (uul$ ?v0) ?v1) ?v2) (fun_app$x ?v0 (fun_app$x ?v1 ?v2))) :pattern ((fun_app$x (fun_app$s (uul$ ?v0) ?v1) ?v2)))))
(assert (forall ((?v0 B_tree_b_tree_fun$) (?v1 A_b_fun_b_tree_fun$) (?v2 A_b_fun$)) (! (= (fun_app$c (fun_app$ah (uum$ ?v0) ?v1) ?v2) (fun_app$x ?v0 (fun_app$c ?v1 ?v2))) :pattern ((fun_app$c (fun_app$ah (uum$ ?v0) ?v1) ?v2)))))
(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_fun$) (?v1 B_tree_a_b_fun_sum_b_tree_fun$) (?v2 B_tree_a_b_fun_sum$) (?v3 B_tree_a_b_fun_sum$)) (! (= (fun_app$ai (fun_app$aj (uvs$ ?v0 ?v1) ?v2) ?v3) (pair$ (fun_app$w ?v0 ?v2) (fun_app$w ?v1 ?v3))) :pattern ((fun_app$ai (fun_app$aj (uvs$ ?v0 ?v1) ?v2) ?v3)))))
(assert (forall ((?v0 B_tree_a_b_fun_sum$)) (= (fun_app$ca (fun_app$fi (comp$ch uvd$) uvl$) ?v0) (id$z ?v0)) ))
(assert (forall ((?v0 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v1 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (= ?v0 (snd$c ?v1)) (exists ((?v2 B$)) (= ?v1 (pair$c ?v2 ?v0)) )) ))
(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (= ?v0 (snd$b ?v1)) (exists ((?v2 B_tree_a_b_fun_sum$)) (= ?v1 (pair$b ?v2 ?v0)) )) ))
-(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v2 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (and (member$a (pair$c ?v0 ?v1) ?v2) (= ?v3 ?v1)) (member$a (pair$c ?v0 ?v3) ?v2)) ))
-(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) (?v3 B_tree_a_b_fun_sum$)) (=> (and (member$ (pair$b ?v0 ?v1) ?v2) (= ?v3 ?v1)) (member$ (pair$b ?v0 ?v3) ?v2)) ))
+(assert (forall ((?v0 B$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$) (?v2 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod_set$) (?v3 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (=> (and (set.member$a (pair$c ?v0 ?v1) ?v2) (= ?v3 ?v1)) (set.member$a (pair$c ?v0 ?v3) ?v2)) ))
+(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum$) (?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_set$) (?v3 B_tree_a_b_fun_sum$)) (=> (and (set.member$ (pair$b ?v0 ?v1) ?v2) (= ?v3 ?v1)) (set.member$ (pair$b ?v0 ?v3) ?v2)) ))
(assert (forall ((?v0 B$) (?v1 B_b_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod_prod$)) (= (= ?v0 (fst$c ?v1)) (exists ((?v2 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= ?v1 (pair$c ?v0 ?v2)) )) ))
(assert (forall ((?v0 B_tree_a_b_fun_sum$) (?v1 B_tree_a_b_fun_sum_b_tree_a_b_fun_sum_prod$)) (= (= ?v0 (fst$b ?v1)) (exists ((?v2 B_tree_a_b_fun_sum$)) (= ?v1 (pair$b ?v0 ?v2)) )) ))
(assert (forall ((?v0 A_b_fun$) (?v1 A_a_fun$)) (= (fun_app$v (comp$b (ctor_rec$ ?v0)) ?v1) (ctor_rec$ (fun_app$v (comp$b ?v0) (fun_app$bh (comp$e (fun_app$bh (comp$e id_bnf$c) ?v1)) id_bnf$c)))) ))
(+ (- i a_last) (- b_first 1)))))) :pattern ((select
(concat1 a a_first a_last b b_first b_last) i)) )))))
-(declare-fun singleton (natural Int) (Array Int natural))
+(declare-fun set.singleton (natural Int) (Array Int natural))
;; singleton_def
(assert
(forall ((v natural))
(forall ((i Int))
- (! (= (select (singleton v i) i) v) :pattern ((select (singleton v i)
+ (! (= (select (set.singleton v i) i) v) :pattern ((select (set.singleton v i)
i)) ))))
(declare-fun compare ((Array Int natural) Int Int (Array Int natural) Int
(declare-fun image2$ (A_llist_a_llist_prod_set$ A_llist_a_llist_prod_a_llist_fun$ A_llist_a_llist_prod_a_llist_fun$) A_llist_a_llist_prod_set$)
(declare-fun in_rel$ (A_llist_a_llist_prod_set$) A_llist_a_llist_bool_fun_fun$)
(declare-fun lnull$a () A_llist_a_llist_prod_llist_bool_fun$)
-(declare-fun member$ (A_llist_a_llist_prod$) A_llist_a_llist_prod_set_bool_fun$)
+(declare-fun set.member$ (A_llist_a_llist_prod$) A_llist_a_llist_prod_set_bool_fun$)
(declare-fun collect$ (A_llist_a_llist_prod_bool_fun$) A_llist_a_llist_prod_set$)
(declare-fun fun_app$ (A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun$ A_llist_a_llist_prod_llist$) A_llist_a_llist_prod_llist$)
(declare-fun lappend$ (A_llist_a_llist_prod_llist$) A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_fun$)
(declare-fun lfinite$ (A_llist_a_llist_prod_llist$) Bool)
(declare-fun lmember$ (A_llist_a_llist_prod$) A_llist_a_llist_prod_llist_bool_fun$)
(declare-fun lprefix$ (A_llist$) A_llist_bool_fun$)
-(declare-fun member$a (A_llist_a_llist_prod_a_llist_a_llist_prod_prod$ A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) Bool)
-(declare-fun member$b (A$ A_set$) Bool)
-(declare-fun member$c (A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod$ A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod_set$) Bool)
+(declare-fun set.member$a (A_llist_a_llist_prod_a_llist_a_llist_prod_prod$ A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) Bool)
+(declare-fun set.member$b (A$ A_set$) Bool)
+(declare-fun set.member$c (A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod$ A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod_set$) Bool)
(declare-fun uncurry$ () A_llist_a_llist_a_llist_a_llist_prod_fun_fun_a_llist_a_llist_prod_a_llist_a_llist_prod_fun_fun$)
(declare-fun collect$a (A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$)
(declare-fun collect$b (A_bool_fun$) A_set$)
(assert (! (forall ((?v0 A_llist$)) (! (= (fun_app$c uve$ ?v0) (lhd$ ?v0)) :pattern ((fun_app$c uve$ ?v0)))) :named a3))
(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (! (= (fun_app$d (fun_app$e uvx$ ?v0) ?v1) (pair$ ?v0 ?v1)) :pattern ((fun_app$d (fun_app$e uvx$ ?v0) ?v1)))) :named a4))
(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$)) (! (= (fun_app$f (fun_app$g uvw$ ?v0) ?v1) (pair$b ?v0 ?v1)) :pattern ((fun_app$f (fun_app$g uvw$ ?v0) ?v1)))) :named a5))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod$)) (! (= (fun_app$h (uui$ ?v0) ?v1) (fun_app$i (member$ ?v1) ?v0)) :pattern ((fun_app$h (uui$ ?v0) ?v1)))) :named a6))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (! (= (fun_app$j (uuh$ ?v0) ?v1) (member$a ?v1 ?v0)) :pattern ((fun_app$j (uuh$ ?v0) ?v1)))) :named a7))
-(assert (! (forall ((?v0 A_set$) (?v1 A$)) (! (= (fun_app$k (uug$ ?v0) ?v1) (member$b ?v1 ?v0)) :pattern ((fun_app$k (uug$ ?v0) ?v1)))) :named a8))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod$)) (! (= (fun_app$h (uui$ ?v0) ?v1) (fun_app$i (set.member$ ?v1) ?v0)) :pattern ((fun_app$h (uui$ ?v0) ?v1)))) :named a6))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (! (= (fun_app$j (uuh$ ?v0) ?v1) (set.member$a ?v1 ?v0)) :pattern ((fun_app$j (uuh$ ?v0) ?v1)))) :named a7))
+(assert (! (forall ((?v0 A_set$) (?v1 A$)) (! (= (fun_app$k (uug$ ?v0) ?v1) (set.member$b ?v1 ?v0)) :pattern ((fun_app$k (uug$ ?v0) ?v1)))) :named a8))
(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$d (fun_app$e (uwd$ ?v0) ?v1) ?v2) (fun_app$d (fun_app$e ?v0 ?v2) ?v1)) :pattern ((fun_app$d (fun_app$e (uwd$ ?v0) ?v1) ?v2)))) :named a9))
(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$l (fun_app$m (uwg$ ?v0) ?v1) ?v2) (fun_app$l (fun_app$m ?v0 ?v2) ?v1)) :pattern ((fun_app$l (fun_app$m (uwg$ ?v0) ?v1) ?v2)))) :named a10))
(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$n (fun_app$o (uwc$ ?v0) ?v1) ?v2) (fun_app$n (fun_app$o ?v0 ?v2) ?v1)) :pattern ((fun_app$n (fun_app$o (uwc$ ?v0) ?v1) ?v2)))) :named a11))
(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$p (fun_app$q (uwf$ ?v0) ?v1) ?v2) (fun_app$p (fun_app$q ?v0 ?v2) ?v1)) :pattern ((fun_app$p (fun_app$q (uwf$ ?v0) ?v1) ?v2)))) :named a12))
(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (uwe$ ?v0) ?v1) ?v2) (fun_app$h (fun_app$r ?v0 ?v2) ?v1)) :pattern ((fun_app$h (fun_app$r (uwe$ ?v0) ?v1) ?v2)))) :named a13))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$s (uwq$ ?v0) ?v1) ?v2) (or (fun_app$i (member$ ?v2) ?v0) (fun_app$i (member$ ?v2) ?v1))) :pattern ((fun_app$h (fun_app$s (uwq$ ?v0) ?v1) ?v2)))) :named a14))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_bool_fun$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$t (uws$ ?v0) ?v1) ?v2) (and (fun_app$i (member$ ?v2) ?v0) (fun_app$h ?v1 ?v2))) :pattern ((fun_app$h (fun_app$t (uws$ ?v0) ?v1) ?v2)))) :named a15))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$l (fun_app$m (uvz$ ?v0) ?v1) ?v2) (fun_app$i (member$ (pair$ ?v1 ?v2)) ?v0)) :pattern ((fun_app$l (fun_app$m (uvz$ ?v0) ?v1) ?v2)))) :named a16))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (uvy$ ?v0) ?v1) ?v2) (member$a (pair$b ?v1 ?v2) ?v0)) :pattern ((fun_app$h (fun_app$r (uvy$ ?v0) ?v1) ?v2)))) :named a17))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$s (uwq$ ?v0) ?v1) ?v2) (or (fun_app$i (set.member$ ?v2) ?v0) (fun_app$i (set.member$ ?v2) ?v1))) :pattern ((fun_app$h (fun_app$s (uwq$ ?v0) ?v1) ?v2)))) :named a14))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_bool_fun$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$t (uws$ ?v0) ?v1) ?v2) (and (fun_app$i (set.member$ ?v2) ?v0) (fun_app$h ?v1 ?v2))) :pattern ((fun_app$h (fun_app$t (uws$ ?v0) ?v1) ?v2)))) :named a15))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$l (fun_app$m (uvz$ ?v0) ?v1) ?v2) (fun_app$i (set.member$ (pair$ ?v1 ?v2)) ?v0)) :pattern ((fun_app$l (fun_app$m (uvz$ ?v0) ?v1) ?v2)))) :named a16))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (uvy$ ?v0) ?v1) ?v2) (set.member$a (pair$b ?v1 ?v2) ?v0)) :pattern ((fun_app$h (fun_app$r (uvy$ ?v0) ?v1) ?v2)))) :named a17))
(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_prod_bool_fun$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$t (uwp$ ?v0) ?v1) ?v2) (or (fun_app$h ?v0 ?v2) (fun_app$h ?v1 ?v2))) :pattern ((fun_app$h (fun_app$t (uwp$ ?v0) ?v1) ?v2)))) :named a18))
(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_prod_bool_fun$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$t (uwr$ ?v0) ?v1) ?v2) (and (fun_app$h ?v0 ?v2) (fun_app$h ?v1 ?v2))) :pattern ((fun_app$h (fun_app$t (uwr$ ?v0) ?v1) ?v2)))) :named a19))
(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_llist$)) (! (= (fun_app$ (fun_app$u (uwh$ ?v0) ?v1) ?v2) (lCons$a ?v1 (fun_app$ (lappend$ ?v2) ?v0))) :pattern ((fun_app$ (fun_app$u (uwh$ ?v0) ?v1) ?v2)))) :named a20))
(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$p (fun_app$q (uue$ ?v0) ?v1) ?v2) (fun_app$r ?v0 (pair$ ?v1 ?v2))) :pattern ((fun_app$p (fun_app$q (uue$ ?v0) ?v1) ?v2)))) :named a26))
(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (! (= (fun_app$h (fun_app$r (uud$ ?v0) ?v1) ?v2) (fun_app$j ?v0 (pair$b ?v1 ?v2))) :pattern ((fun_app$h (fun_app$r (uud$ ?v0) ?v1) ?v2)))) :named a27))
(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$y (uvg$ ?v0) ?v1) ?v2) ?v3) (fun_app$h (fun_app$p (fun_app$q ?v0 ?v2) ?v3) ?v1)) :pattern ((fun_app$l (fun_app$m (fun_app$y (uvg$ ?v0) ?v1) ?v2) ?v3)))) :named a28))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$z (uwk$ ?v0) ?v1) ?v2) ?v3) (fun_app$i (member$ (pair$ (fun_app$a ?v1 ?v2) (fun_app$a ?v1 ?v3))) ?v0)) :pattern ((fun_app$l (fun_app$m (fun_app$z (uwk$ ?v0) ?v1) ?v2) ?v3)))) :named a29))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$z (uwk$ ?v0) ?v1) ?v2) ?v3) (fun_app$i (set.member$ (pair$ (fun_app$a ?v1 ?v2) (fun_app$a ?v1 ?v3))) ?v0)) :pattern ((fun_app$l (fun_app$m (fun_app$z (uwk$ ?v0) ?v1) ?v2) ?v3)))) :named a29))
(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$aa (uwt$ ?v0) ?v1) ?v2) ?v3) (and (= ?v0 ?v2) (= ?v1 ?v3))) :pattern ((fun_app$l (fun_app$m (fun_app$aa (uwt$ ?v0) ?v1) ?v2) ?v3)))) :named a30))
(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$d (fun_app$e (uuv$ ?v0 ?v1) ?v2) ?v3) (fun_app$w (fun_app$ab uncurry$ ?v0) (fun_app$d (fun_app$e ?v1 ?v2) ?v3))) :pattern ((fun_app$d (fun_app$e (uuv$ ?v0 ?v1) ?v2) ?v3)))) :named a31))
(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$ac (uuz$ ?v0) ?v1) ?v2) ?v3) (fun_app$h (fun_app$ad uncurry$a ?v0) (fun_app$d (fun_app$e ?v1 ?v2) ?v3))) :pattern ((fun_app$l (fun_app$m (fun_app$ac (uuz$ ?v0) ?v1) ?v2) ?v3)))) :named a32))
(assert (! (forall ((?v0 A_a_fun$) (?v1 A_a_llist_a_fun_fun$) (?v2 A$) (?v3 A_llist$)) (! (= (fun_app$c (fun_app$au (fun_app$bo (uvp$ ?v0) ?v1) ?v2) ?v3) (fun_app$bp ?v0 (fun_app$c (fun_app$au ?v1 ?v2) ?v3))) :pattern ((fun_app$c (fun_app$au (fun_app$bo (uvp$ ?v0) ?v1) ?v2) ?v3)))) :named a58))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$p (fun_app$q (fun_app$bq (uwo$ ?v0) ?v1) ?v2) ?v3) (fun_app$ad uncurry$a (fun_app$aa (fun_app$br (fun_app$bs (uwn$ ?v0) ?v1) ?v2) ?v3))) :pattern ((fun_app$p (fun_app$q (fun_app$bq (uwo$ ?v0) ?v1) ?v2) ?v3)))) :named a59))
(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_llist_a_llist_prod_set_fun$) (?v2 A_llist$) (?v3 A_llist$)) (! (= (fun_app$p (fun_app$q (fun_app$bt (uwm$ ?v0) ?v1) ?v2) ?v3) (fun_app$ad uncurry$a (fun_app$aa (fun_app$br (fun_app$bu (uwl$ ?v0) ?v1) ?v2) ?v3))) :pattern ((fun_app$p (fun_app$q (fun_app$bt (uwm$ ?v0) ?v1) ?v2) ?v3)))) :named a60))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist$) (?v5 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bs (uwn$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5) (or (fun_app$i (member$ (pair$ ?v2 ?v4)) ?v0) (and (= ?v2 ?v4) (fun_app$i (member$ (pair$ ?v3 ?v5)) ?v1)))) :pattern ((fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bs (uwn$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5)))) :named a61))
-(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_llist_a_llist_prod_set_fun$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist$) (?v5 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bu (uwl$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5) (and (= ?v2 ?v4) (and (fun_app$l ?v0 ?v4) (fun_app$i (member$ (pair$ ?v3 ?v5)) (fun_app$n ?v1 ?v4))))) :pattern ((fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bu (uwl$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5)))) :named a62))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist$) (?v5 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bs (uwn$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5) (or (fun_app$i (set.member$ (pair$ ?v2 ?v4)) ?v0) (and (= ?v2 ?v4) (fun_app$i (set.member$ (pair$ ?v3 ?v5)) ?v1)))) :pattern ((fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bs (uwn$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5)))) :named a61))
+(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_llist_a_llist_prod_set_fun$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist$) (?v5 A_llist$)) (! (= (fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bu (uwl$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5) (and (= ?v2 ?v4) (and (fun_app$l ?v0 ?v4) (fun_app$i (set.member$ (pair$ ?v3 ?v5)) (fun_app$n ?v1 ?v4))))) :pattern ((fun_app$l (fun_app$m (fun_app$aa (fun_app$br (fun_app$bu (uwl$ ?v0) ?v1) ?v2) ?v3) ?v4) ?v5)))) :named a62))
(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (! (= (fun_app$b (fun_app$bv uwa$ ?v0) ?v1) ?v0) :pattern ((fun_app$b (fun_app$bv uwa$ ?v0) ?v1)))) :named a63))
(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (! (= (fun_app$c (fun_app$au uwb$ ?v0) ?v1) ?v0) :pattern ((fun_app$c (fun_app$au uwb$ ?v0) ?v1)))) :named a64))
(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (! (= (fun_app$ (fun_app$u uvu$ ?v0) ?v1) ?v1) :pattern ((fun_app$ (fun_app$u uvu$ ?v0) ?v1)))) :named a65))
(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (! (= (fun_app$l (fun_app$as uvr$ ?v0) ?v1) true) :pattern ((fun_app$l (fun_app$as uvr$ ?v0) ?v1)))) :named a72))
(assert (! (not (fun_app$l (lprefix$ xs$) ys$)) :named a73))
(assert (! (fun_app$l (fun_app$m p$ xs$) ys$) :named a74))
-(assert (! (fun_app$i (member$ (pair$ xs$ ys$)) (collect$ (fun_app$ad uncurry$a p$))) :named a75))
+(assert (! (fun_app$i (set.member$ (pair$ xs$ ys$)) (collect$ (fun_app$ad uncurry$a p$))) :named a75))
(assert (! (forall ((?v0 A_llist$)) (fun_app$l (lprefix$ lNil$) ?v0)) :named a76))
(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$bw (lprefix$a ?v0) ?v1) (fun_app$bw (lprefix$a (lCons$a ?v2 ?v0)) (lCons$a ?v2 ?v1)))) :named a77))
(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A$)) (=> (fun_app$l (lprefix$ ?v0) ?v1) (fun_app$l (lprefix$ (lCons$ ?v2 ?v0)) (lCons$ ?v2 ?v1)))) :named a78))
(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (and (fun_app$l (lprefix$ ?v0) ?v1) (and (forall ((?v2 A_llist$)) (=> (and (= ?v0 lNil$) (= ?v1 ?v2)) false)) (forall ((?v2 A_llist$) (?v3 A_llist$) (?v4 A$)) (=> (and (= ?v0 (lCons$ ?v4 ?v2)) (and (= ?v1 (lCons$ ?v4 ?v3)) (fun_app$l (lprefix$ ?v2) ?v3))) false)))) false)) :named a83))
(assert (! (forall ((?v0 A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$bw (fun_app$by ?v0 ?v1) ?v2) (forall ((?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod_llist$)) (=> (fun_app$bw (fun_app$by ?v0 ?v3) ?v4) (or (exists ((?v5 A_llist_a_llist_prod_llist$)) (and (= ?v3 lNil$a) (= ?v4 ?v5))) (exists ((?v5 A_llist_a_llist_prod_llist$) (?v6 A_llist_a_llist_prod_llist$) (?v7 A_llist_a_llist_prod$)) (and (= ?v3 (lCons$a ?v7 ?v5)) (and (= ?v4 (lCons$a ?v7 ?v6)) (or (fun_app$bw (fun_app$by ?v0 ?v5) ?v6) (fun_app$bw (lprefix$a ?v5) ?v6))))))))) (fun_app$bw (lprefix$a ?v1) ?v2))) :named a84))
(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (=> (and (fun_app$l (fun_app$m ?v0 ?v1) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (fun_app$l (fun_app$m ?v0 ?v3) ?v4) (or (exists ((?v5 A_llist$)) (and (= ?v3 lNil$) (= ?v4 ?v5))) (exists ((?v5 A_llist$) (?v6 A_llist$) (?v7 A$)) (and (= ?v3 (lCons$ ?v7 ?v5)) (and (= ?v4 (lCons$ ?v7 ?v6)) (or (fun_app$l (fun_app$m ?v0 ?v5) ?v6) (fun_app$l (lprefix$ ?v5) ?v6))))))))) (fun_app$l (lprefix$ ?v1) ?v2))) :named a85))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod_set$)) (=> (and (member$c (pair$a ?v0 ?v1) ?v2) (forall ((?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod_llist$)) (=> (member$c (pair$a ?v3 ?v4) ?v2) (or (fun_app$bw lnull$a ?v3) (exists ((?v5 A_llist_a_llist_prod$) (?v6 A_llist_a_llist_prod_llist$) (?v7 A_llist_a_llist_prod_llist$)) (and (= ?v3 (lCons$a ?v5 ?v6)) (and (= ?v4 (lCons$a ?v5 ?v7)) (or (member$c (pair$a ?v6 ?v7) ?v2) (fun_app$bw (lprefix$a ?v6) ?v7))))))))) (fun_app$bw (lprefix$a ?v0) ?v1))) :named a86))
-(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist_a_llist_prod_set$)) (=> (and (fun_app$i (member$ (pair$ ?v0 ?v1)) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (fun_app$i (member$ (pair$ ?v3 ?v4)) ?v2) (or (fun_app$l lnull$ ?v3) (exists ((?v5 A$) (?v6 A_llist$) (?v7 A_llist$)) (and (= ?v3 (lCons$ ?v5 ?v6)) (and (= ?v4 (lCons$ ?v5 ?v7)) (or (fun_app$i (member$ (pair$ ?v6 ?v7)) ?v2) (fun_app$l (lprefix$ ?v6) ?v7))))))))) (fun_app$l (lprefix$ ?v0) ?v1))) :named a87))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist_a_llist_a_llist_prod_llist_prod_set$)) (=> (and (set.member$c (pair$a ?v0 ?v1) ?v2) (forall ((?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod_llist$)) (=> (set.member$c (pair$a ?v3 ?v4) ?v2) (or (fun_app$bw lnull$a ?v3) (exists ((?v5 A_llist_a_llist_prod$) (?v6 A_llist_a_llist_prod_llist$) (?v7 A_llist_a_llist_prod_llist$)) (and (= ?v3 (lCons$a ?v5 ?v6)) (and (= ?v4 (lCons$a ?v5 ?v7)) (or (set.member$c (pair$a ?v6 ?v7) ?v2) (fun_app$bw (lprefix$a ?v6) ?v7))))))))) (fun_app$bw (lprefix$a ?v0) ?v1))) :named a86))
+(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist_a_llist_prod_set$)) (=> (and (fun_app$i (set.member$ (pair$ ?v0 ?v1)) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (fun_app$i (set.member$ (pair$ ?v3 ?v4)) ?v2) (or (fun_app$l lnull$ ?v3) (exists ((?v5 A$) (?v6 A_llist$) (?v7 A_llist$)) (and (= ?v3 (lCons$ ?v5 ?v6)) (and (= ?v4 (lCons$ ?v5 ?v7)) (or (fun_app$i (set.member$ (pair$ ?v6 ?v7)) ?v2) (fun_app$l (lprefix$ ?v6) ?v7))))))))) (fun_app$l (lprefix$ ?v0) ?v1))) :named a87))
(assert (! (forall ((?v0 A$) (?v1 A_llist$) (?v2 A$) (?v3 A_llist$)) (= (= (lCons$ ?v0 ?v1) (lCons$ ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a88))
(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod_llist$)) (= (= (lCons$a ?v0 ?v1) (lCons$a ?v2 ?v3)) (and (= ?v0 ?v2) (= ?v1 ?v3)))) :named a89))
(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (not (fun_app$bw lnull$a ?v0)) (= (lCons$a (lhd$a ?v0) (ltl$a ?v0)) ?v0))) :named a90))
(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$)) (=> (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (= (fun_app$h (fun_app$r ?v0 ?v2) ?v3) (fun_app$j ?v1 (pair$b ?v2 ?v3)))) (= (fun_app$al uncurry$d ?v0) ?v1))) :named a162))
(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (= (fun_app$p (fun_app$q ?v0 ?v2) ?v3) (fun_app$r ?v1 (pair$ ?v2 ?v3)))) (= (fun_app$aj uncurry$c ?v0) ?v1))) :named a163))
(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_prod_bool_fun$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (= (fun_app$l (fun_app$m ?v0 ?v2) ?v3) (fun_app$h ?v1 (pair$ ?v2 ?v3)))) (= (fun_app$ad uncurry$a ?v0) ?v1))) :named a164))
-(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_a_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (=> (member$b ?v0 (fun_app$bz (fun_app$ca ?v1 ?v2) ?v3)) (member$b ?v0 (uncurry$e ?v1 (pair$ ?v2 ?v3))))) :named a165))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (=> (member$a ?v0 (fun_app$cb (fun_app$cc ?v1 ?v2) ?v3)) (member$a ?v0 (uncurry$f ?v1 (pair$ ?v2 ?v3))))) :named a166))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (fun_app$i (member$ ?v0) (fun_app$x (fun_app$cd ?v1 ?v2) ?v3)) (fun_app$i (member$ ?v0) (uncurry$g ?v1 (pair$b ?v2 ?v3))))) :named a167))
-(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (member$b ?v0 (fun_app$ce (fun_app$cf ?v1 ?v2) ?v3)) (member$b ?v0 (uncurry$h ?v1 (pair$b ?v2 ?v3))))) :named a168))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (member$a ?v0 (fun_app$cg (fun_app$ch ?v1 ?v2) ?v3)) (member$a ?v0 (uncurry$i ?v1 (pair$b ?v2 ?v3))))) :named a169))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (=> (fun_app$i (member$ ?v0) (fun_app$n (fun_app$o ?v1 ?v2) ?v3)) (fun_app$i (member$ ?v0) (fun_app$x (fun_app$ah uncurry$b ?v1) (pair$ ?v2 ?v3))))) :named a170))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A$) (?v2 A_llist_a_llist_a_set_fun_fun$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= ?v0 (pair$ ?v3 ?v4)) (member$b ?v1 (fun_app$bz (fun_app$ca ?v2 ?v3) ?v4)))) (member$b ?v1 (uncurry$e ?v2 ?v0)))) :named a171))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= ?v0 (pair$ ?v3 ?v4)) (member$a ?v1 (fun_app$cb (fun_app$cc ?v2 ?v3) ?v4)))) (member$a ?v1 (uncurry$f ?v2 ?v0)))) :named a172))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v3 ?v4)) (fun_app$i (member$ ?v1) (fun_app$x (fun_app$cd ?v2 ?v3) ?v4)))) (fun_app$i (member$ ?v1) (uncurry$g ?v2 ?v0)))) :named a173))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$)) (=> (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v3 ?v4)) (member$b ?v1 (fun_app$ce (fun_app$cf ?v2 ?v3) ?v4)))) (member$b ?v1 (uncurry$h ?v2 ?v0)))) :named a174))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v3 ?v4)) (member$a ?v1 (fun_app$cg (fun_app$ch ?v2 ?v3) ?v4)))) (member$a ?v1 (uncurry$i ?v2 ?v0)))) :named a175))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= ?v0 (pair$ ?v3 ?v4)) (fun_app$i (member$ ?v1) (fun_app$n (fun_app$o ?v2 ?v3) ?v4)))) (fun_app$i (member$ ?v1) (fun_app$x (fun_app$ah uncurry$b ?v2) ?v0)))) :named a176))
+(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_a_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (=> (set.member$b ?v0 (fun_app$bz (fun_app$ca ?v1 ?v2) ?v3)) (set.member$b ?v0 (uncurry$e ?v1 (pair$ ?v2 ?v3))))) :named a165))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (=> (set.member$a ?v0 (fun_app$cb (fun_app$cc ?v1 ?v2) ?v3)) (set.member$a ?v0 (uncurry$f ?v1 (pair$ ?v2 ?v3))))) :named a166))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (fun_app$i (set.member$ ?v0) (fun_app$x (fun_app$cd ?v1 ?v2) ?v3)) (fun_app$i (set.member$ ?v0) (uncurry$g ?v1 (pair$b ?v2 ?v3))))) :named a167))
+(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (set.member$b ?v0 (fun_app$ce (fun_app$cf ?v1 ?v2) ?v3)) (set.member$b ?v0 (uncurry$h ?v1 (pair$b ?v2 ?v3))))) :named a168))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod$)) (=> (set.member$a ?v0 (fun_app$cg (fun_app$ch ?v1 ?v2) ?v3)) (set.member$a ?v0 (uncurry$i ?v1 (pair$b ?v2 ?v3))))) :named a169))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist$) (?v3 A_llist$)) (=> (fun_app$i (set.member$ ?v0) (fun_app$n (fun_app$o ?v1 ?v2) ?v3)) (fun_app$i (set.member$ ?v0) (fun_app$x (fun_app$ah uncurry$b ?v1) (pair$ ?v2 ?v3))))) :named a170))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A$) (?v2 A_llist_a_llist_a_set_fun_fun$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= ?v0 (pair$ ?v3 ?v4)) (set.member$b ?v1 (fun_app$bz (fun_app$ca ?v2 ?v3) ?v4)))) (set.member$b ?v1 (uncurry$e ?v2 ?v0)))) :named a171))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= ?v0 (pair$ ?v3 ?v4)) (set.member$a ?v1 (fun_app$cb (fun_app$cc ?v2 ?v3) ?v4)))) (set.member$a ?v1 (uncurry$f ?v2 ?v0)))) :named a172))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v3 ?v4)) (fun_app$i (set.member$ ?v1) (fun_app$x (fun_app$cd ?v2 ?v3) ?v4)))) (fun_app$i (set.member$ ?v1) (uncurry$g ?v2 ?v0)))) :named a173))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$)) (=> (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v3 ?v4)) (set.member$b ?v1 (fun_app$ce (fun_app$cf ?v2 ?v3) ?v4)))) (set.member$b ?v1 (uncurry$h ?v2 ?v0)))) :named a174))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (= ?v0 (pair$b ?v3 ?v4)) (set.member$a ?v1 (fun_app$cg (fun_app$ch ?v2 ?v3) ?v4)))) (set.member$a ?v1 (uncurry$i ?v2 ?v0)))) :named a175))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= ?v0 (pair$ ?v3 ?v4)) (fun_app$i (set.member$ ?v1) (fun_app$n (fun_app$o ?v2 ?v3) ?v4)))) (fun_app$i (set.member$ ?v1) (fun_app$x (fun_app$ah uncurry$b ?v2) ?v0)))) :named a176))
(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$)) (=> (forall ((?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (= (fun_app$j ?v0 ?v2) (fun_app$j ?v1 ?v2))) (= (collect$a ?v0) (collect$a ?v1)))) :named a177))
(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_prod_bool_fun$)) (=> (forall ((?v2 A_llist_a_llist_prod$)) (= (fun_app$h ?v0 ?v2) (fun_app$h ?v1 ?v2))) (= (collect$ ?v0) (collect$ ?v1)))) :named a178))
(assert (! (forall ((?v0 A_set$)) (= (collect$b (uug$ ?v0)) ?v0)) :named a179))
(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_set$)) (= (collect$a (uuh$ ?v0)) ?v0)) :named a180))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$)) (= (collect$ (uui$ ?v0)) ?v0)) :named a181))
-(assert (! (forall ((?v0 A$) (?v1 A_bool_fun$)) (= (member$b ?v0 (collect$b ?v1)) (fun_app$k ?v1 ?v0))) :named a182))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$)) (= (member$a ?v0 (collect$a ?v1)) (fun_app$j ?v1 ?v0))) :named a183))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_bool_fun$)) (= (fun_app$i (member$ ?v0) (collect$ ?v1)) (fun_app$h ?v1 ?v0))) :named a184))
+(assert (! (forall ((?v0 A$) (?v1 A_bool_fun$)) (= (set.member$b ?v0 (collect$b ?v1)) (fun_app$k ?v1 ?v0))) :named a182))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_prod_bool_fun$)) (= (set.member$a ?v0 (collect$a ?v1)) (fun_app$j ?v1 ?v0))) :named a183))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_bool_fun$)) (= (fun_app$i (set.member$ ?v0) (collect$ ?v1)) (fun_app$h ?v1 ?v0))) :named a184))
(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= (pair$ ?v3 ?v4) ?v0) (fun_app$h (fun_app$p (fun_app$q ?v1 ?v3) ?v4) ?v2))) (fun_app$h (fun_app$r (fun_app$aj uncurry$c ?v1) ?v0) ?v2))) :named a185))
-(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_a_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (member$b ?v0 (uncurry$e ?v1 ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (member$b ?v0 (fun_app$bz (fun_app$ca ?v1 ?v3) ?v4))) false))) false)) :named a186))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (member$a ?v0 (uncurry$f ?v1 ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (member$a ?v0 (fun_app$cb (fun_app$cc ?v1 ?v3) ?v4))) false))) false)) :named a187))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (fun_app$i (member$ ?v0) (uncurry$g ?v1 ?v2)) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v2 (pair$b ?v3 ?v4)) (fun_app$i (member$ ?v0) (fun_app$x (fun_app$cd ?v1 ?v3) ?v4))) false))) false)) :named a188))
-(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (member$b ?v0 (uncurry$h ?v1 ?v2)) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v2 (pair$b ?v3 ?v4)) (member$b ?v0 (fun_app$ce (fun_app$cf ?v1 ?v3) ?v4))) false))) false)) :named a189))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (member$a ?v0 (uncurry$i ?v1 ?v2)) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v2 (pair$b ?v3 ?v4)) (member$a ?v0 (fun_app$cg (fun_app$ch ?v1 ?v3) ?v4))) false))) false)) :named a190))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$i (member$ ?v0) (fun_app$x (fun_app$ah uncurry$b ?v1) ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (fun_app$i (member$ ?v0) (fun_app$n (fun_app$o ?v1 ?v3) ?v4))) false))) false)) :named a191))
+(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_a_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (set.member$b ?v0 (uncurry$e ?v1 ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (set.member$b ?v0 (fun_app$bz (fun_app$ca ?v1 ?v3) ?v4))) false))) false)) :named a186))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (set.member$a ?v0 (uncurry$f ?v1 ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (set.member$a ?v0 (fun_app$cb (fun_app$cc ?v1 ?v3) ?v4))) false))) false)) :named a187))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (fun_app$i (set.member$ ?v0) (uncurry$g ?v1 ?v2)) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v2 (pair$b ?v3 ?v4)) (fun_app$i (set.member$ ?v0) (fun_app$x (fun_app$cd ?v1 ?v3) ?v4))) false))) false)) :named a188))
+(assert (! (forall ((?v0 A$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_set_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (set.member$b ?v0 (uncurry$h ?v1 ?v2)) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v2 (pair$b ?v3 ?v4)) (set.member$b ?v0 (fun_app$ce (fun_app$cf ?v1 ?v3) ?v4))) false))) false)) :named a189))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$) (?v1 A_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_a_llist_a_llist_prod_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_prod$)) (=> (and (set.member$a ?v0 (uncurry$i ?v1 ?v2)) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod$)) (=> (and (= ?v2 (pair$b ?v3 ?v4)) (set.member$a ?v0 (fun_app$cg (fun_app$ch ?v1 ?v3) ?v4))) false))) false)) :named a190))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_set_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$i (set.member$ ?v0) (fun_app$x (fun_app$ah uncurry$b ?v1) ?v2)) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v2 (pair$ ?v3 ?v4)) (fun_app$i (set.member$ ?v0) (fun_app$n (fun_app$o ?v1 ?v3) ?v4))) false))) false)) :named a191))
(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$h (fun_app$r (fun_app$aj uncurry$c ?v0) ?v1) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v1 (pair$ ?v3 ?v4)) (fun_app$h (fun_app$p (fun_app$q ?v0 ?v3) ?v4) ?v2)) false))) false)) :named a192))
(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v2 A_llist_a_llist_prod$)) (=> (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (= (pair$ ?v3 ?v4) ?v0) (fun_app$h (fun_app$p (fun_app$q ?v1 ?v3) ?v4) ?v2))) (fun_app$h (fun_app$r (fun_app$aj uncurry$c ?v1) ?v0) ?v2))) :named a193))
(assert (! (forall ((?v0 A_llist_a_llist_a_llist_a_llist_prod_bool_fun_fun_fun$) (?v1 A_llist_a_llist_prod$) (?v2 A_llist_a_llist_prod$)) (=> (and (fun_app$h (fun_app$r (fun_app$aj uncurry$c ?v0) ?v1) ?v2) (forall ((?v3 A_llist$) (?v4 A_llist$)) (=> (and (= ?v1 (pair$ ?v3 ?v4)) (fun_app$h (fun_app$p (fun_app$q ?v0 ?v3) ?v4) ?v2)) false))) false)) :named a194))
(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (=> (or (not (fun_app$l lnull$ ?v0)) (not (fun_app$l lnull$ ?v1))) (= (ltl$ (fun_app$a (lappend$a ?v0) ?v1)) (fun_app$a (fun_app$cj (case_llist$a (fun_app$a (fun_app$cj (case_llist$a undefined$) uvv$) ?v1)) (uwj$ ?v1)) ?v0)))) :named a366))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_fun$)) (= (inv_image$ ?v0 ?v1) (collect$ (fun_app$ad uncurry$a (fun_app$z (uwk$ ?v0) ?v1))))) :named a367))
(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist_a_llist_a_llist_prod_set_fun$)) (= (same_fst$ ?v0 ?v1) (collect$a (fun_app$al uncurry$d (fun_app$aj uncurry$c (fun_app$bt (uwm$ ?v0) ?v1)))))) :named a368))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod_llist$)) (=> (not (fun_app$bw lnull$a ?v3)) (fun_app$bw (fun_app$bx ?v2 (lhd$a ?v3)) ?v3))) (forall ((?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod$)) (=> (and (not (fun_app$bw lnull$a ?v3)) (and (fun_app$i (member$ ?v4) (lset$ (ltl$a ?v3))) (fun_app$bw (fun_app$bx ?v2 ?v4) (ltl$a ?v3)))) (fun_app$bw (fun_app$bx ?v2 ?v4) ?v3))))) (fun_app$bw (fun_app$bx ?v2 ?v0) ?v1))) :named a369))
-(assert (! (forall ((?v0 A$) (?v1 A_llist$) (?v2 A_a_llist_bool_fun_fun$)) (=> (and (member$b ?v0 (lset$a ?v1)) (and (forall ((?v3 A_llist$)) (=> (not (fun_app$l lnull$ ?v3)) (fun_app$l (fun_app$as ?v2 (lhd$ ?v3)) ?v3))) (forall ((?v3 A_llist$) (?v4 A$)) (=> (and (not (fun_app$l lnull$ ?v3)) (and (member$b ?v4 (lset$a (ltl$ ?v3))) (fun_app$l (fun_app$as ?v2 ?v4) (ltl$ ?v3)))) (fun_app$l (fun_app$as ?v2 ?v4) ?v3))))) (fun_app$l (fun_app$as ?v2 ?v0) ?v1))) :named a370))
-(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist_a_llist_prod_set$) (?v3 A_llist_a_llist_fun$)) (= (fun_app$i (member$ (pair$ ?v0 ?v1)) (inv_image$ ?v2 ?v3)) (fun_app$i (member$ (pair$ (fun_app$a ?v3 ?v0) (fun_app$a ?v3 ?v1))) ?v2))) :named a371))
-(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist_a_llist_a_llist_prod_set_fun$)) (=> (and (fun_app$l ?v0 ?v1) (fun_app$i (member$ (pair$ ?v2 ?v3)) (fun_app$n ?v4 ?v1))) (member$a (pair$b (pair$ ?v1 ?v2) (pair$ ?v1 ?v3)) (same_fst$ ?v0 ?v4)))) :named a372))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (fun_app$i (member$ ?v0) (lset$ (lCons$a ?v0 ?v1)))) :named a373))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (fun_app$i (member$ ?v0) (lset$ (lCons$a ?v0 ?v1)))) :named a374))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$i (member$ ?v0) (lset$ ?v1)) (fun_app$i (member$ ?v0) (lset$ (lCons$a ?v2 ?v1))))) :named a375))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$i (member$ ?v0) (lset$ ?v1)) (fun_app$i (member$ ?v0) (lset$ (lCons$a ?v2 ?v1))))) :named a376))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v2 A_llist_a_llist_prod_llist$)) (=> (= ?v1 (lCons$a ?v0 ?v2)) false)) (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod_llist$)) (=> (and (= ?v1 (lCons$a ?v2 ?v3)) (fun_app$i (member$ ?v0) (lset$ ?v3))) false)))) false)) :named a377))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist_bool_fun$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod_llist$)) (fun_app$bw ?v2 (lCons$a ?v0 ?v3))) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v4)) (and (not (= ?v0 ?v3)) (fun_app$bw ?v2 ?v4))) (fun_app$bw ?v2 (lCons$a ?v3 ?v4)))))) (fun_app$bw ?v2 ?v1))) :named a378))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist_bool_fun$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod_llist$)) (fun_app$bw ?v2 (lCons$a ?v0 ?v3))) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v4)) (fun_app$bw ?v2 ?v4)) (fun_app$bw ?v2 (lCons$a ?v3 ?v4)))))) (fun_app$bw ?v2 ?v1))) :named a379))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v2 A_llist_a_llist_prod_llist$)) (=> (= ?v1 (lCons$a ?v0 ?v2)) false)) (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod_llist$)) (=> (and (= ?v1 (lCons$a ?v2 ?v3)) (fun_app$i (member$ ?v0) (lset$ ?v3))) false)))) false)) :named a380))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$)) (=> (and (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$)) (fun_app$bw (fun_app$bx ?v2 ?v3) (lCons$a ?v3 ?v4))) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$) (?v5 A_llist_a_llist_prod$)) (=> (and (fun_app$i (member$ ?v5) (lset$ ?v4)) (fun_app$bw (fun_app$bx ?v2 ?v5) ?v4)) (fun_app$bw (fun_app$bx ?v2 ?v5) (lCons$a ?v3 ?v4)))))) (fun_app$bw (fun_app$bx ?v2 ?v0) ?v1))) :named a381))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (fun_app$i (member$ ?v0) (lset$ (ltl$a ?v1))) (fun_app$i (member$ ?v0) (lset$ ?v1)))) :named a382))
-(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (=> (member$b ?v0 (lset$a (ltl$ ?v1))) (member$b ?v0 (lset$a ?v1)))) :named a383))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (= (fun_app$i (member$ ?v0) (lset$ ?v1)) (fun_app$bw (lmember$ ?v0) ?v1))) :named a384))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod$)) (=> (and (not (fun_app$bw lnull$a ?v0)) (fun_app$i (member$ ?v1) (lset$ (ltl$a ?v0)))) (fun_app$i (member$ ?v1) (lset$ ?v0)))) :named a385))
-(assert (! (forall ((?v0 A_llist$) (?v1 A$)) (=> (and (not (fun_app$l lnull$ ?v0)) (member$b ?v1 (lset$a (ltl$ ?v0)))) (member$b ?v1 (lset$a ?v0)))) :named a386))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (not (fun_app$bw lnull$a ?v0)) (fun_app$i (member$ (lhd$a ?v0)) (lset$ ?v0)))) :named a387))
-(assert (! (forall ((?v0 A_llist$)) (=> (not (fun_app$l lnull$ ?v0)) (member$b (lhd$ ?v0) (lset$a ?v0)))) :named a388))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$)) (=> (and (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod_llist$)) (=> (not (fun_app$bw lnull$a ?v3)) (fun_app$bw (fun_app$bx ?v2 (lhd$a ?v3)) ?v3))) (forall ((?v3 A_llist_a_llist_prod_llist$) (?v4 A_llist_a_llist_prod$)) (=> (and (not (fun_app$bw lnull$a ?v3)) (and (fun_app$i (set.member$ ?v4) (lset$ (ltl$a ?v3))) (fun_app$bw (fun_app$bx ?v2 ?v4) (ltl$a ?v3)))) (fun_app$bw (fun_app$bx ?v2 ?v4) ?v3))))) (fun_app$bw (fun_app$bx ?v2 ?v0) ?v1))) :named a369))
+(assert (! (forall ((?v0 A$) (?v1 A_llist$) (?v2 A_a_llist_bool_fun_fun$)) (=> (and (set.member$b ?v0 (lset$a ?v1)) (and (forall ((?v3 A_llist$)) (=> (not (fun_app$l lnull$ ?v3)) (fun_app$l (fun_app$as ?v2 (lhd$ ?v3)) ?v3))) (forall ((?v3 A_llist$) (?v4 A$)) (=> (and (not (fun_app$l lnull$ ?v3)) (and (set.member$b ?v4 (lset$a (ltl$ ?v3))) (fun_app$l (fun_app$as ?v2 ?v4) (ltl$ ?v3)))) (fun_app$l (fun_app$as ?v2 ?v4) ?v3))))) (fun_app$l (fun_app$as ?v2 ?v0) ?v1))) :named a370))
+(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist_a_llist_prod_set$) (?v3 A_llist_a_llist_fun$)) (= (fun_app$i (set.member$ (pair$ ?v0 ?v1)) (inv_image$ ?v2 ?v3)) (fun_app$i (set.member$ (pair$ (fun_app$a ?v3 ?v0) (fun_app$a ?v3 ?v1))) ?v2))) :named a371))
+(assert (! (forall ((?v0 A_llist_bool_fun$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist_a_llist_a_llist_prod_set_fun$)) (=> (and (fun_app$l ?v0 ?v1) (fun_app$i (set.member$ (pair$ ?v2 ?v3)) (fun_app$n ?v4 ?v1))) (set.member$a (pair$b (pair$ ?v1 ?v2) (pair$ ?v1 ?v3)) (same_fst$ ?v0 ?v4)))) :named a372))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (fun_app$i (set.member$ ?v0) (lset$ (lCons$a ?v0 ?v1)))) :named a373))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (fun_app$i (set.member$ ?v0) (lset$ (lCons$a ?v0 ?v1)))) :named a374))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (fun_app$i (set.member$ ?v0) (lset$ (lCons$a ?v2 ?v1))))) :named a375))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod$)) (=> (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (fun_app$i (set.member$ ?v0) (lset$ (lCons$a ?v2 ?v1))))) :named a376))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (and (forall ((?v2 A_llist_a_llist_prod_llist$)) (=> (= ?v1 (lCons$a ?v0 ?v2)) false)) (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod_llist$)) (=> (and (= ?v1 (lCons$a ?v2 ?v3)) (fun_app$i (set.member$ ?v0) (lset$ ?v3))) false)))) false)) :named a377))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist_bool_fun$)) (=> (and (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod_llist$)) (fun_app$bw ?v2 (lCons$a ?v0 ?v3))) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (set.member$ ?v0) (lset$ ?v4)) (and (not (= ?v0 ?v3)) (fun_app$bw ?v2 ?v4))) (fun_app$bw ?v2 (lCons$a ?v3 ?v4)))))) (fun_app$bw ?v2 ?v1))) :named a378))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist_bool_fun$)) (=> (and (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod_llist$)) (fun_app$bw ?v2 (lCons$a ?v0 ?v3))) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (set.member$ ?v0) (lset$ ?v4)) (fun_app$bw ?v2 ?v4)) (fun_app$bw ?v2 (lCons$a ?v3 ?v4)))))) (fun_app$bw ?v2 ?v1))) :named a379))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (and (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (and (forall ((?v2 A_llist_a_llist_prod_llist$)) (=> (= ?v1 (lCons$a ?v0 ?v2)) false)) (forall ((?v2 A_llist_a_llist_prod$) (?v3 A_llist_a_llist_prod_llist$)) (=> (and (= ?v1 (lCons$a ?v2 ?v3)) (fun_app$i (set.member$ ?v0) (lset$ ?v3))) false)))) false)) :named a380))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_a_llist_a_llist_prod_llist_bool_fun_fun$)) (=> (and (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (and (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$)) (fun_app$bw (fun_app$bx ?v2 ?v3) (lCons$a ?v3 ?v4))) (forall ((?v3 A_llist_a_llist_prod$) (?v4 A_llist_a_llist_prod_llist$) (?v5 A_llist_a_llist_prod$)) (=> (and (fun_app$i (set.member$ ?v5) (lset$ ?v4)) (fun_app$bw (fun_app$bx ?v2 ?v5) ?v4)) (fun_app$bw (fun_app$bx ?v2 ?v5) (lCons$a ?v3 ?v4)))))) (fun_app$bw (fun_app$bx ?v2 ?v0) ?v1))) :named a381))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (fun_app$i (set.member$ ?v0) (lset$ (ltl$a ?v1))) (fun_app$i (set.member$ ?v0) (lset$ ?v1)))) :named a382))
+(assert (! (forall ((?v0 A$) (?v1 A_llist$)) (=> (set.member$b ?v0 (lset$a (ltl$ ?v1))) (set.member$b ?v0 (lset$a ?v1)))) :named a383))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (= (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (fun_app$bw (lmember$ ?v0) ?v1))) :named a384))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$) (?v1 A_llist_a_llist_prod$)) (=> (and (not (fun_app$bw lnull$a ?v0)) (fun_app$i (set.member$ ?v1) (lset$ (ltl$a ?v0)))) (fun_app$i (set.member$ ?v1) (lset$ ?v0)))) :named a385))
+(assert (! (forall ((?v0 A_llist$) (?v1 A$)) (=> (and (not (fun_app$l lnull$ ?v0)) (set.member$b ?v1 (lset$a (ltl$ ?v0)))) (set.member$b ?v1 (lset$a ?v0)))) :named a386))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_llist$)) (=> (not (fun_app$bw lnull$a ?v0)) (fun_app$i (set.member$ (lhd$a ?v0)) (lset$ ?v0)))) :named a387))
+(assert (! (forall ((?v0 A_llist$)) (=> (not (fun_app$l lnull$ ?v0)) (set.member$b (lhd$ ?v0) (lset$a ?v0)))) :named a388))
(assert (! (forall ((?v0 A_llist$)) (= (lhd$ ?v0) (fun_app$c (fun_app$ck (case_llist$b undefined$a) uwb$) ?v0))) :named a389))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (lex_prod$ ?v0 ?v1) (collect$a (fun_app$al uncurry$d (fun_app$aj uncurry$c (fun_app$bq (uwo$ ?v0) ?v1)))))) :named a390))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (fun_app$i (member$ ?v0) (lset$ ?v1)) (exists ((?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_llist$)) (and (= ?v1 (fun_app$ (lappend$ ?v2) (lCons$a ?v0 ?v3))) (and (lfinite$ ?v2) (not (fun_app$i (member$ ?v0) (lset$ ?v2)))))))) :named a391))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (fun_app$i (member$ ?v0) (lset$ ?v1)) (exists ((?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_llist$)) (and (= ?v1 (fun_app$ (lappend$ ?v2) (lCons$a ?v0 ?v3))) (lfinite$ ?v2))))) :named a392))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (exists ((?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_llist$)) (and (= ?v1 (fun_app$ (lappend$ ?v2) (lCons$a ?v0 ?v3))) (and (lfinite$ ?v2) (not (fun_app$i (set.member$ ?v0) (lset$ ?v2)))))))) :named a391))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$)) (=> (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (exists ((?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_llist$)) (and (= ?v1 (fun_app$ (lappend$ ?v2) (lCons$a ?v0 ?v3))) (lfinite$ ?v2))))) :named a392))
(assert (! (forall ((?v0 A_llist$)) (= (lfinite$a (ltl$ ?v0)) (lfinite$a ?v0))) :named a393))
-(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist_a_llist_prod_set$) (?v5 A_llist_a_llist_prod_set$)) (= (member$a (pair$b (pair$ ?v0 ?v1) (pair$ ?v2 ?v3)) (lex_prod$ ?v4 ?v5)) (or (fun_app$i (member$ (pair$ ?v0 ?v2)) ?v4) (and (= ?v0 ?v2) (fun_app$i (member$ (pair$ ?v1 ?v3)) ?v5))))) :named a394))
+(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_llist$) (?v4 A_llist_a_llist_prod_set$) (?v5 A_llist_a_llist_prod_set$)) (= (set.member$a (pair$b (pair$ ?v0 ?v1) (pair$ ?v2 ?v3)) (lex_prod$ ?v4 ?v5)) (or (fun_app$i (set.member$ (pair$ ?v0 ?v2)) ?v4) (and (= ?v0 ?v2) (fun_app$i (set.member$ (pair$ ?v1 ?v3)) ?v5))))) :named a394))
(assert (! (forall ((?v0 A_llist$)) (=> (fun_app$l lnull$ ?v0) (lfinite$a ?v0))) :named a395))
(assert (! (forall ((?v0 A_llist$) (?v1 A_llist_bool_fun$)) (=> (and (lfinite$a ?v0) (and (forall ((?v2 A_llist$)) (=> (fun_app$l lnull$ ?v2) (fun_app$l ?v1 ?v2))) (forall ((?v2 A_llist$)) (=> (and (lfinite$a ?v2) (and (not (fun_app$l lnull$ ?v2)) (fun_app$l ?v1 (ltl$ ?v2)))) (fun_app$l ?v1 ?v2))))) (fun_app$l ?v1 ?v0))) :named a396))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$)) (= (fun_app$i (member$ ?v0) (lset$ (fun_app$ (lappend$ ?v1) ?v2))) (or (fun_app$i (member$ ?v0) (lset$ ?v1)) (and (lfinite$ ?v1) (fun_app$i (member$ ?v0) (lset$ ?v2)))))) :named a397))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$)) (= (fun_app$i (set.member$ ?v0) (lset$ (fun_app$ (lappend$ ?v1) ?v2))) (or (fun_app$i (set.member$ ?v0) (lset$ ?v1)) (and (lfinite$ ?v1) (fun_app$i (set.member$ ?v0) (lset$ ?v2)))))) :named a397))
(assert (! (forall ((?v0 A_llist_a_llist_prod_bool_fun$) (?v1 A_llist_a_llist_prod_bool_fun$)) (= (collect$ (fun_app$t (uwp$ ?v0) ?v1)) (sup$ (collect$ ?v0) (collect$ ?v1)))) :named a398))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (sup$ ?v0 ?v1) (collect$ (fun_app$s (uwq$ ?v0) ?v1)))) :named a399))
(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$) (?v3 A_a_bool_fun_fun$)) (=> (and (fun_app$l (fun_app$m ?v0 ?v1) ?v2) (forall ((?v4 A_llist$) (?v5 A_llist$)) (=> (fun_app$l (fun_app$m ?v0 ?v4) ?v5) (and (= (fun_app$l lnull$ ?v4) (fun_app$l lnull$ ?v5)) (=> (and (not (fun_app$l lnull$ ?v4)) (not (fun_app$l lnull$ ?v5))) (and (fun_app$k (fun_app$co ?v3 (lhd$ ?v4)) (lhd$ ?v5)) (fun_app$l (fun_app$m ?v0 (ltl$ ?v4)) (ltl$ ?v5)))))))) (fun_app$l (fun_app$m (llist_all2$ ?v3) ?v1) ?v2))) :named a400))
(assert (! (forall ((?v0 A_a_bool_fun_fun$) (?v1 A_llist$) (?v2 A_llist$)) (= (fun_app$l (fun_app$m (llist_all2$ ?v0) ?v1) ?v2) (and (= (fun_app$l lnull$ ?v1) (fun_app$l lnull$ ?v2)) (=> (and (not (fun_app$l lnull$ ?v1)) (not (fun_app$l lnull$ ?v2))) (and (fun_app$k (fun_app$co ?v0 (lhd$ ?v1)) (lhd$ ?v2)) (fun_app$l (fun_app$m (llist_all2$ ?v0) (ltl$ ?v1)) (ltl$ ?v2))))))) :named a401))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (=> (fun_app$i (member$ (pair$ ?v2 ?v3)) ?v0) (fun_app$i (member$ (pair$ ?v2 ?v3)) ?v1))) (fun_app$i (less_eq$ ?v0) ?v1))) :named a402))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$)) (=> (and (fun_app$bw (fun_app$by (llist_all2$a ?v0) ?v1) ?v2) (forall ((?v4 A_llist_a_llist_prod$) (?v5 A_llist_a_llist_prod$)) (=> (and (fun_app$i (member$ ?v4) (lset$ ?v1)) (and (fun_app$i (member$ ?v5) (lset$ ?v2)) (fun_app$h (fun_app$r ?v0 ?v4) ?v5))) (fun_app$h (fun_app$r ?v3 ?v4) ?v5)))) (fun_app$bw (fun_app$by (llist_all2$a ?v3) ?v1) ?v2))) :named a403))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (=> (forall ((?v2 A_llist$) (?v3 A_llist$)) (=> (fun_app$i (set.member$ (pair$ ?v2 ?v3)) ?v0) (fun_app$i (set.member$ (pair$ ?v2 ?v3)) ?v1))) (fun_app$i (less_eq$ ?v0) ?v1))) :named a402))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$) (?v1 A_llist_a_llist_prod_llist$) (?v2 A_llist_a_llist_prod_llist$) (?v3 A_llist_a_llist_prod_a_llist_a_llist_prod_bool_fun_fun$)) (=> (and (fun_app$bw (fun_app$by (llist_all2$a ?v0) ?v1) ?v2) (forall ((?v4 A_llist_a_llist_prod$) (?v5 A_llist_a_llist_prod$)) (=> (and (fun_app$i (set.member$ ?v4) (lset$ ?v1)) (and (fun_app$i (set.member$ ?v5) (lset$ ?v2)) (fun_app$h (fun_app$r ?v0 ?v4) ?v5))) (fun_app$h (fun_app$r ?v3 ?v4) ?v5)))) (fun_app$bw (fun_app$by (llist_all2$a ?v3) ?v1) ?v2))) :named a403))
(assert (! (forall ((?v0 A_llist$)) (less_eq$a (lset$a (ltl$ ?v0)) (lset$a ?v0))) :named a404))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_bool_fun$) (?v2 A_llist_a_llist_prod_bool_fun$)) (= (fun_app$i (less_eq$ ?v0) (collect$ (fun_app$t (uwr$ ?v1) ?v2))) (and (fun_app$i (less_eq$ ?v0) (collect$ ?v1)) (fun_app$i (less_eq$ ?v0) (collect$ ?v2))))) :named a405))
-(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod_set$) (?v3 A_llist_a_llist_prod_bool_fun$)) (=> (and (fun_app$i (member$ ?v0) ?v1) (fun_app$i (less_eq$ ?v1) (collect$ (fun_app$t (uws$ ?v2) ?v3)))) (fun_app$h ?v3 ?v0))) :named a406))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod_bool_fun$) (?v3 A_llist_a_llist_prod_bool_fun$)) (=> (and (fun_app$i (less_eq$ ?v0) ?v1) (forall ((?v4 A_llist_a_llist_prod$)) (=> (and (fun_app$i (member$ ?v4) ?v0) (fun_app$h ?v2 ?v4)) (fun_app$h ?v3 ?v4)))) (fun_app$i (less_eq$ (collect$ (fun_app$t (uws$ ?v0) ?v2))) (collect$ (fun_app$t (uws$ ?v1) ?v3))))) :named a407))
+(assert (! (forall ((?v0 A_llist_a_llist_prod$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod_set$) (?v3 A_llist_a_llist_prod_bool_fun$)) (=> (and (fun_app$i (set.member$ ?v0) ?v1) (fun_app$i (less_eq$ ?v1) (collect$ (fun_app$t (uws$ ?v2) ?v3)))) (fun_app$h ?v3 ?v0))) :named a406))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod_bool_fun$) (?v3 A_llist_a_llist_prod_bool_fun$)) (=> (and (fun_app$i (less_eq$ ?v0) ?v1) (forall ((?v4 A_llist_a_llist_prod$)) (=> (and (fun_app$i (set.member$ ?v4) ?v0) (fun_app$h ?v2 ?v4)) (fun_app$h ?v3 ?v4)))) (fun_app$i (less_eq$ (collect$ (fun_app$t (uws$ ?v0) ?v2))) (collect$ (fun_app$t (uws$ ?v1) ?v3))))) :named a407))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (fun_app$i (less_eq$ ?v0) ?v1) (fun_app$bk (less_eq$b (uui$ ?v0)) (uui$ ?v1)))) :named a408))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (fun_app$bk (less_eq$b (uui$ ?v0)) (uui$ ?v1)) (fun_app$i (less_eq$ ?v0) ?v1))) :named a409))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (= (less_eq$c (uvz$ ?v0) (uvz$ ?v1)) (fun_app$i (less_eq$ ?v0) ?v1))) :named a410))
-(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist_a_llist_prod_set$) (?v3 A_llist$)) (=> (and (fun_app$i (member$ (pair$ ?v0 ?v1)) ?v2) (= ?v3 ?v1)) (fun_app$i (member$ (pair$ ?v0 ?v3)) ?v2))) :named a411))
+(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$) (?v2 A_llist_a_llist_prod_set$) (?v3 A_llist$)) (=> (and (fun_app$i (set.member$ (pair$ ?v0 ?v1)) ?v2) (= ?v3 ?v1)) (fun_app$i (set.member$ (pair$ ?v0 ?v3)) ?v2))) :named a411))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_bool_fun$)) (fun_app$i (less_eq$ (collect$ (fun_app$t (uws$ ?v0) ?v1))) ?v0)) :named a412))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod_bool_fun$)) (=> (fun_app$i (less_eq$ ?v0) ?v1) (= (fun_app$i (less_eq$ ?v0) (collect$ (fun_app$t (uws$ ?v1) ?v2))) (forall ((?v3 A_llist_a_llist_prod$)) (=> (fun_app$i (member$ ?v3) ?v0) (fun_app$h ?v2 ?v3)))))) :named a413))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$) (?v2 A_llist_a_llist_prod_bool_fun$)) (=> (fun_app$i (less_eq$ ?v0) ?v1) (= (fun_app$i (less_eq$ ?v0) (collect$ (fun_app$t (uws$ ?v1) ?v2))) (forall ((?v3 A_llist_a_llist_prod$)) (=> (fun_app$i (set.member$ ?v3) ?v0) (fun_app$h ?v2 ?v3)))))) :named a413))
(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$) (?v1 A_llist_a_llist_bool_fun_fun$)) (=> (less_eq$c ?v0 ?v1) (fun_app$i (less_eq$ (collect$ (fun_app$ad uncurry$a ?v0))) (collect$ (fun_app$ad uncurry$a ?v1))))) :named a414))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (=> (and (fun_app$i (less_eq$ ?v0) (collect$ (fun_app$ad uncurry$a (in_rel$ ?v1)))) (=> (fun_app$i (less_eq$ ?v0) ?v1) false)) false)) :named a415))
-(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$l (fun_app$m (in_rel$ ?v0) ?v1) ?v2) (fun_app$i (member$ (pair$ ?v1 ?v2)) ?v0)) :pattern ((fun_app$l (fun_app$m (in_rel$ ?v0) ?v1) ?v2)))) :named a416))
+(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist$) (?v2 A_llist$)) (! (= (fun_app$l (fun_app$m (in_rel$ ?v0) ?v1) ?v2) (fun_app$i (set.member$ (pair$ ?v1 ?v2)) ?v0)) :pattern ((fun_app$l (fun_app$m (in_rel$ ?v0) ?v1) ?v2)))) :named a416))
(assert (! (forall ((?v0 A_llist_a_llist_bool_fun_fun$)) (= (in_rel$ (collect$ (fun_app$ad uncurry$a ?v0))) ?v0)) :named a417))
(assert (! (forall ((?v0 A_llist_a_llist_prod_set$) (?v1 A_llist_a_llist_prod_set$)) (=> (fun_app$i (less_eq$ ?v0) ?v1) (fun_app$i (less_eq$ ?v0) (collect$ (fun_app$ad uncurry$a (in_rel$ ?v1)))))) :named a418))
-(assert (! (forall ((?v0 A_llist$) (?v1 A_llist_a_llist_prod_a_llist_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist$) (?v4 A_llist_a_llist_prod_a_llist_fun$) (?v5 A_llist_a_llist_prod_set$)) (=> (and (= ?v0 (fun_app$cp ?v1 ?v2)) (and (= ?v3 (fun_app$cp ?v4 ?v2)) (fun_app$i (member$ ?v2) ?v5))) (fun_app$i (member$ (pair$ ?v0 ?v3)) (image2$ ?v5 ?v1 ?v4)))) :named a419))
+(assert (! (forall ((?v0 A_llist$) (?v1 A_llist_a_llist_prod_a_llist_fun$) (?v2 A_llist_a_llist_prod$) (?v3 A_llist$) (?v4 A_llist_a_llist_prod_a_llist_fun$) (?v5 A_llist_a_llist_prod_set$)) (=> (and (= ?v0 (fun_app$cp ?v1 ?v2)) (and (= ?v3 (fun_app$cp ?v4 ?v2)) (fun_app$i (set.member$ ?v2) ?v5))) (fun_app$i (set.member$ (pair$ ?v0 ?v3)) (image2$ ?v5 ?v1 ?v4)))) :named a419))
(assert (! (forall ((?v0 A_llist$) (?v1 A_llist$)) (= (the$ (fun_app$ad uncurry$a (fun_app$aa (uwt$ ?v0) ?v1))) (pair$ ?v0 ?v1))) :named a420))
(check-sat)
(declare-fun grass_null$0 () (Loc Node))
(declare-fun grass_read$0 ((Map (Loc Node) (Loc Node)) (Loc Node))
(Loc Node))
-(declare-fun grass_emptyset$0 () (Set (Loc Node)))
+(declare-fun grass_set.empty$0 () (Set (Loc Node)))
(declare-fun grass_singleton$0 ((Loc Node)) (Set (Loc Node)))
(declare-fun grass_union$0 ((Set (Loc Node)) (Set (Loc Node)))
(Set (Loc Node)))
(not (grass_Btwn$0 next$0 res_2$0 grass_null$0 grass_null$0))
Label$0))
Label_2$0))
-(assert (forall ((x (Loc Node))) (not (grass_member$0 x grass_emptyset$0))))
+(assert (forall ((x (Loc Node))) (not (grass_member$0 x grass_set.empty$0))))
(assert
(forall ((y (Loc Node)) (x (Loc Node)))
(or (and (= x y) (grass_member$0 x (grass_singleton$0 y)))
(assert (= (grass_read$0 next$0 elt$0) grass_null$0))
(assert (= FP_Node$0 sk_?X_3$0))
(assert (= FP_Caller_Node$0 (grass_union$0 FP_Node$0 FP_Caller_Node$0)))
-(assert (= grass_emptyset$0 (grass_intersection$0 sk_?X$0 sk_?X_2$0)))
-(assert (= grass_emptyset$0 grass_emptyset$0))
+(assert (= grass_set.empty$0 (grass_intersection$0 sk_?X$0 sk_?X_2$0)))
+(assert (= grass_set.empty$0 grass_set.empty$0))
(assert (lseg$0 next$0 lst$0 grass_null$0 sk_?X$0))
(assert
(= FP_Caller_final_Node_2$0
(assert
(= (grass_known$1 (lseg$0 next$0 lst$0 grass_null$0 sk_?X$0))
(grass_known$1 (lseg$0 next$0 lst$0 lst$0 sk_?X$0))))
-(assert (= (grass_intersection$0 sk_?X$0 sk_?X_2$0) grass_emptyset$0))
+(assert (= (grass_intersection$0 sk_?X$0 sk_?X_2$0) grass_set.empty$0))
(assert
(=
(grass_union$0 (grass_intersection$0 Alloc_Node$0 FP_Node$0)
(set-option :finite-model-find true)
(set-option :fmf-bound-int true)
(declare-fun X () (Set Int))
-(assert (= (card X) 3))
-(assert (forall ((z Int)) (=> (member z X) (and (> z 0) (< z 2)))))
-(check-sat-assuming ( (forall ((z Int)) (=> (member z X) (> z 0))) ))
+(assert (= (set.card X) 3))
+(assert (forall ((z Int)) (=> (set.member z X) (and (> z 0) (< z 2)))))
+(check-sat-assuming ( (forall ((z Int)) (=> (set.member z X) (> z 0))) ))
(set-info :category "crafted")
(set-info :status unsat)
(declare-sort Set 0)
-(declare-fun member (Int Set) Bool)
-(declare-fun insert (Set Int) Set)
+(declare-fun set.member (Int Set) Bool)
+(declare-fun set.insert (Set Int) Set)
(declare-fun delete (Set Int) Set)
(declare-fun sup (Set) Int)
-(assert (forall ((?x Int) (?s Set)) (member ?x (insert ?s ?x))))
-(assert (forall ((?x Int) (?y Int) (?s Set)) (=> (not (= ?x ?y)) (= (member ?x (insert ?s ?y)) (member ?x ?s)))))
-(assert (forall ((?x Int) (?s Set)) (=> (not (member ?x ?s)) (= (delete ?s ?x) ?s))))
-(assert (forall ((?x Int) (?s Set)) (= (delete (insert ?s ?x) ?x) (delete ?s ?x))))
-(assert (forall ((?x Int) (?y Int) (?s Set)) (=> (not (= ?x ?y)) (= (delete (insert ?s ?y) ?x) (insert (delete ?s ?x) ?y)))))
-(assert (forall ((?s Set)) (member (sup ?s) ?s)))
-(assert (forall ((?s Set) (?x Int)) (=> (member ?x ?s) (<= ?x (sup ?s)))))
-(assert (forall ((?s Set) (?x Int)) (=> (< (sup ?s) ?x) (= (sup (insert ?s ?x)) ?x))))
+(assert (forall ((?x Int) (?s Set)) (set.member ?x (set.insert ?s ?x))))
+(assert (forall ((?x Int) (?y Int) (?s Set)) (=> (not (= ?x ?y)) (= (set.member ?x (set.insert ?s ?y)) (set.member ?x ?s)))))
+(assert (forall ((?x Int) (?s Set)) (=> (not (set.member ?x ?s)) (= (delete ?s ?x) ?s))))
+(assert (forall ((?x Int) (?s Set)) (= (delete (set.insert ?s ?x) ?x) (delete ?s ?x))))
+(assert (forall ((?x Int) (?y Int) (?s Set)) (=> (not (= ?x ?y)) (= (delete (set.insert ?s ?y) ?x) (set.insert (delete ?s ?x) ?y)))))
+(assert (forall ((?s Set)) (set.member (sup ?s) ?s)))
+(assert (forall ((?s Set) (?x Int)) (=> (set.member ?x ?s) (<= ?x (sup ?s)))))
+(assert (forall ((?s Set) (?x Int)) (=> (< (sup ?s) ?x) (= (sup (set.insert ?s ?x)) ?x))))
(declare-fun arr () (Array Int Int))
(declare-fun s0 () Set)
(assert (forall ((?i Int)) (=> (> ?i 0) (< (select arr ?i) (sup s0)))))
(declare-fun s1 () Set)
(declare-fun g (Int) Int)
(assert (forall ((?i Int)) (> (g ?i) 0)))
-(assert (= s1 (insert s0 (select arr (g i1)))))
+(assert (= s1 (set.insert s0 (select arr (g i1)))))
(assert (not (= (sup s1) (sup s0))))
(check-sat)
(exit)
(set-info :status unsat)
(declare-sort Set 0)
(declare-sort Elem 0)
-(declare-fun member (Elem Set) Bool)
-(declare-fun subset (Set Set) Bool)
-(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (=> (and (member ?x ?s1) (subset ?s1 ?s2)) (member ?x ?s2))))
-(assert (forall ((?s1 Set) (?s2 Set)) (=> (not (subset ?s1 ?s2)) (exists ((?x Elem)) (and (member ?x ?s1) (not (member ?x ?s2)))))))
-(assert (forall ((?s1 Set) (?s2 Set)) (=> (forall ((?x Elem)) (=> (member ?x ?s1) (member ?x ?s2))) (subset ?s1 ?s2))))
+(declare-fun set.member (Elem Set) Bool)
+(declare-fun set.subset (Set Set) Bool)
+(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (=> (and (set.member ?x ?s1) (set.subset ?s1 ?s2)) (set.member ?x ?s2))))
+(assert (forall ((?s1 Set) (?s2 Set)) (=> (not (set.subset ?s1 ?s2)) (exists ((?x Elem)) (and (set.member ?x ?s1) (not (set.member ?x ?s2)))))))
+(assert (forall ((?s1 Set) (?s2 Set)) (=> (forall ((?x Elem)) (=> (set.member ?x ?s1) (set.member ?x ?s2))) (set.subset ?s1 ?s2))))
(declare-fun seteq (Set Set) Bool)
(assert (forall ((?s1 Set) (?s2 Set)) (= (seteq ?s1 ?s2) (= ?s1 ?s2))))
-(assert (forall ((?s1 Set) (?s2 Set)) (= (seteq ?s1 ?s2) (and (subset ?s1 ?s2) (subset ?s2 ?s1)))))
+(assert (forall ((?s1 Set) (?s2 Set)) (= (seteq ?s1 ?s2) (and (set.subset ?s1 ?s2) (set.subset ?s2 ?s1)))))
(declare-fun union (Set Set) Set)
-(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (= (member ?x (union ?s1 ?s2)) (or (member ?x ?s1) (member ?x ?s2)))))
-(declare-fun intersection (Set Set) Set)
-(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (= (member ?x (intersection ?s1 ?s2)) (and (member ?x ?s1) (member ?x ?s2)))))
+(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (= (set.member ?x (union ?s1 ?s2)) (or (set.member ?x ?s1) (set.member ?x ?s2)))))
+(declare-fun set.intersection (Set Set) Set)
+(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (= (set.member ?x (set.intersection ?s1 ?s2)) (and (set.member ?x ?s1) (set.member ?x ?s2)))))
(declare-fun difference (Set Set) Set)
-(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (= (member ?x (difference ?s1 ?s2)) (and (member ?x ?s1) (not (member ?x ?s2))))))
+(assert (forall ((?x Elem) (?s1 Set) (?s2 Set)) (= (set.member ?x (difference ?s1 ?s2)) (and (set.member ?x ?s1) (not (set.member ?x ?s2))))))
(declare-fun a () Set)
(declare-fun b () Set)
-(assert (not (seteq (intersection a b) (intersection b a))))
+(assert (not (seteq (set.intersection a b) (set.intersection b a))))
(check-sat)
(exit)
(declare-sort $$unsorted 0)
(declare-fun in ($$unsorted $$unsorted) Bool)
(declare-fun powerset ($$unsorted) $$unsorted)
-(declare-fun subset ($$unsorted $$unsorted) Bool)
+(declare-fun set.subset ($$unsorted $$unsorted) Bool)
(declare-fun empty ($$unsorted) Bool)
(declare-fun element ($$unsorted $$unsorted) Bool)
(declare-fun empty_set () $$unsorted)
(set-info :filename "SEU169+1")
(assert (forall ((A $$unsorted) (B $$unsorted)) (or (not (in A B)) (not (in B A))) ))
-(assert (forall ((A $$unsorted) (B $$unsorted)) (= (= B (powerset A)) (forall ((C $$unsorted)) (= (in C B) (subset C A)) )) ))
+(assert (forall ((A $$unsorted) (B $$unsorted)) (= (= B (powerset A)) (forall ((C $$unsorted)) (= (in C B) (set.subset C A)) )) ))
(assert (and (forall ((A $$unsorted) (B $$unsorted)) (or (empty A) (= (element B A) (in B A))) ) (forall ((A $$unsorted) (B $$unsorted)) (or (not (empty A)) (= (element B A) (empty B))) )))
-(assert (forall ((A $$unsorted) (B $$unsorted)) (= (subset A B) (forall ((C $$unsorted)) (or (not (in C A)) (in C B)) )) ))
+(assert (forall ((A $$unsorted) (B $$unsorted)) (= (set.subset A B) (forall ((C $$unsorted)) (or (not (in C A)) (in C B)) )) ))
(assert (forall ((A $$unsorted)) (not (forall ((B $$unsorted)) (not (element B A)) )) ))
(assert (forall ((A $$unsorted)) (not (empty (powerset A))) ))
(assert (empty empty_set))
(assert (forall ((A $$unsorted)) (or (empty A) (not (forall ((B $$unsorted)) (or (not (element B (powerset A))) (empty B)) ))) ))
(assert (not (forall ((A $$unsorted)) (not (empty A)) )))
(assert (not (forall ((A $$unsorted)) (empty A) )))
-(assert (forall ((A $$unsorted)) (subset A A) ))
+(assert (forall ((A $$unsorted)) (set.subset A A) ))
(assert (forall ((A $$unsorted)) (or (not (empty A)) (= empty_set A)) ))
(assert (forall ((A $$unsorted) (B $$unsorted)) (or (not (in A B)) (not (empty B))) ))
(assert (forall ((A $$unsorted) (B $$unsorted)) (or (not (empty A)) (= A B) (not (empty B))) ))
(declare-fun snth$a (B_stream$ Nat$) B$)
(declare-fun snth$b (A_stream_stream$ Nat$) A_stream$)
(declare-fun snth$c (A_stream$ Nat$) A$)
-(declare-fun member$ (B_stream$ B_stream_set$) Bool)
+(declare-fun set.member$ (B_stream$ B_stream_set$) Bool)
(declare-fun sdrop$a (Nat$ B_stream$) B_stream$)
(declare-fun sdrop$b (Nat$ A_stream_stream$) A_stream_stream$)
(declare-fun sdrop$c (Nat$ A_stream$) A_stream$)
(declare-fun fun_app$ (B_b_stream_fun$ B$) B_stream$)
-(declare-fun member$a (B$ B_set$) Bool)
-(declare-fun member$b (A$ A_set$) Bool)
-(declare-fun member$c (A_stream$ A_stream_set$) Bool)
-(declare-fun member$d (B_stream_stream$ B_stream_stream_set$) Bool)
-(declare-fun member$e (A_stream_stream$ A_stream_stream_set$) Bool)
+(declare-fun set.member$a (B$ B_set$) Bool)
+(declare-fun set.member$b (A$ A_set$) Bool)
+(declare-fun set.member$c (A_stream$ A_stream_set$) Bool)
+(declare-fun set.member$d (B_stream_stream$ B_stream_stream_set$) Bool)
+(declare-fun set.member$e (A_stream_stream$ A_stream_stream_set$) Bool)
(declare-fun streams$ (B_set$) B_stream_set$)
(declare-fun fun_app$a (A_a_stream_fun$ A$) A_stream$)
(declare-fun fun_app$b (B_a_fun$ B$) A$)
(assert (! (forall ((?v0 A_a_fun$) (?v1 A_stream$) (?v2 A_stream$)) (= (= (fun_app$e (smap$b ?v0) ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$f ?v0 (snth$c ?v1 ?v3)) (snth$c ?v2 ?v3))))) :named a64))
(assert (! (forall ((?v0 B_b_fun$) (?v1 B_stream$) (?v2 B_stream$)) (= (= (fun_app$c (smap$a ?v0) ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$d ?v0 (snth$a ?v1 ?v3)) (snth$a ?v2 ?v3))))) :named a65))
(assert (! (forall ((?v0 B_a_fun$) (?v1 B_stream$) (?v2 A_stream$)) (= (= (smap$ ?v0 ?v1) ?v2) (forall ((?v3 Nat$)) (= (fun_app$b ?v0 (snth$a ?v1 ?v3)) (snth$c ?v2 ?v3))))) :named a66))
-(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_a_fun$) (?v3 A_set$)) (=> (and (member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (member$a ?v4 ?v1) (member$b (fun_app$b ?v2 ?v4) ?v3)))) (member$c (smap$ ?v2 ?v0) (streams$a ?v3)))) :named a67))
-(assert (! (forall ((?v0 A_stream$) (?v1 A_set$) (?v2 A_b_fun$) (?v3 B_set$)) (=> (and (member$c ?v0 (streams$a ?v1)) (forall ((?v4 A$)) (=> (member$b ?v4 ?v1) (member$a (fun_app$m ?v2 ?v4) ?v3)))) (member$ (smap$k ?v2 ?v0) (streams$ ?v3)))) :named a68))
-(assert (! (forall ((?v0 A_stream$) (?v1 A_set$) (?v2 A_a_fun$) (?v3 A_set$)) (=> (and (member$c ?v0 (streams$a ?v1)) (forall ((?v4 A$)) (=> (member$b ?v4 ?v1) (member$b (fun_app$f ?v2 ?v4) ?v3)))) (member$c (fun_app$e (smap$b ?v2) ?v0) (streams$a ?v3)))) :named a69))
-(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_b_fun$) (?v3 B_set$)) (=> (and (member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (member$a ?v4 ?v1) (member$a (fun_app$d ?v2 ?v4) ?v3)))) (member$ (fun_app$c (smap$a ?v2) ?v0) (streams$ ?v3)))) :named a70))
-(assert (! (forall ((?v0 B_stream_stream$) (?v1 B_stream_set$) (?v2 B_stream_b_fun$) (?v3 B_set$)) (=> (and (member$d ?v0 (streams$b ?v1)) (forall ((?v4 B_stream$)) (=> (member$ ?v4 ?v1) (member$a (fun_app$n ?v2 ?v4) ?v3)))) (member$ (smap$l ?v2 ?v0) (streams$ ?v3)))) :named a71))
-(assert (! (forall ((?v0 A_stream_stream$) (?v1 A_stream_set$) (?v2 A_stream_b_fun$) (?v3 B_set$)) (=> (and (member$e ?v0 (streams$c ?v1)) (forall ((?v4 A_stream$)) (=> (member$c ?v4 ?v1) (member$a (fun_app$o ?v2 ?v4) ?v3)))) (member$ (smap$m ?v2 ?v0) (streams$ ?v3)))) :named a72))
-(assert (! (forall ((?v0 B_stream_stream$) (?v1 B_stream_set$) (?v2 B_stream_a_fun$) (?v3 A_set$)) (=> (and (member$d ?v0 (streams$b ?v1)) (forall ((?v4 B_stream$)) (=> (member$ ?v4 ?v1) (member$b (fun_app$p ?v2 ?v4) ?v3)))) (member$c (smap$n ?v2 ?v0) (streams$a ?v3)))) :named a73))
-(assert (! (forall ((?v0 A_stream_stream$) (?v1 A_stream_set$) (?v2 A_stream_a_fun$) (?v3 A_set$)) (=> (and (member$e ?v0 (streams$c ?v1)) (forall ((?v4 A_stream$)) (=> (member$c ?v4 ?v1) (member$b (fun_app$q ?v2 ?v4) ?v3)))) (member$c (smap$o ?v2 ?v0) (streams$a ?v3)))) :named a74))
-(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_b_stream_fun$) (?v3 B_stream_set$)) (=> (and (member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (member$a ?v4 ?v1) (member$ (fun_app$ ?v2 ?v4) ?v3)))) (member$d (smap$g ?v2 ?v0) (streams$b ?v3)))) :named a75))
-(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_a_stream_fun$) (?v3 A_stream_set$)) (=> (and (member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (member$a ?v4 ?v1) (member$c (fun_app$k ?v2 ?v4) ?v3)))) (member$e (smap$h ?v2 ?v0) (streams$c ?v3)))) :named a76))
+(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_a_fun$) (?v3 A_set$)) (=> (and (set.member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (set.member$a ?v4 ?v1) (set.member$b (fun_app$b ?v2 ?v4) ?v3)))) (set.member$c (smap$ ?v2 ?v0) (streams$a ?v3)))) :named a67))
+(assert (! (forall ((?v0 A_stream$) (?v1 A_set$) (?v2 A_b_fun$) (?v3 B_set$)) (=> (and (set.member$c ?v0 (streams$a ?v1)) (forall ((?v4 A$)) (=> (set.member$b ?v4 ?v1) (set.member$a (fun_app$m ?v2 ?v4) ?v3)))) (set.member$ (smap$k ?v2 ?v0) (streams$ ?v3)))) :named a68))
+(assert (! (forall ((?v0 A_stream$) (?v1 A_set$) (?v2 A_a_fun$) (?v3 A_set$)) (=> (and (set.member$c ?v0 (streams$a ?v1)) (forall ((?v4 A$)) (=> (set.member$b ?v4 ?v1) (set.member$b (fun_app$f ?v2 ?v4) ?v3)))) (set.member$c (fun_app$e (smap$b ?v2) ?v0) (streams$a ?v3)))) :named a69))
+(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_b_fun$) (?v3 B_set$)) (=> (and (set.member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (set.member$a ?v4 ?v1) (set.member$a (fun_app$d ?v2 ?v4) ?v3)))) (set.member$ (fun_app$c (smap$a ?v2) ?v0) (streams$ ?v3)))) :named a70))
+(assert (! (forall ((?v0 B_stream_stream$) (?v1 B_stream_set$) (?v2 B_stream_b_fun$) (?v3 B_set$)) (=> (and (set.member$d ?v0 (streams$b ?v1)) (forall ((?v4 B_stream$)) (=> (set.member$ ?v4 ?v1) (set.member$a (fun_app$n ?v2 ?v4) ?v3)))) (set.member$ (smap$l ?v2 ?v0) (streams$ ?v3)))) :named a71))
+(assert (! (forall ((?v0 A_stream_stream$) (?v1 A_stream_set$) (?v2 A_stream_b_fun$) (?v3 B_set$)) (=> (and (set.member$e ?v0 (streams$c ?v1)) (forall ((?v4 A_stream$)) (=> (set.member$c ?v4 ?v1) (set.member$a (fun_app$o ?v2 ?v4) ?v3)))) (set.member$ (smap$m ?v2 ?v0) (streams$ ?v3)))) :named a72))
+(assert (! (forall ((?v0 B_stream_stream$) (?v1 B_stream_set$) (?v2 B_stream_a_fun$) (?v3 A_set$)) (=> (and (set.member$d ?v0 (streams$b ?v1)) (forall ((?v4 B_stream$)) (=> (set.member$ ?v4 ?v1) (set.member$b (fun_app$p ?v2 ?v4) ?v3)))) (set.member$c (smap$n ?v2 ?v0) (streams$a ?v3)))) :named a73))
+(assert (! (forall ((?v0 A_stream_stream$) (?v1 A_stream_set$) (?v2 A_stream_a_fun$) (?v3 A_set$)) (=> (and (set.member$e ?v0 (streams$c ?v1)) (forall ((?v4 A_stream$)) (=> (set.member$c ?v4 ?v1) (set.member$b (fun_app$q ?v2 ?v4) ?v3)))) (set.member$c (smap$o ?v2 ?v0) (streams$a ?v3)))) :named a74))
+(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_b_stream_fun$) (?v3 B_stream_set$)) (=> (and (set.member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (set.member$a ?v4 ?v1) (set.member$ (fun_app$ ?v2 ?v4) ?v3)))) (set.member$d (smap$g ?v2 ?v0) (streams$b ?v3)))) :named a75))
+(assert (! (forall ((?v0 B_stream$) (?v1 B_set$) (?v2 B_a_stream_fun$) (?v3 A_stream_set$)) (=> (and (set.member$ ?v0 (streams$ ?v1)) (forall ((?v4 B$)) (=> (set.member$a ?v4 ?v1) (set.member$c (fun_app$k ?v2 ?v4) ?v3)))) (set.member$e (smap$h ?v2 ?v0) (streams$c ?v3)))) :named a76))
(assert (! (forall ((?v0 B_b_fun$) (?v1 B$)) (= (shd$a (fun_app$ (siterate$ ?v0) ?v1)) ?v1)) :named a77))
(assert (! (forall ((?v0 A_a_fun$) (?v1 A$)) (= (shd$ (fun_app$a (siterate$a ?v0) ?v1)) ?v1)) :named a78))
(assert (! (forall ((?v0 B_b_fun$) (?v1 B$)) (= (stl$a (fun_app$ (siterate$ ?v0) ?v1)) (fun_app$ (siterate$ ?v0) (fun_app$d ?v0 ?v1)))) :named a79))
(declare-fun b1 () Atom)
(declare-fun b1_tup () (Tuple Atom))
(assert (= b1_tup (tuple b1)))
-(assert (member b1_tup Book))
+(assert (set.member b1_tup Book))
(declare-fun b2 () Atom)
(declare-fun b2_tup () (Tuple Atom))
(assert (= b2_tup (tuple b2)))
-(assert (member b2_tup Book))
+(assert (set.member b2_tup Book))
(declare-fun b3 () Atom)
(declare-fun b3_tup () (Tuple Atom))
(assert (= b3_tup (tuple b3)))
-(assert (member b3_tup Book))
+(assert (set.member b3_tup Book))
(declare-fun m () Atom)
(declare-fun m_tup () (Tuple Atom))
(assert (= m_tup (tuple m)))
-(assert (member m_tup Name))
+(assert (set.member m_tup Name))
(declare-fun t () Atom)
(declare-fun t_tup () (Tuple Atom))
(assert (= t_tup (tuple t)))
-(assert (member t_tup Target))
-(assert (= (join (singleton m_tup) (join (singleton b1_tup) addr)) (as emptyset (Set (Tuple Atom)))))
-(assert (= (join (singleton b2_tup) addr) (union (join (singleton b1_tup) addr) (singleton (tuple m t)))))
-(assert (= (join (singleton b3_tup) addr) (setminus (join (singleton b2_tup) addr) (singleton (tuple m t)))))
-(assert (not (= (join (singleton b1_tup) addr) (join (singleton b3_tup) addr))))
+(assert (set.member t_tup Target))
+(assert (= (rel.join (set.singleton m_tup) (rel.join (set.singleton b1_tup) addr)) (as set.empty (Set (Tuple Atom)))))
+(assert (= (rel.join (set.singleton b2_tup) addr) (set.union (rel.join (set.singleton b1_tup) addr) (set.singleton (tuple m t)))))
+(assert (= (rel.join (set.singleton b3_tup) addr) (set.minus (rel.join (set.singleton b2_tup) addr) (set.singleton (tuple m t)))))
+(assert (not (= (rel.join (set.singleton b1_tup) addr) (rel.join (set.singleton b3_tup) addr))))
(check-sat)
(declare-fun b1 () Atom)
(declare-fun b1_tup () (Tuple Atom))
(assert (= b1_tup (tuple b1)))
-(assert (member b1_tup Book))
+(assert (set.member b1_tup Book))
(declare-fun b2 () Atom)
(declare-fun b2_tup () (Tuple Atom))
(assert (= b2_tup (tuple b2)))
-(assert (member b2_tup Book))
+(assert (set.member b2_tup Book))
(declare-fun b3 () Atom)
(declare-fun b3_tup () (Tuple Atom))
(assert (= b3_tup (tuple b3)))
-(assert (member b3_tup Book))
+(assert (set.member b3_tup Book))
(declare-fun m () Atom)
(declare-fun m_tup () (Tuple Atom))
(assert (= m_tup (tuple m)))
-(assert (member m_tup Name))
+(assert (set.member m_tup Name))
(declare-fun t () Atom)
(declare-fun t_tup () (Tuple Atom))
(assert (= t_tup (tuple t)))
-(assert (member t_tup Target))
-(assert (= (join (singleton m_tup) (join (singleton b1_tup) addr)) (as emptyset (Set (Tuple Atom)))))
-(assert (= (join (singleton b2_tup) addr) (union (join (singleton b1_tup) addr) (singleton (tuple m t)))))
-(assert (= (join (singleton b3_tup) addr) (setminus (join (singleton b2_tup) addr) (singleton (tuple m t)))))
-(assert (= (join (singleton b1_tup) addr) (join (singleton b3_tup) addr)))
+(assert (set.member t_tup Target))
+(assert (= (rel.join (set.singleton m_tup) (rel.join (set.singleton b1_tup) addr)) (as set.empty (Set (Tuple Atom)))))
+(assert (= (rel.join (set.singleton b2_tup) addr) (set.union (rel.join (set.singleton b1_tup) addr) (set.singleton (tuple m t)))))
+(assert (= (rel.join (set.singleton b3_tup) addr) (set.minus (rel.join (set.singleton b2_tup) addr) (set.singleton (tuple m t)))))
+(assert (= (rel.join (set.singleton b1_tup) addr) (rel.join (set.singleton b3_tup) addr)))
(check-sat)
(declare-fun d () (_ BitVec 1))
(declare-fun e () (_ BitVec 1))
(assert (not (= b c)))
-(assert (member (tuple a u b) x))
-(assert (member (tuple a u c) x))
-(assert (member (tuple d u a) y))
-(assert (not (member (tuple a u u a) (join x y))))
+(assert (set.member (tuple a u b) x))
+(assert (set.member (tuple a u c) x))
+(assert (set.member (tuple d u a) y))
+(assert (not (set.member (tuple a u u a) (rel.join x y))))
(check-sat)
(declare-fun e () (_ BitVec 1))
(declare-fun u () unitb)
(assert (not (= b c)))
-(assert (member (tuple a u b) x))
-(assert (member (tuple a u c) x))
-(assert (member (tuple d u a) y))
-(assert (not (member (tuple a u u a) (join x y))))
+(assert (set.member (tuple a u b) x))
+(assert (set.member (tuple a u c) x))
+(assert (set.member (tuple d u a) y))
+(assert (not (set.member (tuple a u u a) (rel.join x y))))
(check-sat)
(declare-fun d () (_ BitVec 1))
(declare-fun e () (_ BitVec 1))
(assert (not (= b c)))
-(assert (member (tuple a b) x))
-(assert (member (tuple a c) x))
-(assert (member (tuple d a) y))
-(assert (not (member (tuple a a) (join x y))))
+(assert (set.member (tuple a b) x))
+(assert (set.member (tuple a c) x))
+(assert (set.member (tuple d a) y))
+(assert (not (set.member (tuple a a) (rel.join x y))))
(check-sat)
(declare-fun d () (Tuple (_ BitVec 1) (_ BitVec 1)))
(assert (distinct a b))
(assert (distinct c d))
-(assert (member a x))
-(assert (member b x))
-(assert (member a y))
-(assert (member b y))
-(assert (let ((_let_1 (join x y))) (and (not (member c _let_1)) (not (member d _let_1)))))
+(assert (set.member a x))
+(assert (set.member b x))
+(assert (set.member a y))
+(assert (set.member b y))
+(assert (let ((_let_1 (rel.join x y))) (and (not (set.member c _let_1)) (not (set.member d _let_1)))))
(check-sat)
(declare-fun e () (Tuple (_ BitVec 1) (_ BitVec 1)))
(assert (distinct a b))
(assert (distinct c d e))
-(assert (member a x))
-(assert (member b x))
-(assert (member a y))
-(assert (member b y))
-(assert (let ((_let_1 (join x y))) (and (and (not (member c _let_1)) (not (member d _let_1))) (not (member e _let_1)))))
+(assert (set.member a x))
+(assert (set.member b x))
+(assert (set.member a y))
+(assert (set.member b y))
+(assert (let ((_let_1 (rel.join x y))) (and (and (not (set.member c _let_1)) (not (set.member d _let_1))) (not (set.member e _let_1)))))
(check-sat)
(declare-fun d () (_ BitVec 2))
(declare-fun e () (_ BitVec 2))
(assert (not (= b c)))
-(assert (member (tuple a b) x))
-(assert (member (tuple a c) x))
-(assert (member (tuple d a) y))
-(assert (not (member (tuple a a) (join x y))))
+(assert (set.member (tuple a b) x))
+(assert (set.member (tuple a c) x))
+(assert (set.member (tuple d a) y))
+(assert (not (set.member (tuple a a) (rel.join x y))))
(check-sat)
(declare-fun s1 () H_TYPE)
(declare-fun s2 () H_TYPE)
(declare-fun s3 () H_TYPE)
-(assert (= h0 (singleton (tuple s0))))
-(assert (= h1 (singleton (tuple s1))))
-(assert (= h2 (singleton (tuple s2))))
-(assert (= h3 (singleton (tuple s3))))
+(assert (= h0 (set.singleton (tuple s0))))
+(assert (= h1 (set.singleton (tuple s1))))
+(assert (= h2 (set.singleton (tuple s2))))
+(assert (= h3 (set.singleton (tuple s3))))
(declare-fun ref () (Set (Tuple H_TYPE Obj Obj)))
(declare-fun mark () (Set (Tuple H_TYPE Obj)))
(declare-fun empty_obj_set () (Set (Tuple Obj)))
-(assert (= empty_obj_set (as emptyset (Set (Tuple Obj)))))
+(assert (= empty_obj_set (as set.empty (Set (Tuple Obj)))))
(declare-fun root () Obj)
(declare-fun live () Obj)
-(assert (= (join h1 mark) empty_obj_set))
-(assert (subset (join h0 ref) (join h1 ref)))
-(assert (forall ((n Obj)) (=> (member (tuple root n) (tclosure (join h1 ref))) (member (tuple n) (join h2 mark)))))
-(assert (subset (join h1 ref) (join h2 ref)))
-(assert (forall ((n Obj)) (let ((_let_1 (tuple n))) (=> (not (member _let_1 (join h2 mark))) (= (join (singleton _let_1) (join h3 ref)) empty_obj_set)))))
-(assert (forall ((n Obj)) (let ((_let_1 (tuple n))) (let ((_let_2 (singleton _let_1))) (=> (member _let_1 (join h2 mark)) (= (join _let_2 (join h3 ref)) (join _let_2 (join h2 ref))))))))
-(assert (member (tuple root live) (tclosure (join h0 ref))))
-(assert (let ((_let_1 (singleton (tuple live)))) (not (subset (join _let_1 (join h0 ref)) (join _let_1 (join h3 ref))))))
+(assert (= (rel.join h1 mark) empty_obj_set))
+(assert (set.subset (rel.join h0 ref) (rel.join h1 ref)))
+(assert (forall ((n Obj)) (=> (set.member (tuple root n) (rel.tclosure (rel.join h1 ref))) (set.member (tuple n) (rel.join h2 mark)))))
+(assert (set.subset (rel.join h1 ref) (rel.join h2 ref)))
+(assert (forall ((n Obj)) (let ((_let_1 (tuple n))) (=> (not (set.member _let_1 (rel.join h2 mark))) (= (rel.join (set.singleton _let_1) (rel.join h3 ref)) empty_obj_set)))))
+(assert (forall ((n Obj)) (let ((_let_1 (tuple n))) (let ((_let_2 (set.singleton _let_1))) (=> (set.member _let_1 (rel.join h2 mark)) (= (rel.join _let_2 (rel.join h3 ref)) (rel.join _let_2 (rel.join h2 ref))))))))
+(assert (set.member (tuple root live) (rel.tclosure (rel.join h0 ref))))
+(assert (let ((_let_1 (set.singleton (tuple live)))) (not (set.subset (rel.join _let_1 (rel.join h0 ref)) (rel.join _let_1 (rel.join h3 ref))))))
(check-sat)
(declare-fun b () Atom)
(declare-fun c () Atom)
(declare-fun d () Atom)
-(assert (= univ (as univset (Set (Tuple Atom)))))
-(assert (= univ2 (as univset (Set (Tuple Atom Atom)))))
-(assert (= univ2 (product univ univ)))
-(assert (member (tuple a b) x))
-(assert (member (tuple c d) x))
+(assert (= univ (as set.universe (Set (Tuple Atom)))))
+(assert (= univ2 (as set.universe (Set (Tuple Atom Atom)))))
+(assert (= univ2 (rel.product univ univ)))
+(assert (set.member (tuple a b) x))
+(assert (set.member (tuple c d) x))
(assert (not (= a b)))
-(assert (subset (iden univ) x))
+(assert (set.subset (rel.iden univ) x))
(check-sat)
(declare-fun w () (Set (Tuple Int unit)))
(declare-fun z () (Set (Tuple unit Int)))
-(assert (let ((_let_1 (join w z))) (let ((_let_2 (join x y))) (and (= _let_2 _let_1) (= _let_2 (transpose _let_1))))))
-(assert (member (tuple 0 1) (join x y)))
+(assert (let ((_let_1 (rel.join w z))) (let ((_let_2 (rel.join x y))) (and (= _let_2 _let_1) (= _let_2 (rel.transpose _let_1))))))
+(assert (set.member (tuple 0 1) (rel.join x y)))
(declare-fun t () Int)
(assert (and (>= t 0) (<= t 1)))
(declare-fun s () Int)
(assert (and (>= s 0) (<= s 1)))
(assert (= (+ s t) 1))
-(assert (member (tuple s u) w))
-(assert (not (member (tuple u t) z)))
+(assert (set.member (tuple s u) w))
+(assert (not (set.member (tuple u t) z)))
(check-sat)
(declare-fun w () (Set (Tuple Int unit)))
(declare-fun z () (Set (Tuple unit Int)))
-(assert (let ((_let_1 (join w z))) (let ((_let_2 (join x y))) (or (= _let_2 _let_1) (= _let_2 (transpose _let_1))))))
-(assert (member (tuple 0 1) (join x y)))
+(assert (let ((_let_1 (rel.join w z))) (let ((_let_2 (rel.join x y))) (or (= _let_2 _let_1) (= _let_2 (rel.transpose _let_1))))))
+(assert (set.member (tuple 0 1) (rel.join x y)))
(declare-fun t () Int)
(assert (and (>= t 0) (<= t 1)))
(declare-fun s () Int)
(assert (and (>= s 0) (<= s 1)))
(assert (= (+ s t) 1))
-(assert (member (tuple s u) w))
-(assert (not (member (tuple u t) z)))
+(assert (set.member (tuple s u) w))
+(assert (not (set.member (tuple u t) z)))
(check-sat)
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
(declare-fun b () Int)
-(assert (member (tuple 1 7) x))
-(assert (member z x))
-(assert (member (tuple 7 5) y))
-(assert (= t (join_image x 2)))
-(assert (member (tuple 3) (join_image x 2)))
-(assert (= u (join_image x 1)))
-(assert (member (tuple 4) (join_image x 2)))
-(assert (member (tuple b) (join_image x 1)))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member z x))
+(assert (set.member (tuple 7 5) y))
+(assert (= t (rel.join_image x 2)))
+(assert (set.member (tuple 3) (rel.join_image x 2)))
+(assert (= u (rel.join_image x 1)))
+(assert (set.member (tuple 4) (rel.join_image x 2)))
+(assert (set.member (tuple b) (rel.join_image x 1)))
(check-sat)
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 1 5)))
(declare-fun b () Int)
-(assert (member (tuple 1 7) x))
-(assert (member z x))
-(assert (member (tuple 7 5) y))
-(assert (= t (join_image x 2)))
-(assert (= univ (join_image x 0)))
-(assert (member (tuple 100) t))
-(assert (not (member (tuple 3) univ)))
-(assert (= u (join_image x 1)))
-(assert (member (tuple 4) (join_image x 2)))
-(assert (member (tuple b) (join_image x 1)))
+(assert (set.member (tuple 1 7) x))
+(assert (set.member z x))
+(assert (set.member (tuple 7 5) y))
+(assert (= t (rel.join_image x 2)))
+(assert (= univ (rel.join_image x 0)))
+(assert (set.member (tuple 100) t))
+(assert (not (set.member (tuple 3) univ)))
+(assert (= u (rel.join_image x 1)))
+(assert (set.member (tuple 4) (rel.join_image x 2)))
+(assert (set.member (tuple b) (rel.join_image x 1)))
(check-sat)
(declare-fun c () Atom)
(declare-fun d () Atom)
(declare-fun e () Atom)
-(assert (member (tuple a) (join_image x 2)))
-(assert (= x (union (union (singleton (tuple b c)) (singleton (tuple d e))) (singleton (tuple c e)))))
+(assert (set.member (tuple a) (rel.join_image x 2)))
+(assert (= x (set.union (set.union (set.singleton (tuple b c)) (set.singleton (tuple d e))) (set.singleton (tuple c e)))))
(assert (not (= a b)))
(check-sat)
(declare-fun c () Atom)
(declare-fun d () Atom)
(declare-fun e () Atom)
-(assert (member (tuple a) (join_image x 2)))
-(assert (= t (join_image x 2)))
-(assert (= x (union (union (singleton (tuple b c)) (singleton (tuple d e))) (singleton (tuple c e)))))
-(assert (member (tuple c) t))
+(assert (set.member (tuple a) (rel.join_image x 2)))
+(assert (= t (rel.join_image x 2)))
+(assert (= x (set.union (set.union (set.singleton (tuple b c)) (set.singleton (tuple d e))) (set.singleton (tuple c e)))))
+(assert (set.member (tuple c) t))
(check-sat)
(declare-fun e () Atom)
(declare-fun f () Atom)
(declare-fun g () Atom)
-(assert (member (tuple a) (join_image x 2)))
-(assert (member (tuple a) (join_image y 3)))
-(assert (= x (union (union (union (union (singleton (tuple f g)) (singleton (tuple b c))) (singleton (tuple d e))) (singleton (tuple c e))) (singleton (tuple f b)))))
-(assert (member (tuple a f) x))
-(assert (member (tuple a f) y))
+(assert (set.member (tuple a) (rel.join_image x 2)))
+(assert (set.member (tuple a) (rel.join_image y 3)))
+(assert (= x (set.union (set.union (set.union (set.union (set.singleton (tuple f g)) (set.singleton (tuple b c))) (set.singleton (tuple d e))) (set.singleton (tuple c e))) (set.singleton (tuple f b)))))
+(assert (set.member (tuple a f) x))
+(assert (set.member (tuple a f) y))
(assert (= x y))
(assert (not (= a b)))
-(assert (not (member (tuple d) (join_image x 2))))
+(assert (not (set.member (tuple d) (rel.join_image x 2))))
(assert (= f d))
(check-sat)
(declare-fun e () Atom)
(declare-fun f () Atom)
(declare-fun g () Atom)
-(assert (member (tuple a) (join_image x 2)))
-(assert (member (tuple a) (join_image y 1)))
-(assert (= y (union (union (union (singleton (tuple f g)) (singleton (tuple b c))) (singleton (tuple d e))) (singleton (tuple c e)))))
-(assert (= x (union (union (union (singleton (tuple f g)) (singleton (tuple b c))) (singleton (tuple d e))) (singleton (tuple c e)))))
+(assert (set.member (tuple a) (rel.join_image x 2)))
+(assert (set.member (tuple a) (rel.join_image y 1)))
+(assert (= y (set.union (set.union (set.union (set.singleton (tuple f g)) (set.singleton (tuple b c))) (set.singleton (tuple d e))) (set.singleton (tuple c e)))))
+(assert (= x (set.union (set.union (set.union (set.singleton (tuple f g)) (set.singleton (tuple b c))) (set.singleton (tuple d e))) (set.singleton (tuple c e)))))
(assert (or (not (= a b)) (not (= a f))))
(check-sat)
(declare-fun w1 () (Set (Tuple Int Int)))
(declare-fun z2 () (Set (Tuple Int Int)))
(declare-fun w2 () (Set (Tuple Int Int)))
-(assert (not (= z (product x y))))
-(assert (member (tuple 0 1 2 3) z))
-(assert (member (tuple 0 1) z1))
-(assert (member (tuple 0 1) z2))
-(assert (member (tuple 2 3) w1))
-(assert (member (tuple 2 3) w2))
+(assert (not (= z (rel.product x y))))
+(assert (set.member (tuple 0 1 2 3) z))
+(assert (set.member (tuple 0 1) z1))
+(assert (set.member (tuple 0 1) z2))
+(assert (set.member (tuple 2 3) w1))
+(assert (set.member (tuple 2 3) w2))
(assert (or (and (= x z1) (= y w1)) (and (= x z2) (= y w2))))
(check-sat)
(declare-fun z2 () (Set (Tuple Int Int)))
(declare-fun w2 () (Set (Tuple Int Int)))
(declare-fun P ((Set (Tuple Int Int Int Int))) Bool)
-(assert (= z (product x y)))
+(assert (= z (rel.product x y)))
(assert (P z))
-(assert (not (P (singleton (tuple 0 1 2 3)))))
-(assert (member (tuple 0 1) z1))
-(assert (member (tuple 0 1) z2))
-(assert (member (tuple 2 3) w1))
-(assert (member (tuple 2 3) w2))
+(assert (not (P (set.singleton (tuple 0 1 2 3)))))
+(assert (set.member (tuple 0 1) z1))
+(assert (set.member (tuple 0 1) z2))
+(assert (set.member (tuple 2 3) w1))
+(assert (set.member (tuple 2 3) w2))
(assert (or (and (= x z1) (= y w1)) (and (= x z2) (= y w2))))
(check-sat)
(declare-fun b () (Set (Tuple Int Int)))
(declare-fun c () Int)
(declare-fun d () (Tuple Int Int))
-(assert (and (= a (singleton (tuple (+ c 1) 1))) (= (tclosure b) (join a a))))
+(assert (and (= a (set.singleton (tuple (+ c 1) 1))) (= (rel.tclosure b) (rel.join a a))))
(check-sat)
(set-info :status sat)
(declare-fun b () (Set (Tuple Int Int)))
(assert
-(= (join b (tclosure (join b b))) (as emptyset (Set (Tuple Int Int))))
+(= (rel.join b (rel.tclosure (rel.join b b))) (as set.empty (Set (Tuple Int Int))))
)
(assert
-(distinct b (as emptyset (Set (Tuple Int Int))))
+(distinct b (as set.empty (Set (Tuple Int Int))))
)
-(assert (= (join b b) (as emptyset (Set (Tuple Int Int)))))
+(assert (= (rel.join b b) (as set.empty (Set (Tuple Int Int)))))
(check-sat)
(declare-fun w () (Set (Tuple Int Int)))
(declare-fun f () (Tuple Int Int))
(assert (= f (tuple 3 1)))
-(assert (member f x))
+(assert (set.member f x))
(declare-fun g () (Tuple Int Int))
(assert (= g (tuple 1 3)))
-(assert (member g y))
+(assert (set.member g y))
(declare-fun h () (Tuple Int Int))
(assert (= h (tuple 3 5)))
-(assert (member h x))
-(assert (member h y))
-(assert (= r (join x y)))
+(assert (set.member h x))
+(assert (set.member h y))
+(assert (= r (rel.join x y)))
(declare-fun e () (Tuple Int Int))
-(assert (not (member e r)))
-(assert (not (= z (intersection x y))))
-(assert (= z (setminus x y)))
-(assert (subset x y))
-(assert (member e (join r z)))
-(assert (member e x))
-(assert (member e (intersection x y)))
+(assert (not (set.member e r)))
+(assert (not (= z (set.intersection x y))))
+(assert (= z (set.minus x y)))
+(assert (set.subset x y))
+(assert (set.member e (rel.join r z)))
+(assert (set.member e x))
+(assert (set.member e (set.intersection x y)))
(push 1)
(assert true)
(declare-fun w () (Set (Tuple Int Int)))
(declare-fun f () (Tuple Int Int))
(assert (= f (tuple 3 1)))
-(assert (member f x))
+(assert (set.member f x))
(declare-fun g () (Tuple Int Int))
(assert (= g (tuple 1 3)))
-(assert (member g y))
+(assert (set.member g y))
(declare-fun h () (Tuple Int Int))
(assert (= h (tuple 3 5)))
-(assert (member h x))
-(assert (member h y))
-(assert (= r (join x y)))
+(assert (set.member h x))
+(assert (set.member h y))
+(assert (= r (rel.join x y)))
(declare-fun a () Int)
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple a a)))
-(assert (= w (singleton e)))
-(assert (subset (transpose w) y))
-(assert (not (member e r)))
-(assert (not (= z (intersection x y))))
-(assert (= z (setminus x y)))
-(assert (subset x y))
-(assert (member e (join r z)))
-(assert (member e x))
-(assert (member e (intersection x y)))
+(assert (= w (set.singleton e)))
+(assert (set.subset (rel.transpose w) y))
+(assert (not (set.member e r)))
+(assert (not (= z (set.intersection x y))))
+(assert (= z (set.minus x y)))
+(assert (set.subset x y))
+(assert (set.member e (rel.join r z)))
+(assert (set.member e x))
+(assert (set.member e (set.intersection x y)))
(push 1)
(assert true)
(declare-fun w () (Set (Tuple Int Int)))
(declare-fun f () (Tuple Int Int))
(assert (= f (tuple 3 1)))
-(assert (member f x))
+(assert (set.member f x))
(declare-fun g () (Tuple Int Int))
(assert (= g (tuple 1 3)))
-(assert (member g y))
+(assert (set.member g y))
(declare-fun h () (Tuple Int Int))
(assert (= h (tuple 3 5)))
-(assert (member h x))
-(assert (member h y))
-(assert (= r (join x y)))
+(assert (set.member h x))
+(assert (set.member h y))
+(assert (= r (rel.join x y)))
(declare-fun a () (Tuple Int))
(assert (= a (tuple 1)))
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 1 1)))
-(assert (let ((_let_1 (singleton a))) (= w (product _let_1 _let_1))))
-(assert (subset (transpose w) y))
-(assert (not (member e r)))
-(assert (not (= z (intersection x y))))
-(assert (= z (setminus x y)))
-(assert (subset x y))
-(assert (member e (join r z)))
-(assert (member e x))
-(assert (member e (intersection x y)))
+(assert (let ((_let_1 (set.singleton a))) (= w (rel.product _let_1 _let_1))))
+(assert (set.subset (rel.transpose w) y))
+(assert (not (set.member e r)))
+(assert (not (= z (set.intersection x y))))
+(assert (= z (set.minus x y)))
+(assert (set.subset x y))
+(assert (set.member e (rel.join r z)))
+(assert (set.member e x))
+(assert (set.member e (set.intersection x y)))
(push 1)
(assert true)
(declare-fun r2 () (Set (Tuple Int Int)))
(declare-fun d () (Tuple Int Int))
(assert (= d (tuple 1 3)))
-(assert (member (tuple 1 3) y))
+(assert (set.member (tuple 1 3) y))
(declare-fun a () (Tuple Int Int))
-(assert (member a x))
+(assert (set.member a x))
(declare-fun e () (Tuple Int Int))
(assert (= e (tuple 4 3)))
-(assert (= r (join x y)))
-(assert (= r2 (product w z)))
-(assert (not (member e r)))
+(assert (= r (rel.join x y)))
+(assert (= r2 (rel.product w z)))
+(assert (not (set.member e r)))
(assert (not (= r r2)))
(check-sat)
(declare-fun r () (Set (Tuple Int Int)))
(declare-fun a11 () (Tuple Int Int))
(assert (= a11 (tuple 1 1)))
-(assert (member a11 x))
+(assert (set.member a11 x))
(declare-fun a12 () (Tuple Int Int))
(assert (= a12 (tuple 1 2)))
-(assert (member a12 x))
+(assert (set.member a12 x))
(declare-fun a13 () (Tuple Int Int))
(assert (= a13 (tuple 1 3)))
-(assert (member a13 x))
+(assert (set.member a13 x))
(declare-fun a14 () (Tuple Int Int))
(assert (= a14 (tuple 1 4)))
-(assert (member a14 x))
+(assert (set.member a14 x))
(declare-fun a15 () (Tuple Int Int))
(assert (= a15 (tuple 1 5)))
-(assert (member a15 x))
+(assert (set.member a15 x))
(declare-fun a16 () (Tuple Int Int))
(assert (= a16 (tuple 1 6)))
-(assert (member a16 x))
+(assert (set.member a16 x))
(declare-fun a17 () (Tuple Int Int))
(assert (= a17 (tuple 1 7)))
-(assert (member a17 x))
+(assert (set.member a17 x))
(declare-fun a18 () (Tuple Int Int))
(assert (= a18 (tuple 1 8)))
-(assert (member a18 x))
+(assert (set.member a18 x))
(declare-fun a19 () (Tuple Int Int))
(assert (= a19 (tuple 1 9)))
-(assert (member a19 x))
+(assert (set.member a19 x))
(declare-fun a110 () (Tuple Int Int))
(assert (= a110 (tuple 1 10)))
-(assert (member a110 x))
+(assert (set.member a110 x))
(declare-fun a21 () (Tuple Int Int))
(assert (= a21 (tuple 2 1)))
-(assert (member a21 x))
+(assert (set.member a21 x))
(declare-fun a22 () (Tuple Int Int))
(assert (= a22 (tuple 2 2)))
-(assert (member a22 x))
+(assert (set.member a22 x))
(declare-fun a23 () (Tuple Int Int))
(assert (= a23 (tuple 2 3)))
-(assert (member a23 x))
+(assert (set.member a23 x))
(declare-fun a24 () (Tuple Int Int))
(assert (= a24 (tuple 2 4)))
-(assert (member a24 x))
+(assert (set.member a24 x))
(declare-fun a25 () (Tuple Int Int))
(assert (= a25 (tuple 2 5)))
-(assert (member a25 x))
+(assert (set.member a25 x))
(declare-fun a26 () (Tuple Int Int))
(assert (= a26 (tuple 2 6)))
-(assert (member a26 x))
+(assert (set.member a26 x))
(declare-fun a27 () (Tuple Int Int))
(assert (= a27 (tuple 2 7)))
-(assert (member a27 x))
+(assert (set.member a27 x))
(declare-fun a28 () (Tuple Int Int))
(assert (= a28 (tuple 2 8)))
-(assert (member a28 x))
+(assert (set.member a28 x))
(declare-fun a29 () (Tuple Int Int))
(assert (= a29 (tuple 2 9)))
-(assert (member a29 x))
+(assert (set.member a29 x))
(declare-fun a210 () (Tuple Int Int))
(assert (= a210 (tuple 2 10)))
-(assert (member a210 x))
+(assert (set.member a210 x))
(declare-fun a31 () (Tuple Int Int))
(assert (= a31 (tuple 3 1)))
-(assert (member a31 x))
+(assert (set.member a31 x))
(declare-fun a32 () (Tuple Int Int))
(assert (= a32 (tuple 3 2)))
-(assert (member a32 x))
+(assert (set.member a32 x))
(declare-fun a33 () (Tuple Int Int))
(assert (= a33 (tuple 3 3)))
-(assert (member a33 x))
+(assert (set.member a33 x))
(declare-fun a34 () (Tuple Int Int))
(assert (= a34 (tuple 3 4)))
-(assert (member a34 x))
+(assert (set.member a34 x))
(declare-fun a35 () (Tuple Int Int))
(assert (= a35 (tuple 3 5)))
-(assert (member a35 x))
+(assert (set.member a35 x))
(declare-fun a36 () (Tuple Int Int))
(assert (= a36 (tuple 3 6)))
-(assert (member a36 x))
+(assert (set.member a36 x))
(declare-fun a37 () (Tuple Int Int))
(assert (= a37 (tuple 3 7)))
-(assert (member a37 x))
+(assert (set.member a37 x))
(declare-fun a38 () (Tuple Int Int))
(assert (= a38 (tuple 3 8)))
-(assert (member a38 x))
+(assert (set.member a38 x))
(declare-fun a39 () (Tuple Int Int))
(assert (= a39 (tuple 3 9)))
-(assert (member a39 x))
+(assert (set.member a39 x))
(declare-fun a310 () (Tuple Int Int))
(assert (= a310 (tuple 3 10)))
-(assert (member a310 x))
+(assert (set.member a310 x))
(declare-fun a41 () (Tuple Int Int))
(assert (= a41 (tuple 4 1)))
-(assert (member a41 x))
+(assert (set.member a41 x))
(declare-fun a42 () (Tuple Int Int))
(assert (= a42 (tuple 4 2)))
-(assert (member a42 x))
+(assert (set.member a42 x))
(declare-fun a43 () (Tuple Int Int))
(assert (= a43 (tuple 4 3)))
-(assert (member a43 x))
+(assert (set.member a43 x))
(declare-fun a44 () (Tuple Int Int))
(assert (= a44 (tuple 4 4)))
-(assert (member a44 x))
+(assert (set.member a44 x))
(declare-fun a45 () (Tuple Int Int))
(assert (= a45 (tuple 4 5)))
-(assert (member a45 x))
+(assert (set.member a45 x))
(declare-fun a46 () (Tuple Int Int))
(assert (= a46 (tuple 4 6)))
-(assert (member a46 x))
+(assert (set.member a46 x))
(declare-fun a47 () (Tuple Int Int))
(assert (= a47 (tuple 4 7)))
-(assert (member a47 x))
+(assert (set.member a47 x))
(declare-fun a48 () (Tuple Int Int))
(assert (= a48 (tuple 4 8)))
-(assert (member a48 x))
+(assert (set.member a48 x))
(declare-fun a49 () (Tuple Int Int))
(assert (= a49 (tuple 4 9)))
-(assert (member a49 x))
+(assert (set.member a49 x))
(declare-fun a410 () (Tuple Int Int))
(assert (= a410 (tuple 4 10)))
-(assert (member a410 x))
+(assert (set.member a410 x))
(declare-fun a51 () (Tuple Int Int))
(assert (= a51 (tuple 5 1)))
-(assert (member a51 x))
+(assert (set.member a51 x))
(declare-fun a52 () (Tuple Int Int))
(assert (= a52 (tuple 5 2)))
-(assert (member a52 x))
+(assert (set.member a52 x))
(declare-fun a53 () (Tuple Int Int))
(assert (= a53 (tuple 5 3)))
-(assert (member a53 x))
+(assert (set.member a53 x))
(declare-fun a54 () (Tuple Int Int))
(assert (= a54 (tuple 5 4)))
-(assert (member a54 x))
+(assert (set.member a54 x))
(declare-fun a55 () (Tuple Int Int))
(assert (= a55 (tuple 5 5)))
-(assert (member a55 x))
+(assert (set.member a55 x))
(declare-fun a56 () (Tuple Int Int))
(assert (= a56 (tuple 5 6)))
-(assert (member a56 x))
+(assert (set.member a56 x))
(declare-fun a57 () (Tuple Int Int))
(assert (= a57 (tuple 5 7)))
-(assert (member a57 x))
+(assert (set.member a57 x))
(declare-fun a58 () (Tuple Int Int))
(assert (= a58 (tuple 5 8)))
-(assert (member a58 x))
+(assert (set.member a58 x))
(declare-fun a59 () (Tuple Int Int))
(assert (= a59 (tuple 5 9)))
-(assert (member a59 x))
+(assert (set.member a59 x))
(declare-fun a510 () (Tuple Int Int))
(assert (= a510 (tuple 5 10)))
-(assert (member a510 x))
+(assert (set.member a510 x))
(declare-fun a61 () (Tuple Int Int))
(assert (= a61 (tuple 6 1)))
-(assert (member a61 x))
+(assert (set.member a61 x))
(declare-fun a62 () (Tuple Int Int))
(assert (= a62 (tuple 6 2)))
-(assert (member a62 x))
+(assert (set.member a62 x))
(declare-fun a63 () (Tuple Int Int))
(assert (= a63 (tuple 6 3)))
-(assert (member a63 x))
+(assert (set.member a63 x))
(declare-fun a64 () (Tuple Int Int))
(assert (= a64 (tuple 6 4)))
-(assert (member a64 x))
+(assert (set.member a64 x))
(declare-fun a65 () (Tuple Int Int))
(assert (= a65 (tuple 6 5)))
-(assert (member a65 x))
+(assert (set.member a65 x))
(declare-fun a66 () (Tuple Int Int))
(assert (= a66 (tuple 6 6)))
-(assert (member a66 x))
+(assert (set.member a66 x))
(declare-fun a67 () (Tuple Int Int))
(assert (= a67 (tuple 6 7)))
-(assert (member a67 x))
+(assert (set.member a67 x))
(declare-fun a68 () (Tuple Int Int))
(assert (= a68 (tuple 6 8)))
-(assert (member a68 x))
+(assert (set.member a68 x))
(declare-fun a69 () (Tuple Int Int))
(assert (= a69 (tuple 6 9)))
-(assert (member a69 x))
+(assert (set.member a69 x))
(declare-fun a610 () (Tuple Int Int))
(assert (= a610 (tuple 6 10)))
-(assert (member a610 x))
+(assert (set.member a610 x))
(declare-fun a71 () (Tuple Int Int))
(assert (= a71 (tuple 7 1)))
-(assert (member a71 x))
+(assert (set.member a71 x))
(declare-fun a72 () (Tuple Int Int))
(assert (= a72 (tuple 7 2)))
-(assert (member a72 x))
+(assert (set.member a72 x))
(declare-fun a73 () (Tuple Int Int))
(assert (= a73 (tuple 7 3)))
-(assert (member a73 x))
+(assert (set.member a73 x))
(declare-fun a74 () (Tuple Int Int))
(assert (= a74 (tuple 7 4)))
-(assert (member a74 x))
+(assert (set.member a74 x))
(declare-fun a75 () (Tuple Int Int))
(assert (= a75 (tuple 7 5)))
-(assert (member a75 x))
+(assert (set.member a75 x))
(declare-fun a76 () (Tuple Int Int))
(assert (= a76 (tuple 7 6)))
-(assert (member a76 x))
+(assert (set.member a76 x))
(declare-fun a77 () (Tuple Int Int))
(assert (= a77 (tuple 7 7)))
-(assert (member a77 x))
+(assert (set.member a77 x))
(declare-fun a78 () (Tuple Int Int))
(assert (= a78 (tuple 7 8)))
-(assert (member a78 x))
+(assert (set.member a78 x))
(declare-fun a79 () (Tuple Int Int))
(assert (= a79 (tuple 7 9)))
-(assert (member a79 x))
+(assert (set.member a79 x))
(declare-fun a710 () (Tuple Int Int))
(assert (= a710 (tuple 7 10)))
-(assert (member a710 x))
+(assert (set.member a710 x))
(declare-fun a81 () (Tuple Int Int))
(assert (= a81 (tuple 8 1)))
-(assert (member a81 x))
+(assert (set.member a81 x))
(declare-fun a82 () (Tuple Int Int))
(assert (= a82 (tuple 8 2)))
-(assert (member a82 x))
+(assert (set.member a82 x))
(declare-fun a83 () (Tuple Int Int))
(assert (= a83 (tuple 8 3)))
-(assert (member a83 x))
+(assert (set.member a83 x))
(declare-fun a84 () (Tuple Int Int))
(assert (= a84 (tuple 8 4)))
-(assert (member a84 x))
+(assert (set.member a84 x))
(declare-fun a85 () (Tuple Int Int))
(assert (= a85 (tuple 8 5)))
-(assert (member a85 x))
+(assert (set.member a85 x))
(declare-fun a86 () (Tuple Int Int))
(assert (= a86 (tuple 8 6)))
-(assert (member a86 x))
+(assert (set.member a86 x))
(declare-fun a87 () (Tuple Int Int))
(assert (= a87 (tuple 8 7)))
-(assert (member a87 x))
+(assert (set.member a87 x))
(declare-fun a88 () (Tuple Int Int))
(assert (= a88 (tuple 8 8)))
-(assert (member a88 x))
+(assert (set.member a88 x))
(declare-fun a89 () (Tuple Int Int))
(assert (= a89 (tuple 8 9)))
-(assert (member a89 x))
+(assert (set.member a89 x))
(declare-fun a810 () (Tuple Int Int))
(assert (= a810 (tuple 8 10)))
-(assert (member a810 x))
+(assert (set.member a810 x))
(declare-fun a91 () (Tuple Int Int))
(assert (= a91 (tuple 9 1)))
-(assert (member a91 x))
+(assert (set.member a91 x))
(declare-fun a92 () (Tuple Int Int))
(assert (= a92 (tuple 9 2)))
-(assert (member a92 x))
+(assert (set.member a92 x))
(declare-fun a93 () (Tuple Int Int))
(assert (= a93 (tuple 9 3)))
-(assert (member a93 x))
+(assert (set.member a93 x))
(declare-fun a94 () (Tuple Int Int))
(assert (= a94 (tuple 9 4)))
-(assert (member a94 x))
+(assert (set.member a94 x))
(declare-fun a95 () (Tuple Int Int))
(assert (= a95 (tuple 9 5)))
-(assert (member a95 x))
+(assert (set.member a95 x))
(declare-fun a96 () (Tuple Int Int))
(assert (= a96 (tuple 9 6)))
-(assert (member a96 x))
+(assert (set.member a96 x))
(declare-fun a97 () (Tuple Int Int))
(assert (= a97 (tuple 9 7)))
-(assert (member a97 x))
+(assert (set.member a97 x))
(declare-fun a98 () (Tuple Int Int))
(assert (= a98 (tuple 9 8)))
-(assert (member a98 x))
+(assert (set.member a98 x))
(declare-fun a99 () (Tuple Int Int))
(assert (= a99 (tuple 9 9)))
-(assert (member a99 x))
+(assert (set.member a99 x))
(declare-fun a910 () (Tuple Int Int))
(assert (= a910 (tuple 9 10)))
-(assert (member a910 x))
+(assert (set.member a910 x))
(declare-fun a101 () (Tuple Int Int))
(assert (= a101 (tuple 10 1)))
-(assert (member a101 x))
+(assert (set.member a101 x))
(declare-fun a102 () (Tuple Int Int))
(assert (= a102 (tuple 10 2)))
-(assert (member a102 x))
+(assert (set.member a102 x))
(declare-fun a103 () (Tuple Int Int))
(assert (= a103 (tuple 10 3)))
-(assert (member a103 x))
+(assert (set.member a103 x))
(declare-fun a104 () (Tuple Int Int))
(assert (= a104 (tuple 10 4)))
-(assert (member a104 x))
+(assert (set.member a104 x))
(declare-fun a105 () (Tuple Int Int))
(assert (= a105 (tuple 10 5)))
-(assert (member a105 x))
+(assert (set.member a105 x))
(declare-fun a106 () (Tuple Int Int))
(assert (= a106 (tuple 10 6)))
-(assert (member a106 x))
+(assert (set.member a106 x))
(declare-fun a107 () (Tuple Int Int))
(assert (= a107 (tuple 10 7)))
-(assert (member a107 x))
+(assert (set.member a107 x))
(declare-fun a108 () (Tuple Int Int))
(assert (= a108 (tuple 10 8)))
-(assert (member a108 x))
+(assert (set.member a108 x))
(declare-fun a109 () (Tuple Int Int))
(assert (= a109 (tuple 10 9)))
-(assert (member a109 x))
+(assert (set.member a109 x))
(declare-fun a1010 () (Tuple Int Int))
(assert (= a1010 (tuple 10 10)))
-(assert (member a1010 x))
+(assert (set.member a1010 x))
(declare-fun b11 () (Tuple Int Int))
(assert (= b11 (tuple 1 1)))
-(assert (member b11 y))
+(assert (set.member b11 y))
(declare-fun b12 () (Tuple Int Int))
(assert (= b12 (tuple 1 2)))
-(assert (member b12 y))
+(assert (set.member b12 y))
(declare-fun b13 () (Tuple Int Int))
(assert (= b13 (tuple 1 3)))
-(assert (member b13 y))
+(assert (set.member b13 y))
(declare-fun b14 () (Tuple Int Int))
(assert (= b14 (tuple 1 4)))
-(assert (member b14 y))
+(assert (set.member b14 y))
(declare-fun b15 () (Tuple Int Int))
(assert (= b15 (tuple 1 5)))
-(assert (member b15 y))
+(assert (set.member b15 y))
(declare-fun b16 () (Tuple Int Int))
(assert (= b16 (tuple 1 6)))
-(assert (member b16 y))
+(assert (set.member b16 y))
(declare-fun b17 () (Tuple Int Int))
(assert (= b17 (tuple 1 7)))
-(assert (member b17 y))
+(assert (set.member b17 y))
(declare-fun b18 () (Tuple Int Int))
(assert (= b18 (tuple 1 8)))
-(assert (member b18 y))
+(assert (set.member b18 y))
(declare-fun b19 () (Tuple Int Int))
(assert (= b19 (tuple 1 9)))
-(assert (member b19 y))
+(assert (set.member b19 y))
(declare-fun b110 () (Tuple Int Int))
(assert (= b110 (tuple 1 10)))
-(assert (member b110 y))
+(assert (set.member b110 y))
(declare-fun b21 () (Tuple Int Int))
(assert (= b21 (tuple 2 1)))
-(assert (member b21 y))
+(assert (set.member b21 y))
(declare-fun b22 () (Tuple Int Int))
(assert (= b22 (tuple 2 2)))
-(assert (member b22 y))
+(assert (set.member b22 y))
(declare-fun b23 () (Tuple Int Int))
(assert (= b23 (tuple 2 3)))
-(assert (member b23 y))
+(assert (set.member b23 y))
(declare-fun b24 () (Tuple Int Int))
(assert (= b24 (tuple 2 4)))
-(assert (member b24 y))
+(assert (set.member b24 y))
(declare-fun b25 () (Tuple Int Int))
(assert (= b25 (tuple 2 5)))
-(assert (member b25 y))
+(assert (set.member b25 y))
(declare-fun b26 () (Tuple Int Int))
(assert (= b26 (tuple 2 6)))
-(assert (member b26 y))
+(assert (set.member b26 y))
(declare-fun b27 () (Tuple Int Int))
(assert (= b27 (tuple 2 7)))
-(assert (member b27 y))
+(assert (set.member b27 y))
(declare-fun b28 () (Tuple Int Int))
(assert (= b28 (tuple 2 8)))
-(assert (member b28 y))
+(assert (set.member b28 y))
(declare-fun b29 () (Tuple Int Int))
(assert (= b29 (tuple 2 9)))
-(assert (member b29 y))
+(assert (set.member b29 y))
(declare-fun b210 () (Tuple Int Int))
(assert (= b210 (tuple 2 10)))
-(assert (member b210 y))
+(assert (set.member b210 y))
(declare-fun b31 () (Tuple Int Int))
(assert (= b31 (tuple 3 1)))
-(assert (member b31 y))
+(assert (set.member b31 y))
(declare-fun b32 () (Tuple Int Int))
(assert (= b32 (tuple 3 2)))
-(assert (member b32 y))
+(assert (set.member b32 y))
(declare-fun b33 () (Tuple Int Int))
(assert (= b33 (tuple 3 3)))
-(assert (member b33 y))
+(assert (set.member b33 y))
(declare-fun b34 () (Tuple Int Int))
(assert (= b34 (tuple 3 4)))
-(assert (member b34 y))
+(assert (set.member b34 y))
(declare-fun b35 () (Tuple Int Int))
(assert (= b35 (tuple 3 5)))
-(assert (member b35 y))
+(assert (set.member b35 y))
(declare-fun b36 () (Tuple Int Int))
(assert (= b36 (tuple 3 6)))
-(assert (member b36 y))
+(assert (set.member b36 y))
(declare-fun b37 () (Tuple Int Int))
(assert (= b37 (tuple 3 7)))
-(assert (member b37 y))
+(assert (set.member b37 y))
(declare-fun b38 () (Tuple Int Int))
(assert (= b38 (tuple 3 8)))
-(assert (member b38 y))
+(assert (set.member b38 y))
(declare-fun b39 () (Tuple Int Int))
(assert (= b39 (tuple 3 9)))
-(assert (member b39 y))
+(assert (set.member b39 y))
(declare-fun b310 () (Tuple Int Int))
(assert (= b310 (tuple 3 10)))
-(assert (member b310 y))
+(assert (set.member b310 y))
(declare-fun b41 () (Tuple Int Int))
(assert (= b41 (tuple 4 1)))
-(assert (member b41 y))
+(assert (set.member b41 y))
(declare-fun b42 () (Tuple Int Int))
(assert (= b42 (tuple 4 2)))
-(assert (member b42 y))
+(assert (set.member b42 y))
(declare-fun b43 () (Tuple Int Int))
(assert (= b43 (tuple 4 3)))
-(assert (member b43 y))
+(assert (set.member b43 y))
(declare-fun b44 () (Tuple Int Int))
(assert (= b44 (tuple 4 4)))
-(assert (member b44 y))
+(assert (set.member b44 y))
(declare-fun b45 () (Tuple Int Int))
(assert (= b45 (tuple 4 5)))
-(assert (member b45 y))
+(assert (set.member b45 y))
(declare-fun b46 () (Tuple Int Int))
(assert (= b46 (tuple 4 6)))
-(assert (member b46 y))
+(assert (set.member b46 y))
(declare-fun b47 () (Tuple Int Int))
(assert (= b47 (tuple 4 7)))
-(assert (member b47 y))
+(assert (set.member b47 y))
(declare-fun b48 () (Tuple Int Int))
(assert (= b48 (tuple 4 8)))
-(assert (member b48 y))
+(assert (set.member b48 y))
(declare-fun b49 () (Tuple Int Int))
(assert (= b49 (tuple 4 9)))
-(assert (member b49 y))
+(assert (set.member b49 y))
(declare-fun b410 () (Tuple Int Int))
(assert (= b410 (tuple 4 10)))
-(assert (member b410 y))
+(assert (set.member b410 y))
(declare-fun b51 () (Tuple Int Int))
(assert (= b51 (tuple 5 1)))
-(assert (member b51 y))
+(assert (set.member b51 y))
(declare-fun b52 () (Tuple Int Int))
(assert (= b52 (tuple 5 2)))
-(assert (member b52 y))
+(assert (set.member b52 y))
(declare-fun b53 () (Tuple Int Int))
(assert (= b53 (tuple 5 3)))
-(assert (member b53 y))
+(assert (set.member b53 y))
(declare-fun b54 () (Tuple Int Int))
(assert (= b54 (tuple 5 4)))
-(assert (member b54 y))
+(assert (set.member b54 y))
(declare-fun b55 () (Tuple Int Int))
(assert (= b55 (tuple 5 5)))
-(assert (member b55 y))
+(assert (set.member b55 y))
(declare-fun b56 () (Tuple Int Int))
(assert (= b56 (tuple 5 6)))
-(assert (member b56 y))
+(assert (set.member b56 y))
(declare-fun b57 () (Tuple Int Int))
(assert (= b57 (tuple 5 7)))
-(assert (member b57 y))
+(assert (set.member b57 y))
(declare-fun b58 () (Tuple Int Int))
(assert (= b58 (tuple 5 8)))
-(assert (member b58 y))
+(assert (set.member b58 y))
(declare-fun b59 () (Tuple Int Int))
(assert (= b59 (tuple 5 9)))
-(assert (member b59 y))
+(assert (set.member b59 y))
(declare-fun b510 () (Tuple Int Int))
(assert (= b510 (tuple 5 10)))
-(assert (member b510 y))
+(assert (set.member b510 y))
(declare-fun b61 () (Tuple Int Int))
(assert (= b61 (tuple 6 1)))
-(assert (member b61 y))
+(assert (set.member b61 y))
(declare-fun b62 () (Tuple Int Int))
(assert (= b62 (tuple 6 2)))
-(assert (member b62 y))
+(assert (set.member b62 y))
(declare-fun b63 () (Tuple Int Int))
(assert (= b63 (tuple 6 3)))
-(assert (member b63 y))
+(assert (set.member b63 y))
(declare-fun b64 () (Tuple Int Int))
(assert (= b64 (tuple 6 4)))
-(assert (member b64 y))
+(assert (set.member b64 y))
(declare-fun b65 () (Tuple Int Int))
(assert (= b65 (tuple 6 5)))
-(assert (member b65 y))
+(assert (set.member b65 y))
(declare-fun b66 () (Tuple Int Int))
(assert (= b66 (tuple 6 6)))
-(assert (member b66 y))
+(assert (set.member b66 y))
(declare-fun b67 () (Tuple Int Int))
(assert (= b67 (tuple 6 7)))
-(assert (member b67 y))
+(assert (set.member b67 y))
(declare-fun b68 () (Tuple Int Int))
(assert (= b68 (tuple 6 8)))
-(assert (member b68 y))
+(assert (set.member b68 y))
(declare-fun b69 () (Tuple Int Int))
(assert (= b69 (tuple 6 9)))
-(assert (member b69 y))
+(assert (set.member b69 y))
(declare-fun b610 () (Tuple Int Int))
(assert (= b610 (tuple 6 10)))
-(assert (member b610 y))
+(assert (set.member b610 y))
(declare-fun b71 () (Tuple Int Int))
(assert (= b71 (tuple 7 1)))
-(assert (member b71 y))
+(assert (set.member b71 y))
(declare-fun b72 () (Tuple Int Int))
(assert (= b72 (tuple 7 2)))
-(assert (member b72 y))
+(assert (set.member b72 y))
(declare-fun b73 () (Tuple Int Int))
(assert (= b73 (tuple 7 3)))
-(assert (member b73 y))
+(assert (set.member b73 y))
(declare-fun b74 () (Tuple Int Int))
(assert (= b74 (tuple 7 4)))
-(assert (member b74 y))
+(assert (set.member b74 y))
(declare-fun b75 () (Tuple Int Int))
(assert (= b75 (tuple 7 5)))
-(assert (member b75 y))
+(assert (set.member b75 y))
(declare-fun b76 () (Tuple Int Int))
(assert (= b76 (tuple 7 6)))
-(assert (member b76 y))
+(assert (set.member b76 y))
(declare-fun b77 () (Tuple Int Int))
(assert (= b77 (tuple 7 7)))
-(assert (member b77 y))
+(assert (set.member b77 y))
(declare-fun b78 () (Tuple Int Int))
(assert (= b78 (tuple 7 8)))
-(assert (member b78 y))
+(assert (set.member b78 y))
(declare-fun b79 () (Tuple Int Int))
(assert (= b79 (tuple 7 9)))
-(assert (member b79 y))
+(assert (set.member b79 y))
(declare-fun b710 () (Tuple Int Int))
(assert (= b710 (tuple 7 10)))
-(assert (member b710 y))
+(assert (set.member b710 y))
(declare-fun b81 () (Tuple Int Int))
(assert (= b81 (tuple 8 1)))
-(assert (member b81 y))
+(assert (set.member b81 y))
(declare-fun b82 () (Tuple Int Int))
(assert (= b82 (tuple 8 2)))
-(assert (member b82 y))
+(assert (set.member b82 y))
(declare-fun b83 () (Tuple Int Int))
(assert (= b83 (tuple 8 3)))
-(assert (member b83 y))
+(assert (set.member b83 y))
(declare-fun b84 () (Tuple Int Int))
(assert (= b84 (tuple 8 4)))
-(assert (member b84 y))
+(assert (set.member b84 y))
(declare-fun b85 () (Tuple Int Int))
(assert (= b85 (tuple 8 5)))
-(assert (member b85 y))
+(assert (set.member b85 y))
(declare-fun b86 () (Tuple Int Int))
(assert (= b86 (tuple 8 6)))
-(assert (member b86 y))
+(assert (set.member b86 y))
(declare-fun b87 () (Tuple Int Int))
(assert (= b87 (tuple 8 7)))
-(assert (member b87 y))
+(assert (set.member b87 y))
(declare-fun b88 () (Tuple Int Int))
(assert (= b88 (tuple 8 8)))
-(assert (member b88 y))
+(assert (set.member b88 y))
(declare-fun b89 () (Tuple Int Int))
(assert (= b89 (tuple 8 9)))
-(assert (member b89 y))
+(assert (set.member b89 y))
(declare-fun b810 () (Tuple Int Int))
(assert (= b810 (tuple 8 10)))
-(assert (member b810 y))
+(assert (set.member b810 y))
(declare-fun b91 () (Tuple Int Int))
(assert (= b91 (tuple 9 1)))
-(assert (member b91 y))
+(assert (set.member b91 y))
(declare-fun b92 () (Tuple Int Int))
(assert (= b92 (tuple 9 2)))
-(assert (member b92 y))
+(assert (set.member b92 y))
(declare-fun b93 () (Tuple Int Int))
(assert (= b93 (tuple 9 3)))
-(assert (member b93 y))
+(assert (set.member b93 y))
(declare-fun b94 () (Tuple Int Int))
(assert (= b94 (tuple 9 4)))
-(assert (member b94 y))
+(assert (set.member b94 y))
(declare-fun b95 () (Tuple Int Int))
(assert (= b95 (tuple 9 5)))
-(assert (member b95 y))
+(assert (set.member b95 y))
(declare-fun b96 () (Tuple Int Int))
(assert (= b96 (tuple 9 6)))
-(assert (member b96 y))
+(assert (set.member b96 y))
(declare-fun b97 () (Tuple Int Int))
(assert (= b97 (tuple 9 7)))
-(assert (member b97 y))
+(assert (set.member b97 y))
(declare-fun b98 () (Tuple Int Int))
(assert (= b98 (tuple 9 8)))
-(assert (member b98 y))
+(assert (set.member b98 y))
(declare-fun b99 () (Tuple Int Int))
(assert (= b99 (tuple 9 9)))
-(assert (member b99 y))
+(assert (set.member b99 y))
(declare-fun b910 () (Tuple Int Int))
(assert (= b910 (tuple 9 10)))
-(assert (member b910 y))
+(assert (set.member b910 y))
(declare-fun b101 () (Tuple Int Int))
(assert (= b101 (tuple 10 1)))
-(assert (member b101 y))
+(assert (set.member b101 y))
(declare-fun b102 () (Tuple Int Int))
(assert (= b102 (tuple 10 2)))
-(assert (member b102 y))
+(assert (set.member b102 y))
(declare-fun b103 () (Tuple Int Int))
(assert (= b103 (tuple 10 3)))
-(assert (member b103 y))
+(assert (set.member b103 y))
(declare-fun b104 () (Tuple Int Int))
(assert (= b104 (tuple 10 4)))
-(assert (member b104 y))
+(assert (set.member b104 y))
(declare-fun b105 () (Tuple Int Int))
(assert (= b105 (tuple 10 5)))
-(assert (member b105 y))
+(assert (set.member b105 y))
(declare-fun b106 () (Tuple Int Int))
(assert (= b106 (tuple 10 6)))
-(assert (member b106 y))
+(assert (set.member b106 y))
(declare-fun b107 () (Tuple Int Int))
(assert (= b107 (tuple 10 7)))
-(assert (member b107 y))
+(assert (set.member b107 y))
(declare-fun b108 () (Tuple Int Int))
(assert (= b108 (tuple 10 8)))
-(assert (member b108 y))
+(assert (set.member b108 y))
(declare-fun b109 () (Tuple Int Int))
(assert (= b109 (tuple 10 9)))
-(assert (member b109 y))
+(assert (set.member b109 y))
(declare-fun b1010 () (Tuple Int Int))
(assert (= b1010 (tuple 10 10)))
-(assert (member b1010 y))
-(assert (member (tuple 1 9) z))
+(assert (set.member b1010 y))
+(assert (set.member (tuple 1 9) z))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 9 1)))
-(assert (= r (join (join (transpose x) y) z)))
-(assert (not (member a (transpose r))))
+(assert (= r (rel.join (rel.join (rel.transpose x) y) z)))
+(assert (not (set.member a (rel.transpose r))))
(check-sat)
(declare-fun d () Int)
(assert (= a c))
(assert (= a d))
-(assert (member (tuple 1 c) x))
-(assert (member (tuple 2 d) x))
-(assert (member (tuple a 5) y))
-(assert (= y (tclosure x)))
-(assert (member (tuple 2 5) y))
+(assert (set.member (tuple 1 c) x))
+(assert (set.member (tuple 2 d) x))
+(assert (set.member (tuple a 5) y))
+(assert (= y (rel.tclosure x)))
+(assert (set.member (tuple 2 5) y))
(check-sat)
(declare-fun b () Int)
(declare-fun c () Int)
(declare-fun d () Int)
-(assert (member (tuple 1 a) x))
-(assert (member (tuple 1 c) x))
-(assert (member (tuple 1 d) x))
-(assert (member (tuple b 1) x))
+(assert (set.member (tuple 1 a) x))
+(assert (set.member (tuple 1 c) x))
+(assert (set.member (tuple 1 d) x))
+(assert (set.member (tuple b 1) x))
(assert (= b d))
-(assert (member (tuple 2 b) (join (join x x) x)))
-(assert (not (member (tuple 2 1) (tclosure x))))
+(assert (set.member (tuple 2 b) (rel.join (rel.join x x) x)))
+(assert (not (set.member (tuple 2 1) (rel.tclosure x))))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int)))
-(assert (= y (join (tclosure x) x)))
-(assert (not (= y (tclosure x))))
+(assert (= y (rel.join (rel.tclosure x) x)))
+(assert (not (= y (rel.tclosure x))))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun y () (Set (Tuple Int Int)))
-(assert (= y (tclosure x)))
-(assert (not (= y (join (join x x) x))))
+(assert (= y (rel.tclosure x)))
+(assert (not (= y (rel.join (rel.join x x) x))))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun y () (Set (Tuple Int Int)))
-(assert (= y (tclosure x)))
-(assert (not (subset (join (join x x) x) y)))
+(assert (= y (rel.tclosure x)))
+(assert (not (set.subset (rel.join (rel.join x x) x) y)))
(check-sat)
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int)))
(declare-fun w () (Set (Tuple Int Int)))
-(assert (= z (tclosure x)))
-(assert (= w (join x y)))
-(assert (member (tuple 2 2) z))
-(assert (member (tuple 0 3) y))
-(assert (member (tuple (- 1) 3) y))
-(assert (member (tuple 1 3) y))
-(assert (member (tuple (- 2) 3) y))
-(assert (member (tuple 2 3) y))
-(assert (member (tuple 3 3) y))
-(assert (member (tuple 4 3) y))
-(assert (member (tuple 5 3) y))
-(assert (not (member (tuple 2 3) (join x y))))
-(assert (not (member (tuple 2 1) x)))
+(assert (= z (rel.tclosure x)))
+(assert (= w (rel.join x y)))
+(assert (set.member (tuple 2 2) z))
+(assert (set.member (tuple 0 3) y))
+(assert (set.member (tuple (- 1) 3) y))
+(assert (set.member (tuple 1 3) y))
+(assert (set.member (tuple (- 2) 3) y))
+(assert (set.member (tuple 2 3) y))
+(assert (set.member (tuple 3 3) y))
+(assert (set.member (tuple 4 3) y))
+(assert (set.member (tuple 5 3) y))
+(assert (not (set.member (tuple 2 3) (rel.join x y))))
+(assert (not (set.member (tuple 2 1) x)))
(check-sat)
(declare-fun x () (Set (Tuple Int Int)))
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int)))
-(assert (or (= z (transpose y)) (= z (transpose x))))
-(assert (not (= (transpose z) y)))
-(assert (not (= (transpose z) x)))
+(assert (or (= z (rel.transpose y)) (= z (rel.transpose x))))
+(assert (not (= (rel.transpose z) y)))
+(assert (not (= (rel.transpose z) x)))
(check-sat)
(declare-fun y () (Set (Tuple Int Int)))
(declare-fun z () (Set (Tuple Int Int)))
(declare-fun r () (Set (Tuple Int Int)))
-(assert (member (tuple 7 1) x))
-(assert (member (tuple 2 3) x))
-(assert (member (tuple 7 3) y))
-(assert (member (tuple 4 7) y))
-(assert (member (tuple 3 4) z))
+(assert (set.member (tuple 7 1) x))
+(assert (set.member (tuple 2 3) x))
+(assert (set.member (tuple 7 3) y))
+(assert (set.member (tuple 4 7) y))
+(assert (set.member (tuple 3 4) z))
(declare-fun a () (Tuple Int Int))
(assert (= a (tuple 4 1)))
-(assert (= r (join (join (transpose x) y) z)))
-(assert (member a (transpose r)))
+(assert (= r (rel.join (rel.join (rel.transpose x) y) z)))
+(assert (set.member a (rel.transpose r)))
(check-sat)
(declare-fun a () (Tuple Int Int))
(declare-fun b () (Tuple Int Int))
(assert (not (= a b)))
-(assert (member a x))
-(assert (member b y))
-(assert (member b w))
-(assert (member (tuple x y) z))
-(assert (member (tuple w x) z))
-(assert (not (member (tuple x x) (join z z))))
-(assert (member (tuple x (singleton (tuple 0 0))) (join z z)))
+(assert (set.member a x))
+(assert (set.member b y))
+(assert (set.member b w))
+(assert (set.member (tuple x y) z))
+(assert (set.member (tuple w x) z))
+(assert (not (set.member (tuple x x) (rel.join z z))))
+(assert (set.member (tuple x (set.singleton (tuple 0 0))) (rel.join z z)))
(check-sat)
(declare-fun b () (Tuple Int Int))
(declare-fun c () (Tuple (Tuple Int Int) (Tuple Int Int)))
(assert (not (= a b)))
-(assert (member a z))
-(assert (member b z))
-(assert (member (tuple a b) x))
-(assert (member (tuple b a) x))
-(assert (member c x))
+(assert (set.member a z))
+(assert (set.member b z))
+(assert (set.member (tuple a b) x))
+(assert (set.member (tuple b a) x))
+(assert (set.member c x))
(assert (and (not (= c (tuple a b))) (not (= c (tuple b a)))))
(check-sat)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2)))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3v56 () Int)
(declare-fun z3v57 () Int)
(assert (distinct z3v56 z3v57))
(set-info :status sat)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2)))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3v58 () Int)
(declare-fun z3v59 () Int)
(assert (distinct z3v58 z3v59))
(set-info :status sat)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2)))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3v60 () Int)
(declare-fun z3v61 () Int)
(assert (distinct z3v60 z3v61))
(set-logic QF_ALL)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3v66 () Int)
(declare-fun z3v67 () Int)
(set-logic QF_ALL)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3f70 (Int) mySet)
(declare-fun z3f72 (Int) mySet)
(z3f70 z3v270))))
(assert (= z3v242 (z3f77 z3v271 z3v270)))
(assert (= z3v242 z3v243))
-(assert (subset (z3f70 z3v242)
+(assert (set.subset (z3f70 z3v242)
(z3f70 z3v244)))
(assert (= (z3f72 z3v243) smt_set_emp))
(assert (= (z3f72 z3v244)
(set-info :status unsat)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3v66 () Int)
(declare-fun z3v67 () Int)
(assert (distinct z3v66 z3v67))
(set-info :status unsat)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2)))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3v66 () Int)
(declare-fun z3v67 () Int)
(assert (distinct z3v66 z3v67))
(declare-fun x () (Set Bool))
(declare-fun y () (Set Bool))
(declare-fun z () (Set Bool))
-(assert (= x (singleton true)))
-(assert (= y (singleton false)))
+(assert (= x (set.singleton true)))
+(assert (= y (set.singleton false)))
(push 1)
-(assert (= z (complement y)))
+(assert (= z (set.complement y)))
(check-sat)
(declare-fun s () (Set E))
(declare-fun t () (Set E))
(declare-fun u () (Set E))
-(assert (>= (card (union s t)) 8))
-(assert (>= (card (union s u)) 8))
-(assert (<= (card (union t u)) 5))
-(assert (<= (card s) 5))
-(assert (= (as emptyset (Set E)) (intersection t u)))
+(assert (>= (set.card (set.union s t)) 8))
+(assert (>= (set.card (set.union s u)) 8))
+(assert (<= (set.card (set.union t u)) 5))
+(assert (<= (set.card s) 5))
+(assert (= (as set.empty (Set E)) (set.intersection t u)))
(check-sat)
(declare-fun s () (Set E))
(declare-fun t () (Set E))
(declare-fun u () (Set E))
-(assert (>= (card (union s t)) 8))
-(assert (>= (card (union s u)) 8))
-;(assert (<= (card (union t u)) 5))
-(assert (<= (card s) 5))
-(assert (= (as emptyset (Set E)) (intersection t u)))
+(assert (>= (set.card (set.union s t)) 8))
+(assert (>= (set.card (set.union s u)) 8))
+;(assert (<= (set.card (set.union t u)) 5))
+(assert (<= (set.card s) 5))
+(assert (= (as set.empty (Set E)) (set.intersection t u)))
(declare-fun x1 () E)
(declare-fun x2 () E)
(declare-fun x3 () E)
(declare-fun x4 () E)
(declare-fun x5 () E)
(declare-fun x6 () E)
-(assert (member x1 s))
-(assert (member x2 s))
-(assert (member x3 s))
-(assert (member x4 s))
-(assert (member x5 s))
-(assert (member x6 s))
+(assert (set.member x1 s))
+(assert (set.member x2 s))
+(assert (set.member x3 s))
+(assert (set.member x4 s))
+(assert (set.member x5 s))
+(assert (set.member x6 s))
(check-sat)
(declare-fun s () (Set E))
(declare-fun t () (Set E))
(declare-fun u () (Set E))
-(assert (>= (card (union s t)) 8))
-(assert (>= (card (union s u)) 8))
-;(assert (<= (card (union t u)) 5))
-(assert (<= (card s) 5))
-(assert (= (as emptyset (Set E)) (intersection t u)))
+(assert (>= (set.card (set.union s t)) 8))
+(assert (>= (set.card (set.union s u)) 8))
+;(assert (<= (set.card (set.union t u)) 5))
+(assert (<= (set.card s) 5))
+(assert (= (as set.empty (Set E)) (set.intersection t u)))
(declare-fun x1 () E)
(declare-fun x2 () E)
(declare-fun x3 () E)
(declare-fun x4 () E)
(declare-fun x5 () E)
(declare-fun x6 () E)
-(assert (member x1 s))
-(assert (member x2 s))
-(assert (member x3 s))
-(assert (member x4 s))
-(assert (member x5 s))
-(assert (member x6 s))
+(assert (set.member x1 s))
+(assert (set.member x2 s))
+(assert (set.member x3 s))
+(assert (set.member x4 s))
+(assert (set.member x5 s))
+(assert (set.member x6 s))
(assert (distinct x1 x2 x3 x4 x5 x6))
(check-sat)
(declare-fun C () (Set E))
(assert
(and
- (= (as emptyset (Set E))
- (intersection A B))
- (subset C (union A B))
- (>= (card C) 5)
- (<= (card A) 2)
- (<= (card B) 2)
+ (= (as set.empty (Set E))
+ (set.intersection A B))
+ (set.subset C (set.union A B))
+ (>= (set.card C) 5)
+ (<= (set.card A) 2)
+ (<= (set.card B) 2)
)
)
(check-sat)
(declare-fun A19 () (Set E))
(declare-fun A20 () (Set E))
(assert (and
- (= (card A1) 1)
- (= (card A2) 1)
- (= (card A3) 1)
- (= (card A4) 1)
- (= (card A5) 1)
- (= (card A6) 1)
- (= (card A7) 1)
- (= (card A8) 1)
- (= (card A9) 1)
- (= (card A10) 1)
- (= (card A11) 1)
- (= (card A12) 1)
- (= (card A13) 1)
- (= (card A14) 1)
- (= (card A15) 1)
- (= (card A16) 1)
- (= (card A17) 1)
- (= (card A18) 1)
- (= (card A19) 1)
- (= (card A20) 1)
+ (= (set.card A1) 1)
+ (= (set.card A2) 1)
+ (= (set.card A3) 1)
+ (= (set.card A4) 1)
+ (= (set.card A5) 1)
+ (= (set.card A6) 1)
+ (= (set.card A7) 1)
+ (= (set.card A8) 1)
+ (= (set.card A9) 1)
+ (= (set.card A10) 1)
+ (= (set.card A11) 1)
+ (= (set.card A12) 1)
+ (= (set.card A13) 1)
+ (= (set.card A14) 1)
+ (= (set.card A15) 1)
+ (= (set.card A16) 1)
+ (= (set.card A17) 1)
+ (= (set.card A18) 1)
+ (= (set.card A19) 1)
+ (= (set.card A20) 1)
))
-(assert (= 20 (+ (card A1) (card A2) (card A3) (card A4) (card A5) (card A6) (card A7) (card A8) (card A9) (card A10) (card A11) (card A12) (card A13) (card A14) (card A15) (card A16) (card A17) (card A18) (card A19) (card A20))))
+(assert (= 20 (+ (set.card A1) (set.card A2) (set.card A3) (set.card A4) (set.card A5) (set.card A6) (set.card A7) (set.card A8) (set.card A9) (set.card A10) (set.card A11) (set.card A12) (set.card A13) (set.card A14) (set.card A15) (set.card A16) (set.card A17) (set.card A18) (set.card A19) (set.card A20))))
(check-sat)
(declare-fun alloc1 () (Set Int))
(declare-fun alloc2 () (Set Int))
(assert
-(and (member x c)
- (<= (card (setminus alloc1 alloc0)) 1)
- (<= (card (setminus alloc2 alloc1))
- (card (setminus c (singleton x))))
- (> (card (setminus alloc2 alloc0)) (card c))
+(and (set.member x c)
+ (<= (set.card (set.minus alloc1 alloc0)) 1)
+ (<= (set.card (set.minus alloc2 alloc1))
+ (set.card (set.minus c (set.singleton x))))
+ (> (set.card (set.minus alloc2 alloc0)) (set.card c))
))
(check-sat)
(set-option :incremental false)
(declare-fun A () (Set Int))
(declare-fun a () Int)
-(assert (not (= A (as emptyset (Set Int)))))
-(assert (= (choose A) 10))
-(assert (= (choose A) a))
+(assert (not (= A (as set.empty (Set Int)))))
+(assert (= (set.choose A) 10))
+(assert (= (set.choose A) a))
(check-sat)
(set-option :produce-models true)
(declare-fun A () (Set Int))
(declare-fun a () Int)
-(assert (not (= A (as emptyset (Set Int)))))
-(assert (= (choose A) 10))
-(assert (= a (choose A)))
-(assert (exists ((x Int)) (and (= x (choose A)) (= x a))))
+(assert (not (= A (as set.empty (Set Int)))))
+(assert (= (set.choose A) 10))
+(assert (= a (set.choose A)))
+(assert (exists ((x Int)) (and (= x (set.choose A)) (= x a))))
(check-sat)
(set-info :status unsat)
(set-option :produce-models true)
(declare-fun A () (Set Int))
-(assert (distinct (choose A) (choose A)))
+(assert (distinct (set.choose A) (set.choose A)))
(check-sat)
\ No newline at end of file
(set-info :status sat)
(set-option :produce-models true)
(declare-fun A () (Set Int))
-(assert (= (choose A) 10))
-(assert (= A (as emptyset (Set Int))))
+(assert (= (set.choose A) 10))
+(assert (= A (as set.empty (Set Int))))
(check-sat)
(set-option :produce-models true)
(declare-fun A () (Set Int))
(declare-fun a () Int)
-(assert (not (= A (as emptyset (Set Int)))))
-(assert (member 10 A))
-(assert (= a (choose A)))
-;(assert (exists ((x Int)) (and (= x (choose A)) (= x a))))
+(assert (not (= A (as set.empty (Set Int)))))
+(assert (set.member 10 A))
+(assert (= a (set.choose A)))
+;(assert (exists ((x Int)) (and (= x (set.choose A)) (= x a))))
(check-sat)
(declare-fun x () (Set Int))
(declare-fun y () (Set Int))
-(assert (= x (comprehension ((z Int)) (> z 4) (* 5 z))))
-(assert (= y (comprehension ((z Int)) (< z 10) (+ (* 5 z) 1))))
+(assert (= x (set.comprehension ((z Int)) (> z 4) (* 5 z))))
+(assert (= y (set.comprehension ((z Int)) (< z 10) (+ (* 5 z) 1))))
-(assert (not (= (intersection x y) (as emptyset (Set Int)))))
+(assert (not (= (set.intersection x y) (as set.empty (Set Int)))))
(check-sat)
(declare-fun x () (Set Int))
-(assert (subset x (comprehension ((z Int)) true (* 2 z))))
+(assert (set.subset x (set.comprehension ((z Int)) true (* 2 z))))
(declare-fun a () Int)
(declare-fun b () Int)
(assert (= a (+ (* 8 b) 1)))
-(assert (member a x))
+(assert (set.member a x))
(check-sat)
(declare-fun x () (Set Int))
-(assert (subset (comprehension ((z Int)) (>= z 0) (* 3 z)) x))
+(assert (set.subset (set.comprehension ((z Int)) (>= z 0) (* 3 z)) x))
(declare-fun a () Int)
(declare-fun b () Int)
(declare-fun c () Int)
-(assert (not (member a x)))
-(assert (not (member b x)))
-(assert (not (member c x)))
+(assert (not (set.member a x)))
+(assert (not (set.member b x)))
+(assert (not (set.member c x)))
(assert (<= 0 a))
(assert (<= a b))
(assert (<= b c))
(declare-fun x () (Set Int))
-(assert (subset x (comprehension ((z Int)) (> z 0) z)))
+(assert (set.subset x (set.comprehension ((z Int)) (> z 0) z)))
-(assert (member 0 x))
+(assert (set.member 0 x))
(check-sat)
(assert (! (forall ((l1 Loc) (l2 Loc))
(or (not Axiom_1$0)
(or (<= (read$0 data$0 l1) (read$0 data$0 l2))
- (not (Btwn$0 next$0 l1 l2 null$0)) (not (member l1 sk_?X_4$0))
- (not (member l2 sk_?X_4$0)))))
+ (not (Btwn$0 next$0 l1 l2 null$0)) (not (set.member l1 sk_?X_4$0))
+ (not (set.member l2 sk_?X_4$0)))))
:named sortedness_3))
(assert (! (= (read$1 next$0 null$0) null$0) :named read_null_1))
-(assert (! (not (member tmp_2$0 Alloc$0)) :named new_31_11))
+(assert (! (not (set.member tmp_2$0 Alloc$0)) :named new_31_11))
-(assert (! (not (member null$0 Alloc$0)) :named initial_footprint_of_copy_23_11_2))
+(assert (! (not (set.member null$0 Alloc$0)) :named initial_footprint_of_copy_23_11_2))
(assert (! (not (= lst$0 null$0)) :named if_else_26_6))
-(assert (! (= FP_Caller$0 (union FP$0 FP_Caller$0))
+(assert (! (= FP_Caller$0 (set.union FP$0 FP_Caller$0))
:named precondition_of_copy_23_11_4))
(assert (! (= sk_?X_4$0 FP$0) :named precondition_of_copy_23_11_5))
(assert (! (= cp_2$0 res_1$0) :named assign_32_4))
-(assert (! (= FP_1$0 (union FP$0 (singleton tmp_2$0))) :named assign_31_11))
+(assert (! (= FP_1$0 (set.union FP$0 (set.singleton tmp_2$0))) :named assign_31_11))
(assert (! (or (and (Btwn$0 next$0 lst$0 null$0 null$0) Axiom_1$0)
(not (slseg_struct$0 sk_?X_4$0 data$0 next$0 lst$0 null$0)))
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 lst$0 l1 null$0)
- (member l1 (slseg_domain$0 data$0 next$0 lst$0 null$0))
+ (set.member l1 (slseg_domain$0 data$0 next$0 lst$0 null$0))
(not (= l1 null$0)))
(and (or (= l1 null$0) (not (Btwn$0 next$0 lst$0 l1 null$0)))
- (not (member l1 (slseg_domain$0 data$0 next$0 lst$0 null$0))))))
+ (not (set.member l1 (slseg_domain$0 data$0 next$0 lst$0 null$0))))))
:named slseg_footprint_2))
-(assert (! (not (member curr_2$0 FP_1$0)) :named check_heap_access_33_4))
+(assert (! (not (set.member curr_2$0 FP_1$0)) :named check_heap_access_33_4))
(assert (! (not (= tmp_2$0 null$0)) :named new_31_11_1))
(assert (! (= sk_?X_4$0 (slseg_domain$0 data$0 next$0 lst$0 null$0))
:named precondition_of_copy_23_11_7))
-(assert (! (= Alloc$0 (union FP_Caller$0 Alloc$0))
+(assert (! (= Alloc$0 (set.union FP_Caller$0 Alloc$0))
:named initial_footprint_of_copy_23_11_3))
(assert (! (= curr_2$0 lst$0) :named assign_30_4))
-(assert (! (= FP_Caller_1$0 (setminus FP_Caller$0 FP$0)) :named assign_26_2_1))
+(assert (! (= FP_Caller_1$0 (set.minus FP_Caller$0 FP$0)) :named assign_26_2_1))
-(assert (! (= Alloc_1$0 (union Alloc$0 (singleton tmp_2$0))) :named assign_31_11_1))
+(assert (! (= Alloc_1$0 (set.union Alloc$0 (set.singleton tmp_2$0))) :named assign_31_11_1))
(assert (! (forall ((?x Loc)) (Btwn$0 next$0 ?x ?x ?x)) :named btwn_refl_1))
(set-info :status sat)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2)))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3v58 () Int)
(declare-fun z3v59 () Int)
(assert (distinct z3v58 z3v59))
(set-option :fmf-fun true)
(declare-sort a 0)
(declare-const b (Set a))
-(assert (= (card b) 0))
+(assert (= (set.card b) 0))
(check-sat)
(declare-datatype Color ((Red) (Green) (Blue)))
(declare-fun A () (Set (Array Color Color)))
(declare-fun B () (Set (Array Color Color)))
-(assert (> (card A) 25))
-(assert (> (card B) 25))
+(assert (> (set.card A) 25))
+(assert (> (set.card B) 25))
(assert (distinct A B))
(check-sat)
(declare-fun S () (Set (Array Int Unit)))
-(assert (> (card S) 1))
+(assert (> (set.card S) 1))
(check-sat)
(declare-fun A () (Set Bool))
(declare-fun B () (Set Bool))
(declare-fun universe () (Set Bool))
-(assert (= (card A) 2))
-(assert (= (card B) 2))
-(assert (= (intersection A B) (as emptyset (Set Bool))))
-(assert (= universe (as univset (Set Bool))))
+(assert (= (set.card A) 2))
+(assert (= (set.card B) 2))
+(assert (= (set.intersection A B) (as set.empty (Set Bool))))
+(assert (= universe (as set.universe (Set Bool))))
(check-sat)
(set-option :sets-ext true)
(declare-fun A () (Set Bool))
(declare-fun universe () (Set Bool))
-(assert (= (card A) 2))
-(assert (= universe (as univset (Set Bool))))
+(assert (= (set.card A) 2))
+(assert (= universe (as set.universe (Set Bool))))
(check-sat)
(declare-fun A () (Set Bool))
(declare-fun B () (Set Bool))
(declare-fun universe () (Set Bool))
-(assert (= (card A) 2))
-(assert (= (card B) 2))
-(assert (= universe (as univset (Set Bool))))
+(assert (= (set.card A) 2))
+(assert (= (set.card B) 2))
+(assert (= universe (as set.universe (Set Bool))))
(check-sat)
(set-option :produce-models true)
(declare-fun A () (Set Bool))
(declare-fun x () Bool)
-(assert (member (member x A) A))
-(assert (> (card A) 1))
+(assert (set.member (set.member x A) A))
+(assert (> (set.card A) 1))
(check-sat)
(set-option :sets-ext true)
(declare-fun A () (Set Bool))
(declare-fun x () Bool)
-(assert (member (member x A) A))
-(assert (> (card A) 1))
+(assert (set.member (set.member x A) A))
+(assert (> (set.card A) 1))
(declare-fun U () (Set Bool))
-(assert (= U (as univset (Set Bool))))
+(assert (= U (as set.universe (Set Bool))))
(check-sat)
(set-option :sets-ext true)
(declare-fun A () (Set (_ BitVec 3)))
(declare-fun universe () (Set (_ BitVec 3)))
-(assert (= (card A) 3))
-(assert (= universe (as univset (Set (_ BitVec 3)))))
+(assert (= (set.card A) 3))
+(assert (= universe (as set.universe (Set (_ BitVec 3)))))
(check-sat)
(declare-fun A () (Set (_ BitVec 3)))
(declare-fun B () (Set (_ BitVec 3)))
(declare-fun universe () (Set (_ BitVec 3)))
-(assert (= (card A) 5))
-(assert (= (card B) 5))
+(assert (= (set.card A) 5))
+(assert (= (set.card B) 5))
(assert (not (= A B)))
-(assert (= (card (intersection A B)) 2))
-(assert (= (card (setminus A B)) 3))
-(assert (= (card (setminus B A)) 3))
-(assert (= universe (as univset (Set (_ BitVec 3)))))
+(assert (= (set.card (set.intersection A B)) 2))
+(assert (= (set.card (set.minus A B)) 3))
+(assert (= (set.card (set.minus B A)) 3))
+(assert (= universe (as set.universe (Set (_ BitVec 3)))))
(check-sat)
(declare-fun B () (Set (_ BitVec 3)))
(declare-fun universe () (Set (_ BitVec 3)))
(declare-fun x () (_ BitVec 3))
-(assert (= (card A) 3))
-(assert (= (card B) 3))
+(assert (= (set.card A) 3))
+(assert (= (set.card B) 3))
(assert (not (= A B)))
-(assert (= (card (intersection A B)) 1))
-(assert (= (card (setminus A B)) 2))
-(assert (= (card (setminus B A)) 2))
-(assert (not (member x A)))
-(assert (not (member x B)))
-(assert (= universe (as univset (Set (_ BitVec 3)))))
+(assert (= (set.card (set.intersection A B)) 1))
+(assert (= (set.card (set.minus A B)) 2))
+(assert (= (set.card (set.minus B A)) 2))
+(assert (not (set.member x A)))
+(assert (not (set.member x B)))
+(assert (= universe (as set.universe (Set (_ BitVec 3)))))
(check-sat)
(declare-fun B () (Set (_ BitVec 3)))
(declare-fun universe () (Set (_ BitVec 3)))
(declare-fun x () (_ BitVec 3))
-(assert (= (card A) 5))
-(assert (= (card B) 5))
+(assert (= (set.card A) 5))
+(assert (= (set.card B) 5))
(assert (not (= A B)))
-(assert (= (card (intersection A B)) 2))
-(assert (= (card (setminus A B)) 3))
-(assert (= (card (setminus B A)) 3))
-(assert (= universe (as univset (Set (_ BitVec 3)))))
-(assert (not (member x A)))
-(assert (not (member x B)))
+(assert (= (set.card (set.intersection A B)) 2))
+(assert (= (set.card (set.minus A B)) 3))
+(assert (= (set.card (set.minus B A)) 3))
+(assert (= universe (as set.universe (Set (_ BitVec 3)))))
+(assert (not (set.member x A)))
+(assert (not (set.member x B)))
(check-sat)
(declare-datatype Color ((Red) (Green) (Blue) (Purple)))
(declare-fun A () (Set Color))
(declare-fun B () (Set Color))
-(assert (> (card A) (card B) ))
-(assert (member Red B))
+(assert (> (set.card A) (set.card B) ))
+(assert (set.member Red B))
(declare-fun d () Color)
(assert (not (= d Red)))
-(assert (member d B))
-(assert (not (member Green A)))
+(assert (set.member d B))
+(assert (not (set.member Green A)))
(check-sat)
(declare-datatype Color ((Red) (Green) (Blue)))
(declare-fun A () (Set Color))
(declare-fun B () (Set Color))
-(assert (> (card A) (card B) ))
-(assert (member Red B))
+(assert (> (set.card A) (set.card B) ))
+(assert (set.member Red B))
(declare-fun d () Color)
(assert (not (= d Red)))
-(assert (member d B))
-(assert (not (member Green A)))
+(assert (set.member d B))
+(assert (not (set.member Green A)))
(check-sat)
(declare-fun B () (Set Rec))
(declare-fun universe () (Set Rec))
(declare-fun x () Rec)
-(assert (= (card A) 5))
-(assert (= (card B) 5))
-(assert (= (card (intersection A B)) 1))
-(assert (= universe (as univset (Set Rec))))
+(assert (= (set.card A) 5))
+(assert (= (set.card B) 5))
+(assert (= (set.card (set.intersection A B)) 1))
+(assert (= universe (as set.universe (Set Rec))))
(check-sat)
(declare-fun A () (Set Rec))
(declare-fun B () (Set Rec))
(declare-fun universe () (Set Rec))
-(assert (= (card A) 9))
-(assert (= (card B) 9))
-(assert (= (card (intersection A B)) 1))
-(assert (= universe (as univset (Set Rec))))
+(assert (= (set.card A) 9))
+(assert (= (set.card B) 9))
+(assert (= (set.card (set.intersection A B)) 1))
+(assert (= universe (as set.universe (Set Rec))))
(check-sat)
(declare-fun D () (Set (_ BitVec 2)))
(declare-fun x () (_ BitVec 2))
-(assert (not (member x A)))
-(assert (not (member x B)))
-(assert (not (member x C)))
-(assert (not (member x D)))
+(assert (not (set.member x A)))
+(assert (not (set.member x B)))
+(assert (not (set.member x C)))
+(assert (not (set.member x D)))
(declare-fun y () (_ BitVec 2))
-(assert (not (member y A)))
-(assert (not (member y B)))
-(assert (not (member y C)))
-(assert (not (member y D)))
+(assert (not (set.member y A)))
+(assert (not (set.member y B)))
+(assert (not (set.member y C)))
+(assert (not (set.member y D)))
(declare-fun z () (_ BitVec 2))
-(assert (not (member z A)))
-(assert (not (member z B)))
-(assert (not (member z C)))
-(assert (not (member z D)))
+(assert (not (set.member z A)))
+(assert (not (set.member z B)))
+(assert (not (set.member z C)))
+(assert (not (set.member z D)))
(assert (distinct x y z))
-(assert (= (card (union A (union B (union C D)))) 2))
+(assert (= (set.card (set.union A (set.union B (set.union C D)))) 2))
(check-sat)
(declare-fun D () (Set (_ BitVec 3)))
(declare-fun x () (_ BitVec 3))
-(assert (not (member x A)))
-(assert (not (member x B)))
-(assert (not (member x C)))
-(assert (not (member x D)))
+(assert (not (set.member x A)))
+(assert (not (set.member x B)))
+(assert (not (set.member x C)))
+(assert (not (set.member x D)))
(declare-fun y () (_ BitVec 3))
-(assert (not (member y A)))
-(assert (not (member y B)))
-(assert (not (member y C)))
-(assert (not (member y D)))
+(assert (not (set.member y A)))
+(assert (not (set.member y B)))
+(assert (not (set.member y C)))
+(assert (not (set.member y D)))
(declare-fun z () (_ BitVec 3))
-(assert (not (member z A)))
-(assert (not (member z B)))
-(assert (not (member z C)))
-(assert (not (member z D)))
+(assert (not (set.member z A)))
+(assert (not (set.member z B)))
+(assert (not (set.member z C)))
+(assert (not (set.member z D)))
(assert (distinct x y z))
-(assert (= (card (union A (union B (union C D)))) 6))
+(assert (= (set.card (set.union A (set.union B (set.union C D)))) 6))
(check-sat)
(let ((e10 (f0 v0)))
(let ((e11 (* (- e5) e10)))
(let ((e12 (ite (p0 e7 e6) 1 0)))
-(let ((e13 (union v3 v4)))
-(let ((e14 (setminus v2 v2)))
+(let ((e13 (set.union v3 v4)))
+(let ((e14 (set.minus v2 v2)))
(let ((e15 (f1 v1 v4 v1)))
(let ((e16 (f1 e14 v1 v4)))
-(let ((e17 (intersection e16 e15)))
+(let ((e17 (set.intersection e16 e15)))
(let ((e18 (f1 v4 e15 v2)))
-(let ((e19 (ite (p1 e13) (singleton 1) (singleton 0))))
-(let ((e20 (member v0 e17)))
-(let ((e21 (member e7 e16)))
-(let ((e22 (member e10 e16)))
-(let ((e23 (member e8 e17)))
-(let ((e24 (member e9 e14)))
-(let ((e25 (member e8 e16)))
-(let ((e26 (member v0 e13)))
-(let ((e27 (member e12 v4)))
-(let ((e28 (member e8 e14)))
-(let ((e29 (member e8 v1)))
-(let ((e30 (member e10 e13)))
-(let ((e31 (member e7 e13)))
+(let ((e19 (ite (p1 e13) (set.singleton 1) (set.singleton 0))))
+(let ((e20 (set.member v0 e17)))
+(let ((e21 (set.member e7 e16)))
+(let ((e22 (set.member e10 e16)))
+(let ((e23 (set.member e8 e17)))
+(let ((e24 (set.member e9 e14)))
+(let ((e25 (set.member e8 e16)))
+(let ((e26 (set.member v0 e13)))
+(let ((e27 (set.member e12 v4)))
+(let ((e28 (set.member e8 e14)))
+(let ((e29 (set.member e8 v1)))
+(let ((e30 (set.member e10 e13)))
+(let ((e31 (set.member e7 e13)))
(let ((e32 (f1 e13 e13 e13)))
(let ((e33 (f1 e18 v4 e17)))
(let ((e34 (f1 v2 v2 e15)))
; symptom: unsat instead of sat
-; issue/fix: buggy rewriter for setminus
+; issue/fix: buggy rewriter for set.minus
(set-info :source |fuzzsmt|)
(set-info :smt-lib-version 2.6)
(set-info :category "random")
(let ((e13 (* e7 (- e3))))
(let ((e14 (f0 e7)))
(let ((e15 (ite (p0 e9) 1 0)))
-(let ((e16 (setminus v2 v1)))
-(let ((e17 (setminus v1 v2)))
-(let ((e18 (union e17 e17)))
-(let ((e19 (intersection e17 v1)))
-(let ((e20 (intersection e17 e18)))
-(let ((e21 (intersection v1 e16)))
-(let ((e22 (setminus e20 e16)))
-(let ((e23 (ite (p1 v2 e18 e21) (singleton 1) (singleton 0))))
-(let ((e24 (setminus e17 e23)))
-(let ((e25 (union v2 e22)))
-(let ((e26 (union e24 e18)))
-(let ((e27 (ite (p1 e20 e19 e25) (singleton 1) (singleton 0))))
+(let ((e16 (set.minus v2 v1)))
+(let ((e17 (set.minus v1 v2)))
+(let ((e18 (set.union e17 e17)))
+(let ((e19 (set.intersection e17 v1)))
+(let ((e20 (set.intersection e17 e18)))
+(let ((e21 (set.intersection v1 e16)))
+(let ((e22 (set.minus e20 e16)))
+(let ((e23 (ite (p1 v2 e18 e21) (set.singleton 1) (set.singleton 0))))
+(let ((e24 (set.minus e17 e23)))
+(let ((e25 (set.union v2 e22)))
+(let ((e26 (set.union e24 e18)))
+(let ((e27 (ite (p1 e20 e19 e25) (set.singleton 1) (set.singleton 0))))
(let ((e28 (f1 e20)))
-(let ((e29 (member e14 e17)))
-(let ((e30 (member e13 e23)))
-(let ((e31 (member e11 e25)))
-(let ((e32 (member e6 v1)))
-(let ((e33 (member e9 v1)))
-(let ((e34 (member v0 e28)))
-(let ((e35 (member e9 e16)))
-(let ((e36 (member e4 e17)))
-(let ((e37 (member e9 e18)))
-(let ((e38 (member e14 e25)))
-(let ((e39 (member e14 v2)))
-(let ((e40 (member v0 v1)))
-(let ((e41 (member e4 e16)))
-(let ((e42 (member e15 e21)))
-(let ((e43 (member e7 e22)))
-(let ((e44 (member e11 v2)))
-(let ((e45 (member e14 e22)))
-(let ((e46 (member e11 e16)))
-(let ((e47 (member e15 e22)))
-(let ((e48 (member e10 e23)))
-(let ((e49 (member e4 e21)))
-(let ((e50 (member e5 e28)))
-(let ((e51 (member e6 e28)))
-(let ((e52 (member v0 e22)))
-(let ((e53 (member e14 e20)))
+(let ((e29 (set.member e14 e17)))
+(let ((e30 (set.member e13 e23)))
+(let ((e31 (set.member e11 e25)))
+(let ((e32 (set.member e6 v1)))
+(let ((e33 (set.member e9 v1)))
+(let ((e34 (set.member v0 e28)))
+(let ((e35 (set.member e9 e16)))
+(let ((e36 (set.member e4 e17)))
+(let ((e37 (set.member e9 e18)))
+(let ((e38 (set.member e14 e25)))
+(let ((e39 (set.member e14 v2)))
+(let ((e40 (set.member v0 v1)))
+(let ((e41 (set.member e4 e16)))
+(let ((e42 (set.member e15 e21)))
+(let ((e43 (set.member e7 e22)))
+(let ((e44 (set.member e11 v2)))
+(let ((e45 (set.member e14 e22)))
+(let ((e46 (set.member e11 e16)))
+(let ((e47 (set.member e15 e22)))
+(let ((e48 (set.member e10 e23)))
+(let ((e49 (set.member e4 e21)))
+(let ((e50 (set.member e5 e28)))
+(let ((e51 (set.member e6 e28)))
+(let ((e52 (set.member v0 e22)))
+(let ((e53 (set.member e14 e20)))
(let ((e54 (f1 e21)))
(let ((e55 (f1 e28)))
(let ((e56 (f1 e27)))
(let ((e8 (* e6 (- e5))))
(let ((e9 (ite (p0 e7 v0 e6) 1 0)))
(let ((e10 (f0 v0 e8 e8)))
-(let ((e11 (ite (p1 v1) (singleton 1) (singleton 0))))
-(let ((e12 (union v3 v3)))
-(let ((e13 (intersection v3 v1)))
-(let ((e14 (ite (p1 v3) (singleton 1) (singleton 0))))
-(let ((e15 (intersection v2 e14)))
-(let ((e16 (ite (p1 e11) (singleton 1) (singleton 0))))
-(let ((e17 (ite (p1 v4) (singleton 1) (singleton 0))))
-(let ((e18 (union e15 v2)))
-(let ((e19 (ite (p1 e16) (singleton 1) (singleton 0))))
-(let ((e20 (intersection e18 v3)))
-(let ((e21 (setminus v4 e12)))
-(let ((e22 (union v3 v2)))
-(let ((e23 (setminus e12 v4)))
-(let ((e24 (setminus v3 e16)))
-(let ((e25 (intersection e19 e20)))
-(let ((e26 (ite (p1 e15) (singleton 1) (singleton 0))))
-(let ((e27 (setminus e17 e15)))
+(let ((e11 (ite (p1 v1) (set.singleton 1) (set.singleton 0))))
+(let ((e12 (set.union v3 v3)))
+(let ((e13 (set.intersection v3 v1)))
+(let ((e14 (ite (p1 v3) (set.singleton 1) (set.singleton 0))))
+(let ((e15 (set.intersection v2 e14)))
+(let ((e16 (ite (p1 e11) (set.singleton 1) (set.singleton 0))))
+(let ((e17 (ite (p1 v4) (set.singleton 1) (set.singleton 0))))
+(let ((e18 (set.union e15 v2)))
+(let ((e19 (ite (p1 e16) (set.singleton 1) (set.singleton 0))))
+(let ((e20 (set.intersection e18 v3)))
+(let ((e21 (set.minus v4 e12)))
+(let ((e22 (set.union v3 v2)))
+(let ((e23 (set.minus e12 v4)))
+(let ((e24 (set.minus v3 e16)))
+(let ((e25 (set.intersection e19 e20)))
+(let ((e26 (ite (p1 e15) (set.singleton 1) (set.singleton 0))))
+(let ((e27 (set.minus e17 e15)))
(let ((e28 (f1 e23 e12)))
-(let ((e29 (member e10 e16)))
-(let ((e30 (member e10 v1)))
-(let ((e31 (member e7 e19)))
+(let ((e29 (set.member e10 e16)))
+(let ((e30 (set.member e10 v1)))
+(let ((e31 (set.member e7 e19)))
(let ((e32 (f1 e12 e12)))
(let ((e33 (f1 e16 e25)))
(let ((e34 (f1 v1 e27)))
(declare-const universe (Set (Array Int Int)))
(declare-const A (Set (Array Int Int)))
(declare-const B (Set (Array Int Int)))
-(assert (= (card universe) 3))
-(assert (= (card A) 2))
-(assert (= (card B) 2))
-(assert (= (intersection A B) (as emptyset (Set (Array Int Int)))))
-(assert (= universe (as univset (Set (Array Int Int)))))
+(assert (= (set.card universe) 3))
+(assert (= (set.card A) 2))
+(assert (= (set.card B) 2))
+(assert (= (set.intersection A B) (as set.empty (Set (Array Int Int)))))
+(assert (= universe (as set.universe (Set (Array Int Int)))))
(check-sat)
(declare-const universe (Set (Array Int Int)))
(declare-const A (Set (Array Int Int)))
(declare-const B (Set (Array Int Int)))
-(assert (= (card universe) 3))
-(assert (= (card A) 1))
-(assert (= (card B) 2))
-(assert (= (intersection A B) (as emptyset (Set (Array Int Int)))))
-(assert (= universe (as univset (Set (Array Int Int)))))
+(assert (= (set.card universe) 3))
+(assert (= (set.card A) 1))
+(assert (= (set.card B) 2))
+(assert (= (set.intersection A B) (as set.empty (Set (Array Int Int)))))
+(assert (= universe (as set.universe (Set (Array Int Int)))))
(check-sat)
(set-logic QF_ALL)
(set-option :sets-ext true)
(set-info :status unsat)
-(assert (= (card (as univset (Set Int))) 10))
+(assert (= (set.card (as set.universe (Set Int))) 10))
(declare-const universe (Set Int))
(declare-const A (Set Int))
(declare-const B (Set Int))
-(assert (= (card A) 6))
-(assert (= (card B) 5))
-(assert (= (intersection A B) (as emptyset (Set Int))))
-(assert (= universe (as univset (Set Int))))
+(assert (= (set.card A) 6))
+(assert (= (set.card B) 5))
+(assert (= (set.intersection A B) (as set.empty (Set Int))))
+(assert (= universe (as set.universe (Set Int))))
(check-sat)
(set-logic QF_ALL)
(set-option :sets-ext true)
(set-info :status sat)
-(assert (= (card (as univset (Set Int))) 10))
+(assert (= (set.card (as set.universe (Set Int))) 10))
(declare-const universe (Set Int))
(declare-const A (Set Int))
(declare-const B (Set Int))
-(assert (= (card A) 5))
-(assert (= (card B) 5))
-(assert (= (intersection A B) (as emptyset (Set Int))))
-(assert (= universe (as univset (Set Int))))
+(assert (= (set.card A) 5))
+(assert (= (set.card B) 5))
+(assert (= (set.intersection A B) (as set.empty (Set Int))))
+(assert (= universe (as set.universe (Set Int))))
(check-sat)
(assert (! (forall ((l1 Loc) (l2 Loc))
(or (not Axiom$0)
(or (= l1 l2) (< (read$0 data$0 l1) (read$0 data$0 l2))
- (not (Btwn$0 next$0 l1 l2 null$0)) (not (member l1 sk_?X$0))
- (not (member l2 sk_?X$0)))))
+ (not (Btwn$0 next$0 l1 l2 null$0)) (not (set.member l1 sk_?X$0))
+ (not (set.member l2 sk_?X$0)))))
:named strict_sortedness))
(assert (! (forall ((l1 Loc))
(or (= l1 null$0)
- (member (read$0 data$0 l1)
+ (set.member (read$0 data$0 l1)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
(not (Btwn$0 next$0 lst$0 l1 null$0))))
:named sorted_set_1))
(witness$0 (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
null$0)
- (member (read$0 data$0 curr_2$0)
+ (set.member (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
(sorted_set_domain$0 data$0 next$0 lst$0 null$0)))
(not
- (member (read$0 data$0 curr_2$0)
+ (set.member (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))))
:named sorted_set_2))
(witness$0 (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
null$0)
- (member (read$0 data$0 prev_2$0)
+ (set.member (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
(sorted_set_domain$0 data$0 next$0 lst$0 null$0)))
(not
- (member (read$0 data$0 prev_2$0)
+ (set.member (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))))
:named sorted_set_2_1))
(witness$0 (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
null$0)
- (member (read$0 data$0 sk_l1$0)
+ (set.member (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
(sorted_set_domain$0 data$0 next$0 lst$0 null$0)))
(not
- (member (read$0 data$0 sk_l1$0)
+ (set.member (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))))
:named sorted_set_2_2))
(witness$0 (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
null$0)
- (member (read$0 data$0 sk_l1_1$0)
+ (set.member (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
(sorted_set_domain$0 data$0 next$0 lst$0 null$0)))
(not
- (member (read$0 data$0 sk_l1_1$0)
+ (set.member (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))))
:named sorted_set_2_3))
(witness$0 (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
null$0)
- (member (read$0 data$0 sk_l2$0)
+ (set.member (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
(sorted_set_domain$0 data$0 next$0 lst$0 null$0)))
(not
- (member (read$0 data$0 sk_l2$0)
+ (set.member (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))))
:named sorted_set_2_4))
(witness$0 (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
null$0)
- (member (read$0 data$0 sk_l2_1$0)
+ (set.member (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
(sorted_set_domain$0 data$0 next$0 lst$0 null$0)))
(not
- (member (read$0 data$0 sk_l2_1$0)
+ (set.member (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 null$0)))))
:named sorted_set_2_5))
(=
(witness$0 sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0))
null$0)
- (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0)))
+ (set.member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0)))
(or
(and
(= sk_?e$0
(read$0 data$0
(witness$0 sk_?e$0
(sorted_set_c$0 data$0 next$0 lst$0 null$0))))
- (member
+ (set.member
(witness$0 sk_?e$0
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
(sorted_set_domain$0 data$0 next$0 lst$0 null$0)))
- (not (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0)))))
+ (not (set.member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0)))))
:named sorted_set_2_6))
(assert (! (and
(witness$0 sk_?e_3$0
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
null$0)
- (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0)))
+ (set.member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0)))
(or
(and
(= sk_?e_3$0
(read$0 data$0
(witness$0 sk_?e_3$0
(sorted_set_c$0 data$0 next$0 lst$0 null$0))))
- (member
+ (set.member
(witness$0 sk_?e_3$0
(sorted_set_c$0 data$0 next$0 lst$0 null$0))
(sorted_set_domain$0 data$0 next$0 lst$0 null$0)))
- (not (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0)))))
+ (not (set.member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 null$0)))))
:named sorted_set_2_7))
(assert (! (forall ((l1 Loc))
(or (= l1 null$0)
- (member (read$0 data$0 l1)
+ (set.member (read$0 data$0 l1)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
(not (Btwn$0 next$0 curr_2$0 l1 null$0))))
:named sorted_set_1_1))
(assert (! (forall ((l1 Loc))
(or (= l1 curr_2$0)
- (member (read$0 data$0 l1)
+ (set.member (read$0 data$0 l1)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
(not (Btwn$0 next$0 lst$0 l1 curr_2$0))))
:named sorted_set_1_2))
(witness$0 (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
null$0)
- (member (read$0 data$0 curr_2$0)
+ (set.member (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
(sorted_set_domain$0 data$0 next$0 curr_2$0 null$0)))
(not
- (member (read$0 data$0 curr_2$0)
+ (set.member (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))))
:named sorted_set_2_8))
(witness$0 (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
null$0)
- (member (read$0 data$0 prev_2$0)
+ (set.member (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
(sorted_set_domain$0 data$0 next$0 curr_2$0 null$0)))
(not
- (member (read$0 data$0 prev_2$0)
+ (set.member (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))))
:named sorted_set_2_9))
(witness$0 (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
null$0)
- (member (read$0 data$0 sk_l1$0)
+ (set.member (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
(sorted_set_domain$0 data$0 next$0 curr_2$0 null$0)))
(not
- (member (read$0 data$0 sk_l1$0)
+ (set.member (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))))
:named sorted_set_2_10))
(witness$0 (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
null$0)
- (member (read$0 data$0 sk_l1_1$0)
+ (set.member (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
(sorted_set_domain$0 data$0 next$0 curr_2$0 null$0)))
(not
- (member (read$0 data$0 sk_l1_1$0)
+ (set.member (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))))
:named sorted_set_2_11))
(witness$0 (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
null$0)
- (member (read$0 data$0 sk_l2$0)
+ (set.member (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
(sorted_set_domain$0 data$0 next$0 curr_2$0 null$0)))
(not
- (member (read$0 data$0 sk_l2$0)
+ (set.member (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))))
:named sorted_set_2_12))
(witness$0 (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
null$0)
- (member (read$0 data$0 sk_l2_1$0)
+ (set.member (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
(sorted_set_domain$0 data$0 next$0 curr_2$0 null$0)))
(not
- (member (read$0 data$0 sk_l2_1$0)
+ (set.member (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))))
:named sorted_set_2_13))
(witness$0 sk_?e$0
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
null$0)
- (member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))
+ (set.member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))
(or
(and
(= sk_?e$0
(read$0 data$0
(witness$0 sk_?e$0
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
- (member
+ (set.member
(witness$0 sk_?e$0
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
(sorted_set_domain$0 data$0 next$0 curr_2$0 null$0)))
- (not (member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))))
+ (not (set.member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))))
:named sorted_set_2_14))
(assert (! (and
(witness$0 sk_?e_3$0
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
null$0)
- (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))
+ (set.member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))
(or
(and
(= sk_?e_3$0
(read$0 data$0
(witness$0 sk_?e_3$0
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
- (member
+ (set.member
(witness$0 sk_?e_3$0
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
(sorted_set_domain$0 data$0 next$0 curr_2$0 null$0)))
(not
- (member sk_?e_3$0
+ (set.member sk_?e_3$0
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0)))))
:named sorted_set_2_15))
(witness$0 (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
null$0)
- (member (read$0 data$0 curr_2$0)
+ (set.member (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
(sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)))
(not
- (member (read$0 data$0 curr_2$0)
+ (set.member (read$0 data$0 curr_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))))
:named sorted_set_2_16))
(witness$0 (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
null$0)
- (member (read$0 data$0 prev_2$0)
+ (set.member (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
(sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)))
(not
- (member (read$0 data$0 prev_2$0)
+ (set.member (read$0 data$0 prev_2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))))
:named sorted_set_2_17))
(witness$0 (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
null$0)
- (member (read$0 data$0 sk_l1$0)
+ (set.member (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
(sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)))
(not
- (member (read$0 data$0 sk_l1$0)
+ (set.member (read$0 data$0 sk_l1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))))
:named sorted_set_2_18))
(witness$0 (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
null$0)
- (member (read$0 data$0 sk_l1_1$0)
+ (set.member (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
(sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)))
(not
- (member (read$0 data$0 sk_l1_1$0)
+ (set.member (read$0 data$0 sk_l1_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))))
:named sorted_set_2_19))
(witness$0 (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
null$0)
- (member (read$0 data$0 sk_l2$0)
+ (set.member (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
(sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)))
(not
- (member (read$0 data$0 sk_l2$0)
+ (set.member (read$0 data$0 sk_l2$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))))
:named sorted_set_2_20))
(witness$0 (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
null$0)
- (member (read$0 data$0 sk_l2_1$0)
+ (set.member (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))
(or
(and
(read$0 data$0
(witness$0 (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))
- (member
+ (set.member
(witness$0 (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
(sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)))
(not
- (member (read$0 data$0 sk_l2_1$0)
+ (set.member (read$0 data$0 sk_l2_1$0)
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))))
:named sorted_set_2_21))
(witness$0 sk_?e$0
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
null$0)
- (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))
+ (set.member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))
(or
(and
(= sk_?e$0
(read$0 data$0
(witness$0 sk_?e$0
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))
- (member
+ (set.member
(witness$0 sk_?e$0
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
(sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)))
- (not (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))))
+ (not (set.member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))))
:named sorted_set_2_22))
(assert (! (and
(witness$0 sk_?e_3$0
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
null$0)
- (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))
+ (set.member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))
(or
(and
(= sk_?e_3$0
(read$0 data$0
(witness$0 sk_?e_3$0
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))
- (member
+ (set.member
(witness$0 sk_?e_3$0
(sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
(sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0)))
(not
- (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))))
+ (set.member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0)))))
:named sorted_set_2_23))
(assert (! (= (read$1 next$0 null$0) null$0) :named read_null))
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 lst$0 l1 null$0)
- (member l1 (sorted_set_domain$0 data$0 next$0 lst$0 null$0))
+ (set.member l1 (sorted_set_domain$0 data$0 next$0 lst$0 null$0))
(not (= l1 null$0)))
(and (or (= l1 null$0) (not (Btwn$0 next$0 lst$0 l1 null$0)))
(not
- (member l1
+ (set.member l1
(sorted_set_domain$0 data$0 next$0 lst$0 null$0))))))
:named sorted_set_footprint))
-(assert (! (or (member sk_?e_3$0 c2_2$0)
- (and (member sk_?e_2$0 sk_FP_1$0) (not (member sk_?e_2$0 FP$0)))
- (and (member sk_?e_3$0 (union c1_2$0 c2_2$0))
- (not (member sk_?e_3$0 content$0)))
- (and (member sk_?e_3$0 c1_2$0)
+(assert (! (or (set.member sk_?e_3$0 c2_2$0)
+ (and (set.member sk_?e_2$0 sk_FP_1$0) (not (set.member sk_?e_2$0 FP$0)))
+ (and (set.member sk_?e_3$0 (set.union c1_2$0 c2_2$0))
+ (not (set.member sk_?e_3$0 content$0)))
+ (and (set.member sk_?e_3$0 c1_2$0)
(not
- (member sk_?e_3$0
+ (set.member sk_?e_3$0
(sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
- (and (member sk_?e_3$0 content$0)
- (not (member sk_?e_3$0 (union c1_2$0 c2_2$0))))
- (and (member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
- (not (member sk_?e_3$0 c1_2$0)))
+ (and (set.member sk_?e_3$0 content$0)
+ (not (set.member sk_?e_3$0 (set.union c1_2$0 c2_2$0))))
+ (and (set.member sk_?e_3$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
+ (not (set.member sk_?e_3$0 c1_2$0)))
(and (not (= curr_2$0 null$0)) (not (= prev_2$0 null$0))
(not (< (read$0 data$0 prev_2$0) (read$0 data$0 curr_2$0))))
(not (= curr_2$0 lst$0)) (not (= prev_2$0 null$0))
(assert (! (= sk_?X_3$0 (sorted_set_domain$0 data$0 next$0 curr_2$0 null$0))
:named invariant_37_2_3))
-(assert (! (= sk_?X_1$0 (union sk_?X_3$0 sk_?X_4$0)) :named invariant_37_2_4))
+(assert (! (= sk_?X_1$0 (set.union sk_?X_3$0 sk_?X_4$0)) :named invariant_37_2_4))
-(assert (! (= FP_Caller$0 (union FP$0 FP_Caller$0))
+(assert (! (= FP_Caller$0 (set.union FP$0 FP_Caller$0))
:named precondition_of_insert_27_11))
(assert (! (= sk_?X$0 FP$0) :named precondition_of_insert_27_11_1))
-(assert (! (= Alloc$0 (union FP_Caller$0 Alloc$0))
+(assert (! (= Alloc$0 (set.union FP_Caller$0 Alloc$0))
:named initial_footprint_of_insert_27_11))
(assert (! (= curr_2$0 lst$0) :named assign_31_2))
(assert (! (or (sorted_set_struct$0 sk_?X_3$0 data$0 next$0 curr_2$0 null$0 c1_2$0)
(not (Btwn$0 next$0 curr_2$0 null$0 null$0))
- (! (and (Btwn$0 next$0 sk_l1$0 sk_l2$0 null$0) (member sk_l1$0 sk_?X_3$0)
- (member sk_l2$0 sk_?X_3$0) (not (= sk_l1$0 sk_l2$0))
+ (! (and (Btwn$0 next$0 sk_l1$0 sk_l2$0 null$0) (set.member sk_l1$0 sk_?X_3$0)
+ (set.member sk_l2$0 sk_?X_3$0) (not (= sk_l1$0 sk_l2$0))
(not (< (read$0 data$0 sk_l1$0) (read$0 data$0 sk_l2$0))))
:named strict_sortedness_1))
:named unnamed_1))
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 lst$0 l1 curr_2$0)
- (member l1
+ (set.member l1
(sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0))
(not (= l1 curr_2$0)))
(and
(or (= l1 curr_2$0)
(not (Btwn$0 next$0 lst$0 l1 curr_2$0)))
(not
- (member l1
+ (set.member l1
(sorted_set_domain$0 data$0 next$0 lst$0 curr_2$0))))))
:named sorted_set_footprint_1))
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 curr_2$0 l1 null$0)
- (member l1
+ (set.member l1
(sorted_set_domain$0 data$0 next$0 curr_2$0 null$0))
(not (= l1 null$0)))
(and
(or (= l1 null$0)
(not (Btwn$0 next$0 curr_2$0 l1 null$0)))
(not
- (member l1
+ (set.member l1
(sorted_set_domain$0 data$0 next$0 curr_2$0
null$0))))))
:named sorted_set_footprint_2))
-(assert (! (not (member null$0 Alloc$0)) :named initial_footprint_of_insert_27_11_1))
+(assert (! (not (set.member null$0 Alloc$0)) :named initial_footprint_of_insert_27_11_1))
(assert (! (or (= prev_2$0 curr_2$0)
- (member sk_?e_1$0 (intersection sk_?X_4$0 sk_?X_3$0))
- (and (member sk_?e_1$0 sk_FP$0) (not (member sk_?e_1$0 FP$0)))
- (and (member sk_?e$0 (union c1_2$0 c2_2$0)) (not (member sk_?e$0 content$0)))
- (and (member sk_?e$0 c1_2$0)
- (not (member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
- (and (member sk_?e$0 c2_2$0)
- (not (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))
- (and (member sk_?e$0 content$0) (not (member sk_?e$0 (union c1_2$0 c2_2$0))))
- (and (member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
- (not (member sk_?e$0 c1_2$0)))
- (and (member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
- (not (member sk_?e$0 c2_2$0)))
+ (set.member sk_?e_1$0 (set.intersection sk_?X_4$0 sk_?X_3$0))
+ (and (set.member sk_?e_1$0 sk_FP$0) (not (set.member sk_?e_1$0 FP$0)))
+ (and (set.member sk_?e$0 (set.union c1_2$0 c2_2$0)) (not (set.member sk_?e$0 content$0)))
+ (and (set.member sk_?e$0 c1_2$0)
+ (not (set.member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))))
+ (and (set.member sk_?e$0 c2_2$0)
+ (not (set.member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))))
+ (and (set.member sk_?e$0 content$0) (not (set.member sk_?e$0 (set.union c1_2$0 c2_2$0))))
+ (and (set.member sk_?e$0 (sorted_set_c$0 data$0 next$0 curr_2$0 null$0))
+ (not (set.member sk_?e$0 c1_2$0)))
+ (and (set.member sk_?e$0 (sorted_set_c$0 data$0 next$0 lst$0 curr_2$0))
+ (not (set.member sk_?e$0 c2_2$0)))
(and (not (= curr_2$0 null$0)) (not (= prev_2$0 null$0))
(not (< (read$0 data$0 prev_2$0) (read$0 data$0 curr_2$0))))
(not (= (read$1 next$0 prev_2$0) curr_2$0))
(assert (! (= prev_2$0 null$0) :named assign_32_2))
-(assert (! (= c2_2$0 (as emptyset SetInt)) :named assign_35_2))
+(assert (! (= c2_2$0 (as set.empty SetInt)) :named assign_35_2))
-(assert (! (= FP_Caller_1$0 (setminus FP_Caller$0 FP$0)) :named assign_29_0))
+(assert (! (= FP_Caller_1$0 (set.minus FP_Caller$0 FP$0)) :named assign_29_0))
(assert (! (or (sorted_set_struct$0 sk_?X_5$0 data$0 next$0 lst$0 curr_2$0 c2_2$0)
(not (Btwn$0 next$0 lst$0 curr_2$0 curr_2$0))
(! (and (Btwn$0 next$0 sk_l1_1$0 sk_l2_1$0 curr_2$0)
- (member sk_l1_1$0 sk_?X_5$0) (member sk_l2_1$0 sk_?X_5$0)
+ (set.member sk_l1_1$0 sk_?X_5$0) (set.member sk_l2_1$0 sk_?X_5$0)
(not (= sk_l1_1$0 sk_l2_1$0))
(not (< (read$0 data$0 sk_l1_1$0) (read$0 data$0 sk_l2_1$0))))
:named strict_sortedness_2))
(set-info :status sat)
(declare-fun S () (Set Int))
(declare-fun x () Int)
-(assert (= (choose (singleton x)) 5))
-(assert (= (singleton x) S))
-(assert (is_singleton S))
-(assert (is_singleton (singleton 3)))
+(assert (= (set.choose (set.singleton x)) 5))
+(assert (= (set.singleton x) S))
+(assert (set.is_singleton S))
+(assert (set.is_singleton (set.singleton 3)))
(check-sat)
(declare-fun s () (Set Int))
(declare-fun u () Unit)
-(assert (= s (insert y s)))
+(assert (= s (set.insert y s)))
(assert (=> b (= uu u)))
(push 1)
(declare-fun b () (Set Int))
(declare-fun c () (Set Int))
(declare-fun UNIVERALSET () (Set Int))
-(assert (subset b UNIVERALSET))
-(assert (subset c UNIVERALSET))
+(assert (set.subset b UNIVERALSET))
+(assert (set.subset c UNIVERALSET))
(assert (> n 0))
-(assert (= (card UNIVERALSET) n))
-(assert (= (card b) m))
-(assert (= (card c) (- f m)))
+(assert (= (set.card UNIVERALSET) n))
+(assert (= (set.card b) m))
+(assert (= (set.card c) (- f m)))
(assert (>= m 0))
(assert (>= f m))
(assert (> n (+ (* 2 f) m)))
-(assert (>= (card (setminus UNIVERALSET (intersection (setminus UNIVERALSET b) (setminus UNIVERALSET c)))) n))
+(assert (>= (set.card (set.minus UNIVERALSET (set.intersection (set.minus UNIVERALSET b) (set.minus UNIVERALSET c)))) n))
(check-sat)
(declare-fun d () (Set (Tuple String String)))
(declare-fun f () (Set Int))
(declare-fun e () Int)
-(assert (= b (insert (tuple "" 1) (tuple "" 2) (singleton (tuple "" 4)))))
-(assert (= c (insert (tuple 1 "1") (tuple 2 "2") (singleton (tuple 7 "")))))
-(assert (= d (join b c)))
-(assert (= e (card f)))
+(assert (= b (set.insert (tuple "" 1) (tuple "" 2) (set.singleton (tuple "" 4)))))
+(assert (= c (set.insert (tuple 1 "1") (tuple 2 "2") (set.singleton (tuple 7 "")))))
+(assert (= d (rel.join b c)))
+(assert (= e (set.card f)))
(check-sat)
(set-info :status unsat)
(declare-fun st1 () (Set Int))
(declare-fun st7 () (Set Int))
-(assert (> 0 (card (intersection st1 (union st7 st1)))))
-(assert (subset st1 st7))
+(assert (> 0 (set.card (set.intersection st1 (set.union st7 st1)))))
+(assert (set.subset st1 st7))
(check-sat)
(set-info :status unsat)
(declare-fun st3 () (Set String))
(declare-fun st9 () (Set String))
-(assert (is_singleton (intersection st3 st9)))
-(assert (< 1 (card (intersection st3 st9))))
-(assert (is_singleton st9))
+(assert (set.is_singleton (set.intersection st3 st9)))
+(assert (< 1 (set.card (set.intersection st3 st9))))
+(assert (set.is_singleton st9))
(check-sat)
(declare-fun c () (Set Int))
(declare-fun e () (Set Int))
-(assert (= e (union b e)))
-(assert (= (card b) d))
-(assert (= (card c) 0))
+(assert (= e (set.union b e)))
+(assert (= (set.card b) d))
+(assert (= (set.card c) 0))
(assert (= 0 (mod 0 d)))
-(assert (> (card (setminus e (intersection (intersection e b) (setminus e c)))) 1))
+(assert (> (set.card (set.minus e (set.intersection (set.intersection e b) (set.minus e c)))) 1))
(check-sat)
(set-logic ALL)
(set-info :status sat)
(declare-fun s () (Set Int))
-(assert (> (card s) 1))
-(assert (and (member 0 s) (exists ((x Int)) (member (mod x 1) s))))
+(assert (> (set.card s) 1))
+(assert (and (set.member 0 s) (exists ((x Int)) (set.member (mod x 1) s))))
(check-sat)
(set-info :status sat)
(declare-const zero Int)
(declare-fun A () (Set Int))
-(assert (exists ((x Int)) (= A (singleton x))))
-(assert (member (- zero) A))
+(assert (exists ((x Int)) (= A (set.singleton x))))
+(assert (set.member (- zero) A))
(check-sat)
(set-logic ALL)
(set-info :status unsat)
(declare-fun S () (Set Int))
-(assert (is_singleton (complement (complement S))))
-(assert (= 2 (card S)))
+(assert (set.is_singleton (set.complement (set.complement S))))
+(assert (= 2 (set.card S)))
(check-sat)
\ No newline at end of file
(set-logic ALL)
(set-info :status unsat)
(declare-fun S () (Set Int))
-(assert (is_singleton (setminus (as univset (Set Int)) (setminus (as univset (Set Int)) S))))
-(assert (= 2 (card S)))
+(assert (set.is_singleton (set.minus (as set.universe (Set Int)) (set.minus (as set.universe (Set Int)) S))))
+(assert (= 2 (set.card S)))
(check-sat)
\ No newline at end of file
(set-info :status sat)
(declare-fun s () (Set Real))
(declare-fun t3 () (Set Real))
-(assert (or (member 1.0 t3) (member 0.0 s)))
-(assert (not (= t3 (setminus s (singleton 1.0)))))
+(assert (or (set.member 1.0 t3) (set.member 0.0 s)))
+(assert (not (= t3 (set.minus s (set.singleton 1.0)))))
(check-sat)
(declare-fun r1 () Real)
(declare-fun st9 () (Set String))
(declare-fun str2 () String)
-(assert (is_singleton (ite (= str2 (str.substr str2 0 (to_int r1))) st9 (as emptyset (Set String)))))
+(assert (set.is_singleton (ite (= str2 (str.substr str2 0 (to_int r1))) st9 (as set.empty (Set String)))))
(check-sat)
; EXPECT: sat
; Observed behavior:
-; --check-model failed for set-term (union (z3f69 z3v151) (singleton z3v143))
+; --check-model failed for set-term (set.union (z3f69 z3v151) (set.singleton z3v143))
; with different set of elements in the model for representative and the node
; itself.
;
(set-info :status sat)
(define-sort Elt () Int)
(define-sort mySet () (Set Elt ))
-(define-fun smt_set_emp () mySet (as emptyset mySet))
-(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (member x s))
-(define-fun smt_set_add ((s mySet) (x Elt)) mySet (union s (singleton x)))
-(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (union s1 s2))
-(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (intersection s1 s2))
+(define-fun smt_set_emp () mySet (as set.empty mySet))
+(define-fun smt_set_mem ((x Elt) (s mySet)) Bool (set.member x s))
+(define-fun smt_set_add ((s mySet) (x Elt)) mySet (set.union s (set.singleton x)))
+(define-fun smt_set_cup ((s1 mySet) (s2 mySet)) mySet (set.union s1 s2))
+(define-fun smt_set_cap ((s1 mySet) (s2 mySet)) mySet (set.intersection s1 s2))
;(define-fun smt_set_com ((s mySet)) mySet ((_ map not) s))
-(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (setminus s1 s2))
+(define-fun smt_set_dif ((s1 mySet) (s2 mySet)) mySet (set.minus s1 s2))
;(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (= smt_set_emp (smt_set_dif s1 s2)))
-(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (subset s1 s2))
+(define-fun smt_set_sub ((s1 mySet) (s2 mySet)) Bool (set.subset s1 s2))
(declare-fun z3v58 () Int)
(declare-fun z3v59 () Int)
(z3f69 z3v140))))
(assert (= (z3f69 z3v152)
- (smt_set_cup (singleton z3v143) (z3f69 z3v151))))
+ (smt_set_cup (set.singleton z3v143) (z3f69 z3v151))))
(assert (= (z3f70 z3v152)
- (smt_set_cup (singleton z3v143) (z3f70 z3v151))))
+ (smt_set_cup (set.singleton z3v143) (z3f70 z3v151))))
(assert (and
(= (z3f69 z3v142)
- (smt_set_cup (singleton z3v143) (z3f69 z3v141)))
+ (smt_set_cup (set.singleton z3v143) (z3f69 z3v141)))
(= (z3f70 z3v142)
- (smt_set_cup (singleton z3v143) (z3f70 z3v141)))
+ (smt_set_cup (set.singleton z3v143) (z3f70 z3v141)))
(= z3v142 (z3f92 z3v143 z3v141))
(= z3v142 z3v144)
(= (z3f62 z3v61) z3v61)
:named btwn_step_10))
(assert (! (forall ((?f FldLoc))
- (or (member (ep$0 ?f sk_?X_30$0 null$0) sk_?X_30$0)
+ (or (set.member (ep$0 ?f sk_?X_30$0 null$0) sk_?X_30$0)
(= null$0 (ep$0 ?f sk_?X_30$0 null$0))))
:named entry-point3_10))
(assert (! (forall ((?f FldLoc))
- (or (member (ep$0 ?f sk_?X_30$0 lst_1$0) sk_?X_30$0)
+ (or (set.member (ep$0 ?f sk_?X_30$0 lst_1$0) sk_?X_30$0)
(= lst_1$0 (ep$0 ?f sk_?X_30$0 lst_1$0))))
:named entry-point3_11))
(assert (! (forall ((?f FldLoc))
- (or (member (ep$0 ?f sk_?X_30$0 curr_3$0) sk_?X_30$0)
+ (or (set.member (ep$0 ?f sk_?X_30$0 curr_3$0) sk_?X_30$0)
(= curr_3$0 (ep$0 ?f sk_?X_30$0 curr_3$0))))
:named entry-point3_12))
(assert (! (forall ((?f FldLoc))
- (or (member (ep$0 ?f sk_?X_30$0 tmp_2$0) sk_?X_30$0)
+ (or (set.member (ep$0 ?f sk_?X_30$0 tmp_2$0) sk_?X_30$0)
(= tmp_2$0 (ep$0 ?f sk_?X_30$0 tmp_2$0))))
:named entry-point3_13))
(assert (! (forall ((?f FldLoc) (?y Loc))
(or (Btwn$0 ?f null$0 (ep$0 ?f sk_?X_30$0 null$0) ?y)
- (not (Btwn$0 ?f null$0 ?y ?y)) (not (member ?y sk_?X_30$0))))
+ (not (Btwn$0 ?f null$0 ?y ?y)) (not (set.member ?y sk_?X_30$0))))
:named entry-point4_10))
(assert (! (forall ((?f FldLoc) (?y Loc))
(or (Btwn$0 ?f lst_1$0 (ep$0 ?f sk_?X_30$0 lst_1$0) ?y)
- (not (Btwn$0 ?f lst_1$0 ?y ?y)) (not (member ?y sk_?X_30$0))))
+ (not (Btwn$0 ?f lst_1$0 ?y ?y)) (not (set.member ?y sk_?X_30$0))))
:named entry-point4_11))
(assert (! (forall ((?f FldLoc) (?y Loc))
(or (Btwn$0 ?f curr_3$0 (ep$0 ?f sk_?X_30$0 curr_3$0) ?y)
- (not (Btwn$0 ?f curr_3$0 ?y ?y)) (not (member ?y sk_?X_30$0))))
+ (not (Btwn$0 ?f curr_3$0 ?y ?y)) (not (set.member ?y sk_?X_30$0))))
:named entry-point4_12))
(assert (! (forall ((?f FldLoc) (?y Loc))
(or (Btwn$0 ?f tmp_2$0 (ep$0 ?f sk_?X_30$0 tmp_2$0) ?y)
- (not (Btwn$0 ?f tmp_2$0 ?y ?y)) (not (member ?y sk_?X_30$0))))
+ (not (Btwn$0 ?f tmp_2$0 ?y ?y)) (not (set.member ?y sk_?X_30$0))))
:named entry-point4_13))
(assert (! (forall ((?f FldLoc) (?y Loc))
- (or (not (Btwn$0 ?f null$0 ?y ?y)) (not (member ?y sk_?X_30$0))
- (member (ep$0 ?f sk_?X_30$0 null$0) sk_?X_30$0)))
+ (or (not (Btwn$0 ?f null$0 ?y ?y)) (not (set.member ?y sk_?X_30$0))
+ (set.member (ep$0 ?f sk_?X_30$0 null$0) sk_?X_30$0)))
:named entry-point2_10))
(assert (! (forall ((?f FldLoc) (?y Loc))
- (or (not (Btwn$0 ?f lst_1$0 ?y ?y)) (not (member ?y sk_?X_30$0))
- (member (ep$0 ?f sk_?X_30$0 lst_1$0) sk_?X_30$0)))
+ (or (not (Btwn$0 ?f lst_1$0 ?y ?y)) (not (set.member ?y sk_?X_30$0))
+ (set.member (ep$0 ?f sk_?X_30$0 lst_1$0) sk_?X_30$0)))
:named entry-point2_11))
(assert (! (forall ((?f FldLoc) (?y Loc))
- (or (not (Btwn$0 ?f curr_3$0 ?y ?y)) (not (member ?y sk_?X_30$0))
- (member (ep$0 ?f sk_?X_30$0 curr_3$0) sk_?X_30$0)))
+ (or (not (Btwn$0 ?f curr_3$0 ?y ?y)) (not (set.member ?y sk_?X_30$0))
+ (set.member (ep$0 ?f sk_?X_30$0 curr_3$0) sk_?X_30$0)))
:named entry-point2_12))
(assert (! (forall ((?f FldLoc) (?y Loc))
- (or (not (Btwn$0 ?f tmp_2$0 ?y ?y)) (not (member ?y sk_?X_30$0))
- (member (ep$0 ?f sk_?X_30$0 tmp_2$0) sk_?X_30$0)))
+ (or (not (Btwn$0 ?f tmp_2$0 ?y ?y)) (not (set.member ?y sk_?X_30$0))
+ (set.member (ep$0 ?f sk_?X_30$0 tmp_2$0) sk_?X_30$0)))
:named entry-point2_13))
(assert (! (= (read$0 (write$0 next$0 curr_3$0 (read$0 next$0 tmp_2$0)) curr_3$0)
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 lst$0 l1 curr_2$0)
- (member l1 (lseg_domain$0 next$0 lst$0 curr_2$0))
+ (set.member l1 (lseg_domain$0 next$0 lst$0 curr_2$0))
(not (= l1 curr_2$0)))
(and
(or (= l1 curr_2$0)
(not (Btwn$0 next$0 lst$0 l1 curr_2$0)))
- (not (member l1 (lseg_domain$0 next$0 lst$0 curr_2$0))))))
+ (not (set.member l1 (lseg_domain$0 next$0 lst$0 curr_2$0))))))
:named lseg_footprint_20))
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 curr_3$0 l1 null$0)
- (member l1 (lseg_domain$0 next$0 curr_3$0 null$0))
+ (set.member l1 (lseg_domain$0 next$0 curr_3$0 null$0))
(not (= l1 null$0)))
(and
(or (= l1 null$0)
(not (Btwn$0 next$0 curr_3$0 l1 null$0)))
- (not (member l1 (lseg_domain$0 next$0 curr_3$0 null$0))))))
+ (not (set.member l1 (lseg_domain$0 next$0 curr_3$0 null$0))))))
:named lseg_footprint_21))
-(assert (! (not (member tmp_2$0 FP_2$0)) :named check_free_31_6))
+(assert (! (not (set.member tmp_2$0 FP_2$0)) :named check_free_31_6))
-(assert (! (not (member null$0 Alloc$0)) :named framecondition_of_remove_loop_18_4_15))
+(assert (! (not (set.member null$0 Alloc$0)) :named framecondition_of_remove_loop_18_4_15))
(assert (! (not (= lst$0 null$0)) :named if_else_13_6_4))
-(assert (! (= FP_Caller$0 (union FP$0 FP_Caller$0))
+(assert (! (= FP_Caller$0 (set.union FP$0 FP_Caller$0))
:named precondition_of_remove_10_11_20))
(assert (! (= sk_?X_33$0 FP$0) :named precondition_of_remove_10_11_21))
(assert (! (lseg_struct$0 sk_?X_32$0 next$0 lst$0 curr_2$0) :named invariant_18_4_62))
-(assert (! (= FP$0 (union FP_1$0 FP$0)) :named invariant_18_4_63))
+(assert (! (= FP$0 (set.union FP_1$0 FP$0)) :named invariant_18_4_63))
(assert (! (= sk_?X_31$0 (lseg_domain$0 next$0 curr_2$0 null$0))
:named invariant_18_4_64))
-(assert (! (= sk_?X_30$0 (union sk_?X_31$0 sk_?X_32$0)) :named invariant_18_4_65))
+(assert (! (= sk_?X_30$0 (set.union sk_?X_31$0 sk_?X_32$0)) :named invariant_18_4_65))
-(assert (! (= (as emptyset SetLoc) (as emptyset SetLoc)) :named invariant_18_4_66))
+(assert (! (= (as set.empty SetLoc) (as set.empty SetLoc)) :named invariant_18_4_66))
(assert (! (lseg_struct$0 sk_?X_28$0 next$0 curr_3$0 null$0)
:named invariant_18_4_67))
-(assert (! (= sk_?X_29$0 (union sk_?X_28$0 sk_?X_27$0)) :named invariant_18_4_68))
+(assert (! (= sk_?X_29$0 (set.union sk_?X_28$0 sk_?X_27$0)) :named invariant_18_4_68))
(assert (! (= sk_?X_28$0 (lseg_domain$0 next$0 curr_3$0 null$0))
:named invariant_18_4_69))
-(assert (! (= (as emptyset SetLoc) (intersection sk_?X_27$0 sk_?X_28$0))
+(assert (! (= (as set.empty SetLoc) (set.intersection sk_?X_27$0 sk_?X_28$0))
:named invariant_18_4_70))
-(assert (! (= Alloc$0 (union FP_Caller$0 Alloc$0))
+(assert (! (= Alloc$0 (set.union FP_Caller$0 Alloc$0))
:named initial_footprint_of_remove_10_11_10))
(assert (! (Frame$0 FP_1$0 Alloc$0 next$0 next$0)
(assert (! (= curr_2$0 lst$0) :named assign_17_4_4))
(assert (! (= FP_2$0
- (union (setminus FP$0 FP_1$0)
- (union (intersection Alloc$0 FP_1$0) (setminus Alloc$0 Alloc$0))))
+ (set.union (set.minus FP$0 FP_1$0)
+ (set.union (set.intersection Alloc$0 FP_1$0) (set.minus Alloc$0 Alloc$0))))
:named framecondition_of_remove_loop_18_4_17))
(assert (! (or (Btwn$0 next$0 lst$0 curr_2$0 curr_2$0)
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 lst_1$0 l1 curr_3$0)
- (member l1 (lseg_domain$0 next$0 lst_1$0 curr_3$0))
+ (set.member l1 (lseg_domain$0 next$0 lst_1$0 curr_3$0))
(not (= l1 curr_3$0)))
(and
(or (= l1 curr_3$0)
(not (Btwn$0 next$0 lst_1$0 l1 curr_3$0)))
- (not (member l1 (lseg_domain$0 next$0 lst_1$0 curr_3$0))))))
+ (not (set.member l1 (lseg_domain$0 next$0 lst_1$0 curr_3$0))))))
:named lseg_footprint_22))
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 lst$0 l1 null$0)
- (member l1 (lseg_domain$0 next$0 lst$0 null$0))
+ (set.member l1 (lseg_domain$0 next$0 lst$0 null$0))
(not (= l1 null$0)))
(and (or (= l1 null$0) (not (Btwn$0 next$0 lst$0 l1 null$0)))
- (not (member l1 (lseg_domain$0 next$0 lst$0 null$0))))))
+ (not (set.member l1 (lseg_domain$0 next$0 lst$0 null$0))))))
:named lseg_footprint_23))
(assert (! (forall ((l1 Loc))
(or
(and (Btwn$0 next$0 curr_2$0 l1 null$0)
- (member l1 (lseg_domain$0 next$0 curr_2$0 null$0))
+ (set.member l1 (lseg_domain$0 next$0 curr_2$0 null$0))
(not (= l1 null$0)))
(and
(or (= l1 null$0)
(not (Btwn$0 next$0 curr_2$0 l1 null$0)))
- (not (member l1 (lseg_domain$0 next$0 curr_2$0 null$0))))))
+ (not (set.member l1 (lseg_domain$0 next$0 curr_2$0 null$0))))))
:named lseg_footprint_24))
-(assert (! (not (member null$0 Alloc$0)) :named initial_footprint_of_remove_10_11_11))
+(assert (! (not (set.member null$0 Alloc$0)) :named initial_footprint_of_remove_10_11_11))
(assert (! (not (= tmp_2$0 null$0)) :named if_else_28_8_2))
(assert (! (= sk_?X_30$0 FP_1$0) :named invariant_18_4_74))
-(assert (! (= (as emptyset SetLoc) (intersection sk_?X_32$0 sk_?X_31$0))
+(assert (! (= (as set.empty SetLoc) (set.intersection sk_?X_32$0 sk_?X_31$0))
:named invariant_18_4_75))
(assert (! (not (= curr_3$0 null$0)) :named invariant_18_4_76))
:named invariant_18_4_77))
(assert (! (= sk_?X_29$0
- (union (intersection Alloc$0 FP_1$0) (setminus Alloc$0 Alloc$0)))
+ (set.union (set.intersection Alloc$0 FP_1$0) (set.minus Alloc$0 Alloc$0)))
:named invariant_18_4_78))
(assert (! (= sk_?X_27$0 (lseg_domain$0 next$0 lst_1$0 curr_3$0))
:named invariant_18_4_79))
-(assert (! (= (as emptyset SetLoc) (as emptyset SetLoc)) :named invariant_18_4_80))
+(assert (! (= (as set.empty SetLoc) (as set.empty SetLoc)) :named invariant_18_4_80))
-(assert (! (= Alloc$0 (union FP_2$0 Alloc$0))
+(assert (! (= Alloc$0 (set.union FP_2$0 Alloc$0))
:named framecondition_of_remove_loop_18_4_18))
(assert (! (= tmp_2$0 (read$0 next$0 curr_3$0)) :named assign_27_4_2))
(assert (! (= lst_1$0 lst$0) :named framecondition_of_remove_loop_18_4_19))
-(assert (! (= FP_Caller_1$0 (setminus FP_Caller$0 FP$0)) :named assign_13_2_5))
+(assert (! (= FP_Caller_1$0 (set.minus FP_Caller$0 FP$0)) :named assign_13_2_5))
(assert (! (or (Btwn$0 next$0 lst_1$0 curr_3$0 curr_3$0)
(not (lseg_struct$0 sk_?X_27$0 next$0 lst_1$0 curr_3$0)))
(declare-fun x () (Set U))
-(assert (subset x (comprehension ((z U)) (not (= z a)) z)))
+(assert (set.subset x (set.comprehension ((z U)) (not (= z a)) z)))
-(assert (not (member b x)))
-(assert (member c x))
+(assert (not (set.member b x)))
+(assert (set.member c x))
(check-sat)
(declare-fun S () myset)
; 0 elements
-(assert (not (= S (as emptyset myset))))
+(assert (not (= S (as set.empty myset))))
; 1 element is S
-(assert (not (= S (singleton (as emptyset (Set (_ BitVec 1)))))))
-(assert (not (= S (singleton (singleton (_ bv0 1)) ))))
-(assert (not (= S (singleton (singleton (_ bv1 1)) ))))
-(assert (not (= S (singleton (union (singleton (_ bv0 1))
- (singleton (_ bv1 1)))))))
+(assert (not (= S (set.singleton (as set.empty (Set (_ BitVec 1)))))))
+(assert (not (= S (set.singleton (set.singleton (_ bv0 1)) ))))
+(assert (not (= S (set.singleton (set.singleton (_ bv1 1)) ))))
+(assert (not (= S (set.singleton (set.union (set.singleton (_ bv0 1))
+ (set.singleton (_ bv1 1)))))))
; 2 elements in S
-(assert (not (= S (union (singleton (as emptyset (Set (_ BitVec 1))))
- (singleton (singleton (_ bv0 1)))) )))
-(assert (not (= S (union (singleton (as emptyset (Set (_ BitVec 1))))
- (singleton (singleton (_ bv1 1)))))))
-(assert (not (= S (union (singleton (as emptyset (Set (_ BitVec 1))))
- (singleton (union (singleton (_ bv0 1))
- (singleton (_ bv1 1))))))))
-(assert (not (= S (union (singleton (union (singleton (_ bv0 1))
- (singleton (_ bv1 1))))
- (singleton (singleton (_ bv0 1)))) )))
-(assert (not (= S (union (singleton (singleton (_ bv0 1)))
- (singleton (singleton (_ bv1 1)))) )))
-(assert (not (= S (union (singleton (union (singleton (_ bv0 1))
- (singleton (_ bv1 1))))
- (singleton (singleton (_ bv1 1)))))))
+(assert (not (= S (set.union (set.singleton (as set.empty (Set (_ BitVec 1))))
+ (set.singleton (set.singleton (_ bv0 1)))) )))
+(assert (not (= S (set.union (set.singleton (as set.empty (Set (_ BitVec 1))))
+ (set.singleton (set.singleton (_ bv1 1)))))))
+(assert (not (= S (set.union (set.singleton (as set.empty (Set (_ BitVec 1))))
+ (set.singleton (set.union (set.singleton (_ bv0 1))
+ (set.singleton (_ bv1 1))))))))
+(assert (not (= S (set.union (set.singleton (set.union (set.singleton (_ bv0 1))
+ (set.singleton (_ bv1 1))))
+ (set.singleton (set.singleton (_ bv0 1)))) )))
+(assert (not (= S (set.union (set.singleton (set.singleton (_ bv0 1)))
+ (set.singleton (set.singleton (_ bv1 1)))) )))
+(assert (not (= S (set.union (set.singleton (set.union (set.singleton (_ bv0 1))
+ (set.singleton (_ bv1 1))))
+ (set.singleton (set.singleton (_ bv1 1)))))))
; 3 elements in S
-(assert (not (= S (union (singleton (singleton (_ bv1 1)))
- (union (singleton (as emptyset (Set (_ BitVec 1))))
- (singleton (singleton (_ bv0 1))))) )))
-(assert (not (= S (union (singleton (union (singleton (_ bv0 1))
- (singleton (_ bv1 1))))
- (union (singleton (as emptyset (Set (_ BitVec 1))))
- (singleton (singleton (_ bv1 1))))) )))
-(assert (not (= S (union (singleton (union (singleton (_ bv0 1))
- (singleton (_ bv1 1))))
- (union (singleton (singleton (_ bv0 1)))
- (singleton (singleton (_ bv1 1))))) )))
-(assert (not (= S (union (singleton (union (singleton (_ bv0 1))
- (singleton (_ bv1 1))))
- (union (singleton (as emptyset (Set (_ BitVec 1))))
- (singleton (singleton (_ bv0 1))))) )))
+(assert (not (= S (set.union (set.singleton (set.singleton (_ bv1 1)))
+ (set.union (set.singleton (as set.empty (Set (_ BitVec 1))))
+ (set.singleton (set.singleton (_ bv0 1))))) )))
+(assert (not (= S (set.union (set.singleton (set.union (set.singleton (_ bv0 1))
+ (set.singleton (_ bv1 1))))
+ (set.union (set.singleton (as set.empty (Set (_ BitVec 1))))
+ (set.singleton (set.singleton (_ bv1 1))))) )))
+(assert (not (= S (set.union (set.singleton (set.union (set.singleton (_ bv0 1))
+ (set.singleton (_ bv1 1))))
+ (set.union (set.singleton (set.singleton (_ bv0 1)))
+ (set.singleton (set.singleton (_ bv1 1))))) )))
+(assert (not (= S (set.union (set.singleton (set.union (set.singleton (_ bv0 1))
+ (set.singleton (_ bv1 1))))
+ (set.union (set.singleton (as set.empty (Set (_ BitVec 1))))
+ (set.singleton (set.singleton (_ bv0 1))))) )))
; 4 elements in S
-(assert (not (= S (union (singleton (union (singleton (_ bv0 1))
- (singleton (_ bv1 1))))
- (union (singleton (singleton (_ bv1 1)))
- (union (singleton (as emptyset (Set (_ BitVec 1))))
- (singleton (singleton (_ bv0 1)))))) )))
+(assert (not (= S (set.union (set.singleton (set.union (set.singleton (_ bv0 1))
+ (set.singleton (_ bv1 1))))
+ (set.union (set.singleton (set.singleton (_ bv1 1)))
+ (set.union (set.singleton (as set.empty (Set (_ BitVec 1))))
+ (set.singleton (set.singleton (_ bv0 1)))))) )))
(check-sat)
(declare-fun b () (Set (Tuple Int Real)))
(declare-fun x () (Tuple Real Real))
(assert (let ((_let_1 0.0)) (not (= x (tuple _let_1 _let_1)))))
-(assert (member (tuple ((_ tuple_select 0) x) (to_int ((_ tuple_select 1) x))) a))
-(assert (member (tuple (to_int ((_ tuple_select 0) x)) ((_ tuple_select 1) x)) b))
+(assert (set.member (tuple ((_ tuple_select 0) x) (to_int ((_ tuple_select 1) x))) a))
+(assert (set.member (tuple (to_int ((_ tuple_select 0) x)) ((_ tuple_select 1) x)) b))
(assert (not (= ((_ tuple_select 0) x) ((_ tuple_select 1) x))))
(check-sat)
(declare-fun t () (Set Int))
(declare-fun s () (Set Int))
(declare-const v Bool)
-(assert (forall ((q Bool)) (distinct v (subset s t))))
-(assert (= 1 (card t)))
+(assert (forall ((q Bool)) (distinct v (set.subset s t))))
+(assert (= 1 (set.card t)))
(check-sat)
(assert v)
(check-sat)
(let ((e12 (* (- e4) e7)))
(let ((e13 (- e10)))
(let ((e14 (f0 e5 e7 e6)))
-(let ((e15 (member v0 v1)))
-(let ((e16 (member e12 v2)))
-(let ((e17 (member e14 v1)))
+(let ((e15 (set.member v0 v1)))
+(let ((e16 (set.member e12 v2)))
+(let ((e17 (set.member e14 v1)))
(let ((e18 (f1 v3)))
(let ((e19 (f1 v2)))
(let ((e20 (f1 v1)))
(declare-fun f ((Set Bool)) Int)
(declare-fun s () (Set Bool))
-(assert (member true s))
-(assert (member false s))
-(assert (= a (f (as univset (Set Bool)))))
+(assert (set.member true s))
+(assert (set.member false s))
+(assert (= a (f (as set.universe (Set Bool)))))
-(assert (= (f (as emptyset (Set Bool))) 1))
-(assert (= (f (singleton true)) 2))
-(assert (= (f (singleton false)) 3))
-(assert (= (f (union (singleton true) (singleton false))) 4))
+(assert (= (f (as set.empty (Set Bool))) 1))
+(assert (= (f (set.singleton true)) 2))
+(assert (= (f (set.singleton false)) 3))
+(assert (= (f (set.union (set.singleton true) (set.singleton false))) 4))
(check-sat)
(declare-fun st8 () (Set String))
(declare-fun str6 () String)
(declare-fun str7 () String)
-(assert (= 0 (card st8)))
+(assert (= 0 (set.card st8)))
(assert (str.in_re str6 (re.opt re.none)))
(assert (str.in_re (str.substr str7 0 i8) re.allchar))
-(assert (xor true (subset st8 st6) (not (= str7 str6)) true))
+(assert (xor true (set.subset st8 st6) (not (= str7 str6)) true))
(check-sat)
(set-logic ALL)
(synth-fun P ((x (Set Int))) Bool)
-(constraint (not (P (as emptyset (Set Int)))))
-(constraint (not (P (insert 1 2 (as emptyset (Set Int))))))
-(constraint (P (insert 0 (as emptyset (Set Int)))))
-(constraint (P (insert 0 4 5 (as emptyset (Set Int)))))
-(constraint (not (P (singleton 45))))
+(constraint (not (P (as set.empty (Set Int)))))
+(constraint (not (P (set.insert 1 2 (as set.empty (Set Int))))))
+(constraint (P (set.insert 0 (as set.empty (Set Int)))))
+(constraint (P (set.insert 0 4 5 (as set.empty (Set Int)))))
+(constraint (not (P (set.singleton 45))))
(check-synth)
(declare-fun B () (Set Int))
(declare-fun C () (Set Int))
-(assert (and (member x A) (member x B) (member x C)))
-(assert (member y C))
+(assert (and (set.member x A) (set.member x B) (set.member x C)))
+(assert (set.member y C))
(check-sat)
-(assert (= F (insert x y (singleton z))))
-(assert (subset F A))
+(assert (= F (set.insert x y (set.singleton z))))
+(assert (set.subset F A))
(assert (= x y))
(assert (or (> (+ x y z) 3) (< (p x (+ (* 3 y) (* 3 z))) 5)))
-(assert (subset A (insert y (singleton z))))
+(assert (set.subset A (set.insert y (set.singleton z))))
(declare-fun i () Int)
(declare-fun j () Int)
-(assert (subset A (insert g h i (singleton f))))
-(assert (= C (setminus A B) ))
-(assert (subset B A))
-(assert (= C (intersection A B)))
-(assert (member j C))
+(assert (set.subset A (set.insert g h i (set.singleton f))))
+(assert (= C (set.minus A B) ))
+(assert (set.subset B A))
+(assert (= C (set.intersection A B)))
+(assert (set.member j C))
(check-sat)
(declare-fun emptymyTypeSet () (Set myType))
-(assert (= emptymyTypeSet (as emptyset (Set myType))))
+(assert (= emptymyTypeSet (as set.empty (Set myType))))
(declare-fun d () (Array myType |__cvc5_record_pos_(Set myType)_neg_(Set myType)|))
(declare-fun l () (Array myType (Set String)))
-(assert (= (select l A) (union (singleton "L") (singleton "H"))))
-(assert (= (select l B) (singleton "L")))
+(assert (= (select l A) (set.union (set.singleton "L") (set.singleton "H"))))
+(assert (= (select l B) (set.singleton "L")))
(declare-fun ic0_i () (Set myType))
(declare-fun ic0_c () (Set myType))
-(assert (forall ((r myType)) (=> (member r ic0_i) (forall ((r2 myType)) (=> (member r2 (neg (select d r))) (member r2 ic0_c))))))
-(assert (subset (singleton A) ic0_i))
-(assert (or (exists ((e0 myType)) (=> (member e0 ic0_i) (subset (select l A) (select l e0)))) (subset (intersection ic0_i ic0_c) emptymyTypeSet)))
+(assert (forall ((r myType)) (=> (set.member r ic0_i) (forall ((r2 myType)) (=> (set.member r2 (neg (select d r))) (set.member r2 ic0_c))))))
+(assert (set.subset (set.singleton A) ic0_i))
+(assert (or (exists ((e0 myType)) (=> (set.member e0 ic0_i) (set.subset (select l A) (select l e0)))) (set.subset (set.intersection ic0_i ic0_c) emptymyTypeSet)))
(declare-fun ic1_i () (Set myType))
(declare-fun ic1_c () (Set myType))
-(assert (forall ((r myType)) (=> (member r (pos (select d B))) (member r ic1_i))))
-(assert (or (exists ((e1 myType)) (=> (member e1 ic1_i) (subset (select l B) (select l e1)))) (subset (intersection ic1_i ic1_c) emptymyTypeSet)))
+(assert (forall ((r myType)) (=> (set.member r (pos (select d B))) (set.member r ic1_i))))
+(assert (or (exists ((e1 myType)) (=> (set.member e1 ic1_i) (set.subset (select l B) (select l e1)))) (set.subset (set.intersection ic1_i ic1_c) emptymyTypeSet)))
(check-sat)
(declare-fun LIFT (Int) Int)
(declare-fun BIT_BAND (Int Int) Int)
(declare-fun POW2 (Int) Int)
-(declare-fun choose (Int Int Int) Int)
+(declare-fun set.choose (Int Int Int) Int)
(declare-fun DIV (Int Int) Int)
(declare-fun MULT (Int Int) Int)
(declare-fun PLUS (Int Int Int) Int)
(declare-fun i () Int)
(declare-fun head () Int)
(assert (not (or (not (forall ((?A Int) (?i Int) (?v Int)) (= (select1 (store1 ?A ?i ?v) ?i) ?v))) (not (forall ((?A Int) (?i Int) (?j Int) (?v Int)) (=> (not (= ?i ?j)) (= (select1 (store1 ?A ?i ?v) ?j) (select1 ?A ?j))))) (not (forall ((?A Int) (?o Int) (?f Int) (?v Int)) (= (select2 (store2 ?A ?o ?f ?v) ?o ?f) ?v))) (not (forall ((?A Int) (?o Int) (?f Int) (?p Int) (?g Int) (?v Int)) (=> (not (= ?o ?p)) (= (select2 (store2 ?A ?o ?f ?v) ?p ?g) (select2 ?A ?p ?g))))) (not (forall ((?A Int) (?o Int) (?f Int) (?p Int) (?g Int) (?v Int)) (=> (not (= ?f ?g)) (= (select2 (store2 ?A ?o ?f ?v) ?p ?g) (select2 ?A ?p ?g))))) (not (forall ((?x_1 Int) (?y Int)) (= (= (boolIff ?x_1 ?y) true_1) (= (= ?x_1 true_1) (= ?y true_1))))) (not (forall ((?x_1 Int) (?y Int)) (= (= (boolImplies ?x_1 ?y) true_1) (=> (= ?x_1 true_1) (= ?y true_1))))) (not (forall ((?x_1 Int) (?y Int)) (= (= (boolAnd ?x_1 ?y) true_1) (not (or (not (= ?x_1 true_1)) (not (= ?y true_1))))))) (not (forall ((?x_1 Int) (?y Int)) (= (= (boolOr ?x_1 ?y) true_1) (or (= ?x_1 true_1) (= ?y true_1))))) (not (forall ((?x_1 Int)) (! (= (= (boolNot ?x_1) true_1) (not (= ?x_1 true_1))) :pattern ((boolNot ?x_1)) ))) (not (forall ((?x_1 Int) (?y Int)) (= (= (anyEqual ?x_1 ?y) true_1) (= ?x_1 ?y)))) (not (forall ((?x_1 Int) (?y Int)) (! (= (= (anyNeq ?x_1 ?y) true_1) (not (= ?x_1 ?y))) :pattern ((anyNeq ?x_1 ?y)) ))) (not (forall ((?x_1 Int) (?y Int)) (= (= (intLess ?x_1 ?y) true_1) (< ?x_1 ?y)))) (not (forall ((?x_1 Int) (?y Int)) (= (= (intAtMost ?x_1 ?y) true_1) (<= ?x_1 ?y)))) (not (forall ((?x_1 Int) (?y Int)) (= (= (intAtLeast ?x_1 ?y) true_1) (>= ?x_1 ?y)))) (not (forall ((?x_1 Int) (?y Int)) (= (= (intGreater ?x_1 ?y) true_1) (> ?x_1 ?y)))) (not (distinct false_1 true_1)) (not (forall ((?t Int)) (! (= (x ?t ?t) true_1) :pattern ((x ?t ?t)) ))) (not (forall ((?t Int) (?u Int) (?v Int)) (! (=> (not (or (not (= (x ?t ?u) true_1)) (not (= (x ?u ?v) true_1)))) (= (x ?t ?v) true_1)) :pattern ((x ?t ?u) (x ?u ?v)) ))) (not (forall ((?t Int) (?u Int)) (! (=> (not (or (not (= (x ?t ?u) true_1)) (not (= (x ?u ?t) true_1)))) (= ?t ?u)) :pattern ((x ?t ?u) (x ?u ?t)) ))))))
-(assert (not (or (not (distinct UNALLOCATED ALLOCATED FREED BYTE next_foo_name p_foo_name n_foo_name INT4_name PINT4_name PPINT4_name PPfoo_name Pfoo_name foo_name)) (not (forall ((?b0 Int) (?c0 Int)) (! (=> (= (OneByteToInt ?b0) (OneByteToInt ?c0)) (= ?b0 ?c0)) :pattern ((OneByteToInt ?b0) (OneByteToInt ?c0)) ))) (not (forall ((?b0 Int) (?b1 Int) (?c0 Int) (?c1 Int)) (! (=> (= (TwoBytesToInt ?b0 ?b1) (TwoBytesToInt ?c0 ?c1)) (not (or (not (= ?b0 ?c0)) (not (= ?b1 ?c1))))) :pattern ((TwoBytesToInt ?b0 ?b1) (TwoBytesToInt ?c0 ?c1)) ))) (not (forall ((?b0 Int) (?b1 Int) (?b2 Int) (?b3 Int) (?c0 Int) (?c1 Int) (?c2 Int) (?c3 Int)) (! (=> (= (FourBytesToInt ?b0 ?b1 ?b2 ?b3) (FourBytesToInt ?c0 ?c1 ?c2 ?c3)) (not (or (not (= ?b0 ?c0)) (not (= ?b1 ?c1)) (not (= ?b2 ?c2)) (not (= ?b3 ?c3))))) :pattern ((FourBytesToInt ?b0 ?b1 ?b2 ?b3) (FourBytesToInt ?c0 ?c1 ?c2 ?c3)) ))) (not (forall ((?n Int) (?x_1 Int) (?y Int)) (! (=> (= (select1 (AtLeast ?n ?x_1) ?y) true_1) (not (or (not (<= ?x_1 ?y)) (not (= (Rep ?n ?x_1) (Rep ?n ?y)))))) :pattern ((select1 (AtLeast ?n ?x_1) ?y)) ))) (not (forall ((?n Int) (?x_1 Int) (?y Int)) (! (=> (not (or (not (<= ?x_1 ?y)) (not (= (Rep ?n ?x_1) (Rep ?n ?y))))) (= (select1 (AtLeast ?n ?x_1) ?y) true_1)) :pattern ((AtLeast ?n ?x_1) (Rep ?n ?x_1) (Rep ?n ?y)) ))) (not (forall ((?n Int) (?x_1 Int)) (! (= (select1 (AtLeast ?n ?x_1) ?x_1) true_1) :pattern ((AtLeast ?n ?x_1)) ))) (not (forall ((?n Int) (?x_1 Int) (?z Int)) (! (= (Rep ?n ?x_1) (Rep ?n (PLUS ?x_1 ?n ?z))) :pattern ((PLUS ?x_1 ?n ?z)) ))) (not (forall ((?n Int) (?x_1 Int)) (! (exists ((?k Int)) (= (- (Rep ?n ?x_1) ?x_1) (* ?n ?k))) :pattern ((Rep ?n ?x_1)) ))) (not (forall ((?x_1 Int) (?n Int) (?z Int)) (! (=> (<= ?z 0) (= (Equal (HavocArray ?x_1 ?n ?z) Empty) true_1)) :pattern ((HavocArray ?x_1 ?n ?z)) ))) (not (forall ((?x_1 Int) (?n Int) (?z Int)) (! (=> (> ?z 0) (= (Equal (HavocArray ?x_1 ?n ?z) (Difference (AtLeast ?n ?x_1) (AtLeast ?n (PLUS ?x_1 ?n ?z)))) true_1)) :pattern ((HavocArray ?x_1 ?n ?z)) ))) (not (forall ((?x_1 Int)) (not (= (select1 Empty ?x_1) true_1)))) (not (forall ((?x_1 Int) (?y Int)) (! (= (= (select1 (Singleton ?y) ?x_1) true_1) (= ?x_1 ?y)) :pattern ((select1 (Singleton ?y) ?x_1)) ))) (not (forall ((?y Int)) (! (= (select1 (Singleton ?y) ?y) true_1) :pattern ((Singleton ?y)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (= (= (select1 (Union ?S ?T) ?x_1) true_1) (or (= (select1 ?S ?x_1) true_1) (= (select1 ?T ?x_1) true_1))) :pattern ((select1 (Union ?S ?T) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (Union ?S ?T) ?x_1) true_1)) :pattern ((Union ?S ?T) (select1 ?S ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (= (select1 ?T ?x_1) true_1) (= (select1 (Union ?S ?T) ?x_1) true_1)) :pattern ((Union ?S ?T) (select1 ?T ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (= (= (select1 (Intersection ?S ?T) ?x_1) true_1) (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (select1 ?T ?x_1) true_1))))) :pattern ((select1 (Intersection ?S ?T) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (select1 ?T ?x_1) true_1)))) (= (select1 (Intersection ?S ?T) ?x_1) true_1)) :pattern ((Intersection ?S ?T) (select1 ?S ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (select1 ?T ?x_1) true_1)))) (= (select1 (Intersection ?S ?T) ?x_1) true_1)) :pattern ((Intersection ?S ?T) (select1 ?T ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (= (= (select1 (Difference ?S ?T) ?x_1) true_1) (not (or (not (= (select1 ?S ?x_1) true_1)) (not (not (= (select1 ?T ?x_1) true_1)))))) :pattern ((select1 (Difference ?S ?T) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (= (select1 ?S ?x_1) true_1) (or (= (select1 (Difference ?S ?T) ?x_1) true_1) (= (select1 ?T ?x_1) true_1))) :pattern ((Difference ?S ?T) (select1 ?S ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?M Int)) (! (=> (= (select1 (Dereference ?S ?M) ?x_1) true_1) (exists ((?y Int)) (not (or (not (= ?x_1 (select1 ?M ?y))) (not (= (select1 ?S ?y) true_1)))))) :pattern ((select1 (Dereference ?S ?M) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?M Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (Dereference ?S ?M) (select1 ?M ?x_1)) true_1)) :pattern ((select1 ?M ?x_1) (select1 ?S ?x_1) (Dereference ?S ?M)) ))) (not (forall ((?x_1 Int) (?y Int) (?S Int) (?M Int)) (! (=> (not (= (select1 ?S ?x_1) true_1)) (= (Equal (Dereference ?S (store1 ?M ?x_1 ?y)) (Dereference ?S ?M)) true_1)) :pattern ((Dereference ?S (store1 ?M ?x_1 ?y))) ))) (not (forall ((?x_1 Int) (?y Int) (?S Int) (?M Int)) (! (let ((?v_0 (select1 ?M ?x_1))) (=> (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (Equal (Intersection (Inverse ?M ?v_0) ?S) (Singleton ?x_1)) true_1)))) (= (Equal (Dereference ?S (store1 ?M ?x_1 ?y)) (Union (Difference (Dereference ?S ?M) (Singleton ?v_0)) (Singleton ?y))) true_1))) :pattern ((Dereference ?S (store1 ?M ?x_1 ?y))) ))) (not (forall ((?x_1 Int) (?y Int) (?S Int) (?M Int)) (! (=> (not (or (not (= (select1 ?S ?x_1) true_1)) (not (not (= (Equal (Intersection (Inverse ?M (select1 ?M ?x_1)) ?S) (Singleton ?x_1)) true_1))))) (= (Equal (Dereference ?S (store1 ?M ?x_1 ?y)) (Union (Dereference ?S ?M) (Singleton ?y))) true_1)) :pattern ((Dereference ?S (store1 ?M ?x_1 ?y))) ))) (not (forall ((?f Int) (?x_1 Int)) (! (= (select1 (Inverse ?f (select1 ?f ?x_1)) ?x_1) true_1) :pattern ((Inverse ?f (select1 ?f ?x_1))) ))) (not (forall ((?f Int) (?x_1 Int) (?y Int)) (! (= (Equal (Inverse (store1 ?f ?x_1 ?y) ?y) (Union (Inverse ?f ?y) (Singleton ?x_1))) true_1) :pattern ((Inverse (store1 ?f ?x_1 ?y) ?y)) ))) (not (forall ((?f Int) (?x_1 Int) (?y Int) (?z Int)) (! (or (= ?y ?z) (= (Equal (Inverse (store1 ?f ?x_1 ?y) ?z) (Difference (Inverse ?f ?z) (Singleton ?x_1))) true_1)) :pattern ((Inverse (store1 ?f ?x_1 ?y) ?z)) ))) (not (forall ((?S Int) (?T Int)) (! (= (= (Equal ?S ?T) true_1) (not (or (not (= (Subset ?S ?T) true_1)) (not (= (Subset ?T ?S) true_1))))) :pattern ((Equal ?S ?T)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (Subset ?S ?T) true_1)))) (= (select1 ?T ?x_1) true_1)) :pattern ((select1 ?S ?x_1) (Subset ?S ?T)) ))) (not (forall ((?S Int) (?T Int)) (! (or (= (Subset ?S ?T) true_1) (exists ((?x_1 Int)) (not (or (not (= (select1 ?S ?x_1) true_1)) (not (not (= (select1 ?T ?x_1) true_1))))))) :pattern ((Subset ?S ?T)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (not (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (Disjoint ?S ?T) true_1)) (not (= (select1 ?T ?x_1) true_1))))) :pattern ((select1 ?S ?x_1) (Disjoint ?S ?T) (select1 ?T ?x_1)) ))) (not (forall ((?S Int) (?T Int)) (! (or (= (Disjoint ?S ?T) true_1) (exists ((?x_1 Int)) (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (select1 ?T ?x_1) true_1)))))) :pattern ((Disjoint ?S ?T)) ))) (not (forall ((?M Int) (?x_1 Int)) (! (= (select1 (Unified ?M) ?x_1) (select1 (select1 ?M (Field ?x_1)) ?x_1)) :pattern ((select1 (Unified ?M) ?x_1)) ))) (not (forall ((?M Int) (?x_1 Int) (?y Int)) (! (let ((?v_1 (Field ?x_1))) (= (Unified (store1 ?M ?v_1 (store1 (select1 ?M ?v_1) ?x_1 ?y))) (store1 (Unified ?M) ?x_1 ?y))) :pattern ((Unified (store1 ?M (Field ?x_1) (store1 (select1 ?M (Field ?x_1)) ?x_1 ?y)))) ))) (not (forall ((?v Int) (?t Int)) (! (=> (= (select1 (Values ?t) ?v) true_1) (= (HasType ?v ?t) true_1)) :pattern ((select1 (Values ?t) ?v)) ))) (not (forall ((?v Int) (?t Int)) (! (=> (= (HasType ?v ?t) true_1) (= (select1 (Values ?t) ?v) true_1)) :pattern ((HasType ?v ?t) (Values ?t)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a next_foo_name) true_1) (= (Field ?a) next_foo_name)) :pattern ((Match ?a next_foo_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v next_foo_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v foo_name) true_1)))))) :pattern ((HasType ?v next_foo_name)) :pattern ((Match ?v foo_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a p_foo_name) true_1) (= (Field ?a) p_foo_name)) :pattern ((Match ?a p_foo_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v p_foo_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v INT4_name) true_1)))))) :pattern ((HasType ?v p_foo_name)) :pattern ((Match ?v INT4_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a n_foo_name) true_1) (= (Field ?a) n_foo_name)) :pattern ((Match ?a n_foo_name)) ))) (not (forall ((?v Int)) (= (HasType ?v n_foo_name) true_1))) (not (forall ((?a Int)) (! (= (= (Match ?a INT4_name) true_1) (= (Field ?a) INT4_name)) :pattern ((Match ?a INT4_name)) ))) (not (forall ((?v Int)) (= (HasType ?v INT4_name) true_1))) (not (forall ((?a Int)) (! (= (= (Match ?a PINT4_name) true_1) (= (Field ?a) PINT4_name)) :pattern ((Match ?a PINT4_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v PINT4_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v INT4_name) true_1)))))) :pattern ((HasType ?v PINT4_name)) :pattern ((Match ?v INT4_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a PPINT4_name) true_1) (= (Field ?a) PPINT4_name)) :pattern ((Match ?a PPINT4_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v PPINT4_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v PINT4_name) true_1)))))) :pattern ((HasType ?v PPINT4_name)) :pattern ((Match ?v PINT4_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a PPfoo_name) true_1) (= (Field ?a) PPfoo_name)) :pattern ((Match ?a PPfoo_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v PPfoo_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v Pfoo_name) true_1)))))) :pattern ((HasType ?v PPfoo_name)) :pattern ((Match ?v Pfoo_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a Pfoo_name) true_1) (= (Field ?a) Pfoo_name)) :pattern ((Match ?a Pfoo_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v Pfoo_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v foo_name) true_1)))))) :pattern ((HasType ?v Pfoo_name)) :pattern ((Match ?v foo_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a foo_name) true_1) (not (or (not true) (not (= (Match (next_foo ?a) next_foo_name) true_1)) (not (= (Match (p_foo ?a) p_foo_name) true_1)) (not (= (Match (n_foo ?a) n_foo_name) true_1))))) :pattern ((Match ?a foo_name)) ))) (not (forall ((?x_1 Int)) (! (= (next_fooInv (next_foo ?x_1)) ?x_1) :pattern ((next_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (next_foo (next_fooInv ?x_1)) ?x_1) :pattern ((next_fooInv ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_next_foo ?S) ?x_1) true_1) (= (select1 ?S (next_fooInv ?x_1)) true_1)) :pattern ((select1 (S_next_foo ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_next_fooInv ?S) ?x_1) true_1) (= (select1 ?S (next_foo ?x_1)) true_1)) :pattern ((select1 (S_next_fooInv ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_next_foo ?S) (next_foo ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_next_foo ?S)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_next_fooInv ?S) (next_fooInv ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_next_fooInv ?S)) ))) (not (forall ((?x_1 Int)) (! (= (next_foo ?x_1) (+ ?x_1 0)) :pattern ((next_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (next_fooInv ?x_1) (- ?x_1 0)) :pattern ((next_fooInv ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 0 1) (next_fooInv ?x_1)) :pattern ((MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 0 1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_LEFT_PTR ?x_1 1 0) (next_fooInv ?x_1)) :pattern ((MINUS_LEFT_PTR ?x_1 1 0)) ))) (not (forall ((?x_1 Int)) (! (= (p_fooInv (p_foo ?x_1)) ?x_1) :pattern ((p_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (p_foo (p_fooInv ?x_1)) ?x_1) :pattern ((p_fooInv ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_p_foo ?S) ?x_1) true_1) (= (select1 ?S (p_fooInv ?x_1)) true_1)) :pattern ((select1 (S_p_foo ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_p_fooInv ?S) ?x_1) true_1) (= (select1 ?S (p_foo ?x_1)) true_1)) :pattern ((select1 (S_p_fooInv ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_p_foo ?S) (p_foo ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_p_foo ?S)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_p_fooInv ?S) (p_fooInv ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_p_fooInv ?S)) ))) (not (forall ((?x_1 Int)) (! (= (p_foo ?x_1) (+ ?x_1 4)) :pattern ((p_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (p_fooInv ?x_1) (- ?x_1 4)) :pattern ((p_fooInv ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 4 1) (p_fooInv ?x_1)) :pattern ((MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 4 1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_LEFT_PTR ?x_1 1 4) (p_fooInv ?x_1)) :pattern ((MINUS_LEFT_PTR ?x_1 1 4)) ))) (not (forall ((?x_1 Int)) (! (= (n_fooInv (n_foo ?x_1)) ?x_1) :pattern ((n_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (n_foo (n_fooInv ?x_1)) ?x_1) :pattern ((n_fooInv ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_n_foo ?S) ?x_1) true_1) (= (select1 ?S (n_fooInv ?x_1)) true_1)) :pattern ((select1 (S_n_foo ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_n_fooInv ?S) ?x_1) true_1) (= (select1 ?S (n_foo ?x_1)) true_1)) :pattern ((select1 (S_n_fooInv ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_n_foo ?S) (n_foo ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_n_foo ?S)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_n_fooInv ?S) (n_fooInv ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_n_fooInv ?S)) ))) (not (forall ((?x_1 Int)) (! (= (n_foo ?x_1) (+ ?x_1 8)) :pattern ((n_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (n_fooInv ?x_1) (- ?x_1 8)) :pattern ((n_fooInv ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 8 1) (n_fooInv ?x_1)) :pattern ((MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 8 1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_LEFT_PTR ?x_1 1 8) (n_fooInv ?x_1)) :pattern ((MINUS_LEFT_PTR ?x_1 1 8)) ))) (not (forall ((?a Int) (?b Int) (?size Int)) (! (let ((?v_3 (MINUS_BOTH_PTR_OR_BOTH_INT ?a ?b ?size)) (?v_2 (- ?a ?b))) (not (or (not (<= (* ?size ?v_3) ?v_2)) (not (< ?v_2 (* ?size (+ ?v_3 1))))))) :pattern ((MINUS_BOTH_PTR_OR_BOTH_INT ?a ?b ?size)) ))) (not (forall ((?a Int) (?a_size Int) (?b Int)) (! (= (MINUS_LEFT_PTR ?a ?a_size ?b) (- ?a (* ?a_size ?b))) :pattern ((MINUS_LEFT_PTR ?a ?a_size ?b)) ))) (not (forall ((?a Int) (?a_size Int) (?b Int)) (! (= (PLUS ?a ?a_size ?b) (+ ?a (* ?a_size ?b))) :pattern ((PLUS ?a ?a_size ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (= (MULT ?a ?b) (* ?a ?b)) :pattern ((MULT ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (let ((?v_4 (DIV ?a ?b))) (=> (not (or (not (>= ?a 0)) (not (> ?b 0)))) (not (or (not (<= (* ?b ?v_4) ?a)) (not (< ?a (* ?b (+ ?v_4 1)))))))) :pattern ((DIV ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (let ((?v_5 (DIV ?a ?b))) (=> (not (or (not (>= ?a 0)) (not (< ?b 0)))) (not (or (not (<= (* ?b ?v_5) ?a)) (not (< ?a (* ?b (- ?v_5 1)))))))) :pattern ((DIV ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (let ((?v_6 (DIV ?a ?b))) (=> (not (or (not (< ?a 0)) (not (> ?b 0)))) (not (or (not (>= (* ?b ?v_6) ?a)) (not (> ?a (* ?b (- ?v_6 1)))))))) :pattern ((DIV ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (let ((?v_7 (DIV ?a ?b))) (=> (not (or (not (< ?a 0)) (not (< ?b 0)))) (not (or (not (>= (* ?b ?v_7) ?a)) (not (> ?a (* ?b (+ ?v_7 1)))))))) :pattern ((DIV ?a ?b)) ))) (not (= (POW2 1) true_1)) (not (= (POW2 2) true_1)) (not (= (POW2 4) true_1)) (not (= (POW2 8) true_1)) (not (= (POW2 16) true_1)) (not (= (POW2 32) true_1)) (not (= (POW2 64) true_1)) (not (= (POW2 128) true_1)) (not (= (POW2 256) true_1)) (not (= (POW2 512) true_1)) (not (= (POW2 1024) true_1)) (not (= (POW2 2048) true_1)) (not (= (POW2 4096) true_1)) (not (= (POW2 8192) true_1)) (not (= (POW2 16384) true_1)) (not (= (POW2 32768) true_1)) (not (= (POW2 65536) true_1)) (not (= (POW2 131072) true_1)) (not (= (POW2 262144) true_1)) (not (= (POW2 524288) true_1)) (not (= (POW2 1048576) true_1)) (not (= (POW2 2097152) true_1)) (not (= (POW2 4194304) true_1)) (not (= (POW2 8388608) true_1)) (not (= (POW2 16777216) true_1)) (not (= (POW2 33554432) true_1)) (not (forall ((?a Int) (?b Int) (?c Int)) (! (=> (= ?a true_1) (= (choose ?a ?b ?c) ?b)) :pattern ((choose ?a ?b ?c)) ))) (not (forall ((?a Int) (?b Int) (?c Int)) (! (=> (not (= ?a true_1)) (= (choose ?a ?b ?c) ?c)) :pattern ((choose ?a ?b ?c)) ))) (not (forall ((?a Int) (?b Int)) (! (=> (= ?a ?b) (= (BIT_BAND ?a ?b) ?a)) :pattern ((BIT_BAND ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (=> (not (or (not (= (POW2 ?a) true_1)) (not (= (POW2 ?b) true_1)) (not (not (= ?a ?b))))) (= (BIT_BAND ?a ?b) 0)) :pattern ((BIT_BAND ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (=> (or (= ?a 0) (= ?b 0)) (= (BIT_BAND ?a ?b) 0)) :pattern ((BIT_BAND ?a ?b)) ))) (not (forall ((?a Int)) (! (= (= ?a true_1) (not (= (LIFT ?a) 0))) :pattern ((LIFT ?a)) ))) (not (forall ((?a Int)) (! (=> (= ?a 0) (not (= (boolNot ?a) 0))) :pattern ((boolNot ?a)) ))) (not (forall ((?a Int)) (! (=> (not (= ?a 0)) (= (boolNot ?a) 0)) :pattern ((boolNot ?a)) ))) (not (forall ((?a Int)) (! (=> (= ?a 0) (not (= (NULL_CHECK ?a) 0))) :pattern ((NULL_CHECK ?a)) ))) (not (forall ((?a Int)) (! (=> (not (= ?a 0)) (= (NULL_CHECK ?a) 0)) :pattern ((NULL_CHECK ?a)) ))))))
+(assert (not (or (not (distinct UNALLOCATED ALLOCATED FREED BYTE next_foo_name p_foo_name n_foo_name INT4_name PINT4_name PPINT4_name PPfoo_name Pfoo_name foo_name)) (not (forall ((?b0 Int) (?c0 Int)) (! (=> (= (OneByteToInt ?b0) (OneByteToInt ?c0)) (= ?b0 ?c0)) :pattern ((OneByteToInt ?b0) (OneByteToInt ?c0)) ))) (not (forall ((?b0 Int) (?b1 Int) (?c0 Int) (?c1 Int)) (! (=> (= (TwoBytesToInt ?b0 ?b1) (TwoBytesToInt ?c0 ?c1)) (not (or (not (= ?b0 ?c0)) (not (= ?b1 ?c1))))) :pattern ((TwoBytesToInt ?b0 ?b1) (TwoBytesToInt ?c0 ?c1)) ))) (not (forall ((?b0 Int) (?b1 Int) (?b2 Int) (?b3 Int) (?c0 Int) (?c1 Int) (?c2 Int) (?c3 Int)) (! (=> (= (FourBytesToInt ?b0 ?b1 ?b2 ?b3) (FourBytesToInt ?c0 ?c1 ?c2 ?c3)) (not (or (not (= ?b0 ?c0)) (not (= ?b1 ?c1)) (not (= ?b2 ?c2)) (not (= ?b3 ?c3))))) :pattern ((FourBytesToInt ?b0 ?b1 ?b2 ?b3) (FourBytesToInt ?c0 ?c1 ?c2 ?c3)) ))) (not (forall ((?n Int) (?x_1 Int) (?y Int)) (! (=> (= (select1 (AtLeast ?n ?x_1) ?y) true_1) (not (or (not (<= ?x_1 ?y)) (not (= (Rep ?n ?x_1) (Rep ?n ?y)))))) :pattern ((select1 (AtLeast ?n ?x_1) ?y)) ))) (not (forall ((?n Int) (?x_1 Int) (?y Int)) (! (=> (not (or (not (<= ?x_1 ?y)) (not (= (Rep ?n ?x_1) (Rep ?n ?y))))) (= (select1 (AtLeast ?n ?x_1) ?y) true_1)) :pattern ((AtLeast ?n ?x_1) (Rep ?n ?x_1) (Rep ?n ?y)) ))) (not (forall ((?n Int) (?x_1 Int)) (! (= (select1 (AtLeast ?n ?x_1) ?x_1) true_1) :pattern ((AtLeast ?n ?x_1)) ))) (not (forall ((?n Int) (?x_1 Int) (?z Int)) (! (= (Rep ?n ?x_1) (Rep ?n (PLUS ?x_1 ?n ?z))) :pattern ((PLUS ?x_1 ?n ?z)) ))) (not (forall ((?n Int) (?x_1 Int)) (! (exists ((?k Int)) (= (- (Rep ?n ?x_1) ?x_1) (* ?n ?k))) :pattern ((Rep ?n ?x_1)) ))) (not (forall ((?x_1 Int) (?n Int) (?z Int)) (! (=> (<= ?z 0) (= (Equal (HavocArray ?x_1 ?n ?z) Empty) true_1)) :pattern ((HavocArray ?x_1 ?n ?z)) ))) (not (forall ((?x_1 Int) (?n Int) (?z Int)) (! (=> (> ?z 0) (= (Equal (HavocArray ?x_1 ?n ?z) (Difference (AtLeast ?n ?x_1) (AtLeast ?n (PLUS ?x_1 ?n ?z)))) true_1)) :pattern ((HavocArray ?x_1 ?n ?z)) ))) (not (forall ((?x_1 Int)) (not (= (select1 Empty ?x_1) true_1)))) (not (forall ((?x_1 Int) (?y Int)) (! (= (= (select1 (Singleton ?y) ?x_1) true_1) (= ?x_1 ?y)) :pattern ((select1 (Singleton ?y) ?x_1)) ))) (not (forall ((?y Int)) (! (= (select1 (Singleton ?y) ?y) true_1) :pattern ((Singleton ?y)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (= (= (select1 (Union ?S ?T) ?x_1) true_1) (or (= (select1 ?S ?x_1) true_1) (= (select1 ?T ?x_1) true_1))) :pattern ((select1 (Union ?S ?T) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (Union ?S ?T) ?x_1) true_1)) :pattern ((Union ?S ?T) (select1 ?S ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (= (select1 ?T ?x_1) true_1) (= (select1 (Union ?S ?T) ?x_1) true_1)) :pattern ((Union ?S ?T) (select1 ?T ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (= (= (select1 (Intersection ?S ?T) ?x_1) true_1) (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (select1 ?T ?x_1) true_1))))) :pattern ((select1 (Intersection ?S ?T) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (select1 ?T ?x_1) true_1)))) (= (select1 (Intersection ?S ?T) ?x_1) true_1)) :pattern ((Intersection ?S ?T) (select1 ?S ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (select1 ?T ?x_1) true_1)))) (= (select1 (Intersection ?S ?T) ?x_1) true_1)) :pattern ((Intersection ?S ?T) (select1 ?T ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (= (= (select1 (Difference ?S ?T) ?x_1) true_1) (not (or (not (= (select1 ?S ?x_1) true_1)) (not (not (= (select1 ?T ?x_1) true_1)))))) :pattern ((select1 (Difference ?S ?T) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (= (select1 ?S ?x_1) true_1) (or (= (select1 (Difference ?S ?T) ?x_1) true_1) (= (select1 ?T ?x_1) true_1))) :pattern ((Difference ?S ?T) (select1 ?S ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?M Int)) (! (=> (= (select1 (Dereference ?S ?M) ?x_1) true_1) (exists ((?y Int)) (not (or (not (= ?x_1 (select1 ?M ?y))) (not (= (select1 ?S ?y) true_1)))))) :pattern ((select1 (Dereference ?S ?M) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int) (?M Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (Dereference ?S ?M) (select1 ?M ?x_1)) true_1)) :pattern ((select1 ?M ?x_1) (select1 ?S ?x_1) (Dereference ?S ?M)) ))) (not (forall ((?x_1 Int) (?y Int) (?S Int) (?M Int)) (! (=> (not (= (select1 ?S ?x_1) true_1)) (= (Equal (Dereference ?S (store1 ?M ?x_1 ?y)) (Dereference ?S ?M)) true_1)) :pattern ((Dereference ?S (store1 ?M ?x_1 ?y))) ))) (not (forall ((?x_1 Int) (?y Int) (?S Int) (?M Int)) (! (let ((?v_0 (select1 ?M ?x_1))) (=> (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (Equal (Intersection (Inverse ?M ?v_0) ?S) (Singleton ?x_1)) true_1)))) (= (Equal (Dereference ?S (store1 ?M ?x_1 ?y)) (Union (Difference (Dereference ?S ?M) (Singleton ?v_0)) (Singleton ?y))) true_1))) :pattern ((Dereference ?S (store1 ?M ?x_1 ?y))) ))) (not (forall ((?x_1 Int) (?y Int) (?S Int) (?M Int)) (! (=> (not (or (not (= (select1 ?S ?x_1) true_1)) (not (not (= (Equal (Intersection (Inverse ?M (select1 ?M ?x_1)) ?S) (Singleton ?x_1)) true_1))))) (= (Equal (Dereference ?S (store1 ?M ?x_1 ?y)) (Union (Dereference ?S ?M) (Singleton ?y))) true_1)) :pattern ((Dereference ?S (store1 ?M ?x_1 ?y))) ))) (not (forall ((?f Int) (?x_1 Int)) (! (= (select1 (Inverse ?f (select1 ?f ?x_1)) ?x_1) true_1) :pattern ((Inverse ?f (select1 ?f ?x_1))) ))) (not (forall ((?f Int) (?x_1 Int) (?y Int)) (! (= (Equal (Inverse (store1 ?f ?x_1 ?y) ?y) (Union (Inverse ?f ?y) (Singleton ?x_1))) true_1) :pattern ((Inverse (store1 ?f ?x_1 ?y) ?y)) ))) (not (forall ((?f Int) (?x_1 Int) (?y Int) (?z Int)) (! (or (= ?y ?z) (= (Equal (Inverse (store1 ?f ?x_1 ?y) ?z) (Difference (Inverse ?f ?z) (Singleton ?x_1))) true_1)) :pattern ((Inverse (store1 ?f ?x_1 ?y) ?z)) ))) (not (forall ((?S Int) (?T Int)) (! (= (= (Equal ?S ?T) true_1) (not (or (not (= (Subset ?S ?T) true_1)) (not (= (Subset ?T ?S) true_1))))) :pattern ((Equal ?S ?T)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (=> (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (Subset ?S ?T) true_1)))) (= (select1 ?T ?x_1) true_1)) :pattern ((select1 ?S ?x_1) (Subset ?S ?T)) ))) (not (forall ((?S Int) (?T Int)) (! (or (= (Subset ?S ?T) true_1) (exists ((?x_1 Int)) (not (or (not (= (select1 ?S ?x_1) true_1)) (not (not (= (select1 ?T ?x_1) true_1))))))) :pattern ((Subset ?S ?T)) ))) (not (forall ((?x_1 Int) (?S Int) (?T Int)) (! (not (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (Disjoint ?S ?T) true_1)) (not (= (select1 ?T ?x_1) true_1))))) :pattern ((select1 ?S ?x_1) (Disjoint ?S ?T) (select1 ?T ?x_1)) ))) (not (forall ((?S Int) (?T Int)) (! (or (= (Disjoint ?S ?T) true_1) (exists ((?x_1 Int)) (not (or (not (= (select1 ?S ?x_1) true_1)) (not (= (select1 ?T ?x_1) true_1)))))) :pattern ((Disjoint ?S ?T)) ))) (not (forall ((?M Int) (?x_1 Int)) (! (= (select1 (Unified ?M) ?x_1) (select1 (select1 ?M (Field ?x_1)) ?x_1)) :pattern ((select1 (Unified ?M) ?x_1)) ))) (not (forall ((?M Int) (?x_1 Int) (?y Int)) (! (let ((?v_1 (Field ?x_1))) (= (Unified (store1 ?M ?v_1 (store1 (select1 ?M ?v_1) ?x_1 ?y))) (store1 (Unified ?M) ?x_1 ?y))) :pattern ((Unified (store1 ?M (Field ?x_1) (store1 (select1 ?M (Field ?x_1)) ?x_1 ?y)))) ))) (not (forall ((?v Int) (?t Int)) (! (=> (= (select1 (Values ?t) ?v) true_1) (= (HasType ?v ?t) true_1)) :pattern ((select1 (Values ?t) ?v)) ))) (not (forall ((?v Int) (?t Int)) (! (=> (= (HasType ?v ?t) true_1) (= (select1 (Values ?t) ?v) true_1)) :pattern ((HasType ?v ?t) (Values ?t)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a next_foo_name) true_1) (= (Field ?a) next_foo_name)) :pattern ((Match ?a next_foo_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v next_foo_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v foo_name) true_1)))))) :pattern ((HasType ?v next_foo_name)) :pattern ((Match ?v foo_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a p_foo_name) true_1) (= (Field ?a) p_foo_name)) :pattern ((Match ?a p_foo_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v p_foo_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v INT4_name) true_1)))))) :pattern ((HasType ?v p_foo_name)) :pattern ((Match ?v INT4_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a n_foo_name) true_1) (= (Field ?a) n_foo_name)) :pattern ((Match ?a n_foo_name)) ))) (not (forall ((?v Int)) (= (HasType ?v n_foo_name) true_1))) (not (forall ((?a Int)) (! (= (= (Match ?a INT4_name) true_1) (= (Field ?a) INT4_name)) :pattern ((Match ?a INT4_name)) ))) (not (forall ((?v Int)) (= (HasType ?v INT4_name) true_1))) (not (forall ((?a Int)) (! (= (= (Match ?a PINT4_name) true_1) (= (Field ?a) PINT4_name)) :pattern ((Match ?a PINT4_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v PINT4_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v INT4_name) true_1)))))) :pattern ((HasType ?v PINT4_name)) :pattern ((Match ?v INT4_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a PPINT4_name) true_1) (= (Field ?a) PPINT4_name)) :pattern ((Match ?a PPINT4_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v PPINT4_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v PINT4_name) true_1)))))) :pattern ((HasType ?v PPINT4_name)) :pattern ((Match ?v PINT4_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a PPfoo_name) true_1) (= (Field ?a) PPfoo_name)) :pattern ((Match ?a PPfoo_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v PPfoo_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v Pfoo_name) true_1)))))) :pattern ((HasType ?v PPfoo_name)) :pattern ((Match ?v Pfoo_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a Pfoo_name) true_1) (= (Field ?a) Pfoo_name)) :pattern ((Match ?a Pfoo_name)) ))) (not (forall ((?v Int)) (! (= (= (HasType ?v Pfoo_name) true_1) (or (= ?v 0) (not (or (not (> ?v 0)) (not (= (Match ?v foo_name) true_1)))))) :pattern ((HasType ?v Pfoo_name)) :pattern ((Match ?v foo_name)) ))) (not (forall ((?a Int)) (! (= (= (Match ?a foo_name) true_1) (not (or (not true) (not (= (Match (next_foo ?a) next_foo_name) true_1)) (not (= (Match (p_foo ?a) p_foo_name) true_1)) (not (= (Match (n_foo ?a) n_foo_name) true_1))))) :pattern ((Match ?a foo_name)) ))) (not (forall ((?x_1 Int)) (! (= (next_fooInv (next_foo ?x_1)) ?x_1) :pattern ((next_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (next_foo (next_fooInv ?x_1)) ?x_1) :pattern ((next_fooInv ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_next_foo ?S) ?x_1) true_1) (= (select1 ?S (next_fooInv ?x_1)) true_1)) :pattern ((select1 (S_next_foo ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_next_fooInv ?S) ?x_1) true_1) (= (select1 ?S (next_foo ?x_1)) true_1)) :pattern ((select1 (S_next_fooInv ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_next_foo ?S) (next_foo ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_next_foo ?S)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_next_fooInv ?S) (next_fooInv ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_next_fooInv ?S)) ))) (not (forall ((?x_1 Int)) (! (= (next_foo ?x_1) (+ ?x_1 0)) :pattern ((next_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (next_fooInv ?x_1) (- ?x_1 0)) :pattern ((next_fooInv ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 0 1) (next_fooInv ?x_1)) :pattern ((MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 0 1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_LEFT_PTR ?x_1 1 0) (next_fooInv ?x_1)) :pattern ((MINUS_LEFT_PTR ?x_1 1 0)) ))) (not (forall ((?x_1 Int)) (! (= (p_fooInv (p_foo ?x_1)) ?x_1) :pattern ((p_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (p_foo (p_fooInv ?x_1)) ?x_1) :pattern ((p_fooInv ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_p_foo ?S) ?x_1) true_1) (= (select1 ?S (p_fooInv ?x_1)) true_1)) :pattern ((select1 (S_p_foo ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_p_fooInv ?S) ?x_1) true_1) (= (select1 ?S (p_foo ?x_1)) true_1)) :pattern ((select1 (S_p_fooInv ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_p_foo ?S) (p_foo ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_p_foo ?S)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_p_fooInv ?S) (p_fooInv ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_p_fooInv ?S)) ))) (not (forall ((?x_1 Int)) (! (= (p_foo ?x_1) (+ ?x_1 4)) :pattern ((p_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (p_fooInv ?x_1) (- ?x_1 4)) :pattern ((p_fooInv ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 4 1) (p_fooInv ?x_1)) :pattern ((MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 4 1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_LEFT_PTR ?x_1 1 4) (p_fooInv ?x_1)) :pattern ((MINUS_LEFT_PTR ?x_1 1 4)) ))) (not (forall ((?x_1 Int)) (! (= (n_fooInv (n_foo ?x_1)) ?x_1) :pattern ((n_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (n_foo (n_fooInv ?x_1)) ?x_1) :pattern ((n_fooInv ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_n_foo ?S) ?x_1) true_1) (= (select1 ?S (n_fooInv ?x_1)) true_1)) :pattern ((select1 (S_n_foo ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (= (= (select1 (S_n_fooInv ?S) ?x_1) true_1) (= (select1 ?S (n_foo ?x_1)) true_1)) :pattern ((select1 (S_n_fooInv ?S) ?x_1)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_n_foo ?S) (n_foo ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_n_foo ?S)) ))) (not (forall ((?x_1 Int) (?S Int)) (! (=> (= (select1 ?S ?x_1) true_1) (= (select1 (S_n_fooInv ?S) (n_fooInv ?x_1)) true_1)) :pattern ((select1 ?S ?x_1) (S_n_fooInv ?S)) ))) (not (forall ((?x_1 Int)) (! (= (n_foo ?x_1) (+ ?x_1 8)) :pattern ((n_foo ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (n_fooInv ?x_1) (- ?x_1 8)) :pattern ((n_fooInv ?x_1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 8 1) (n_fooInv ?x_1)) :pattern ((MINUS_BOTH_PTR_OR_BOTH_INT ?x_1 8 1)) ))) (not (forall ((?x_1 Int)) (! (= (MINUS_LEFT_PTR ?x_1 1 8) (n_fooInv ?x_1)) :pattern ((MINUS_LEFT_PTR ?x_1 1 8)) ))) (not (forall ((?a Int) (?b Int) (?size Int)) (! (let ((?v_3 (MINUS_BOTH_PTR_OR_BOTH_INT ?a ?b ?size)) (?v_2 (- ?a ?b))) (not (or (not (<= (* ?size ?v_3) ?v_2)) (not (< ?v_2 (* ?size (+ ?v_3 1))))))) :pattern ((MINUS_BOTH_PTR_OR_BOTH_INT ?a ?b ?size)) ))) (not (forall ((?a Int) (?a_size Int) (?b Int)) (! (= (MINUS_LEFT_PTR ?a ?a_size ?b) (- ?a (* ?a_size ?b))) :pattern ((MINUS_LEFT_PTR ?a ?a_size ?b)) ))) (not (forall ((?a Int) (?a_size Int) (?b Int)) (! (= (PLUS ?a ?a_size ?b) (+ ?a (* ?a_size ?b))) :pattern ((PLUS ?a ?a_size ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (= (MULT ?a ?b) (* ?a ?b)) :pattern ((MULT ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (let ((?v_4 (DIV ?a ?b))) (=> (not (or (not (>= ?a 0)) (not (> ?b 0)))) (not (or (not (<= (* ?b ?v_4) ?a)) (not (< ?a (* ?b (+ ?v_4 1)))))))) :pattern ((DIV ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (let ((?v_5 (DIV ?a ?b))) (=> (not (or (not (>= ?a 0)) (not (< ?b 0)))) (not (or (not (<= (* ?b ?v_5) ?a)) (not (< ?a (* ?b (- ?v_5 1)))))))) :pattern ((DIV ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (let ((?v_6 (DIV ?a ?b))) (=> (not (or (not (< ?a 0)) (not (> ?b 0)))) (not (or (not (>= (* ?b ?v_6) ?a)) (not (> ?a (* ?b (- ?v_6 1)))))))) :pattern ((DIV ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (let ((?v_7 (DIV ?a ?b))) (=> (not (or (not (< ?a 0)) (not (< ?b 0)))) (not (or (not (>= (* ?b ?v_7) ?a)) (not (> ?a (* ?b (+ ?v_7 1)))))))) :pattern ((DIV ?a ?b)) ))) (not (= (POW2 1) true_1)) (not (= (POW2 2) true_1)) (not (= (POW2 4) true_1)) (not (= (POW2 8) true_1)) (not (= (POW2 16) true_1)) (not (= (POW2 32) true_1)) (not (= (POW2 64) true_1)) (not (= (POW2 128) true_1)) (not (= (POW2 256) true_1)) (not (= (POW2 512) true_1)) (not (= (POW2 1024) true_1)) (not (= (POW2 2048) true_1)) (not (= (POW2 4096) true_1)) (not (= (POW2 8192) true_1)) (not (= (POW2 16384) true_1)) (not (= (POW2 32768) true_1)) (not (= (POW2 65536) true_1)) (not (= (POW2 131072) true_1)) (not (= (POW2 262144) true_1)) (not (= (POW2 524288) true_1)) (not (= (POW2 1048576) true_1)) (not (= (POW2 2097152) true_1)) (not (= (POW2 4194304) true_1)) (not (= (POW2 8388608) true_1)) (not (= (POW2 16777216) true_1)) (not (= (POW2 33554432) true_1)) (not (forall ((?a Int) (?b Int) (?c Int)) (! (=> (= ?a true_1) (= (set.choose ?a ?b ?c) ?b)) :pattern ((set.choose ?a ?b ?c)) ))) (not (forall ((?a Int) (?b Int) (?c Int)) (! (=> (not (= ?a true_1)) (= (set.choose ?a ?b ?c) ?c)) :pattern ((set.choose ?a ?b ?c)) ))) (not (forall ((?a Int) (?b Int)) (! (=> (= ?a ?b) (= (BIT_BAND ?a ?b) ?a)) :pattern ((BIT_BAND ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (=> (not (or (not (= (POW2 ?a) true_1)) (not (= (POW2 ?b) true_1)) (not (not (= ?a ?b))))) (= (BIT_BAND ?a ?b) 0)) :pattern ((BIT_BAND ?a ?b)) ))) (not (forall ((?a Int) (?b Int)) (! (=> (or (= ?a 0) (= ?b 0)) (= (BIT_BAND ?a ?b) 0)) :pattern ((BIT_BAND ?a ?b)) ))) (not (forall ((?a Int)) (! (= (= ?a true_1) (not (= (LIFT ?a) 0))) :pattern ((LIFT ?a)) ))) (not (forall ((?a Int)) (! (=> (= ?a 0) (not (= (boolNot ?a) 0))) :pattern ((boolNot ?a)) ))) (not (forall ((?a Int)) (! (=> (not (= ?a 0)) (= (boolNot ?a) 0)) :pattern ((boolNot ?a)) ))) (not (forall ((?a Int)) (! (=> (= ?a 0) (not (= (NULL_CHECK ?a) 0))) :pattern ((NULL_CHECK ?a)) ))) (not (forall ((?a Int)) (! (=> (not (= ?a 0)) (= (NULL_CHECK ?a) 0)) :pattern ((NULL_CHECK ?a)) ))))))
(assert (let ((?v_52 (forall ((?a Int)) (! (let ((?v_53 (Field ?a))) (= (HasType (select1 (select1 Mem_3 ?v_53) ?a) ?v_53) true_1)) :pattern ((select1 (select1 Mem_3 (Field ?a)) ?a)) ))) (?v_51 (= (HasType result_bar_24_4_1__0 INT4_name) true_1)) (?v_50 (not (or (not (<= 0 head_0)) (not (<= head_0 0))))) (?v_49 (= head_0 0)) (?v_48 (=> true (=> false true))) (?v_44 (= (HasType sum_1 INT4_name) true_1))) (let ((?v_47 (not ?v_44)) (?v_29 (= (HasType i_1 INT4_name) true_1))) (let ((?v_35 (not ?v_29)) (?v_43 (= (HasType head_1 Pfoo_name) true_1))) (let ((?v_46 (not ?v_43)) (?v_28 (forall ((?a Int)) (! (let ((?v_54 (Field ?a))) (= (HasType (select1 (select1 Mem_1 ?v_54) ?a) ?v_54) true_1)) :pattern ((select1 (select1 Mem_1 (Field ?a)) ?a)) )))) (let ((?v_42 (not ?v_28)) (?v_12 (Field 0))) (let ((?v_10 (select1 (select1 Mem ?v_12) 0)) (?v_45 (select1 (select1 Mem_1 ?v_12) 0)) (?v_11 (forall ((?f Int)) (! (let ((?v_55 (select1 alloc (Base ?f)))) (or (= ?v_55 UNALLOCATED) (= ?v_55 ?v_55))) :pattern ((select1 alloc (Base ?f))) ))) (?v_41 (next_foo head_0)) (?v_22 (not ?v_49)) (?v_19 (n_foo head_0))) (let ((?v_23 (Field ?v_19))) (let ((?v_24 (select1 (select1 Mem_1 ?v_23) ?v_19))) (let ((?v_40 (< i_1 ?v_24)) (?v_30 (= (HasType tempBoogie0_2 INT4_name) true_1))) (let ((?v_36 (not ?v_30)) (?v_39 (= (HasType i_2 INT4_name) true_1)) (?v_14 (= (HasType head_0 Pfoo_name) true_1))) (let ((?v_17 (not ?v_14)) (?v_34 (forall ((?a Int)) (! (let ((?v_56 (Field ?a))) (= (HasType (select1 (select1 Mem_2 ?v_56) ?a) ?v_56) true_1)) :pattern ((select1 (select1 Mem_2 (Field ?a)) ?a)) )))) (let ((?v_38 (not ?v_34)) (?v_21 (select1 (select1 Mem_0 ?v_12) 0)) (?v_37 (not (or (not (<= 0 i_2)) (not (<= i_2 (select1 (select1 Mem_2 ?v_23) ?v_19)))))) (?v_25 (p_foo head_0))) (let ((?v_26 (select1 (select1 Mem_1 (Field ?v_25)) ?v_25))) (let ((?v_27 (PLUS ?v_26 4 i_1))) (let ((?v_32 (Field ?v_27))) (let ((?v_33 (select1 Mem_1 ?v_32)) (?v_31 (not (= ?v_26 0))) (?v_15 (= (HasType sum_0 INT4_name) true_1))) (let ((?v_18 (not ?v_15)) (?v_2 (= (HasType 0 INT4_name) true_1))) (let ((?v_8 (not ?v_2)) (?v_13 (forall ((?a Int)) (! (let ((?v_57 (Field ?a))) (= (HasType (select1 (select1 Mem_0 ?v_57) ?a) ?v_57) true_1)) :pattern ((select1 (select1 Mem_0 (Field ?a)) ?a)) )))) (let ((?v_16 (not ?v_13)) (?v_4 (not (<= 0 0)))) (let ((?v_20 (not (or ?v_4 (not (<= 0 (select1 (select1 Mem_0 ?v_23) ?v_19)))))) (?v_5 (not (or ?v_4 ?v_4))) (?v_0 (= (HasType head1 Pfoo_name) true_1))) (let ((?v_7 (not ?v_0)) (?v_1 (forall ((?a Int)) (! (let ((?v_58 (Field ?a))) (= (HasType (select1 (select1 Mem ?v_58) ?a) ?v_58) true_1)) :pattern ((select1 (select1 Mem (Field ?a)) ?a)) )))) (let ((?v_6 (not ?v_1)) (?v_9 (not (or ?v_4 ?v_4 ?v_4 ?v_4))) (?v_3 (= (HasType sum INT4_name) true_1))) (not (=> true (=> ?v_0 (=> ?v_1 (=> (forall ((?H_pfoo Int)) (let ((?v_59 (n_foo ?H_pfoo))) (let ((?v_61 (select1 (select1 Mem (Field ?v_59)) ?v_59)) (?v_60 (p_foo ?H_pfoo))) (=> (= (HasType ?H_pfoo Pfoo_name) true_1) (not (or (not (>= ?v_61 0)) (not (= (Subset Empty (HavocArray (select1 (select1 Mem (Field ?v_60)) ?v_60) 4 ?v_61)) true_1)) (not (forall ((?H_pint Int)) (! (=> (= (select1 (HavocArray (select1 (select1 Mem (Field ?v_60)) ?v_60) 4 ?v_61) ?H_pint) true_1) (= (HasType ?H_pint PINT4_name) true_1)) :pattern ((select1 (HavocArray (select1 (select1 Mem (Field ?v_60)) ?v_60) 4 ?v_61) ?H_pint)) ))))))))) (=> true (=> (not (= (select1 alloc head1) UNALLOCATED)) (=> (= (HasType head Pfoo_name) true_1) (=> ?v_0 (=> (= (HasType i INT4_name) true_1) (=> ?v_3 (=> (= (HasType result_bar_24_4_1_ INT4_name) true_1) (=> true (=> true (=> true (=> true (=> true (=> true (not (or ?v_6 (not (=> ?v_1 (not (or ?v_7 (not (=> ?v_0 (not (or ?v_8 (not (=> ?v_2 (not (or (not ?v_3) (not (=> ?v_3 (=> ?v_5 (=> true (=> ?v_5 (=> ?v_5 (=> true (=> ?v_5 (not (or ?v_6 (not (=> ?v_1 (not (or ?v_7 (not (=> ?v_0 (not (or ?v_8 (not (=> ?v_2 (not (or ?v_8 (not (=> ?v_2 (=> ?v_9 (=> true (=> ?v_9 (=> ?v_9 (=> true (=> ?v_11 (=> (forall ((?f Int) (?m Int)) (! (let ((?v_62 (select1 (select1 Mem ?f) ?m))) (= ?v_62 ?v_62)) :pattern ((select1 (select1 Mem ?f) ?m)) )) (=> (= ?v_10 ?v_10) (not (or ?v_6 (not (=> ?v_1 (not (or ?v_7 (not (=> ?v_0 (not (or ?v_8 (not (=> ?v_2 (not (or ?v_8 (not (=> ?v_2 (=> true (=> true (=> true (=> ?v_11 (=> (forall ((?f Int) (?m Int)) (! (= (select1 (select1 Mem_0 ?f) ?m) (select1 (select1 Mem ?f) ?m)) :pattern ((select1 (select1 Mem_0 ?f) ?m)) )) (=> (= ?v_21 ?v_10) (=> ?v_13 (=> ?v_14 (=> (= (HasType i_0 INT4_name) true_1) (=> ?v_15 (=> true (not (or (not (=> true (=> true (=> ?v_22 (=> true (=> true (=> true (not (or ?v_16 (not (=> ?v_13 (not (or ?v_17 (not (=> ?v_14 (not (or ?v_8 (not (=> ?v_2 (not (or ?v_18 (not (=> ?v_15 (=> ?v_5 (=> true (=> ?v_5 (=> ?v_5 (=> true (=> ?v_5 (not (or ?v_16 (not (=> ?v_13 (not (or ?v_17 (not (=> ?v_14 (not (or ?v_8 (not (=> ?v_2 (not (or ?v_18 (not (=> ?v_15 (=> ?v_5 (=> true (=> ?v_5 (=> ?v_5 (=> true (not (or (not ?v_20) (not (=> ?v_20 (=> ?v_11 (=> (forall ((?f Int) (?m Int)) (! (let ((?v_63 (select1 (select1 Mem_0 ?f) ?m))) (= ?v_63 ?v_63)) :pattern ((select1 (select1 Mem_0 ?f) ?m)) )) (=> (= ?v_21 ?v_21) (not (or ?v_16 (not (=> ?v_13 (not (or ?v_17 (not (=> ?v_14 (not (or ?v_8 (not (=> ?v_2 (not (or ?v_18 (not (=> ?v_15 (=> ?v_22 (=> true (=> true (=> true (=> (not (or (not (<= 0 i_1)) (not (<= i_1 ?v_24)))) (=> ?v_11 (=> (forall ((?f Int) (?m Int)) (! (= (select1 (select1 Mem_1 ?f) ?m) (select1 (select1 Mem_0 ?f) ?m)) :pattern ((select1 (select1 Mem_1 ?f) ?m)) )) (=> (= ?v_45 ?v_21) (=> ?v_28 (=> ?v_14 (=> ?v_29 (=> ?v_44 (=> ?v_22 (=> true (not (or (not (=> true (=> true (=> ?v_40 (=> true (=> true (=> true (=> ?v_22 (=> ?v_31 (=> (= tempBoogie0_2 (PLUS sum_1 1 (select1 ?v_33 ?v_27))) (not (or ?v_42 (not (=> ?v_28 (not (or ?v_17 (not (=> ?v_14 (not (or ?v_35 (not (=> ?v_29 (not (or ?v_36 (not (=> ?v_30 (=> true (=> true (=> true (=> ?v_22 (=> ?v_31 (=> (= Mem_2 (store1 Mem_1 ?v_32 (store1 ?v_33 ?v_27 42))) (not (or ?v_38 (not (=> ?v_34 (not (or ?v_17 (not (=> ?v_14 (not (or ?v_35 (not (=> ?v_29 (not (or ?v_36 (not (=> ?v_30 (=> true (=> true (=> true (=> (= i_2 (PLUS i_1 1 1)) (=> true (=> true (=> true (not (or (not ?v_37) (not (=> ?v_37 (=> ?v_11 (=> (forall ((?f Int) (?m Int)) (! (= (select1 (select1 Mem_2 ?f) ?m) (select1 (select1 Mem_0 ?f) ?m)) :pattern ((select1 (select1 Mem_2 ?f) ?m)) )) (=> (= (select1 (select1 Mem_2 ?v_12) 0) ?v_21) (not (or ?v_38 (not (=> ?v_34 (not (or ?v_17 (not (=> ?v_14 (not (or (not ?v_39) (not (=> ?v_39 (not (or ?v_36 (not (=> ?v_30 (=> ?v_22 ?v_48))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) (not (=> true (=> true (=> (not ?v_40) (=> true (=> true (=> true (=> ?v_22 (=> (= head_1 (select1 (select1 Mem_1 (Field ?v_41)) ?v_41)) (not (or ?v_42 (not (=> ?v_28 (not (or ?v_46 (not (=> ?v_43 (not (or ?v_35 (not (=> ?v_29 (not (or ?v_47 (not (=> ?v_44 (=> true (=> true (=> true (=> ?v_11 (=> (forall ((?f Int) (?m Int)) (! (= (select1 (select1 Mem_1 ?f) ?m) (select1 (select1 Mem ?f) ?m)) :pattern ((select1 (select1 Mem_1 ?f) ?m)) )) (=> (= ?v_45 ?v_10) (not (or ?v_42 (not (=> ?v_28 (not (or ?v_46 (not (=> ?v_43 (not (or ?v_35 (not (=> ?v_29 (not (or ?v_47 (not (=> ?v_44 ?v_48)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) (not (=> true (=> true (=> ?v_49 (=> ?v_50 (=> true (=> ?v_50 (=> ?v_50 (=> true (=> ?v_50 (=> (forall ((?m Int)) (! (let ((?v_65 (Field ?m)) (?v_64 (not (not (= (select1 alloc (Base ?m)) ALLOCATED))))) (=> (not (or ?v_64 ?v_64)) (= (select1 (select1 Mem_0 ?v_65) ?m) (select1 (select1 Mem ?v_65) ?m)))) :pattern ((select1 (select1 Mem_0 (Field ?m)) ?m)) )) (=> ?v_50 (=> true (=> (= LOOP_12_alloc_1 LOOP_12_alloc_0) (=> (= i_3 i_0) (=> (= sum_2 sum_0) (=> (= tempBoogie0_3 tempBoogie0_0) (=> (= head_2 head_0) (=> (= result_bar_24_4_1__0 sum_0) (=> (= LOOP_12_Mem_1 LOOP_12_Mem_0) (=> (= Mem_3 Mem_0) (=> true (=> true (not (or (not ?v_51) (not (=> ?v_51 (not (or (not ?v_52) (not (=> ?v_52 true)))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
(check-sat)
(exit)
(declare-fun succ$a (Msg_list_set$ Msg_list$) Msg_set$)
(declare-fun succ$b (Agent_list_set$ Agent_list$) Agent_set$)
(declare-fun append$ (Event_list$ Event_list$) Event_list$)
-(declare-fun insert$ (Msg$ Msg_set$) Msg_set$)
-(declare-fun member$ (Agent$ Agent_set$) Bool)
+(declare-fun set.insert$ (Msg$ Msg_set$) Msg_set$)
+(declare-fun set.member$ (Agent$ Agent_set$) Bool)
(declare-fun splice$ (Event_list$) (-> Event_list$ Event_list$))
(declare-fun append$a (Msg_list$ Msg_list$) Msg_list$)
(declare-fun append$b (Agent_list$ Agent_list$) Agent_list$)
(declare-fun collect$ ((-> Msg$ Bool)) Msg_set$)
-(declare-fun insert$a (Event$) (-> Event_list$ Event_list$))
-(declare-fun insert$b (Event$ Event_set$) Event_set$)
-(declare-fun insert$c (Agent$ Agent_set$) Agent_set$)
-(declare-fun insert$d (Msg$ Msg_list$) Msg_list$)
-(declare-fun insert$e (Agent$ Agent_list$) Agent_list$)
+(declare-fun set.insert$a (Event$) (-> Event_list$ Event_list$))
+(declare-fun set.insert$b (Event$ Event_set$) Event_set$)
+(declare-fun set.insert$c (Agent$ Agent_set$) Agent_set$)
+(declare-fun set.insert$d (Msg$ Msg_list$) Msg_list$)
+(declare-fun set.insert$e (Agent$ Agent_list$) Agent_list$)
(declare-fun less_eq$ (Msg_set$ Msg_set$) Bool)
(declare-fun list_ex$ ((-> Event$ Bool)) (-> Event_list$ Bool))
-(declare-fun member$a (Msg$ Msg_set$) Bool)
-(declare-fun member$b (Event$ Event_set$) Bool)
-(declare-fun member$c (Event_list$ Event_list_set$) Bool)
-(declare-fun member$d (Event_list$ Event$) Bool)
-(declare-fun member$e (Msg_list$ Msg_list_set$) Bool)
-(declare-fun member$f (Agent_list$ Agent_list_set$) Bool)
-(declare-fun member$g (Msg_list$ Msg$) Bool)
-(declare-fun member$h (Agent_list$ Agent$) Bool)
+(declare-fun set.member$a (Msg$ Msg_set$) Bool)
+(declare-fun set.member$b (Event$ Event_set$) Bool)
+(declare-fun set.member$c (Event_list$ Event_list_set$) Bool)
+(declare-fun set.member$d (Event_list$ Event$) Bool)
+(declare-fun set.member$e (Msg_list$ Msg_list_set$) Bool)
+(declare-fun set.member$f (Agent_list$ Agent_list_set$) Bool)
+(declare-fun set.member$g (Msg_list$ Msg$) Bool)
+(declare-fun set.member$h (Agent_list$ Agent$) Bool)
(declare-fun rotate1$ (Event_list$) Event_list$)
(declare-fun subseqs$ (Event_list$) Event_list_list$)
(declare-fun antimono$ ((-> Msg_set$ Msg_set$)) Bool)
(declare-fun takeWhile$a ((-> Msg$ Bool) Msg_list$) Msg_list$)
(declare-fun takeWhile$b ((-> Agent$ Bool) Agent_list$) Agent_list$)
(declare-fun product_lists$ (Event_list_list$) Event_list_list$)
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent$)) (! (= (uue$ ?v0 ?v1) (member$ ?v1 ?v0)) :pattern ((uue$ ?v0 ?v1)))) :named a0))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg$)) (! (= (uuf$ ?v0 ?v1) (member$a ?v1 ?v0)) :pattern ((uuf$ ?v0 ?v1)))) :named a1))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event$)) (! (= (uud$ ?v0 ?v1) (member$b ?v1 ?v0)) :pattern ((uud$ ?v0 ?v1)))) :named a2))
-(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (! (= (uuq$ ?v0 ?v1 ?v2) (ite (member$ ?v1 bad$) (insert$ ?v2 (knows$ spy$ ?v0)) (knows$ spy$ ?v0))) :pattern ((uuq$ ?v0 ?v1 ?v2)))) :named a3))
-(assert (! (forall ((?v0 Event_list_set$) (?v1 Event_list$) (?v2 Event$)) (! (= (uuj$ ?v0 ?v1 ?v2) (member$c (append$ ?v1 (cons$ ?v2 nil$)) ?v0)) :pattern ((uuj$ ?v0 ?v1 ?v2)))) :named a4))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (! (= (uun$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (member$ ?v2 ?v1))) :pattern ((uun$ ?v0 ?v1 ?v2)))) :named a5))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (! (= (uul$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (member$a ?v2 ?v1))) :pattern ((uul$ ?v0 ?v1 ?v2)))) :named a6))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (! (= (uum$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (member$b ?v2 ?v1))) :pattern ((uum$ ?v0 ?v1 ?v2)))) :named a7))
-(assert (! (forall ((?v0 Agent_set$) (?v1 (-> Agent$ Bool)) (?v2 Agent$)) (! (= (uub$ ?v0 ?v1 ?v2) (and (member$ ?v2 ?v0) (?v1 ?v2))) :pattern ((uub$ ?v0 ?v1 ?v2)))) :named a8))
-(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg$ Bool)) (?v2 Msg$)) (! (= (uuc$ ?v0 ?v1 ?v2) (and (member$a ?v2 ?v0) (?v1 ?v2))) :pattern ((uuc$ ?v0 ?v1 ?v2)))) :named a9))
-(assert (! (forall ((?v0 Event_set$) (?v1 (-> Event$ Bool)) (?v2 Event$)) (! (= (uua$ ?v0 ?v1 ?v2) (and (member$b ?v2 ?v0) (?v1 ?v2))) :pattern ((uua$ ?v0 ?v1 ?v2)))) :named a10))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent$)) (! (= (uue$ ?v0 ?v1) (set.member$ ?v1 ?v0)) :pattern ((uue$ ?v0 ?v1)))) :named a0))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg$)) (! (= (uuf$ ?v0 ?v1) (set.member$a ?v1 ?v0)) :pattern ((uuf$ ?v0 ?v1)))) :named a1))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event$)) (! (= (uud$ ?v0 ?v1) (set.member$b ?v1 ?v0)) :pattern ((uud$ ?v0 ?v1)))) :named a2))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (! (= (uuq$ ?v0 ?v1 ?v2) (ite (set.member$ ?v1 bad$) (set.insert$ ?v2 (knows$ spy$ ?v0)) (knows$ spy$ ?v0))) :pattern ((uuq$ ?v0 ?v1 ?v2)))) :named a3))
+(assert (! (forall ((?v0 Event_list_set$) (?v1 Event_list$) (?v2 Event$)) (! (= (uuj$ ?v0 ?v1 ?v2) (set.member$c (append$ ?v1 (cons$ ?v2 nil$)) ?v0)) :pattern ((uuj$ ?v0 ?v1 ?v2)))) :named a4))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (! (= (uun$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (set.member$ ?v2 ?v1))) :pattern ((uun$ ?v0 ?v1 ?v2)))) :named a5))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (! (= (uul$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (set.member$a ?v2 ?v1))) :pattern ((uul$ ?v0 ?v1 ?v2)))) :named a6))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (! (= (uum$ ?v0 ?v1 ?v2) (or (= ?v2 ?v0) (set.member$b ?v2 ?v1))) :pattern ((uum$ ?v0 ?v1 ?v2)))) :named a7))
+(assert (! (forall ((?v0 Agent_set$) (?v1 (-> Agent$ Bool)) (?v2 Agent$)) (! (= (uub$ ?v0 ?v1 ?v2) (and (set.member$ ?v2 ?v0) (?v1 ?v2))) :pattern ((uub$ ?v0 ?v1 ?v2)))) :named a8))
+(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg$ Bool)) (?v2 Msg$)) (! (= (uuc$ ?v0 ?v1 ?v2) (and (set.member$a ?v2 ?v0) (?v1 ?v2))) :pattern ((uuc$ ?v0 ?v1 ?v2)))) :named a9))
+(assert (! (forall ((?v0 Event_set$) (?v1 (-> Event$ Bool)) (?v2 Event$)) (! (= (uua$ ?v0 ?v1 ?v2) (and (set.member$b ?v2 ?v0) (?v1 ?v2))) :pattern ((uua$ ?v0 ?v1 ?v2)))) :named a10))
(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 (-> Msg$ Bool)) (?v2 Msg$)) (! (= (uu$ ?v0 ?v1 ?v2) (and (?v0 ?v2) (?v1 ?v2))) :pattern ((uu$ ?v0 ?v1 ?v2)))) :named a11))
(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool)) (?v2 Msg$)) (! (= (uuk$ ?v0 ?v1 ?v2) (=> (not (= ?v2 ?v0)) (?v1 ?v2))) :pattern ((uuk$ ?v0 ?v1 ?v2)))) :named a12))
(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event$)) (! (= (uui$ ?v0 ?v1 ?v2) (or (not (?v0 ?v2)) (= ?v1 ?v2))) :pattern ((uui$ ?v0 ?v1 ?v2)))) :named a13))
(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (! (= (uup$ ?v0 ?v1 ?v2) (knows$ spy$ ?v0)) :pattern ((uup$ ?v0 ?v1 ?v2)))) :named a14))
-(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Msg$)) (! (= (uus$ ?v0 ?v1 ?v2 ?v3) (ite (= ?v2 ?v0) (insert$ ?v3 (knows$ ?v0 ?v1)) (knows$ ?v0 ?v1))) :pattern ((uus$ ?v0 ?v1 ?v2 ?v3)))) :named a15))
-(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (! (= (uuo$ ?v0 ?v1 ?v2 ?v3) (insert$ ?v3 (knows$ spy$ ?v0))) :pattern ((uuo$ ?v0 ?v1 ?v2 ?v3)))) :named a16))
-(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Agent$) (?v4 Msg$)) (! (= (uur$ ?v0 ?v1 ?v2 ?v3 ?v4) (ite (= ?v2 ?v0) (insert$ ?v4 (knows$ ?v0 ?v1)) (knows$ ?v0 ?v1))) :pattern ((uur$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a17))
+(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Msg$)) (! (= (uus$ ?v0 ?v1 ?v2 ?v3) (ite (= ?v2 ?v0) (set.insert$ ?v3 (knows$ ?v0 ?v1)) (knows$ ?v0 ?v1))) :pattern ((uus$ ?v0 ?v1 ?v2 ?v3)))) :named a15))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (! (= (uuo$ ?v0 ?v1 ?v2 ?v3) (set.insert$ ?v3 (knows$ spy$ ?v0))) :pattern ((uuo$ ?v0 ?v1 ?v2 ?v3)))) :named a16))
+(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Agent$) (?v4 Msg$)) (! (= (uur$ ?v0 ?v1 ?v2 ?v3 ?v4) (ite (= ?v2 ?v0) (set.insert$ ?v4 (knows$ ?v0 ?v1)) (knows$ ?v0 ?v1))) :pattern ((uur$ ?v0 ?v1 ?v2 ?v3 ?v4)))) :named a17))
(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (uug$ ?v0 ?v1) false) :pattern ((uug$ ?v0 ?v1)))) :named a18))
(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (uuh$ ?v0 ?v1) true) :pattern ((uuh$ ?v0 ?v1)))) :named a19))
(assert (! (not (less_eq$ (knows$ spy$ (takeWhile$ p$ nil$)) (knows$ spy$ nil$))) :named a20))
(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (takeWhile$ ?v0 (takeWhile$ ?v0 ?v1)) (takeWhile$ ?v0 ?v1))) :named a21))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (=> (forall ((?v2 Event$)) (=> (member$b ?v2 ?v0) (member$b ?v2 ?v1))) (less_eq$a ?v0 ?v1))) :named a22))
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (=> (forall ((?v2 Agent$)) (=> (member$ ?v2 ?v0) (member$ ?v2 ?v1))) (less_eq$b ?v0 ?v1))) :named a23))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (forall ((?v2 Msg$)) (=> (member$a ?v2 ?v0) (member$a ?v2 ?v1))) (less_eq$ ?v0 ?v1))) :named a24))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (=> (forall ((?v2 Event$)) (=> (set.member$b ?v2 ?v0) (set.member$b ?v2 ?v1))) (less_eq$a ?v0 ?v1))) :named a22))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (=> (forall ((?v2 Agent$)) (=> (set.member$ ?v2 ?v0) (set.member$ ?v2 ?v1))) (less_eq$b ?v0 ?v1))) :named a23))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (forall ((?v2 Msg$)) (=> (set.member$a ?v2 ?v0) (set.member$a ?v2 ?v1))) (less_eq$ ?v0 ?v1))) :named a24))
(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) (= ?v0 ?v1))) :named a25))
(assert (! (forall ((?v0 Msg_set$)) (less_eq$ ?v0 ?v0)) :named a26))
(assert (! (forall ((?v0 (-> Event$ Bool))) (! (= (takeWhile$ ?v0 nil$) nil$) :pattern ((takeWhile$ ?v0)))) :named a27))
(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg$ Bool)) (?v2 (-> Msg$ Bool))) (= (less_eq$ ?v0 (collect$ (uu$ ?v1 ?v2))) (and (less_eq$ ?v0 (collect$ ?v1)) (less_eq$ ?v0 (collect$ ?v2))))) :named a28))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$) (?v3 (-> Event$ Bool))) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v1 (collect$a (uua$ ?v2 ?v3)))) (?v3 ?v0))) :named a29))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$) (?v3 (-> Agent$ Bool))) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v1 (collect$b (uub$ ?v2 ?v3)))) (?v3 ?v0))) :named a30))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$) (?v3 (-> Msg$ Bool))) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v1 (collect$ (uuc$ ?v2 ?v3)))) (?v3 ?v0))) :named a31))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$) (?v3 (-> Event$ Bool))) (=> (and (set.member$b ?v0 ?v1) (less_eq$a ?v1 (collect$a (uua$ ?v2 ?v3)))) (?v3 ?v0))) :named a29))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$) (?v3 (-> Agent$ Bool))) (=> (and (set.member$ ?v0 ?v1) (less_eq$b ?v1 (collect$b (uub$ ?v2 ?v3)))) (?v3 ?v0))) :named a30))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$) (?v3 (-> Msg$ Bool))) (=> (and (set.member$a ?v0 ?v1) (less_eq$ ?v1 (collect$ (uuc$ ?v2 ?v3)))) (?v3 ?v0))) :named a31))
(assert (! (forall ((?v0 Event_set$) (?v1 (-> Event$ Bool))) (less_eq$a (collect$a (uua$ ?v0 ?v1)) ?v0)) :named a32))
(assert (! (forall ((?v0 Agent_set$) (?v1 (-> Agent$ Bool))) (less_eq$b (collect$b (uub$ ?v0 ?v1)) ?v0)) :named a33))
(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg$ Bool))) (less_eq$ (collect$ (uuc$ ?v0 ?v1)) ?v0)) :named a34))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (less_eq$a ?v0 ?v1) (forall ((?v4 Event$)) (=> (and (member$b ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$a (collect$a (uua$ ?v0 ?v2)) (collect$a (uua$ ?v1 ?v3))))) :named a35))
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (less_eq$b ?v0 ?v1) (forall ((?v4 Agent$)) (=> (and (member$ ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$b (collect$b (uub$ ?v0 ?v2)) (collect$b (uub$ ?v1 ?v3))))) :named a36))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (less_eq$ ?v0 ?v1) (forall ((?v4 Msg$)) (=> (and (member$a ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$ (collect$ (uuc$ ?v0 ?v2)) (collect$ (uuc$ ?v1 ?v3))))) :named a37))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 (-> Event$ Bool))) (=> (less_eq$a ?v0 ?v1) (= (less_eq$a ?v0 (collect$a (uua$ ?v1 ?v2))) (forall ((?v3 Event$)) (=> (member$b ?v3 ?v0) (?v2 ?v3)))))) :named a38))
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 (-> Agent$ Bool))) (=> (less_eq$b ?v0 ?v1) (= (less_eq$b ?v0 (collect$b (uub$ ?v1 ?v2))) (forall ((?v3 Agent$)) (=> (member$ ?v3 ?v0) (?v2 ?v3)))))) :named a39))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg$ Bool))) (=> (less_eq$ ?v0 ?v1) (= (less_eq$ ?v0 (collect$ (uuc$ ?v1 ?v2))) (forall ((?v3 Msg$)) (=> (member$a ?v3 ?v0) (?v2 ?v3)))))) :named a40))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (less_eq$a ?v0 ?v1) (forall ((?v4 Event$)) (=> (and (set.member$b ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$a (collect$a (uua$ ?v0 ?v2)) (collect$a (uua$ ?v1 ?v3))))) :named a35))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (less_eq$b ?v0 ?v1) (forall ((?v4 Agent$)) (=> (and (set.member$ ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$b (collect$b (uub$ ?v0 ?v2)) (collect$b (uub$ ?v1 ?v3))))) :named a36))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (less_eq$ ?v0 ?v1) (forall ((?v4 Msg$)) (=> (and (set.member$a ?v4 ?v0) (?v2 ?v4)) (?v3 ?v4)))) (less_eq$ (collect$ (uuc$ ?v0 ?v2)) (collect$ (uuc$ ?v1 ?v3))))) :named a37))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 (-> Event$ Bool))) (=> (less_eq$a ?v0 ?v1) (= (less_eq$a ?v0 (collect$a (uua$ ?v1 ?v2))) (forall ((?v3 Event$)) (=> (set.member$b ?v3 ?v0) (?v2 ?v3)))))) :named a38))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 (-> Agent$ Bool))) (=> (less_eq$b ?v0 ?v1) (= (less_eq$b ?v0 (collect$b (uub$ ?v1 ?v2))) (forall ((?v3 Agent$)) (=> (set.member$ ?v3 ?v0) (?v2 ?v3)))))) :named a39))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg$ Bool))) (=> (less_eq$ ?v0 ?v1) (= (less_eq$ ?v0 (collect$ (uuc$ ?v1 ?v2))) (forall ((?v3 Msg$)) (=> (set.member$a ?v3 ?v0) (?v2 ?v3)))))) :named a40))
(assert (! (forall ((?v0 Event_list$)) (=> (and (=> (= ?v0 nil$) false) (=> (not (= ?v0 nil$)) false)) false)) :named a41))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (member$b ?v2 ?v0)) (member$b ?v2 ?v1))) :named a42))
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (member$ ?v2 ?v0)) (member$ ?v2 ?v1))) :named a43))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (member$a ?v2 ?v0)) (member$a ?v2 ?v1))) :named a44))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (set.member$b ?v2 ?v0)) (set.member$b ?v2 ?v1))) :named a42))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (set.member$ ?v2 ?v0)) (set.member$ ?v2 ?v1))) :named a43))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (set.member$a ?v2 ?v0)) (set.member$a ?v2 ?v1))) :named a44))
(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (less_eq$c (uud$ ?v0) (uud$ ?v1)))) :named a45))
(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (less_eq$d (uue$ ?v0) (uue$ ?v1)))) :named a46))
(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (less_eq$e (uuf$ ?v0) (uuf$ ?v1)))) :named a47))
(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 (-> Msg_set$ Msg_set$)) (?v3 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (and (less_eq$ (?v2 ?v1) ?v3) (forall ((?v4 Msg_set$) (?v5 Msg_set$)) (=> (less_eq$ ?v4 ?v5) (less_eq$ (?v2 ?v4) (?v2 ?v5)))))) (less_eq$ (?v2 ?v0) ?v3))) :named a62))
(assert (! (forall ((?v0 Msg_set$) (?v1 (-> Msg_set$ Msg_set$)) (?v2 Msg_set$) (?v3 Msg_set$)) (=> (and (less_eq$ ?v0 (?v1 ?v2)) (and (less_eq$ ?v2 ?v3) (forall ((?v4 Msg_set$) (?v5 Msg_set$)) (=> (less_eq$ ?v4 ?v5) (less_eq$ (?v1 ?v4) (?v1 ?v5)))))) (less_eq$ ?v0 (?v1 ?v3)))) :named a63))
(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 (-> Msg$ Bool))) (= (less_eq$ (collect$ ?v0) (collect$ ?v1)) (forall ((?v2 Msg$)) (=> (?v0 ?v2) (?v1 ?v2))))) :named a64))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (not (member$b ?v2 ?v1))) (not (member$b ?v2 ?v0)))) :named a65))
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (not (member$ ?v2 ?v1))) (not (member$ ?v2 ?v0)))) :named a66))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (not (member$a ?v2 ?v1))) (not (member$a ?v2 ?v0)))) :named a67))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (not (set.member$b ?v2 ?v1))) (not (set.member$b ?v2 ?v0)))) :named a65))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (not (set.member$ ?v2 ?v1))) (not (set.member$ ?v2 ?v0)))) :named a66))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (not (set.member$a ?v2 ?v1))) (not (set.member$a ?v2 ?v0)))) :named a67))
(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (= ?v0 ?v1) (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)))) :named a68))
(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v2)) (less_eq$ ?v0 ?v2))) :named a69))
(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 (-> Msg$ Bool))) (=> (forall ((?v2 Msg$)) (=> (?v0 ?v2) (?v1 ?v2))) (less_eq$ (collect$ ?v0) (collect$ ?v1)))) :named a70))
(assert (! (forall ((?v0 Msg_set$)) (less_eq$ ?v0 ?v0)) :named a71))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v1 ?v2)) (member$b ?v0 ?v2))) :named a72))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v1 ?v2)) (member$ ?v0 ?v2))) :named a73))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v1 ?v2)) (member$a ?v0 ?v2))) :named a74))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 ?v0) (member$b ?v2 ?v1))))) :named a75))
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 ?v0) (member$ ?v2 ?v1))))) :named a76))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 ?v0) (member$a ?v2 ?v1))))) :named a77))
-(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool))) (= (member$a ?v0 (collect$ ?v1)) (?v1 ?v0))) :named a78))
-(assert (! (forall ((?v0 Event$) (?v1 (-> Event$ Bool))) (= (member$b ?v0 (collect$a ?v1)) (?v1 ?v0))) :named a79))
-(assert (! (forall ((?v0 Agent$) (?v1 (-> Agent$ Bool))) (= (member$ ?v0 (collect$b ?v1)) (?v1 ?v0))) :named a80))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (set.member$b ?v0 ?v1) (less_eq$a ?v1 ?v2)) (set.member$b ?v0 ?v2))) :named a72))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (set.member$ ?v0 ?v1) (less_eq$b ?v1 ?v2)) (set.member$ ?v0 ?v2))) :named a73))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (set.member$a ?v0 ?v1) (less_eq$ ?v1 ?v2)) (set.member$a ?v0 ?v2))) :named a74))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (forall ((?v2 Event$)) (=> (set.member$b ?v2 ?v0) (set.member$b ?v2 ?v1))))) :named a75))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (forall ((?v2 Agent$)) (=> (set.member$ ?v2 ?v0) (set.member$ ?v2 ?v1))))) :named a76))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (forall ((?v2 Msg$)) (=> (set.member$a ?v2 ?v0) (set.member$a ?v2 ?v1))))) :named a77))
+(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool))) (= (set.member$a ?v0 (collect$ ?v1)) (?v1 ?v0))) :named a78))
+(assert (! (forall ((?v0 Event$) (?v1 (-> Event$ Bool))) (= (set.member$b ?v0 (collect$a ?v1)) (?v1 ?v0))) :named a79))
+(assert (! (forall ((?v0 Agent$) (?v1 (-> Agent$ Bool))) (= (set.member$ ?v0 (collect$b ?v1)) (?v1 ?v0))) :named a80))
(assert (! (forall ((?v0 Msg_set$)) (= (collect$ (uuf$ ?v0)) ?v0)) :named a81))
(assert (! (forall ((?v0 Event_set$)) (= (collect$a (uud$ ?v0)) ?v0)) :named a82))
(assert (! (forall ((?v0 Agent_set$)) (= (collect$b (uue$ ?v0)) ?v0)) :named a83))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v1 ?v2)) (member$b ?v0 ?v2))) :named a84))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v1 ?v2)) (member$ ?v0 ?v2))) :named a85))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v1 ?v2)) (member$a ?v0 ?v2))) :named a86))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (set.member$b ?v0 ?v1) (less_eq$a ?v1 ?v2)) (set.member$b ?v0 ?v2))) :named a84))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (set.member$ ?v0 ?v1) (less_eq$b ?v1 ?v2)) (set.member$ ?v0 ?v2))) :named a85))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (set.member$a ?v0 ?v1) (less_eq$ ?v1 ?v2)) (set.member$a ?v0 ?v2))) :named a86))
(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (= ?v0 ?v1) (less_eq$ ?v1 ?v0))) :named a87))
(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (= ?v0 ?v1) (less_eq$ ?v0 ?v1))) :named a88))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 ?v0) (member$b ?v2 ?v1))))) :named a89))
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 ?v0) (member$ ?v2 ?v1))))) :named a90))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 ?v0) (member$a ?v2 ?v1))))) :named a91))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$a ?v0 ?v1) (forall ((?v2 Event$)) (=> (set.member$b ?v2 ?v0) (set.member$b ?v2 ?v1))))) :named a89))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$b ?v0 ?v1) (forall ((?v2 Agent$)) (=> (set.member$ ?v2 ?v0) (set.member$ ?v2 ?v1))))) :named a90))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$ ?v0 ?v1) (forall ((?v2 Msg$)) (=> (set.member$a ?v2 ?v0) (set.member$a ?v2 ?v1))))) :named a91))
(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (=> (and (= ?v0 ?v1) (=> (and (less_eq$ ?v0 ?v1) (less_eq$ ?v1 ?v0)) false)) false)) :named a92))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (and (=> (not (member$b ?v2 ?v0)) false) (=> (member$b ?v2 ?v1) false))) false)) :named a93))
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (and (=> (not (member$ ?v2 ?v0)) false) (=> (member$ ?v2 ?v1) false))) false)) :named a94))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (and (=> (not (member$a ?v2 ?v0)) false) (=> (member$a ?v2 ?v1) false))) false)) :named a95))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (member$b ?v2 ?v0)) (member$b ?v2 ?v1))) :named a96))
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (member$ ?v2 ?v0)) (member$ ?v2 ?v1))) :named a97))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (member$a ?v2 ?v0)) (member$a ?v2 ?v1))) :named a98))
-(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (member$b ?v2 ?v0)) (member$b ?v2 ?v1))) :named a99))
-(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (member$ ?v2 ?v0)) (member$ ?v2 ?v1))) :named a100))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (member$a ?v2 ?v0)) (member$a ?v2 ?v1))) :named a101))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (and (=> (not (set.member$b ?v2 ?v0)) false) (=> (set.member$b ?v2 ?v1) false))) false)) :named a93))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (and (=> (not (set.member$ ?v2 ?v0)) false) (=> (set.member$ ?v2 ?v1) false))) false)) :named a94))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (and (=> (not (set.member$a ?v2 ?v0)) false) (=> (set.member$a ?v2 ?v1) false))) false)) :named a95))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (set.member$b ?v2 ?v0)) (set.member$b ?v2 ?v1))) :named a96))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (set.member$ ?v2 ?v0)) (set.member$ ?v2 ?v1))) :named a97))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (set.member$a ?v2 ?v0)) (set.member$a ?v2 ?v1))) :named a98))
+(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$) (?v2 Event$)) (=> (and (less_eq$a ?v0 ?v1) (set.member$b ?v2 ?v0)) (set.member$b ?v2 ?v1))) :named a99))
+(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$) (?v2 Agent$)) (=> (and (less_eq$b ?v0 ?v1) (set.member$ ?v2 ?v0)) (set.member$ ?v2 ?v1))) :named a100))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (and (less_eq$ ?v0 ?v1) (set.member$a ?v2 ?v0)) (set.member$a ?v2 ?v1))) :named a101))
(assert (! (forall ((?v0 Event_set$) (?v1 Event_set$)) (= (less_eq$c (uud$ ?v0) (uud$ ?v1)) (less_eq$a ?v0 ?v1))) :named a102))
(assert (! (forall ((?v0 Agent_set$) (?v1 Agent_set$)) (= (less_eq$d (uue$ ?v0) (uue$ ?v1)) (less_eq$b ?v0 ?v1))) :named a103))
(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$)) (= (less_eq$e (uuf$ ?v0) (uuf$ ?v1)) (less_eq$ ?v0 ?v1))) :named a104))
(assert (! (forall ((?v0 (-> Event$ Event_list$))) (! (= (bind$ nil$ ?v0) nil$) :pattern ((bind$ nil$ ?v0)))) :named a106))
(assert (! (forall ((?v0 (-> Msg_set$ Bool)) (?v1 Msg_set$)) (=> (and (?v0 ?v1) (forall ((?v2 Msg_set$)) (=> (?v0 ?v2) (less_eq$ ?v2 ?v1)))) (= (greatest$ ?v0) ?v1))) :named a107))
(assert (! (forall ((?v0 (-> Msg_set$ Bool)) (?v1 Msg_set$) (?v2 (-> Msg_set$ Bool))) (=> (and (?v0 ?v1) (and (forall ((?v3 Msg_set$)) (=> (?v0 ?v3) (less_eq$ ?v3 ?v1))) (forall ((?v3 Msg_set$)) (=> (and (?v0 ?v3) (forall ((?v4 Msg_set$)) (=> (?v0 ?v4) (less_eq$ ?v4 ?v3)))) (?v2 ?v3))))) (?v2 (greatest$ ?v0)))) :named a108))
-(assert (! (forall ((?v0 Event$)) (! (= (member$d nil$ ?v0) false) :pattern ((member$d nil$ ?v0)))) :named a109))
+(assert (! (forall ((?v0 Event$)) (! (= (set.member$d nil$ ?v0) false) :pattern ((set.member$d nil$ ?v0)))) :named a109))
(assert (! (forall ((?v0 (-> Bool Msg_set$)) (?v1 (-> Bool Msg_set$))) (! (= (less_eq$f ?v0 ?v1) (and (less_eq$ (?v0 false) (?v1 false)) (less_eq$ (?v0 true) (?v1 true)))) :pattern ((less_eq$f ?v0 ?v1)))) :named a110))
(assert (! (forall ((?v0 Nat$)) (! (= (gen_length$ ?v0 nil$) ?v0) :pattern ((gen_length$ ?v0)))) :named a111))
(assert (! (forall ((?v0 (-> Event$ Event_list$))) (! (= (maps$ ?v0 nil$) nil$) :pattern ((maps$ ?v0)))) :named a112))
(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$) (?v3 Event_list$)) (! (= (splice$ (cons$ ?v0 ?v1) (cons$ ?v2 ?v3)) (cons$ ?v0 (cons$ ?v2 (splice$ ?v1 ?v3)))) :pattern ((splice$ (cons$ ?v0 ?v1) (cons$ ?v2 ?v3))))) :named a142))
(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Event$)) (less_eq$ (knows$ ?v0 ?v1) (knows$ ?v0 (cons$ ?v2 ?v1)))) :named a143))
(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (null$ (cons$ ?v0 ?v1)) false) :pattern ((cons$ ?v0 ?v1)))) :named a144))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$)) (! (= (member$d (cons$ ?v0 ?v1) ?v2) (or (= ?v0 ?v2) (member$d ?v1 ?v2))) :pattern ((member$d (cons$ ?v0 ?v1) ?v2)))) :named a145))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$)) (! (= (set.member$d (cons$ ?v0 ?v1) ?v2) (or (= ?v0 ?v2) (set.member$d ?v1 ?v2))) :pattern ((set.member$d (cons$ ?v0 ?v1) ?v2)))) :named a145))
(assert (! (forall ((?v0 Agent$) (?v1 Event_list$)) (less_eq$ (initState$ ?v0) (knows$ ?v0 ?v1))) :named a146))
(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (! (= (takeWhile$ ?v0 (cons$ ?v1 ?v2)) (ite (?v0 ?v1) (cons$ ?v1 (takeWhile$ ?v0 ?v2)) nil$)) :pattern ((takeWhile$ ?v0 (cons$ ?v1 ?v2))))) :named a147))
(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (less_eq$ (knows$ spy$ ?v0) (knows$ spy$ (cons$ (gets$ ?v1 ?v2) ?v0)))) :named a148))
-(assert (! (forall ((?v0 Event$)) (! (= (insert$a ?v0 nil$) (cons$ ?v0 nil$)) :pattern ((insert$a ?v0)))) :named a149))
+(assert (! (forall ((?v0 Event$)) (! (= (set.insert$a ?v0 nil$) (cons$ ?v0 nil$)) :pattern ((set.insert$a ?v0)))) :named a149))
(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (! (= (knows$ spy$ (cons$ (gets$ ?v0 ?v1) ?v2)) (knows$ spy$ ?v2)) :pattern ((cons$ (gets$ ?v0 ?v1) ?v2)))) :named a150))
(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (less_eq$ (knows$ spy$ ?v0) (knows$ spy$ (cons$ (notes$ ?v1 ?v2) ?v0)))) :named a151))
(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event$) (?v2 Event_list$)) (= (list_ex1$ ?v0 (cons$ ?v1 ?v2)) (ite (?v0 ?v1) (list_all$ (uui$ ?v0 ?v1) ?v2) (list_ex1$ ?v0 ?v2)))) :named a152))
(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (rotate1$ (cons$ ?v0 ?v1)) (append$ ?v1 (cons$ ?v0 nil$)))) :named a200))
(assert (! (forall ((?v0 Agent$) (?v1 Event_list$) (?v2 Agent$) (?v3 Agent$) (?v4 Msg$)) (less_eq$ (knows$ ?v0 ?v1) (knows$ ?v0 (cons$ (says$ ?v2 ?v3 ?v4) ?v1)))) :named a201))
(assert (! (forall ((?v0 Event_list_set$) (?v1 Event_list$)) (= (succ$ ?v0 ?v1) (collect$a (uuj$ ?v0 ?v1)))) :named a202))
-(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (= (knows$ spy$ (append$ ?v0 (cons$ (says$ ?v1 ?v2 ?v3) nil$))) (insert$ ?v3 (knows$ spy$ ?v0)))) :named a203))
-(assert (! (forall ((?v0 Msg$) (?v1 Agent$) (?v2 Event_list$)) (=> (and (member$a ?v0 (knows$ ?v1 ?v2)) (not (= ?v1 spy$))) (exists ((?v3 Agent$)) (or (member$b (says$ ?v1 ?v3 ?v0) (set$ ?v2)) (or (member$b (gets$ ?v1 ?v0) (set$ ?v2)) (or (member$b (notes$ ?v1 ?v0) (set$ ?v2)) (member$a ?v0 (initState$ ?v1)))))))) :named a204))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list_set$) (?v2 Msg_list$)) (=> (member$a ?v0 (succ$a ?v1 ?v2)) (member$e (append$a ?v2 (cons$b ?v0 nil$b)) ?v1))) :named a205))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list_set$) (?v2 Agent_list$)) (=> (member$ ?v0 (succ$b ?v1 ?v2)) (member$f (append$b ?v2 (cons$c ?v0 nil$c)) ?v1))) :named a206))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list_set$) (?v2 Event_list$)) (=> (member$b ?v0 (succ$ ?v1 ?v2)) (member$c (append$ ?v2 (cons$ ?v0 nil$)) ?v1))) :named a207))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (= (insert$ ?v0 (insert$ ?v0 ?v1)) (insert$ ?v0 ?v1))) :named a208))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (= (member$a ?v0 (insert$ ?v1 ?v2)) (or (= ?v0 ?v1) (member$a ?v0 ?v2)))) :named a209))
-(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_set$)) (= (member$b ?v0 (insert$b ?v1 ?v2)) (or (= ?v0 ?v1) (member$b ?v0 ?v2)))) :named a210))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_set$)) (= (member$ ?v0 (insert$c ?v1 ?v2)) (or (= ?v0 ?v1) (member$ ?v0 ?v2)))) :named a211))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (=> (=> (not (member$a ?v0 ?v1)) (= ?v0 ?v2)) (member$a ?v0 (insert$ ?v2 ?v1)))) :named a212))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (=> (=> (not (member$b ?v0 ?v1)) (= ?v0 ?v2)) (member$b ?v0 (insert$b ?v2 ?v1)))) :named a213))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (=> (=> (not (member$ ?v0 ?v1)) (= ?v0 ?v2)) (member$ ?v0 (insert$c ?v2 ?v1)))) :named a214))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (= (less_eq$a (insert$b ?v0 ?v1) ?v2) (and (member$b ?v0 ?v2) (less_eq$a ?v1 ?v2)))) :named a215))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (= (less_eq$b (insert$c ?v0 ?v1) ?v2) (and (member$ ?v0 ?v2) (less_eq$b ?v1 ?v2)))) :named a216))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (= (less_eq$ (insert$ ?v0 ?v1) ?v2) (and (member$a ?v0 ?v2) (less_eq$ ?v1 ?v2)))) :named a217))
-(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$)) (= (= (takeWhile$a ?v0 ?v1) ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 (set$a ?v1)) (?v0 ?v2))))) :named a218))
-(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$)) (= (= (takeWhile$b ?v0 ?v1) ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 (set$b ?v1)) (?v0 ?v2))))) :named a219))
-(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (= (takeWhile$ ?v0 ?v1) ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 (set$ ?v1)) (?v0 ?v2))))) :named a220))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Agent$) (?v3 Msg$)) (= (knows$ spy$ (append$ ?v0 (cons$ (says$ ?v1 ?v2 ?v3) nil$))) (set.insert$ ?v3 (knows$ spy$ ?v0)))) :named a203))
+(assert (! (forall ((?v0 Msg$) (?v1 Agent$) (?v2 Event_list$)) (=> (and (set.member$a ?v0 (knows$ ?v1 ?v2)) (not (= ?v1 spy$))) (exists ((?v3 Agent$)) (or (set.member$b (says$ ?v1 ?v3 ?v0) (set$ ?v2)) (or (set.member$b (gets$ ?v1 ?v0) (set$ ?v2)) (or (set.member$b (notes$ ?v1 ?v0) (set$ ?v2)) (set.member$a ?v0 (initState$ ?v1)))))))) :named a204))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list_set$) (?v2 Msg_list$)) (=> (set.member$a ?v0 (succ$a ?v1 ?v2)) (set.member$e (append$a ?v2 (cons$b ?v0 nil$b)) ?v1))) :named a205))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list_set$) (?v2 Agent_list$)) (=> (set.member$ ?v0 (succ$b ?v1 ?v2)) (set.member$f (append$b ?v2 (cons$c ?v0 nil$c)) ?v1))) :named a206))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list_set$) (?v2 Event_list$)) (=> (set.member$b ?v0 (succ$ ?v1 ?v2)) (set.member$c (append$ ?v2 (cons$ ?v0 nil$)) ?v1))) :named a207))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (= (set.insert$ ?v0 (set.insert$ ?v0 ?v1)) (set.insert$ ?v0 ?v1))) :named a208))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (= (set.member$a ?v0 (set.insert$ ?v1 ?v2)) (or (= ?v0 ?v1) (set.member$a ?v0 ?v2)))) :named a209))
+(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_set$)) (= (set.member$b ?v0 (set.insert$b ?v1 ?v2)) (or (= ?v0 ?v1) (set.member$b ?v0 ?v2)))) :named a210))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_set$)) (= (set.member$ ?v0 (set.insert$c ?v1 ?v2)) (or (= ?v0 ?v1) (set.member$ ?v0 ?v2)))) :named a211))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (=> (=> (not (set.member$a ?v0 ?v1)) (= ?v0 ?v2)) (set.member$a ?v0 (set.insert$ ?v2 ?v1)))) :named a212))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (=> (=> (not (set.member$b ?v0 ?v1)) (= ?v0 ?v2)) (set.member$b ?v0 (set.insert$b ?v2 ?v1)))) :named a213))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (=> (=> (not (set.member$ ?v0 ?v1)) (= ?v0 ?v2)) (set.member$ ?v0 (set.insert$c ?v2 ?v1)))) :named a214))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (= (less_eq$a (set.insert$b ?v0 ?v1) ?v2) (and (set.member$b ?v0 ?v2) (less_eq$a ?v1 ?v2)))) :named a215))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (= (less_eq$b (set.insert$c ?v0 ?v1) ?v2) (and (set.member$ ?v0 ?v2) (less_eq$b ?v1 ?v2)))) :named a216))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (= (less_eq$ (set.insert$ ?v0 ?v1) ?v2) (and (set.member$a ?v0 ?v2) (less_eq$ ?v1 ?v2)))) :named a217))
+(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$)) (= (= (takeWhile$a ?v0 ?v1) ?v1) (forall ((?v2 Msg$)) (=> (set.member$a ?v2 (set$a ?v1)) (?v0 ?v2))))) :named a218))
+(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$)) (= (= (takeWhile$b ?v0 ?v1) ?v1) (forall ((?v2 Agent$)) (=> (set.member$ ?v2 (set$b ?v1)) (?v0 ?v2))))) :named a219))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (= (takeWhile$ ?v0 ?v1) ?v1) (forall ((?v2 Event$)) (=> (set.member$b ?v2 (set$ ?v1)) (?v0 ?v2))))) :named a220))
(assert (! (forall ((?v0 Event_list$)) (= (set$ (rotate1$ ?v0)) (set$ ?v0))) :named a221))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (=> (member$a ?v0 (set$a ?v1)) (= (insert$d ?v0 ?v1) ?v1)) :pattern ((insert$d ?v0 ?v1)))) :named a222))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (=> (member$ ?v0 (set$b ?v1)) (= (insert$e ?v0 ?v1) ?v1)) :pattern ((insert$e ?v0 ?v1)))) :named a223))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (=> (member$b ?v0 (set$ ?v1)) (= (insert$a ?v0 ?v1) ?v1)) :pattern ((insert$a ?v0 ?v1)))) :named a224))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (= (set$a (cons$b ?v0 ?v1)) (insert$ ?v0 (set$a ?v1))) :pattern ((cons$b ?v0 ?v1)))) :named a225))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (set$ (cons$ ?v0 ?v1)) (insert$b ?v0 (set$ ?v1))) :pattern ((cons$ ?v0 ?v1)))) :named a226))
-(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool)) (?v2 Msg_list$)) (=> (forall ((?v3 Msg$)) (=> (member$a ?v3 (set$a ?v0)) (?v1 ?v3))) (= (takeWhile$a ?v1 (append$a ?v0 ?v2)) (append$a ?v0 (takeWhile$a ?v1 ?v2))))) :named a227))
-(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool)) (?v2 Agent_list$)) (=> (forall ((?v3 Agent$)) (=> (member$ ?v3 (set$b ?v0)) (?v1 ?v3))) (= (takeWhile$b ?v1 (append$b ?v0 ?v2)) (append$b ?v0 (takeWhile$b ?v1 ?v2))))) :named a228))
-(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool)) (?v2 Event_list$)) (=> (forall ((?v3 Event$)) (=> (member$b ?v3 (set$ ?v0)) (?v1 ?v3))) (= (takeWhile$ ?v1 (append$ ?v0 ?v2)) (append$ ?v0 (takeWhile$ ?v1 ?v2))))) :named a229))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 Msg_list$)) (=> (and (member$a ?v0 (set$a ?v1)) (not (?v2 ?v0))) (= (takeWhile$a ?v2 (append$a ?v1 ?v3)) (takeWhile$a ?v2 ?v1)))) :named a230))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 Agent_list$)) (=> (and (member$ ?v0 (set$b ?v1)) (not (?v2 ?v0))) (= (takeWhile$b ?v2 (append$b ?v1 ?v3)) (takeWhile$b ?v2 ?v1)))) :named a231))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 Event_list$)) (=> (and (member$b ?v0 (set$ ?v1)) (not (?v2 ?v0))) (= (takeWhile$ ?v2 (append$ ?v1 ?v3)) (takeWhile$ ?v2 ?v1)))) :named a232))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (set$a (insert$d ?v0 ?v1)) (insert$ ?v0 (set$a ?v1)))) :named a233))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (set$ (insert$a ?v0 ?v1)) (insert$b ?v0 (set$ ?v1)))) :named a234))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (=> (not (member$a ?v0 (set$a ?v1))) (= (insert$d ?v0 ?v1) (cons$b ?v0 ?v1))) :pattern ((insert$d ?v0 ?v1)))) :named a235))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (=> (not (member$ ?v0 (set$b ?v1))) (= (insert$e ?v0 ?v1) (cons$c ?v0 ?v1))) :pattern ((insert$e ?v0 ?v1)))) :named a236))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (=> (not (member$b ?v0 (set$ ?v1))) (= (insert$a ?v0 ?v1) (cons$ ?v0 ?v1))) :pattern ((insert$a ?v0 ?v1)))) :named a237))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (! (= (knows$ spy$ (cons$ (says$ ?v0 ?v1 ?v2) ?v3)) (insert$ ?v2 (knows$ spy$ ?v3))) :pattern ((cons$ (says$ ?v0 ?v1 ?v2) ?v3)))) :named a238))
-(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_set$)) (= (less_eq$b (set$b ?v0) ?v1) (forall ((?v2 Agent$)) (=> (member$ ?v2 (set$b ?v0)) (member$ ?v2 ?v1))))) :named a239))
-(assert (! (forall ((?v0 Event_list$) (?v1 Event_set$)) (= (less_eq$a (set$ ?v0) ?v1) (forall ((?v2 Event$)) (=> (member$b ?v2 (set$ ?v0)) (member$b ?v2 ?v1))))) :named a240))
-(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_set$)) (= (less_eq$ (set$a ?v0) ?v1) (forall ((?v2 Msg$)) (=> (member$a ?v2 (set$a ?v0)) (member$a ?v2 ?v1))))) :named a241))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (member$b ?v0 ?v1) (less_eq$a ?v2 ?v1)) (less_eq$a (insert$b ?v0 ?v2) ?v1))) :named a242))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (member$ ?v0 ?v1) (less_eq$b ?v2 ?v1)) (less_eq$b (insert$c ?v0 ?v2) ?v1))) :named a243))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (member$a ?v0 ?v1) (less_eq$ ?v2 ?v1)) (less_eq$ (insert$ ?v0 ?v2) ?v1))) :named a244))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (less_eq$ ?v0 ?v1) (less_eq$ ?v0 (insert$ ?v2 ?v1)))) :named a245))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg$)) (less_eq$ ?v0 (insert$ ?v1 ?v0))) :named a246))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (not (member$b ?v0 ?v1)) (= (less_eq$a ?v1 (insert$b ?v0 ?v2)) (less_eq$a ?v1 ?v2)))) :named a247))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (not (member$ ?v0 ?v1)) (= (less_eq$b ?v1 (insert$c ?v0 ?v2)) (less_eq$b ?v1 ?v2)))) :named a248))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (not (member$a ?v0 ?v1)) (= (less_eq$ ?v1 (insert$ ?v0 ?v2)) (less_eq$ ?v1 ?v2)))) :named a249))
-(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (less_eq$ ?v0 ?v1) (less_eq$ (insert$ ?v2 ?v0) (insert$ ?v2 ?v1)))) :named a250))
-(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (member$a ?v4 (set$a ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$a ?v2 ?v0) (list_ex$a ?v3 ?v1)))) :named a251))
-(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (member$ ?v4 (set$b ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$b ?v2 ?v0) (list_ex$b ?v3 ?v1)))) :named a252))
-(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (member$b ?v4 (set$ ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$ ?v2 ?v0) (list_ex$ ?v3 ?v1)))) :named a253))
-(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool))) (= (insert$ ?v0 (collect$ ?v1)) (collect$ (uuk$ ?v0 ?v1)))) :named a254))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (= (insert$ ?v0 ?v1) (collect$ (uul$ ?v0 ?v1)))) :named a255))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (= (insert$b ?v0 ?v1) (collect$a (uum$ ?v0 ?v1)))) :named a256))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (= (insert$c ?v0 ?v1) (collect$b (uun$ ?v0 ?v1)))) :named a257))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (=> (member$a ?v0 ?v1) (exists ((?v2 Msg_set$)) (and (= ?v1 (insert$ ?v0 ?v2)) (not (member$a ?v0 ?v2)))))) :named a258))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (=> (member$b ?v0 ?v1) (exists ((?v2 Event_set$)) (and (= ?v1 (insert$b ?v0 ?v2)) (not (member$b ?v0 ?v2)))))) :named a259))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (=> (member$ ?v0 ?v1) (exists ((?v2 Agent_set$)) (and (= ?v1 (insert$c ?v0 ?v2)) (not (member$ ?v0 ?v2)))))) :named a260))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (= (insert$ ?v0 (insert$ ?v1 ?v2)) (insert$ ?v1 (insert$ ?v0 ?v2)))) :named a261))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$) (?v3 Msg_set$)) (=> (and (not (member$a ?v0 ?v1)) (not (member$a ?v2 ?v3))) (= (= (insert$ ?v0 ?v1) (insert$ ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Msg_set$)) (and (= ?v1 (insert$ ?v2 ?v4)) (and (not (member$a ?v2 ?v4)) (and (= ?v3 (insert$ ?v0 ?v4)) (not (member$a ?v0 ?v4)))))))))) :named a262))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$) (?v3 Event_set$)) (=> (and (not (member$b ?v0 ?v1)) (not (member$b ?v2 ?v3))) (= (= (insert$b ?v0 ?v1) (insert$b ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Event_set$)) (and (= ?v1 (insert$b ?v2 ?v4)) (and (not (member$b ?v2 ?v4)) (and (= ?v3 (insert$b ?v0 ?v4)) (not (member$b ?v0 ?v4)))))))))) :named a263))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$) (?v3 Agent_set$)) (=> (and (not (member$ ?v0 ?v1)) (not (member$ ?v2 ?v3))) (= (= (insert$c ?v0 ?v1) (insert$c ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Agent_set$)) (and (= ?v1 (insert$c ?v2 ?v4)) (and (not (member$ ?v2 ?v4)) (and (= ?v3 (insert$c ?v0 ?v4)) (not (member$ ?v0 ?v4)))))))))) :named a264))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (! (=> (member$a ?v0 ?v1) (= (insert$ ?v0 ?v1) ?v1)) :pattern ((insert$ ?v0 ?v1)))) :named a265))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (! (=> (member$b ?v0 ?v1) (= (insert$b ?v0 ?v1) ?v1)) :pattern ((insert$b ?v0 ?v1)))) :named a266))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (! (=> (member$ ?v0 ?v1) (= (insert$c ?v0 ?v1) ?v1)) :pattern ((insert$c ?v0 ?v1)))) :named a267))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (not (member$a ?v0 ?v1)) (not (member$a ?v0 ?v2))) (= (= (insert$ ?v0 ?v1) (insert$ ?v0 ?v2)) (= ?v1 ?v2)))) :named a268))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (not (member$b ?v0 ?v1)) (not (member$b ?v0 ?v2))) (= (= (insert$b ?v0 ?v1) (insert$b ?v0 ?v2)) (= ?v1 ?v2)))) :named a269))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (not (member$ ?v0 ?v1)) (not (member$ ?v0 ?v2))) (= (= (insert$c ?v0 ?v1) (insert$c ?v0 ?v2)) (= ?v1 ?v2)))) :named a270))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (=> (and (member$a ?v0 ?v1) (forall ((?v2 Msg_set$)) (=> (and (= ?v1 (insert$ ?v0 ?v2)) (not (member$a ?v0 ?v2))) false))) false)) :named a271))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (=> (and (member$b ?v0 ?v1) (forall ((?v2 Event_set$)) (=> (and (= ?v1 (insert$b ?v0 ?v2)) (not (member$b ?v0 ?v2))) false))) false)) :named a272))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (=> (and (member$ ?v0 ?v1) (forall ((?v2 Agent_set$)) (=> (and (= ?v1 (insert$c ?v0 ?v2)) (not (member$ ?v0 ?v2))) false))) false)) :named a273))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (=> (member$a ?v0 ?v1) (member$a ?v0 (insert$ ?v2 ?v1)))) :named a274))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (=> (member$b ?v0 ?v1) (member$b ?v0 (insert$b ?v2 ?v1)))) :named a275))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (=> (member$ ?v0 ?v1) (member$ ?v0 (insert$c ?v2 ?v1)))) :named a276))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (member$a ?v0 (insert$ ?v0 ?v1))) :named a277))
-(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (member$b ?v0 (insert$b ?v0 ?v1))) :named a278))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (member$ ?v0 (insert$c ?v0 ?v1))) :named a279))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (=> (and (member$a ?v0 (insert$ ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (member$a ?v0 ?v2) false))) false)) :named a280))
-(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_set$)) (=> (and (member$b ?v0 (insert$b ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (member$b ?v0 ?v2) false))) false)) :named a281))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_set$)) (=> (and (member$ ?v0 (insert$c ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (member$ ?v0 ?v2) false))) false)) :named a282))
-(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool)) (?v2 Msg_list$)) (=> (member$a ?v0 (set$a (takeWhile$a ?v1 ?v2))) (and (member$a ?v0 (set$a ?v2)) (?v1 ?v0)))) :named a283))
-(assert (! (forall ((?v0 Agent$) (?v1 (-> Agent$ Bool)) (?v2 Agent_list$)) (=> (member$ ?v0 (set$b (takeWhile$b ?v1 ?v2))) (and (member$ ?v0 (set$b ?v2)) (?v1 ?v0)))) :named a284))
-(assert (! (forall ((?v0 Event$) (?v1 (-> Event$ Bool)) (?v2 Event_list$)) (=> (member$b ?v0 (set$ (takeWhile$ ?v1 ?v2))) (and (member$b ?v0 (set$ ?v2)) (?v1 ?v0)))) :named a285))
-(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (member$a ?v4 (set$a ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$a ?v2 ?v0) (takeWhile$a ?v3 ?v1)))) :named a286))
-(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (member$ ?v4 (set$b ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$b ?v2 ?v0) (takeWhile$b ?v3 ?v1)))) :named a287))
-(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (member$b ?v4 (set$ ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$ ?v2 ?v0) (takeWhile$ ?v3 ?v1)))) :named a288))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 Msg$)) (=> (member$a ?v0 (set$a ?v1)) (member$a ?v0 (set$a (cons$b ?v2 ?v1))))) :named a289))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 Agent$)) (=> (member$ ?v0 (set$b ?v1)) (member$ ?v0 (set$b (cons$c ?v2 ?v1))))) :named a290))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$)) (=> (member$b ?v0 (set$ ?v1)) (member$b ?v0 (set$ (cons$ ?v2 ?v1))))) :named a291))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (member$a ?v0 (set$a (cons$b ?v0 ?v1)))) :named a292))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (member$ ?v0 (set$b (cons$c ?v0 ?v1)))) :named a293))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (member$b ?v0 (set$ (cons$ ?v0 ?v1)))) :named a294))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_list$)) (=> (member$a ?v0 (set$a (cons$b ?v1 ?v2))) (or (= ?v0 ?v1) (member$a ?v0 (set$a ?v2))))) :named a295))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_list$)) (=> (member$ ?v0 (set$b (cons$c ?v1 ?v2))) (or (= ?v0 ?v1) (member$ ?v0 (set$b ?v2))))) :named a296))
-(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_list$)) (=> (member$b ?v0 (set$ (cons$ ?v1 ?v2))) (or (= ?v0 ?v1) (member$b ?v0 (set$ ?v2))))) :named a297))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (and (member$a ?v0 (set$a ?v1)) (and (forall ((?v2 Msg_list$)) (=> (= ?v1 (cons$b ?v0 ?v2)) false)) (forall ((?v2 Msg$) (?v3 Msg_list$)) (=> (and (= ?v1 (cons$b ?v2 ?v3)) (member$a ?v0 (set$a ?v3))) false)))) false)) :named a298))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (and (member$ ?v0 (set$b ?v1)) (and (forall ((?v2 Agent_list$)) (=> (= ?v1 (cons$c ?v0 ?v2)) false)) (forall ((?v2 Agent$) (?v3 Agent_list$)) (=> (and (= ?v1 (cons$c ?v2 ?v3)) (member$ ?v0 (set$b ?v3))) false)))) false)) :named a299))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (and (member$b ?v0 (set$ ?v1)) (and (forall ((?v2 Event_list$)) (=> (= ?v1 (cons$ ?v0 ?v2)) false)) (forall ((?v2 Event$) (?v3 Event_list$)) (=> (and (= ?v1 (cons$ ?v2 ?v3)) (member$b ?v0 (set$ ?v3))) false)))) false)) :named a300))
-(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (member$a ?v4 (set$a ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$a ?v2 ?v0) (list_all$a ?v3 ?v1)))) :named a301))
-(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (member$ ?v4 (set$b ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$b ?v2 ?v0) (list_all$b ?v3 ?v1)))) :named a302))
-(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (member$b ?v4 (set$ ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$ ?v2 ?v0) (list_all$ ?v3 ?v1)))) :named a303))
-(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$) (?v2 (-> Msg$ Bool))) (=> (and (list_all$a ?v0 ?v1) (forall ((?v3 Msg$)) (=> (and (member$a ?v3 (set$a ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$a ?v2 ?v1))) :named a304))
-(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$) (?v2 (-> Agent$ Bool))) (=> (and (list_all$b ?v0 ?v1) (forall ((?v3 Agent$)) (=> (and (member$ ?v3 (set$b ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$b ?v2 ?v1))) :named a305))
-(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$) (?v2 (-> Event$ Bool))) (=> (and (list_all$ ?v0 ?v1) (forall ((?v3 Event$)) (=> (and (member$b ?v3 (set$ ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$ ?v2 ?v1))) :named a306))
-(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$)) (= (list_ex1$a ?v0 ?v1) (exists ((?v2 Msg$)) (and (and (member$a ?v2 (set$a ?v1)) (?v0 ?v2)) (forall ((?v3 Msg$)) (=> (and (member$a ?v3 (set$a ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a307))
-(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$)) (= (list_ex1$b ?v0 ?v1) (exists ((?v2 Agent$)) (and (and (member$ ?v2 (set$b ?v1)) (?v0 ?v2)) (forall ((?v3 Agent$)) (=> (and (member$ ?v3 (set$b ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a308))
-(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (list_ex1$ ?v0 ?v1) (exists ((?v2 Event$)) (and (and (member$b ?v2 (set$ ?v1)) (?v0 ?v2)) (forall ((?v3 Event$)) (=> (and (member$b ?v3 (set$ ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a309))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (member$g ?v1 ?v0))) :named a310))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (member$h ?v1 ?v0))) :named a311))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (member$d ?v1 ?v0))) :named a312))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (=> (set.member$a ?v0 (set$a ?v1)) (= (set.insert$d ?v0 ?v1) ?v1)) :pattern ((set.insert$d ?v0 ?v1)))) :named a222))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (=> (set.member$ ?v0 (set$b ?v1)) (= (set.insert$e ?v0 ?v1) ?v1)) :pattern ((set.insert$e ?v0 ?v1)))) :named a223))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (=> (set.member$b ?v0 (set$ ?v1)) (= (set.insert$a ?v0 ?v1) ?v1)) :pattern ((set.insert$a ?v0 ?v1)))) :named a224))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (= (set$a (cons$b ?v0 ?v1)) (set.insert$ ?v0 (set$a ?v1))) :pattern ((cons$b ?v0 ?v1)))) :named a225))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (set$ (cons$ ?v0 ?v1)) (set.insert$b ?v0 (set$ ?v1))) :pattern ((cons$ ?v0 ?v1)))) :named a226))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool)) (?v2 Msg_list$)) (=> (forall ((?v3 Msg$)) (=> (set.member$a ?v3 (set$a ?v0)) (?v1 ?v3))) (= (takeWhile$a ?v1 (append$a ?v0 ?v2)) (append$a ?v0 (takeWhile$a ?v1 ?v2))))) :named a227))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool)) (?v2 Agent_list$)) (=> (forall ((?v3 Agent$)) (=> (set.member$ ?v3 (set$b ?v0)) (?v1 ?v3))) (= (takeWhile$b ?v1 (append$b ?v0 ?v2)) (append$b ?v0 (takeWhile$b ?v1 ?v2))))) :named a228))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool)) (?v2 Event_list$)) (=> (forall ((?v3 Event$)) (=> (set.member$b ?v3 (set$ ?v0)) (?v1 ?v3))) (= (takeWhile$ ?v1 (append$ ?v0 ?v2)) (append$ ?v0 (takeWhile$ ?v1 ?v2))))) :named a229))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 Msg_list$)) (=> (and (set.member$a ?v0 (set$a ?v1)) (not (?v2 ?v0))) (= (takeWhile$a ?v2 (append$a ?v1 ?v3)) (takeWhile$a ?v2 ?v1)))) :named a230))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 Agent_list$)) (=> (and (set.member$ ?v0 (set$b ?v1)) (not (?v2 ?v0))) (= (takeWhile$b ?v2 (append$b ?v1 ?v3)) (takeWhile$b ?v2 ?v1)))) :named a231))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 Event_list$)) (=> (and (set.member$b ?v0 (set$ ?v1)) (not (?v2 ?v0))) (= (takeWhile$ ?v2 (append$ ?v1 ?v3)) (takeWhile$ ?v2 ?v1)))) :named a232))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (set$a (set.insert$d ?v0 ?v1)) (set.insert$ ?v0 (set$a ?v1)))) :named a233))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (set$ (set.insert$a ?v0 ?v1)) (set.insert$b ?v0 (set$ ?v1)))) :named a234))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (=> (not (set.member$a ?v0 (set$a ?v1))) (= (set.insert$d ?v0 ?v1) (cons$b ?v0 ?v1))) :pattern ((set.insert$d ?v0 ?v1)))) :named a235))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (=> (not (set.member$ ?v0 (set$b ?v1))) (= (set.insert$e ?v0 ?v1) (cons$c ?v0 ?v1))) :pattern ((set.insert$e ?v0 ?v1)))) :named a236))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (=> (not (set.member$b ?v0 (set$ ?v1))) (= (set.insert$a ?v0 ?v1) (cons$ ?v0 ?v1))) :pattern ((set.insert$a ?v0 ?v1)))) :named a237))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (! (= (knows$ spy$ (cons$ (says$ ?v0 ?v1 ?v2) ?v3)) (set.insert$ ?v2 (knows$ spy$ ?v3))) :pattern ((cons$ (says$ ?v0 ?v1 ?v2) ?v3)))) :named a238))
+(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_set$)) (= (less_eq$b (set$b ?v0) ?v1) (forall ((?v2 Agent$)) (=> (set.member$ ?v2 (set$b ?v0)) (set.member$ ?v2 ?v1))))) :named a239))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_set$)) (= (less_eq$a (set$ ?v0) ?v1) (forall ((?v2 Event$)) (=> (set.member$b ?v2 (set$ ?v0)) (set.member$b ?v2 ?v1))))) :named a240))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_set$)) (= (less_eq$ (set$a ?v0) ?v1) (forall ((?v2 Msg$)) (=> (set.member$a ?v2 (set$a ?v0)) (set.member$a ?v2 ?v1))))) :named a241))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (set.member$b ?v0 ?v1) (less_eq$a ?v2 ?v1)) (less_eq$a (set.insert$b ?v0 ?v2) ?v1))) :named a242))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (set.member$ ?v0 ?v1) (less_eq$b ?v2 ?v1)) (less_eq$b (set.insert$c ?v0 ?v2) ?v1))) :named a243))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (set.member$a ?v0 ?v1) (less_eq$ ?v2 ?v1)) (less_eq$ (set.insert$ ?v0 ?v2) ?v1))) :named a244))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (less_eq$ ?v0 ?v1) (less_eq$ ?v0 (set.insert$ ?v2 ?v1)))) :named a245))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg$)) (less_eq$ ?v0 (set.insert$ ?v1 ?v0))) :named a246))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (not (set.member$b ?v0 ?v1)) (= (less_eq$a ?v1 (set.insert$b ?v0 ?v2)) (less_eq$a ?v1 ?v2)))) :named a247))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (not (set.member$ ?v0 ?v1)) (= (less_eq$b ?v1 (set.insert$c ?v0 ?v2)) (less_eq$b ?v1 ?v2)))) :named a248))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (not (set.member$a ?v0 ?v1)) (= (less_eq$ ?v1 (set.insert$ ?v0 ?v2)) (less_eq$ ?v1 ?v2)))) :named a249))
+(assert (! (forall ((?v0 Msg_set$) (?v1 Msg_set$) (?v2 Msg$)) (=> (less_eq$ ?v0 ?v1) (less_eq$ (set.insert$ ?v2 ?v0) (set.insert$ ?v2 ?v1)))) :named a250))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (set.member$a ?v4 (set$a ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$a ?v2 ?v0) (list_ex$a ?v3 ?v1)))) :named a251))
+(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (set.member$ ?v4 (set$b ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$b ?v2 ?v0) (list_ex$b ?v3 ?v1)))) :named a252))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (set.member$b ?v4 (set$ ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_ex$ ?v2 ?v0) (list_ex$ ?v3 ?v1)))) :named a253))
+(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool))) (= (set.insert$ ?v0 (collect$ ?v1)) (collect$ (uuk$ ?v0 ?v1)))) :named a254))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (= (set.insert$ ?v0 ?v1) (collect$ (uul$ ?v0 ?v1)))) :named a255))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (= (set.insert$b ?v0 ?v1) (collect$a (uum$ ?v0 ?v1)))) :named a256))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (= (set.insert$c ?v0 ?v1) (collect$b (uun$ ?v0 ?v1)))) :named a257))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (=> (set.member$a ?v0 ?v1) (exists ((?v2 Msg_set$)) (and (= ?v1 (set.insert$ ?v0 ?v2)) (not (set.member$a ?v0 ?v2)))))) :named a258))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (=> (set.member$b ?v0 ?v1) (exists ((?v2 Event_set$)) (and (= ?v1 (set.insert$b ?v0 ?v2)) (not (set.member$b ?v0 ?v2)))))) :named a259))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (=> (set.member$ ?v0 ?v1) (exists ((?v2 Agent_set$)) (and (= ?v1 (set.insert$c ?v0 ?v2)) (not (set.member$ ?v0 ?v2)))))) :named a260))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (= (set.insert$ ?v0 (set.insert$ ?v1 ?v2)) (set.insert$ ?v1 (set.insert$ ?v0 ?v2)))) :named a261))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$) (?v3 Msg_set$)) (=> (and (not (set.member$a ?v0 ?v1)) (not (set.member$a ?v2 ?v3))) (= (= (set.insert$ ?v0 ?v1) (set.insert$ ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Msg_set$)) (and (= ?v1 (set.insert$ ?v2 ?v4)) (and (not (set.member$a ?v2 ?v4)) (and (= ?v3 (set.insert$ ?v0 ?v4)) (not (set.member$a ?v0 ?v4)))))))))) :named a262))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$) (?v3 Event_set$)) (=> (and (not (set.member$b ?v0 ?v1)) (not (set.member$b ?v2 ?v3))) (= (= (set.insert$b ?v0 ?v1) (set.insert$b ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Event_set$)) (and (= ?v1 (set.insert$b ?v2 ?v4)) (and (not (set.member$b ?v2 ?v4)) (and (= ?v3 (set.insert$b ?v0 ?v4)) (not (set.member$b ?v0 ?v4)))))))))) :named a263))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$) (?v3 Agent_set$)) (=> (and (not (set.member$ ?v0 ?v1)) (not (set.member$ ?v2 ?v3))) (= (= (set.insert$c ?v0 ?v1) (set.insert$c ?v2 ?v3)) (ite (= ?v0 ?v2) (= ?v1 ?v3) (exists ((?v4 Agent_set$)) (and (= ?v1 (set.insert$c ?v2 ?v4)) (and (not (set.member$ ?v2 ?v4)) (and (= ?v3 (set.insert$c ?v0 ?v4)) (not (set.member$ ?v0 ?v4)))))))))) :named a264))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (! (=> (set.member$a ?v0 ?v1) (= (set.insert$ ?v0 ?v1) ?v1)) :pattern ((set.insert$ ?v0 ?v1)))) :named a265))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (! (=> (set.member$b ?v0 ?v1) (= (set.insert$b ?v0 ?v1) ?v1)) :pattern ((set.insert$b ?v0 ?v1)))) :named a266))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (! (=> (set.member$ ?v0 ?v1) (= (set.insert$c ?v0 ?v1) ?v1)) :pattern ((set.insert$c ?v0 ?v1)))) :named a267))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg_set$)) (=> (and (not (set.member$a ?v0 ?v1)) (not (set.member$a ?v0 ?v2))) (= (= (set.insert$ ?v0 ?v1) (set.insert$ ?v0 ?v2)) (= ?v1 ?v2)))) :named a268))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event_set$)) (=> (and (not (set.member$b ?v0 ?v1)) (not (set.member$b ?v0 ?v2))) (= (= (set.insert$b ?v0 ?v1) (set.insert$b ?v0 ?v2)) (= ?v1 ?v2)))) :named a269))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent_set$)) (=> (and (not (set.member$ ?v0 ?v1)) (not (set.member$ ?v0 ?v2))) (= (= (set.insert$c ?v0 ?v1) (set.insert$c ?v0 ?v2)) (= ?v1 ?v2)))) :named a270))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (=> (and (set.member$a ?v0 ?v1) (forall ((?v2 Msg_set$)) (=> (and (= ?v1 (set.insert$ ?v0 ?v2)) (not (set.member$a ?v0 ?v2))) false))) false)) :named a271))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (=> (and (set.member$b ?v0 ?v1) (forall ((?v2 Event_set$)) (=> (and (= ?v1 (set.insert$b ?v0 ?v2)) (not (set.member$b ?v0 ?v2))) false))) false)) :named a272))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (=> (and (set.member$ ?v0 ?v1) (forall ((?v2 Agent_set$)) (=> (and (= ?v1 (set.insert$c ?v0 ?v2)) (not (set.member$ ?v0 ?v2))) false))) false)) :named a273))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$) (?v2 Msg$)) (=> (set.member$a ?v0 ?v1) (set.member$a ?v0 (set.insert$ ?v2 ?v1)))) :named a274))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$) (?v2 Event$)) (=> (set.member$b ?v0 ?v1) (set.member$b ?v0 (set.insert$b ?v2 ?v1)))) :named a275))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$) (?v2 Agent$)) (=> (set.member$ ?v0 ?v1) (set.member$ ?v0 (set.insert$c ?v2 ?v1)))) :named a276))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_set$)) (set.member$a ?v0 (set.insert$ ?v0 ?v1))) :named a277))
+(assert (! (forall ((?v0 Event$) (?v1 Event_set$)) (set.member$b ?v0 (set.insert$b ?v0 ?v1))) :named a278))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_set$)) (set.member$ ?v0 (set.insert$c ?v0 ?v1))) :named a279))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_set$)) (=> (and (set.member$a ?v0 (set.insert$ ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (set.member$a ?v0 ?v2) false))) false)) :named a280))
+(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_set$)) (=> (and (set.member$b ?v0 (set.insert$b ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (set.member$b ?v0 ?v2) false))) false)) :named a281))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_set$)) (=> (and (set.member$ ?v0 (set.insert$c ?v1 ?v2)) (and (=> (= ?v0 ?v1) false) (=> (set.member$ ?v0 ?v2) false))) false)) :named a282))
+(assert (! (forall ((?v0 Msg$) (?v1 (-> Msg$ Bool)) (?v2 Msg_list$)) (=> (set.member$a ?v0 (set$a (takeWhile$a ?v1 ?v2))) (and (set.member$a ?v0 (set$a ?v2)) (?v1 ?v0)))) :named a283))
+(assert (! (forall ((?v0 Agent$) (?v1 (-> Agent$ Bool)) (?v2 Agent_list$)) (=> (set.member$ ?v0 (set$b (takeWhile$b ?v1 ?v2))) (and (set.member$ ?v0 (set$b ?v2)) (?v1 ?v0)))) :named a284))
+(assert (! (forall ((?v0 Event$) (?v1 (-> Event$ Bool)) (?v2 Event_list$)) (=> (set.member$b ?v0 (set$ (takeWhile$ ?v1 ?v2))) (and (set.member$b ?v0 (set$ ?v2)) (?v1 ?v0)))) :named a285))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (set.member$a ?v4 (set$a ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$a ?v2 ?v0) (takeWhile$a ?v3 ?v1)))) :named a286))
+(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (set.member$ ?v4 (set$b ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$b ?v2 ?v0) (takeWhile$b ?v3 ?v1)))) :named a287))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (set.member$b ?v4 (set$ ?v0)) (= (?v2 ?v4) (?v3 ?v4))))) (= (takeWhile$ ?v2 ?v0) (takeWhile$ ?v3 ?v1)))) :named a288))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 Msg$)) (=> (set.member$a ?v0 (set$a ?v1)) (set.member$a ?v0 (set$a (cons$b ?v2 ?v1))))) :named a289))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 Agent$)) (=> (set.member$ ?v0 (set$b ?v1)) (set.member$ ?v0 (set$b (cons$c ?v2 ?v1))))) :named a290))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event$)) (=> (set.member$b ?v0 (set$ ?v1)) (set.member$b ?v0 (set$ (cons$ ?v2 ?v1))))) :named a291))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (set.member$a ?v0 (set$a (cons$b ?v0 ?v1)))) :named a292))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (set.member$ ?v0 (set$b (cons$c ?v0 ?v1)))) :named a293))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (set.member$b ?v0 (set$ (cons$ ?v0 ?v1)))) :named a294))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg$) (?v2 Msg_list$)) (=> (set.member$a ?v0 (set$a (cons$b ?v1 ?v2))) (or (= ?v0 ?v1) (set.member$a ?v0 (set$a ?v2))))) :named a295))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Agent_list$)) (=> (set.member$ ?v0 (set$b (cons$c ?v1 ?v2))) (or (= ?v0 ?v1) (set.member$ ?v0 (set$b ?v2))))) :named a296))
+(assert (! (forall ((?v0 Event$) (?v1 Event$) (?v2 Event_list$)) (=> (set.member$b ?v0 (set$ (cons$ ?v1 ?v2))) (or (= ?v0 ?v1) (set.member$b ?v0 (set$ ?v2))))) :named a297))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (and (set.member$a ?v0 (set$a ?v1)) (and (forall ((?v2 Msg_list$)) (=> (= ?v1 (cons$b ?v0 ?v2)) false)) (forall ((?v2 Msg$) (?v3 Msg_list$)) (=> (and (= ?v1 (cons$b ?v2 ?v3)) (set.member$a ?v0 (set$a ?v3))) false)))) false)) :named a298))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (and (set.member$ ?v0 (set$b ?v1)) (and (forall ((?v2 Agent_list$)) (=> (= ?v1 (cons$c ?v0 ?v2)) false)) (forall ((?v2 Agent$) (?v3 Agent_list$)) (=> (and (= ?v1 (cons$c ?v2 ?v3)) (set.member$ ?v0 (set$b ?v3))) false)))) false)) :named a299))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (and (set.member$b ?v0 (set$ ?v1)) (and (forall ((?v2 Event_list$)) (=> (= ?v1 (cons$ ?v0 ?v2)) false)) (forall ((?v2 Event$) (?v3 Event_list$)) (=> (and (= ?v1 (cons$ ?v2 ?v3)) (set.member$b ?v0 (set$ ?v3))) false)))) false)) :named a300))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg_list$) (?v2 (-> Msg$ Bool)) (?v3 (-> Msg$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Msg$)) (=> (set.member$a ?v4 (set$a ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$a ?v2 ?v0) (list_all$a ?v3 ?v1)))) :named a301))
+(assert (! (forall ((?v0 Agent_list$) (?v1 Agent_list$) (?v2 (-> Agent$ Bool)) (?v3 (-> Agent$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Agent$)) (=> (set.member$ ?v4 (set$b ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$b ?v2 ?v0) (list_all$b ?v3 ?v1)))) :named a302))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event_list$) (?v2 (-> Event$ Bool)) (?v3 (-> Event$ Bool))) (=> (and (= ?v0 ?v1) (forall ((?v4 Event$)) (=> (set.member$b ?v4 (set$ ?v1)) (= (?v2 ?v4) (?v3 ?v4))))) (= (list_all$ ?v2 ?v0) (list_all$ ?v3 ?v1)))) :named a303))
+(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$) (?v2 (-> Msg$ Bool))) (=> (and (list_all$a ?v0 ?v1) (forall ((?v3 Msg$)) (=> (and (set.member$a ?v3 (set$a ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$a ?v2 ?v1))) :named a304))
+(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$) (?v2 (-> Agent$ Bool))) (=> (and (list_all$b ?v0 ?v1) (forall ((?v3 Agent$)) (=> (and (set.member$ ?v3 (set$b ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$b ?v2 ?v1))) :named a305))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$) (?v2 (-> Event$ Bool))) (=> (and (list_all$ ?v0 ?v1) (forall ((?v3 Event$)) (=> (and (set.member$b ?v3 (set$ ?v1)) (?v0 ?v3)) (?v2 ?v3)))) (list_all$ ?v2 ?v1))) :named a306))
+(assert (! (forall ((?v0 (-> Msg$ Bool)) (?v1 Msg_list$)) (= (list_ex1$a ?v0 ?v1) (exists ((?v2 Msg$)) (and (and (set.member$a ?v2 (set$a ?v1)) (?v0 ?v2)) (forall ((?v3 Msg$)) (=> (and (set.member$a ?v3 (set$a ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a307))
+(assert (! (forall ((?v0 (-> Agent$ Bool)) (?v1 Agent_list$)) (= (list_ex1$b ?v0 ?v1) (exists ((?v2 Agent$)) (and (and (set.member$ ?v2 (set$b ?v1)) (?v0 ?v2)) (forall ((?v3 Agent$)) (=> (and (set.member$ ?v3 (set$b ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a308))
+(assert (! (forall ((?v0 (-> Event$ Bool)) (?v1 Event_list$)) (= (list_ex1$ ?v0 ?v1) (exists ((?v2 Event$)) (and (and (set.member$b ?v2 (set$ ?v1)) (?v0 ?v2)) (forall ((?v3 Event$)) (=> (and (set.member$b ?v3 (set$ ?v1)) (?v0 ?v3)) (= ?v3 ?v2))))))) :named a309))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (set.member$a ?v0 (set$a ?v1)) (set.member$g ?v1 ?v0))) :named a310))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (set.member$ ?v0 (set$b ?v1)) (set.member$h ?v1 ?v0))) :named a311))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (set.member$b ?v0 (set$ ?v1)) (set.member$d ?v1 ?v0))) :named a312))
(assert (! (forall ((?v0 Event_list$) (?v1 Event$)) (less_eq$a (set$ ?v0) (set$ (cons$ ?v1 ?v0)))) :named a313))
(assert (! (forall ((?v0 Msg_list$) (?v1 Msg$)) (less_eq$ (set$a ?v0) (set$a (cons$b ?v1 ?v0)))) :named a314))
-(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (= (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v2)) (not (?v1 ?v5))))))))) :named a315))
-(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (= (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v2)) (not (?v1 ?v5))))))))) :named a316))
-(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (= (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v2)) (not (?v1 ?v5))))))))) :named a317))
-(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (= (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v4)) (not (?v1 ?v5))))))))) :named a318))
-(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (= (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v4)) (not (?v1 ?v5))))))))) :named a319))
-(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (= (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v4)) (not (?v1 ?v5))))))))) :named a320))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v2))))))) :named a321))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v2))))))) :named a322))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v2))))))) :named a323))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v3))))))) :named a324))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v3))))))) :named a325))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v3))))))) :named a326))
-(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a327))
-(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a328))
-(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a329))
-(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a330))
-(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a331))
-(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a332))
-(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v2)) (not (?v1 ?v5))))))))) :named a333))
-(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v2)) (not (?v1 ?v5))))))))) :named a334))
-(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v2)) (not (?v1 ?v5))))))))) :named a335))
-(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (member$a ?v5 (set$a ?v4)) (not (?v1 ?v5))))))))) :named a336))
-(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (member$ ?v5 (set$b ?v4)) (not (?v1 ?v5))))))))) :named a337))
-(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (member$b ?v5 (set$ ?v4)) (not (?v1 ?v5))))))))) :named a338))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3)))))) :named a339))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3)))))) :named a340))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3)))))) :named a341))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 Msg_list$) (?v3 Msg_list$) (?v4 Msg_list$)) (=> (and (not (member$a ?v0 (set$a ?v1))) (not (member$a ?v0 (set$a ?v2)))) (= (= (append$a ?v1 (cons$b ?v0 ?v2)) (append$a ?v3 (cons$b ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a342))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 Agent_list$) (?v3 Agent_list$) (?v4 Agent_list$)) (=> (and (not (member$ ?v0 (set$b ?v1))) (not (member$ ?v0 (set$b ?v2)))) (= (= (append$b ?v1 (cons$c ?v0 ?v2)) (append$b ?v3 (cons$c ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a343))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$) (?v4 Event_list$)) (=> (and (not (member$b ?v0 (set$ ?v1))) (not (member$b ?v0 (set$ ?v2)))) (= (= (append$ ?v1 (cons$ ?v0 ?v2)) (append$ ?v3 (cons$ ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a344))
-(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a345))
-(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a346))
-(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a347))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v2))))))) :named a348))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v2))))))) :named a349))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v2))))))) :named a350))
-(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (?v1 ?v3))))) :named a351))
-(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (?v1 ?v3))))) :named a352))
-(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (?v1 ?v3))))) :named a353))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (member$a ?v0 (set$a ?v3))))))) :named a354))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (member$ ?v0 (set$b ?v3))))))) :named a355))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (member$b ?v0 (set$ ?v3))))))) :named a356))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3)))))) :named a357))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3)))))) :named a358))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3)))))) :named a359))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (=> (member$b (says$ ?v0 ?v1 ?v2) (set$ ?v3)) (member$a ?v2 (knows$ ?v0 ?v3)))) :named a360))
-(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (member$b (notes$ ?v0 ?v1) (set$ ?v2)) (member$a ?v1 (knows$ ?v0 ?v2)))) :named a361))
-(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (= (insert$d ?v0 ?v1) (ite (member$a ?v0 (set$a ?v1)) ?v1 (cons$b ?v0 ?v1))) :pattern ((insert$d ?v0 ?v1)))) :named a362))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (= (insert$e ?v0 ?v1) (ite (member$ ?v0 (set$b ?v1)) ?v1 (cons$c ?v0 ?v1))) :pattern ((insert$e ?v0 ?v1)))) :named a363))
-(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (insert$a ?v0 ?v1) (ite (member$b ?v0 (set$ ?v1)) ?v1 (cons$ ?v0 ?v1))) :pattern ((insert$a ?v0 ?v1)))) :named a364))
-(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (=> (member$b (says$ ?v0 ?v1 ?v2) (set$ ?v3)) (member$a ?v2 (knows$ spy$ ?v3)))) :named a365))
-(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (and (not (= ?v0 spy$)) (member$b (gets$ ?v0 ?v1) (set$ ?v2))) (member$a ?v1 (knows$ ?v0 ?v2)))) :named a366))
-(assert (! (forall ((?v0 Msg$) (?v1 Event_list$)) (=> (member$a ?v0 (knows$ spy$ ?v1)) (exists ((?v2 Agent$) (?v3 Agent$)) (or (member$b (says$ ?v2 ?v3 ?v0) (set$ ?v1)) (or (member$b (notes$ ?v2 ?v0) (set$ ?v1)) (member$a ?v0 (initState$ spy$))))))) :named a367))
-(assert (! (forall ((?v0 Msg_list$) (?v1 Msg$) (?v2 Msg_list_set$)) (=> (member$e (append$a ?v0 (cons$b ?v1 nil$b)) ?v2) (member$a ?v1 (succ$a ?v2 ?v0)))) :named a368))
-(assert (! (forall ((?v0 Agent_list$) (?v1 Agent$) (?v2 Agent_list_set$)) (=> (member$f (append$b ?v0 (cons$c ?v1 nil$c)) ?v2) (member$ ?v1 (succ$b ?v2 ?v0)))) :named a369))
-(assert (! (forall ((?v0 Event_list$) (?v1 Event$) (?v2 Event_list_set$)) (=> (member$c (append$ ?v0 (cons$ ?v1 nil$)) ?v2) (member$b ?v1 (succ$ ?v2 ?v0)))) :named a370))
-(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (= (knows$ spy$ (append$ ?v0 (cons$ (notes$ ?v1 ?v2) nil$))) (ite (member$ ?v1 bad$) (insert$ ?v2 (knows$ spy$ ?v0)) (knows$ spy$ ?v0)))) :named a371))
-(assert (! (member$ spy$ bad$) :named a372))
-(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (! (= (knows$ spy$ (cons$ (notes$ ?v0 ?v1) ?v2)) (ite (member$ ?v0 bad$) (insert$ ?v1 (knows$ spy$ ?v2)) (knows$ spy$ ?v2))) :pattern ((cons$ (notes$ ?v0 ?v1) ?v2)))) :named a373))
-(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (and (member$b (notes$ ?v0 ?v1) (set$ ?v2)) (member$ ?v0 bad$)) (member$a ?v1 (knows$ spy$ ?v2)))) :named a374))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (= (exists ((?v2 Msg$)) (and (set.member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (set.member$a ?v5 (set$a ?v2)) (not (?v1 ?v5))))))))) :named a315))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (= (exists ((?v2 Agent$)) (and (set.member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (set.member$ ?v5 (set$b ?v2)) (not (?v1 ?v5))))))))) :named a316))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (= (exists ((?v2 Event$)) (and (set.member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (set.member$b ?v5 (set$ ?v2)) (not (?v1 ?v5))))))))) :named a317))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (= (exists ((?v2 Msg$)) (and (set.member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (set.member$a ?v5 (set$a ?v4)) (not (?v1 ?v5))))))))) :named a318))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (= (exists ((?v2 Agent$)) (and (set.member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (set.member$ ?v5 (set$b ?v4)) (not (?v1 ?v5))))))))) :named a319))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (= (exists ((?v2 Event$)) (and (set.member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (set.member$b ?v5 (set$ ?v4)) (not (?v1 ?v5))))))))) :named a320))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (set.member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (set.member$a ?v0 (set$a ?v2))))))) :named a321))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (set.member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (set.member$ ?v0 (set$b ?v2))))))) :named a322))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (set.member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (set.member$b ?v0 (set$ ?v2))))))) :named a323))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (set.member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (set.member$a ?v0 (set$a ?v3))))))) :named a324))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (set.member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (set.member$ ?v0 (set$b ?v3))))))) :named a325))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (set.member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (set.member$b ?v0 (set$ ?v3))))))) :named a326))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (set.member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (set.member$a ?v5 (set$a ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a327))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (set.member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (set.member$ ?v5 (set$b ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a328))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (set.member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (set.member$b ?v5 (set$ ?v2)) (not (?v1 ?v5)))))) false))) false)) :named a329))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (set.member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (set.member$a ?v5 (set$a ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a330))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (set.member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (set.member$ ?v5 (set$b ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a331))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (set.member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (set.member$b ?v5 (set$ ?v4)) (not (?v1 ?v5)))))) false))) false)) :named a332))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (set.member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (set.member$a ?v5 (set$a ?v2)) (not (?v1 ?v5))))))))) :named a333))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (set.member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (set.member$ ?v5 (set$b ?v2)) (not (?v1 ?v5))))))))) :named a334))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (set.member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (set.member$b ?v5 (set$ ?v2)) (not (?v1 ?v5))))))))) :named a335))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (set.member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Msg$)) (=> (set.member$a ?v5 (set$a ?v4)) (not (?v1 ?v5))))))))) :named a336))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (set.member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Agent$)) (=> (set.member$ ?v5 (set$b ?v4)) (not (?v1 ?v5))))))))) :named a337))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (set.member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (and (?v1 ?v3) (forall ((?v5 Event$)) (=> (set.member$b ?v5 (set$ ?v4)) (not (?v1 ?v5))))))))) :named a338))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (= (set.member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3)))))) :named a339))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (= (set.member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3)))))) :named a340))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (= (set.member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3)))))) :named a341))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$) (?v2 Msg_list$) (?v3 Msg_list$) (?v4 Msg_list$)) (=> (and (not (set.member$a ?v0 (set$a ?v1))) (not (set.member$a ?v0 (set$a ?v2)))) (= (= (append$a ?v1 (cons$b ?v0 ?v2)) (append$a ?v3 (cons$b ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a342))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$) (?v2 Agent_list$) (?v3 Agent_list$) (?v4 Agent_list$)) (=> (and (not (set.member$ ?v0 (set$b ?v1))) (not (set.member$ ?v0 (set$b ?v2)))) (= (= (append$b ?v1 (cons$c ?v0 ?v2)) (append$b ?v3 (cons$c ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a343))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$) (?v2 Event_list$) (?v3 Event_list$) (?v4 Event_list$)) (=> (and (not (set.member$b ?v0 (set$ ?v1))) (not (set.member$b ?v0 (set$ ?v2)))) (= (= (append$ ?v1 (cons$ ?v0 ?v2)) (append$ ?v3 (cons$ ?v0 ?v4))) (and (= ?v1 ?v3) (= ?v2 ?v4))))) :named a344))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (and (exists ((?v2 Msg$)) (and (set.member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (forall ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (=> (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a345))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (and (exists ((?v2 Agent$)) (and (set.member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (forall ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (=> (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a346))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (and (exists ((?v2 Event$)) (and (set.member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (forall ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (=> (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (?v1 ?v3)) false))) false)) :named a347))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (set.member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (set.member$a ?v0 (set$a ?v2))))))) :named a348))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (set.member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (set.member$ ?v0 (set$b ?v2))))))) :named a349))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (set.member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (set.member$b ?v0 (set$ ?v2))))))) :named a350))
+(assert (! (forall ((?v0 Msg_list$) (?v1 (-> Msg$ Bool))) (=> (exists ((?v2 Msg$)) (and (set.member$a ?v2 (set$a ?v0)) (?v1 ?v2))) (exists ((?v2 Msg_list$) (?v3 Msg$) (?v4 Msg_list$)) (and (= ?v0 (append$a ?v2 (cons$b ?v3 ?v4))) (?v1 ?v3))))) :named a351))
+(assert (! (forall ((?v0 Agent_list$) (?v1 (-> Agent$ Bool))) (=> (exists ((?v2 Agent$)) (and (set.member$ ?v2 (set$b ?v0)) (?v1 ?v2))) (exists ((?v2 Agent_list$) (?v3 Agent$) (?v4 Agent_list$)) (and (= ?v0 (append$b ?v2 (cons$c ?v3 ?v4))) (?v1 ?v3))))) :named a352))
+(assert (! (forall ((?v0 Event_list$) (?v1 (-> Event$ Bool))) (=> (exists ((?v2 Event$)) (and (set.member$b ?v2 (set$ ?v0)) (?v1 ?v2))) (exists ((?v2 Event_list$) (?v3 Event$) (?v4 Event_list$)) (and (= ?v0 (append$ ?v2 (cons$ ?v3 ?v4))) (?v1 ?v3))))) :named a353))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (set.member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (and (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3))) (not (set.member$a ?v0 (set$a ?v3))))))) :named a354))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (set.member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (and (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3))) (not (set.member$ ?v0 (set$b ?v3))))))) :named a355))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (set.member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (and (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3))) (not (set.member$b ?v0 (set$ ?v3))))))) :named a356))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (=> (set.member$a ?v0 (set$a ?v1)) (exists ((?v2 Msg_list$) (?v3 Msg_list$)) (= ?v1 (append$a ?v2 (cons$b ?v0 ?v3)))))) :named a357))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (=> (set.member$ ?v0 (set$b ?v1)) (exists ((?v2 Agent_list$) (?v3 Agent_list$)) (= ?v1 (append$b ?v2 (cons$c ?v0 ?v3)))))) :named a358))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (=> (set.member$b ?v0 (set$ ?v1)) (exists ((?v2 Event_list$) (?v3 Event_list$)) (= ?v1 (append$ ?v2 (cons$ ?v0 ?v3)))))) :named a359))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (=> (set.member$b (says$ ?v0 ?v1 ?v2) (set$ ?v3)) (set.member$a ?v2 (knows$ ?v0 ?v3)))) :named a360))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (set.member$b (notes$ ?v0 ?v1) (set$ ?v2)) (set.member$a ?v1 (knows$ ?v0 ?v2)))) :named a361))
+(assert (! (forall ((?v0 Msg$) (?v1 Msg_list$)) (! (= (set.insert$d ?v0 ?v1) (ite (set.member$a ?v0 (set$a ?v1)) ?v1 (cons$b ?v0 ?v1))) :pattern ((set.insert$d ?v0 ?v1)))) :named a362))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent_list$)) (! (= (set.insert$e ?v0 ?v1) (ite (set.member$ ?v0 (set$b ?v1)) ?v1 (cons$c ?v0 ?v1))) :pattern ((set.insert$e ?v0 ?v1)))) :named a363))
+(assert (! (forall ((?v0 Event$) (?v1 Event_list$)) (! (= (set.insert$a ?v0 ?v1) (ite (set.member$b ?v0 (set$ ?v1)) ?v1 (cons$ ?v0 ?v1))) :pattern ((set.insert$a ?v0 ?v1)))) :named a364))
+(assert (! (forall ((?v0 Agent$) (?v1 Agent$) (?v2 Msg$) (?v3 Event_list$)) (=> (set.member$b (says$ ?v0 ?v1 ?v2) (set$ ?v3)) (set.member$a ?v2 (knows$ spy$ ?v3)))) :named a365))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (and (not (= ?v0 spy$)) (set.member$b (gets$ ?v0 ?v1) (set$ ?v2))) (set.member$a ?v1 (knows$ ?v0 ?v2)))) :named a366))
+(assert (! (forall ((?v0 Msg$) (?v1 Event_list$)) (=> (set.member$a ?v0 (knows$ spy$ ?v1)) (exists ((?v2 Agent$) (?v3 Agent$)) (or (set.member$b (says$ ?v2 ?v3 ?v0) (set$ ?v1)) (or (set.member$b (notes$ ?v2 ?v0) (set$ ?v1)) (set.member$a ?v0 (initState$ spy$))))))) :named a367))
+(assert (! (forall ((?v0 Msg_list$) (?v1 Msg$) (?v2 Msg_list_set$)) (=> (set.member$e (append$a ?v0 (cons$b ?v1 nil$b)) ?v2) (set.member$a ?v1 (succ$a ?v2 ?v0)))) :named a368))
+(assert (! (forall ((?v0 Agent_list$) (?v1 Agent$) (?v2 Agent_list_set$)) (=> (set.member$f (append$b ?v0 (cons$c ?v1 nil$c)) ?v2) (set.member$ ?v1 (succ$b ?v2 ?v0)))) :named a369))
+(assert (! (forall ((?v0 Event_list$) (?v1 Event$) (?v2 Event_list_set$)) (=> (set.member$c (append$ ?v0 (cons$ ?v1 nil$)) ?v2) (set.member$b ?v1 (succ$ ?v2 ?v0)))) :named a370))
+(assert (! (forall ((?v0 Event_list$) (?v1 Agent$) (?v2 Msg$)) (= (knows$ spy$ (append$ ?v0 (cons$ (notes$ ?v1 ?v2) nil$))) (ite (set.member$ ?v1 bad$) (set.insert$ ?v2 (knows$ spy$ ?v0)) (knows$ spy$ ?v0)))) :named a371))
+(assert (! (set.member$ spy$ bad$) :named a372))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (! (= (knows$ spy$ (cons$ (notes$ ?v0 ?v1) ?v2)) (ite (set.member$ ?v0 bad$) (set.insert$ ?v1 (knows$ spy$ ?v2)) (knows$ spy$ ?v2))) :pattern ((cons$ (notes$ ?v0 ?v1) ?v2)))) :named a373))
+(assert (! (forall ((?v0 Agent$) (?v1 Msg$) (?v2 Event_list$)) (=> (and (set.member$b (notes$ ?v0 ?v1) (set$ ?v2)) (set.member$ ?v0 bad$)) (set.member$a ?v1 (knows$ spy$ ?v2)))) :named a374))
(assert (! (forall ((?v0 Agent$) (?v1 Event$) (?v2 Event_list$)) (= (knows$ ?v0 (cons$ ?v1 ?v2)) (ite (= ?v0 spy$) (case_event$ (uuo$ ?v2) (uup$ ?v2) (uuq$ ?v2) ?v1) (case_event$ (uur$ ?v0 ?v2) (uus$ ?v0 ?v2) (uus$ ?v0 ?v2) ?v1)))) :named a375))
(check-sat)
(set-logic ALL)
(synth-fun f ((x Int)) (Set Int))
-(constraint (member 45 (f 45)))
-(constraint (member 8 (f 8)))
-(constraint (member 0 (f 3)))
+(constraint (set.member 45 (f 45)))
+(constraint (set.member 8 (f 8)))
+(constraint (set.member 0 (f 3)))
(check-synth)
(declare-fun D () (Set Int))
(declare-fun x () Int)
-(assert (not (member x A)))
-(assert (not (member x B)))
-(assert (not (member x C)))
-(assert (not (member x D)))
+(assert (not (set.member x A)))
+(assert (not (set.member x B)))
+(assert (not (set.member x C)))
+(assert (not (set.member x D)))
(declare-fun y () Int)
-(assert (not (member y A)))
-(assert (not (member y B)))
-(assert (not (member y C)))
-(assert (not (member y D)))
+(assert (not (set.member y A)))
+(assert (not (set.member y B)))
+(assert (not (set.member y C)))
+(assert (not (set.member y D)))
(declare-fun z () Int)
-(assert (not (member z A)))
-(assert (not (member z B)))
-(assert (not (member z C)))
-(assert (not (member z D)))
+(assert (not (set.member z A)))
+(assert (not (set.member z B)))
+(assert (not (set.member z C)))
+(assert (not (set.member z D)))
(assert (distinct x y z))
-(assert (= (card (union A (union B (union C D)))) 6))
+(assert (= (set.card (union A (union B (union C D)))) 6))
-(assert (= (card (as univset (Set Int))) 8))
+(assert (= (set.card (as set.universe (Set Int))) 8))
(check-sat)
Term[] elements = new Term[] {d_solver.mkBoolean(true),
d_solver.mkInteger(3),
d_solver.mkString("C"),
- d_solver.mkTerm(SINGLETON, d_solver.mkString("Z"))};
+ d_solver.mkTerm(SET_SINGLETON, d_solver.mkString("Z"))};
Term tuple = d_solver.mkTuple(sorts, elements);
assertEquals(elements[indices[i]], simplifiedTerm);
}
- assertEquals("((_ tuple_project 0 3 2 0 1 2) (tuple true 3 \"C\" (singleton "
- + "\"Z\")))",
+ assertEquals("((_ tuple_project 0 3 2 0 1 2) (tuple true 3 \"C\" "
+ + "(set.singleton \"Z\")))",
projection.toString());
}
}
Term i2 = d_solver.mkInteger(7);
Term s1 = d_solver.mkEmptySet(s);
- Term s2 = d_solver.mkTerm(Kind.SINGLETON, i1);
- Term s3 = d_solver.mkTerm(Kind.SINGLETON, i1);
- Term s4 = d_solver.mkTerm(Kind.SINGLETON, i2);
- Term s5 = d_solver.mkTerm(Kind.UNION, s2, d_solver.mkTerm(Kind.UNION, s3, s4));
+ Term s2 = d_solver.mkTerm(Kind.SET_SINGLETON, i1);
+ Term s3 = d_solver.mkTerm(Kind.SET_SINGLETON, i1);
+ Term s4 = d_solver.mkTerm(Kind.SET_SINGLETON, i2);
+ Term s5 = d_solver.mkTerm(Kind.SET_UNION, s2, d_solver.mkTerm(Kind.SET_UNION, s3, s4));
assertTrue(s1.isSetValue());
assertTrue(s2.isSetValue());
d_solver.mkBoolean(true),
d_solver.mkInteger(3),
d_solver.mkString("C"),
- d_solver.mkTerm(SINGLETON, d_solver.mkString("Z"))};
+ d_solver.mkTerm(SET_SINGLETON, d_solver.mkString("Z"))};
Term tuple = d_solver.mkTuple(sorts, elements);
}
ASSERT_EQ(
- "((_ tuple_project 0 3 2 0 1 2) (tuple true 3 \"C\" (singleton "
+ "((_ tuple_project 0 3 2 0 1 2) (tuple true 3 \"C\" (set.singleton "
"\"Z\")))",
projection.toString());
}
Term i2 = d_solver.mkInteger(7);
Term s1 = d_solver.mkEmptySet(s);
- Term s2 = d_solver.mkTerm(Kind::SINGLETON, i1);
- Term s3 = d_solver.mkTerm(Kind::SINGLETON, i1);
- Term s4 = d_solver.mkTerm(Kind::SINGLETON, i2);
- Term s5 =
- d_solver.mkTerm(Kind::UNION, s2, d_solver.mkTerm(Kind::UNION, s3, s4));
+ Term s2 = d_solver.mkTerm(Kind::SET_SINGLETON, i1);
+ Term s3 = d_solver.mkTerm(Kind::SET_SINGLETON, i1);
+ Term s4 = d_solver.mkTerm(Kind::SET_SINGLETON, i2);
+ Term s5 = d_solver.mkTerm(
+ Kind::SET_UNION, s2, d_solver.mkTerm(Kind::SET_UNION, s3, s4));
ASSERT_TRUE(s1.isSetValue());
ASSERT_TRUE(s2.isSetValue());
ASSERT_EQ(output2, NormalForm::evaluate(input2));
// for normal sets, the first node is the largest, not smallest
- Node normalSet = d_nodeManager->mkNode(UNION, ySingleton, xSingleton);
+ Node normalSet = d_nodeManager->mkNode(SET_UNION, ySingleton, xSingleton);
Node input3 = d_nodeManager->mkNode(BAG_FROM_SET, normalSet);
Node output3 = d_nodeManager->mkNode(UNION_DISJOINT, x_1, y_1);
ASSERT_EQ(output3, NormalForm::evaluate(input3));
// for normal sets, the first node is the largest, not smallest
Node normalBag = d_nodeManager->mkNode(UNION_DISJOINT, x_4, y_5);
Node input3 = d_nodeManager->mkNode(BAG_TO_SET, normalBag);
- Node output3 = d_nodeManager->mkNode(UNION, ySingleton, xSingleton);
+ Node output3 = d_nodeManager->mkNode(SET_UNION, ySingleton, xSingleton);
ASSERT_EQ(output3, NormalForm::evaluate(input3));
}
} // namespace test
Term emptyReal = d_solver.mkEmptySet(d_solver.mkSetSort(realSort));
Term integerOne = d_solver.mkInteger(1);
Term realOne = d_solver.mkReal(1);
- Term singletonInt = d_solver.mkTerm(api::SINGLETON, integerOne);
- Term singletonReal = d_solver.mkTerm(api::SINGLETON, realOne);
+ Term singletonInt = d_solver.mkTerm(api::SET_SINGLETON, integerOne);
+ Term singletonReal = d_solver.mkTerm(api::SET_SINGLETON, realOne);
// (union
// (singleton (singleton_op Int) 1)
// (as emptyset (Set Real)))
- ASSERT_THROW(d_solver.mkTerm(UNION, singletonInt, emptyReal),
+ ASSERT_THROW(d_solver.mkTerm(SET_UNION, singletonInt, emptyReal),
CVC5ApiException);
// (union
// (singleton (singleton_op Real) 1)
// (as emptyset (Set Real)))
- ASSERT_NO_THROW(d_solver.mkTerm(UNION, singletonReal, emptyReal));
+ ASSERT_NO_THROW(d_solver.mkTerm(SET_UNION, singletonReal, emptyReal));
}
TEST_F(TestTheoryWhiteSetsTypeRuleInternal, singleton_node)
{
Node singletonInt =
- d_nodeManager->mkConst(SingletonOp(d_nodeManager->integerType()));
+ d_nodeManager->mkConst(SetSingletonOp(d_nodeManager->integerType()));
Node singletonReal =
- d_nodeManager->mkConst(SingletonOp(d_nodeManager->realType()));
+ d_nodeManager->mkConst(SetSingletonOp(d_nodeManager->realType()));
Node intConstant = d_nodeManager->mkConst(Rational(1));
Node realConstant = d_nodeManager->mkConst(Rational(1, 5));
// (singleton (singleton_op Real) 1)
projects / cvc5.git / commitdiff