http://cvc4.stanford.edu/w/api.php?action=feedcontributions&feedformat=atom&user=AjreynolCVC4 - User contributions [en]2026-04-05T21:34:32ZUser contributionsMediaWiki 1.26.4http://cvc4.stanford.edu/w/index.php?title=Sets&diff=5746Sets2019-08-13T14:47:25Z<p>Ajreynol: </p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
==Semantics==<br />
<br />
The semantics of most of the above operators (e.g. set union, intersection, difference) are straightforward. The semantics for the universe set and complement are more subtle and is explained in the following.<br />
<br />
The universe set (as univset (Set T)) is *not* interpreted as the set containing all elements of type T. Instead it may be interpreted as any set such that all sets of type (Set T) are interpreted as subsets of it. In other words, it is the union of the interpretation of all (finite) sets in our input. For example:<br />
(declare-fun x () (Set Int))<br />
(declare-fun y () (Set Int))<br />
(declare-fun z () (Set Int))<br />
(assert (member 0 x))<br />
(assert (member 1 y))<br />
(assert (= z (as univset (Set Int))))<br />
(check-sat)<br />
Here, a possible model is:<br />
(define-fun x () (singleton 0))<br />
(define-fun y () (singleton 1))<br />
(define-fun z () (union (singleton 1) (singleton 0)))<br />
Notice that the universe set in this example is interpreted the same as z, and is such that all sets in this example (x, y, and z) are subsets of it.<br />
<br />
The set complement operator for (Set T) is interpreted relative to the interpretation of the universe set for (Set T), and not relative to the set of all elements of type T. That is, for all sets X of type (Set T), the complement operator is such that: <br />
(complement X) = (setminus (as univset (Set T)) X)<br />
holds in all models.<br />
<br />
The motivation for these semantics is to ensure that the universe set for type T and applications of set complement can always be interpreted as a finite set in (quantifier-free) inputs, even if the cardinality of T is infinite. Above, notice that we were able to find a model for the universe set of type (Set Int) that contained two elements only.<br />
<br />
=Finite Relations=<br />
<br />
* [https://github.com/CVC4/CVC4/blob/master/test/regress/regress0/rels/rel_join_1_1.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/master/test/regress/regress0/rels/relations-ops.smt2 SMT language example]<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.'''mkSetType'''( em.'''mkTupleType'''( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-<br />
<br />
For more details, see our CADE 2017 paper on an extension of the decision procedure for sets, as described in [http://homepage.cs.uiowa.edu/~tinelli/papers/MenEtAl-CADE-17.pdf].</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5745Sets2019-08-13T14:38:42Z<p>Ajreynol: </p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
==Semantics==<br />
<br />
The semantics of most of the above operators (e.g. set union, intersection, difference) are straightforward. The semantics for the universe set and complement are more subtle and is explained in the following.<br />
<br />
The universe set (as univset (Set T)) is *not* interpreted as the set containing all elements of type T. Instead it may be interpreted as any set such that all sets of type (Set T) are interpreted as subsets of it. In other words, it is the union of the interpretation of all (finite) sets in our input. For example:<br />
(declare-fun x () (Set Int))<br />
(declare-fun y () (Set Int))<br />
(declare-fun z () (Set Int))<br />
(assert (member 0 x))<br />
(assert (member 1 y))<br />
(assert (= z (as univset (Set Int))))<br />
(check-sat)<br />
Here, a possible model is:<br />
(define-fun x () (singleton 0))<br />
(define-fun y () (singleton 1))<br />
(define-fun z () (union (singleton 1) (singleton 0)))<br />
Notice that the universe set in this example is interpreted the same as z, and is such that all sets in this example (x, y, and z) are subsets of it.<br />
<br />
The set complement operator for (Set T) is interpreted relative to the interpretation of the universe set for (Set T), and not relative to the set of all elements of type T. That is, for all sets X of type (Set T), the complement operator is such that: <br />
(complement X) = (setminus (as univset (Set T)) X)<br />
holds in all models.<br />
<br />
The motivation for these semantics is to ensure that the universe set for type T and applications of set complement can always be interpreted as a finite set in (quantifier-free) inputs, even if the cardinality of T is infinite. Above, notice that we were able to find a model for the universe set of type (Set Int) that contained two elements only.<br />
<br />
=Finite Relations=<br />
<br />
* [https://github.com/CVC4/CVC4/blob/master/test/regress/regress0/rels/rel_join_1_1.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/master/test/regress/regress0/rels/relations-ops.smt2 SMT language example]<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.'''mkSetType'''( em.'''mkTupleType'''( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5744Sets2019-03-12T19:36:40Z<p>Ajreynol: </p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
==Semantics==<br />
<br />
The semantics of most of the above operators (e.g. set union, intersection, difference) are straightforward. The semantics for the universe set and complement are more subtle and is explained in the following.<br />
<br />
The universe set (as univset (Set T)) is *not* interpreted as the set containing all elements of type T. Instead it may be interpreted as any set such that all sets of type (Set T) are interpreted as subsets of it. In other words, it is the union of the interpretation of all (finite) sets in our input. For example:<br />
(declare-fun x () (Set Int))<br />
(declare-fun y () (Set Int))<br />
(declare-fun z () (Set Int))<br />
(assert (member 0 x))<br />
(assert (member 1 y))<br />
(assert (= z (as univset (Set Int))))<br />
(check-sat)<br />
Here, a possible model is:<br />
(define-fun x () (singleton 0))<br />
(define-fun y () (singleton 1))<br />
(define-fun z () (union (singleton 1) (singleton 0)))<br />
Notice that the universe set in this example is interpreted the same as z, and is such that all sets in this example (x, y, and z) are subsets of it.<br />
<br />
The set complement operator for (Set T) is interpreted relative to the interpretation of the universe set for (Set T), and not relative to the set of all elements of type T. That is, for all sets X of type (Set T), the complement operator is such that: <br />
(complement X) = (setminus (as univset (Set T)) X)<br />
holds in all models.<br />
<br />
The motivation for these semantics is to ensure that the universe set for type T and applications of set complement can always be interpreted as a finite set in (quantifier-free) inputs, even if the cardinality of T is infinite. Above, notice that we were able to find a model for the universe set of type (Set Int) that contained two elements only.<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.'''mkSetType'''( em.'''mkTupleType'''( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5743Sets2019-03-12T19:34:59Z<p>Ajreynol: </p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
==Semantics==<br />
<br />
Most of the above operators (e.g. set union, intersection, difference) have semantics that are straightforward. The semantics for the universe set is more subtle and is explained in the following.<br />
<br />
The universe set (as univset (Set T)) is *not* interpreted as the set containing all elements of type T. Instead it is defined as any set such that all sets of type (Set T) are interpreted as subsets of it. For example:<br />
(declare-fun x () (Set Int))<br />
(declare-fun y () (Set Int))<br />
(declare-fun z () (Set Int))<br />
(assert (member 0 x))<br />
(assert (member 1 y))<br />
(assert (= z (as univset (Set Int))))<br />
(check-sat)<br />
Here, a possible model is:<br />
(define-fun x () (singleton 0))<br />
(define-fun y () (singleton 1))<br />
(define-fun z () (union (singleton 1) (singleton 0)))<br />
Notice that the universe set in this example is interpreted the same as z, and is such that all sets in this example (x, y, and z) are subsets of it.<br />
<br />
The set complement operator for (Set T) is interpreted relative to the interpretation of the universe set for (Set T), and not relative to the set of all elements of type T. That is, for all sets X of type (Set T), the complement operator is such that: <br />
(complement X) = (setminus (as univset (Set T)) X)<br />
holds in all models.<br />
<br />
The motivation for these semantics is to ensure that the universe set for type T and applications of set complement can always be interpreted as a finite set in (quantifier-free) inputs, even if the cardinality of T is infinite. Above, notice that we were able to find a model for the universe set of type (Set Int) that contained two elements only.<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.'''mkSetType'''( em.'''mkTupleType'''( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5742Sets2019-03-12T19:34:06Z<p>Ajreynol: </p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
==Semantics==<br />
<br />
Most of the above operators (e.g. set union, intersection, difference) have semantics that are straightforward. The semantics for the universe set is more subtle and is explained in the following.<br />
<br />
The universe set (as univset (Set T)) is *not* interpreted as the set containing all elements of type T. Instead it is defined as any set such that all sets of type (Set T) are interpreted as subsets of it. For example:<br />
(declare-fun x () (Set Int))<br />
(declare-fun y () (Set Int))<br />
(declare-fun z () (Set Int))<br />
(assert (member 0 x))<br />
(assert (member 1 y))<br />
(assert (= z (as univset (Set Int))))<br />
(check-sat)<br />
Here, a possible model is:<br />
(define-fun x () (singleton 0))<br />
(define-fun y () (singleton 1))<br />
(define-fun z () (uniont (singleton 1) (singleton 0)))<br />
Notice that the universe set in this example is interpreted the same as z, and is such that all sets in this example (x, y, and z) are subsets of it.<br />
<br />
The set complement operator for (Set T) is interpreted relative to the interpretation of the universe set for (Set T), and not relative to the set of all elements of type T. That is, for all sets X of type (Set T), the complement operator is such that: <br />
(complement X) = (setminus (as univset (Set T)) X)<br />
holds in all models.<br />
<br />
The motivation for these semantics is to ensure that the universe set for type T and applications of set complement can always be interpreted as a finite set in (quantifier-free) inputs, even if the cardinality of T is infinite.<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.'''mkSetType'''( em.'''mkTupleType'''( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5741Sets2019-03-12T19:28:32Z<p>Ajreynol: </p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
==Semantics==<br />
<br />
Most of the above operators (e.g. set union, intersection, difference) have semantics that are straightforward. The semantics for the universe set is more subtle and is explained in the following.<br />
<br />
The universe set (as univset (Set T)) is not <br />
<br />
For all sets X of type (Set T), the complement operator is such that: <br />
(complement X) = (setminus (as univset (Set T)) X)<br />
holds in all models.<br />
<br />
The motivation for these semantics is to ensure that the universe set and applications of set complement can always be interpreted as a finite set in (quantifier-free) inputs.<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.'''mkSetType'''( em.'''mkTupleType'''( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5735Strings2018-12-11T18:35:47Z<p>Ajreynol: /* Extended Functions */</p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', i.e. those with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding. <br />
To limit the alphabet of the strings solver to the 128 printable ASCII characters, use:<br />
(set-option :--strings-print-ascii)<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
==Regular Expression Memberships==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Andrew Reynolds, Maverick Woo, Clark Barrett, David Brumley, Tianyi Liang, Cesare Tinelli. [http://homepage.divms.uiowa.edu/~ajreynol/cav17a.pdf Scaling Up DPLL(T) String Solvers Using Context-Dependent Simplification]. CAV 2017.<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5734Strings2018-12-11T18:34:01Z<p>Ajreynol: </p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', i.e. those with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding. <br />
To limit the alphabet of the strings solver to the 128 printable ASCII characters, use:<br />
(set-option :--strings-print-ascii)<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
==Regular Expression Memberships==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
Character in String:<br />
(str.at s i)<br />
where s is a string term and i is an integer.<br />
The index is starting from 0.<br />
<br />
Sub-String:<br />
(str.substr s i j )<br />
where s is a string term, i and j are integers.<br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Andrew Reynolds, Maverick Woo, Clark Barrett, David Brumley, Tianyi Liang, Cesare Tinelli. [http://homepage.divms.uiowa.edu/~ajreynol/cav17a.pdf Scaling Up DPLL(T) String Solvers Using Context-Dependent Simplification]. CAV 2017.<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5733Strings2018-12-11T18:31:58Z<p>Ajreynol: </p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', i.e. those with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding. <br />
To limit the alphabet of the strings solver to the 128 printable ASCII characters, use:<br />
(set-option :--strings-print-ascii)<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
==Regular Expression Memberships==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
Character in String:<br />
(str.at s i)<br />
where s is a string term and i is an integer.<br />
The index is starting from 0.<br />
<br />
Sub-String:<br />
(str.substr s i j )<br />
where s is a string term, i and j are integers.<br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5732Strings2018-12-11T18:31:22Z<p>Ajreynol: </p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', i.e. those with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding. <br />
To limit the alphabet of the strings solver to the 128 printable ASCII characters, use:<br />
(set-option :--strings-print-ascii)<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
==Regular Expression Memberships==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
Character in String:<br />
(str.at s i)<br />
where s is a string term and i is an integer.<br />
The index is starting from 0.<br />
<br />
Sub-String:<br />
(str.substr s i j )<br />
where s is a string term, i and j are integers.<br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Extensions=<br />
Together with other engine in CVC4, we can extend new functionality in the theory of strings. For example,<br />
(define-fun fun1 ((?x String) (?s String)) Bool<br />
(or (= ?x ?s)<br />
(> (str.len ?x) (str.len ?s))<br />
))<br />
Quantifiers over bounded Integers (with strings in the body) are supported in the experimental mode; however, quantifiers over strings are still under development.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5731Strings2018-12-11T18:30:58Z<p>Ajreynol: /* Extended Functions */</p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', i.e. those with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding. <br />
To limit the alphabet of the strings solver to the 128 printable ASCII characters, use:<br />
(set-option :--strings-print-ascii)<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
==Escape Sequences for Regular Expressions==<br />
Currently, it is for CVC format only. (Coming soon.)<br />
<br />
==Symbolic Regular Expression==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
Character in String:<br />
(str.at s i)<br />
where s is a string term and i is an integer.<br />
The index is starting from 0.<br />
<br />
Sub-String:<br />
(str.substr s i j )<br />
where s is a string term, i and j are integers.<br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Extensions=<br />
Together with other engine in CVC4, we can extend new functionality in the theory of strings. For example,<br />
(define-fun fun1 ((?x String) (?s String)) Bool<br />
(or (= ?x ?s)<br />
(> (str.len ?x) (str.len ?s))<br />
))<br />
Quantifiers over bounded Integers (with strings in the body) are supported in the experimental mode; however, quantifiers over strings are still under development.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5730Strings2018-12-11T18:30:36Z<p>Ajreynol: /* Theory Signature */</p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', i.e. those with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding. <br />
To limit the alphabet of the strings solver to the 128 printable ASCII characters, use:<br />
(set-option :--strings-print-ascii)<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
==Escape Sequences for Regular Expressions==<br />
Currently, it is for CVC format only. (Coming soon.)<br />
<br />
==Symbolic Regular Expression==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Extensions=<br />
Together with other engine in CVC4, we can extend new functionality in the theory of strings. For example,<br />
(define-fun fun1 ((?x String) (?s String)) Bool<br />
(or (= ?x ?s)<br />
(> (str.len ?x) (str.len ?s))<br />
))<br />
Quantifiers over bounded Integers (with strings in the body) are supported in the experimental mode; however, quantifiers over strings are still under development.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5729Strings2018-12-11T18:29:50Z<p>Ajreynol: </p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', i.e. those with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding. <br />
To limit the alphabet of the strings solver to the 128 printable ASCII characters, use:<br />
(set-option :--strings-print-ascii)<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
Character in String:<br />
(str.at s i)<br />
where s is a string term and i is an integer.<br />
The index is starting from 0.<br />
<br />
Sub-String:<br />
(str.substr s i j )<br />
where s is a string term, i and j are integers.<br />
<br />
==Escape Sequences for Regular Expressions==<br />
Currently, it is for CVC format only. (Coming soon.)<br />
<br />
==Symbolic Regular Expression==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Extensions=<br />
Together with other engine in CVC4, we can extend new functionality in the theory of strings. For example,<br />
(define-fun fun1 ((?x String) (?s String)) Bool<br />
(or (= ?x ?s)<br />
(> (str.len ?x) (str.len ?s))<br />
))<br />
Quantifiers over bounded Integers (with strings in the body) are supported in the experimental mode; however, quantifiers over strings are still under development.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5728Strings2018-12-11T18:29:34Z<p>Ajreynol: /* Options */</p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', i.e. those with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding. <br />
To limit the alphabet of the strings solver to the 128 printable ASCII characters, use:<br />
(set-option :--strings-print-ascii)<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Alphabet==<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', which are encoded <br />
in the same way in all Extended ASCII versions.<br />
<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Printable Characters==<br />
A ''printable'' character is any character with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
Character in String:<br />
(str.at s i)<br />
where s is a string term and i is an integer.<br />
The index is starting from 0.<br />
<br />
Sub-String:<br />
(str.substr s i j )<br />
where s is a string term, i and j are integers.<br />
<br />
==Escape Sequences for Regular Expressions==<br />
Currently, it is for CVC format only. (Coming soon.)<br />
<br />
==Symbolic Regular Expression==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Extensions=<br />
Together with other engine in CVC4, we can extend new functionality in the theory of strings. For example,<br />
(define-fun fun1 ((?x String) (?s String)) Bool<br />
(or (= ?x ?s)<br />
(> (str.len ?x) (str.len ?s))<br />
))<br />
Quantifiers over bounded Integers (with strings in the body) are supported in the experimental mode; however, quantifiers over strings are still under development.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5727Strings2018-12-11T18:28:01Z<p>Ajreynol: /* Options */</p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
By default, the strings solver uses the standard ASCII alphabet, which has cardinality 256.<br />
A ''printable'' character is any character with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding.<br />
To limit the alphabet of the strings solver to the 128 printable ASCII characters, use:<br />
(set-option :--strings-print-ascii)<br />
<br />
==Alphabet==<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', which are encoded <br />
in the same way in all Extended ASCII versions.<br />
<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Printable Characters==<br />
A ''printable'' character is any character with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
Character in String:<br />
(str.at s i)<br />
where s is a string term and i is an integer.<br />
The index is starting from 0.<br />
<br />
Sub-String:<br />
(str.substr s i j )<br />
where s is a string term, i and j are integers.<br />
<br />
==Escape Sequences for Regular Expressions==<br />
Currently, it is for CVC format only. (Coming soon.)<br />
<br />
==Symbolic Regular Expression==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Extensions=<br />
Together with other engine in CVC4, we can extend new functionality in the theory of strings. For example,<br />
(define-fun fun1 ((?x String) (?s String)) Bool<br />
(or (= ?x ?s)<br />
(> (str.len ?x) (str.len ?s))<br />
))<br />
Quantifiers over bounded Integers (with strings in the body) are supported in the experimental mode; however, quantifiers over strings are still under development.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5726Strings2018-12-11T18:27:28Z<p>Ajreynol: /* Options */</p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
By default, the strings solver uses the standard ASCII alphabet, which has cardinality 256.<br />
To limit the alphabet of the strings solver to the 128 printable ASCII characters, use:<br />
(set-option :--strings-print-ascii)<br />
<br />
==Alphabet==<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', which are encoded <br />
in the same way in all Extended ASCII versions.<br />
<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Printable Characters==<br />
A ''printable'' character is any character with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
Character in String:<br />
(str.at s i)<br />
where s is a string term and i is an integer.<br />
The index is starting from 0.<br />
<br />
Sub-String:<br />
(str.substr s i j )<br />
where s is a string term, i and j are integers.<br />
<br />
==Escape Sequences for Regular Expressions==<br />
Currently, it is for CVC format only. (Coming soon.)<br />
<br />
==Symbolic Regular Expression==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Extensions=<br />
Together with other engine in CVC4, we can extend new functionality in the theory of strings. For example,<br />
(define-fun fun1 ((?x String) (?s String)) Bool<br />
(or (= ?x ?s)<br />
(> (str.len ?x) (str.len ?s))<br />
))<br />
Quantifiers over bounded Integers (with strings in the body) are supported in the experimental mode; however, quantifiers over strings are still under development.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5725Strings2018-12-11T18:24:03Z<p>Ajreynol: /* Syntax */</p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5] or greater, <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitrary alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet (although one is in development http://smtlib.cs.uiowa.edu/theories-UnicodeStrings.shtml), <br />
the logic and operator names described below are tentative and might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
For string applications that require reasoning about length, the logic should be extended to also include linear integer arithmetic:<br />
(set-logic QF_SLIA)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACEALL'''( X, Y, Z )</code><br />
| <code>('''str.replaceall''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPLALL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
We refer to all functions apart from string length and string concatenation as ''extended functions'' in the following.<br />
<br />
==Options==<br />
The extended functions in the theory are disabled by default,<br />
even in the <code>ALL_SUPPORTED</code> logic. To enable them, use:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems where all strings are interpreted with small lengths.<br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver can be much '''slower''' than in default mode, <br />
so we recommend it as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
To set up string alphabet cardinality (256 by default, expert option):<br />
(set-option :strings-alphabet-card n)<br />
This is a reserved option for the extension of the sequence theory.<br />
<br />
==Alphabet==<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', which are encoded <br />
in the same way in all Extended ASCII versions.<br />
<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Printable Characters==<br />
A ''printable'' character is any character with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
Character in String:<br />
(str.at s i)<br />
where s is a string term and i is an integer.<br />
The index is starting from 0.<br />
<br />
Sub-String:<br />
(str.substr s i j )<br />
where s is a string term, i and j are integers.<br />
<br />
==Escape Sequences for Regular Expressions==<br />
Currently, it is for CVC format only. (Coming soon.)<br />
<br />
==Symbolic Regular Expression==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Extensions=<br />
Together with other engine in CVC4, we can extend new functionality in the theory of strings. For example,<br />
(define-fun fun1 ((?x String) (?s String)) Bool<br />
(or (= ?x ?s)<br />
(> (str.len ?x) (str.len ?s))<br />
))<br />
Quantifiers over bounded Integers (with strings in the body) are supported in the experimental mode; however, quantifiers over strings are still under development.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Separation_Logic&diff=5724Separation Logic2018-08-02T16:59:34Z<p>Ajreynol: </p>
<hr />
<div>CVC4 supports a syntax for separation logic as an extension of the *.smt2 language.<br />
<br />
=Signature=<br />
<br />
Given a (decidable) base theory T, CVC4 has a [http://homepage.divms.uiowa.edu/~ajreynol/atva16.pdf decision procedure] for quantifier-free <math>SL(T)_{Loc,Data}</math> formulas, where "Loc" and "Data" are any sort belonging to T.<br />
A <math>SL(T)_{Loc,Data}</math> formula is one from the following grammar:<br />
F : L | (emp t u) | (pto t u) | (sep F1 ... Fn) | (wand F1 F2) | ~F1 | F1 op ... op Fn<br />
where "op" is any classical Boolean connective, t and u are terms built from symbols in the signature of T of sort Loc and Data respectively, and L is a T-literal.<br />
The operator "emp" denotes the empty heap constraint, the operator "pto" denotes the points-to predicate,<br />
the operator "sep" denotes separation start and is variadic, and the operator "wand" denote magic wand.<br />
<br />
=Semantics=<br />
<br />
A satisfiability relation <math>I,h \models_{SL} \varphi</math> is defined for <math>SL(T)_{Loc,Data}</math> formulas <math>\varphi</math>,<br />
where I is an interpretation, and h is a heap. The semantics of separation logic operators are as follows:<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
| <math>I,h \models_{SL} </math> L<br />
| Iff <br />
| <math>I \models</math> L, if L is a T-literal<br />
|-<br />
| <math>I,h \models_{SL}</math> (emp <math>t \ u</math>)<br />
| Iff <br />
| <math>h = \emptyset</math><br />
|-<br />
| <math>I,h \models_{SL}</math> (pto <math>t \ u</math>)<br />
| Iff <br />
| <math>h = \{(t^I,u^I)\} \text{ and } t^I\not=nil^I</math><br />
|-<br />
| <math>I,h \models_{SL} </math> (sep <math>\phi_1 \ldots \phi_n</math>)<br />
| Iff <br />
| there exist heaps <math>h_1,\ldots,h_n</math> s.t. <math>h=h_1\uplus \ldots \uplus h_n</math> and <math>I,h_i \models_{SL} \phi_i, i = 1,\ldots,n</math><br />
|-<br />
| <math>I,h \models_{SL}</math> (wand <math>\phi_1 \ \phi_2</math>)<br />
| Iff <br />
| for all heaps <math>h'</math> if <math>h'\#h</math> and <math>I,h' \models_{SL} \phi_1</math> then <math>I,h'\uplus h \models_{SL} \phi_2</math><br />
|}<br />
<br />
where <math>h_1 \uplus \ldots \uplus h_n</math> denotes the disjoint union of heaps <math>h_1, \ldots, h_n</math> and<br />
<math>h'\#h</math> denotes that heaps h' and h are disjoint, and <math>nil</math> is a distinguished variable of sort Loc.<br />
All classical Boolean connectives are interpreted as expected.<br />
Note that the arguments of "emp" are used to denote the type of the heap and have no meaning otherwise.<br />
<br />
=Syntax=<br />
Separation logic in CVC4 requires the "all supported" logic:<br />
(set-logic QF_ALL_SUPPORTED)<br />
<br />
The syntax for the operators of separation logic is summarized in the following table:<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Empty heap<br />
| <code>N/A</code><br />
| <code>(_ '''emp''' T1 T2)</code><br />
| <code>em.mkExpr('''kind::SEP_EMP''', X, Y);</code> where X and Y are of type T1 and T2.<br />
|-<br />
| Points-to<br />
| <code>N/A</code><br />
| <code>('''pto''' X Y)</code><br />
| <code>em.mkExpr('''kind::SEP_PTO''', X, Y);</code><br />
|-<br />
| Separation star<br />
| <code>N/A</code><br />
| <code>('''sep''' C1 ... Cn)</code><br />
| <code>em.mkExpr('''kind::SEP_STAR''', C1, ..., Cn);</code><br />
|-<br />
| Magic wand<br />
| <code>N/A</code><br />
| <code>('''wand''' C1 C2)</code><br />
| <code>em.mkExpr('''kind::SEP_WAND''', C1, C2);</code><br />
|-<br />
| Nil element<br />
| <code>N/A</code><br />
| <code>('''as nil''' T)</code><br />
| <code>em.mkUniqueVar(T,'''kind::SEP_NIL''');</code><br />
|}<br />
<br />
=Examples=<br />
<br />
The following input on heaps Int -> Int is unsatisfiable:<br />
(set-logic QF_ALL_SUPPORTED)<br />
(set-info :status unsat)<br />
(declare-const x Int)<br />
(declare-const a Int)<br />
(declare-const b Int)<br />
(assert (and (pto x a) (pto x b)))<br />
(assert (not (= a b)))<br />
(check-sat)<br />
<br />
The following input on heaps U -> Int is satisfiable. Notice that the formula (not (emp x 0)) is satisfied by heaps U -> Int (the types of x and 0 respectively) whose domain is non-empty.<br />
(set-logic QF_ALL_SUPPORTED)<br />
(set-info :status unsat)<br />
(declare-sort U 0)<br />
(declare-const x U)<br />
(declare-const a Int)<br />
(assert (and (not (_ emp Int U)) (pto x a))<br />
(check-sat)<br />
<br />
The following input on heaps Int -> Node is satisfiable, where Node denotes a user-defined inductive [[Datatypes|datatype]]:<br />
(set-logic QF_ALL_SUPPORTED)<br />
(set-info :status sat)<br />
(declare-const x Int)<br />
(declare-const y Int)<br />
(declare-const z Int)<br />
(declare-datatypes () ((Node (node (data Int) (left Int) (right Int)))))<br />
(assert (pto x (node 0 y z)))<br />
(check-sat)<br />
<br />
Given a separation logic input, <br />
the sorts Loc and Data are inferred by CVC4, and must be consistent across all predicates occurring in an input. CVC4 does not accept an input such as:<br />
(set-logic QF_ALL_SUPPORTED)<br />
(declare-sort U 0)<br />
(declare-const x U)<br />
(assert (and (pto x 0) (pto 1 2)))<br />
since the sorts of the first arguments of the points-to predicates do not agree.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5722Datatypes2018-05-08T18:51:20Z<p>Ajreynol: /* Syntax/API */</p>
<hr />
<div>=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))<br />
<br />
=Syntax/API=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''DT''')</code><br />
| <code>smt.setLogic("QF_'''DT'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code><br><br />
<code>types.push_back(em.mkIntegerType());</code><br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Record Sort<br />
| [# f1:<Sort_1>, ..., fn:<Sort_n> #]<br />
| n/a<br />
| CVC4::ExprManager::mkRecordType(const Record& r)<br />
|-<br />
| <br />
| <code>t: '''[#''' fst:'''INT''', snd:'''INT]''';</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br><br />
<code>vec.push_back(std::pair<std::string, Type>("fst",em.integerType());</code><br><br />
<code>vec.push_back(std::pair<std::string, Type>("snd",em.integerType());</code><br><br />
<code>Record r(vec);</code><br><br />
<code>em.'''mkRecordType'''(r);</code><br />
|-<br />
| Record constructor<br />
| <code>'''(# f1 := t1, ..., fn := tn #)'''</code><br />
| n/a<br />
| <code>Record r(vec);</code><br><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Record selector<br />
| <code>'''f1(t)'''</code><br />
| n/a<br />
| <code>Record r(vec);</code><br><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-}</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5721Datatypes2018-05-08T18:51:02Z<p>Ajreynol: /* Syntax/API */</p>
<hr />
<div>=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))<br />
<br />
=Syntax/API=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''DT''')</code><br />
| <code>smt.setLogic("QF_'''DT'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Record Sort<br />
| [# f1:<Sort_1>, ..., fn:<Sort_n> #]<br />
| n/a<br />
| CVC4::ExprManager::mkRecordType(const Record& r)<br />
|-<br />
| <br />
| <code>t: '''[#''' fst:'''INT''', snd:'''INT]''';</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br><br />
<code>vec.push_back(std::pair<std::string, Type>("fst",em.integerType());</code><br><br />
<code>vec.push_back(std::pair<std::string, Type>("snd",em.integerType());</code><br><br />
<code>Record r(vec);</code><br><br />
<code>em.'''mkRecordType'''(r);</code><br />
|-<br />
| Record constructor<br />
| <code>'''(# f1 := t1, ..., fn := tn #)'''</code><br />
| n/a<br />
| <code>Record r(vec);</code><br><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Record selector<br />
| <code>'''f1(t)'''</code><br />
| n/a<br />
| <code>Record r(vec);</code><br><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-}</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=About_CVC4&diff=5720About CVC42018-05-08T13:57:04Z<p>Ajreynol: </p>
<hr />
<div>CVC4 is an automatic theorem prover for [http://en.wikipedia.org/wiki/Satisfiability_Modulo_Theories Satisifiability Modulo Theories (SMT)] (for a more formal introduction to SMT see the following book chapter [https://cs.stanford.edu/~barrett/pubs/BSST09.pdf Satisfiability Modulo Theories] ). Technically, it is an automated validity checker for a many-sorted (i.e., typed) first-order logic with built-in theories.<br />
It can be used to prove the validity (or, dually, the satisfiability) of a formula with respect to several built-in logical theories and their combination.<br />
<br />
CVC4 currently has support for the following theories:<br />
* equality over free (aka uninterpreted) function and predicate symbols<br />
* real and integer linear arithmetic<br />
* bit-vectors<br />
* arrays<br />
* [[Datatypes|tuples]]<br />
* [[Datatypes|records]]<br />
* user-defined inductive [[Datatypes|datatypes]]<br />
* [[Strings|strings]]<br />
* [[Sets|finite sets and relations]]<br />
* [[Separation Logic|separation logic]]<br />
<br />
CVC4 has a wide variety of features including:<br />
<br />
* support for quantifiers through heuristic instantiation;<br />
* an interactive text-based interface;<br />
* a rich [http://cvc4.cs.stanford.edu/cvc4-builds/documentation/public/latest/ C++ API] for embedding in other systems;<br />
* model generation abilities;<br />
* source compatibility with much of the CVC3 API via a "compatibility library";<br />
* essentially no limit on its use for research or commercial purposes (see [https://github.com/CVC4/CVC4/blob/master/COPYING license]).<br />
<br />
=Web site=<br />
<br />
For more information and the latest news about CVC4, visit the [http://cvc4.cs.stanford.edu CVC4 web site].<br />
<br />
=Decision Procedures=<br />
* Architecture<br />
** See the [http://dl.acm.org/citation.cfm?id=2032319 CVC4 tool paper].<br />
* Arithmetic<br />
** CVC4 solves linear real arithmetic using an implementation of [http://link.springer.com/chapter/10.1007%2F11817963_11? Simplex for DPLL(T)]. For a more complete introduction see the [http://yices.csl.sri.com/sri-csl-06-01.pdf tech report].<br />
** The linear arithmetic module includes heuristics from [http://eprints-phd.biblio.unitn.it/166/2/thesis.pdf Section 2.5 of Alberto Griggio's thesis] and a few currently unpublished ones.<br />
** Integers are currently handled by first solving the real relaxation of the constraints, and then using a combination of [http://www.cs.wm.edu/~idillig/cav2009.pdf Cuts from Proofs] and branching to ensure integer solutions. This approach and the equational solver used are described in [https://es.fbk.eu/people/griggio/papers/jsat12.pdf A Practical Approach to Satisfiability Modulo Linear Integer Arithmetic].<br />
** A technical report is planned to explain a number of small details and extensions including analysis to improve simplex's conflicts, handling disequalities, supporting model generation in CVC4's combination framework, heuristically propagating equalities over sharing terms, tableau row based propagation, and terminating simplex with unknown.<br />
** A heuristic approach non-linear arithmetic is supported based on this paper [https://es-static.fbk.eu/people/griggio/papers/tacas17.pdf].<br />
* Arrays<br />
** Arrays are implemented in a manner inspired by the [http://research.microsoft.com/en-us/um/people/leonardo/files/fmcad09.pdf Generalized, efficient array decision procedures] paper with a few major modifications.<br />
* Bitvectors<br />
** Bitvectors is implemented primarily via a lazy schema for bitblasting. See [http://eprints-phd.biblio.unitn.it/345/ Anders Franzen's thesis chapter 3].<br />
* Combination<br />
** Theory combination is based on the care graph framework described in both [http://cs.nyu.edu/~dejan/papers/jovanovic-fmsd2012.pdf Being careful about theory combination] and [http://cs.nyu.edu/~dejan/papers/jovanovic-frocos2011.pdf Sharing is Caring: Combination of Theories].<br />
* Datatypes<br />
** CVC4 implements [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf An Abstract Decision Procedure for a Theory of Inductive Data Types].<br />
** This procedure has been extended to incorporate coinductive datatypes [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf].<br />
** The datatypes decision procedure is optimized via the use of shared selectors, described in this paper [http://homepage.divms.uiowa.edu/~ajreynol/ijcar18.pdf].<br />
* Quantifiers<br />
** E-matching and conflict-based quantifier instantiation [http://homepage.cs.uiowa.edu/~ajreynol/fmcad14.pdf].<br />
** Finite model finding [http://homepage.cs.uiowa.edu/~ajreynol/thesis.pdf].<br />
** Enumerative instantiation, as described in [http://homepage.divms.uiowa.edu/~ajreynol/tacas18.pdf].<br />
** Techniques for finding counterexamples for conjectures in the presence of recursive functions [http://homepage.cs.uiowa.edu/~ajreynol/ijcar16a.pdf].<br />
** Automated induction for datatypes [http://homepage.cs.uiowa.edu/~ajreynol/vmcai15.pdf].<br />
** A decision procedure for quantified linear integer and real arithmetic [http://homepage.divms.uiowa.edu/~ajreynol/fmsd17-instla.pdf].<br />
** A dedicated approach for quantified bit-vectors based on invertibility conditions, as described in [http://homepage.divms.uiowa.edu/~ajreynol/cav18.pdf].<br />
** Support for syntax-guided synthesis, as described in [http://homepage.cs.uiowa.edu/~ajreynol/cav15a.pdf].<br />
* Relations<br />
** An extension of the decision procedure for sets, as described in [http://homepage.cs.uiowa.edu/~tinelli/papers/MenEtAl-CADE-17.pdf].<br />
* SAT Solver<br />
** The main sat solver is based on [http://minisat.se/ minisat v2.2.0].<br />
** Additionally, we (optionally, and enabled by default for certain theories) use non-clausal analysis to cut down search space of minisat. For more details see the article [http://cs.nyu.edu/~kshitij/articles/cvc4-branching-heuristic.pdf A branching heuristic in CVC4].<br />
* Separation Logic<br />
** A decision procedure for a fragment quantifier-free separation logic containing negation, separation star and magic wand is implemented and can be composed with other decision procedures supported by CVC4. For details see [http://homepage.divms.uiowa.edu/~ajreynol/atva16.pdf A Decision Procedure for Separation Logic in SMT].<br />
* Sets<br />
** Adaptation of tableau-based decision procedure described [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.10.5176 here].<br />
* Strings<br />
** Original approach described in our [http://www.cs.stanford.edu/~barrett/pubs/LRT+14.pdf CAV 2014 paper: A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].<br />
** Decision procedure for regular memberships with length [http://homepage.cs.uiowa.edu/~ajreynol/frocos15.pdf].<br />
* Uninterpreted functions<br />
** UF (without cardinality) is handled in a manner inspired by [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.70.1745 Simplify's tech report].<br />
** UF + cardinality is described [http://www.divms.uiowa.edu/~ajreynol/pres-fmf12.pdf this presentation] and is used for finite model finding.<br />
<br />
=History of CVC=<br />
<br />
[[File:svc.gif|thumb|border|100px|The SVC logo.]]<br />
[[File:cvc3_logo.jpg|thumb|border|100px|The CVC3 logo.]]<br />
[[File:cvc3_night_logo.png|thumb|border|100px|The CVC3 "by night" logo, used for nightly builds and regressions.]]<br />
[[File:cvc3cvc4.png|thumb|border|100px|An early CVC4 logo.]]<br />
<br />
The Cooperating Validity Checker series has a long history. The<br />
Stanford Validity Checker (SVC) came first in 1996, incorporating<br />
theories and its own SAT solver. Its successor, the Cooperating<br />
Validity Checker (CVC), had a more optimized internal design, produced<br />
proofs, used the Chaff SAT solver, and featured a number of usability<br />
enhancements. Its name comes from the cooperative nature of decision<br />
procedures in Nelson-Oppen theory combination, which share amongst<br />
each other equalities between shared terms. CVC Lite, first made<br />
available in 2003, was a rewrite of CVC that attempted to make CVC<br />
more flexible (hence the "lite") while extending the feature set: CVC<br />
Lite supported quantifiers where its predecessors did not. CVC3 was a<br />
major overhaul of portions of CVC Lite: it added better decision<br />
procedure implementations, added support for using MiniSat in the<br />
core, and had generally better performance.<br />
<br />
[[File:cvc4-logo.png|thumb|border|100px|The CVC4 logo.]]<br />
CVC4 is the new version, the fifth generation of this validity checker<br />
line that is now celebrating sixteen years of heritage. It represents<br />
a complete re-evaluation of the core architecture to be both<br />
performant and to serve as a cutting-edge research vehicle for the<br />
next several years. Rather than taking CVC3 and redesigning problem<br />
parts, we've taken a clean-room approach, starting from scratch.<br />
Before using any designs from CVC3, we have thoroughly scrutinized,<br />
vetted, and updated them. Many parts of CVC4 bear only a superficial<br />
resemblance, if any, to their correspondent in CVC3.<br />
<br />
However, CVC4 is fundamentally similar to CVC3 and many other modern<br />
SMT solvers: it is a DPLL(T) solver, with a SAT solver at its core and<br />
a delegation path to different decision procedure implementations,<br />
each in charge of solving formulas in some background theory.<br />
<br />
The re-evaluation and ground-up rewrite was necessitated, we felt, by<br />
the performance characteristics of CVC3. CVC3 has many useful<br />
features, but some core aspects of the design led to high memory use,<br />
and the use of heavyweight computation (where more nimble engineering<br />
approaches could suffice) makes CVC3 a much slower prover than other<br />
tools. As these designs are central to CVC3, a new version was<br />
preferable to a selective re-engineering, which would have ballooned<br />
in short order.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=About_CVC4&diff=5719About CVC42018-05-08T13:56:43Z<p>Ajreynol: </p>
<hr />
<div>CVC4 is an automatic theorem prover for [http://en.wikipedia.org/wiki/Satisfiability_Modulo_Theories Satisifiability Modulo Theories (SMT)] (for a more formal introduction to SMT see the following book chapter [https://cs.stanford.edu/~barrett/pubs/BSST09.pdf Satisfiability Modulo Theories] ). Technically, it is an automated validity checker for a many-sorted (i.e., typed) first-order logic with built-in theories.<br />
It can be used to prove the validity (or, dually, the satisfiability) of a formula with respect to several built-in logical theories and their combination.<br />
<br />
CVC4 currently has support for the following theories:<br />
* equality over free (aka uninterpreted) function and predicate symbols<br />
* real and integer linear arithmetic<br />
* bit-vectors<br />
* arrays<br />
* [[tuples|datatypes]]<br />
* [[records|datatypes]]<br />
* user-defined inductive [[Datatypes|datatypes]]<br />
* [[Strings|strings]]<br />
* [[Sets|finite sets and relations]]<br />
* [[Separation Logic|separation logic]]<br />
<br />
CVC4 has a wide variety of features including:<br />
<br />
* support for quantifiers through heuristic instantiation;<br />
* an interactive text-based interface;<br />
* a rich [http://cvc4.cs.stanford.edu/cvc4-builds/documentation/public/latest/ C++ API] for embedding in other systems;<br />
* model generation abilities;<br />
* source compatibility with much of the CVC3 API via a "compatibility library";<br />
* essentially no limit on its use for research or commercial purposes (see [https://github.com/CVC4/CVC4/blob/master/COPYING license]).<br />
<br />
=Web site=<br />
<br />
For more information and the latest news about CVC4, visit the [http://cvc4.cs.stanford.edu CVC4 web site].<br />
<br />
=Decision Procedures=<br />
* Architecture<br />
** See the [http://dl.acm.org/citation.cfm?id=2032319 CVC4 tool paper].<br />
* Arithmetic<br />
** CVC4 solves linear real arithmetic using an implementation of [http://link.springer.com/chapter/10.1007%2F11817963_11? Simplex for DPLL(T)]. For a more complete introduction see the [http://yices.csl.sri.com/sri-csl-06-01.pdf tech report].<br />
** The linear arithmetic module includes heuristics from [http://eprints-phd.biblio.unitn.it/166/2/thesis.pdf Section 2.5 of Alberto Griggio's thesis] and a few currently unpublished ones.<br />
** Integers are currently handled by first solving the real relaxation of the constraints, and then using a combination of [http://www.cs.wm.edu/~idillig/cav2009.pdf Cuts from Proofs] and branching to ensure integer solutions. This approach and the equational solver used are described in [https://es.fbk.eu/people/griggio/papers/jsat12.pdf A Practical Approach to Satisfiability Modulo Linear Integer Arithmetic].<br />
** A technical report is planned to explain a number of small details and extensions including analysis to improve simplex's conflicts, handling disequalities, supporting model generation in CVC4's combination framework, heuristically propagating equalities over sharing terms, tableau row based propagation, and terminating simplex with unknown.<br />
** A heuristic approach non-linear arithmetic is supported based on this paper [https://es-static.fbk.eu/people/griggio/papers/tacas17.pdf].<br />
* Arrays<br />
** Arrays are implemented in a manner inspired by the [http://research.microsoft.com/en-us/um/people/leonardo/files/fmcad09.pdf Generalized, efficient array decision procedures] paper with a few major modifications.<br />
* Bitvectors<br />
** Bitvectors is implemented primarily via a lazy schema for bitblasting. See [http://eprints-phd.biblio.unitn.it/345/ Anders Franzen's thesis chapter 3].<br />
* Combination<br />
** Theory combination is based on the care graph framework described in both [http://cs.nyu.edu/~dejan/papers/jovanovic-fmsd2012.pdf Being careful about theory combination] and [http://cs.nyu.edu/~dejan/papers/jovanovic-frocos2011.pdf Sharing is Caring: Combination of Theories].<br />
* Datatypes<br />
** CVC4 implements [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf An Abstract Decision Procedure for a Theory of Inductive Data Types].<br />
** This procedure has been extended to incorporate coinductive datatypes [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf].<br />
** The datatypes decision procedure is optimized via the use of shared selectors, described in this paper [http://homepage.divms.uiowa.edu/~ajreynol/ijcar18.pdf].<br />
* Quantifiers<br />
** E-matching and conflict-based quantifier instantiation [http://homepage.cs.uiowa.edu/~ajreynol/fmcad14.pdf].<br />
** Finite model finding [http://homepage.cs.uiowa.edu/~ajreynol/thesis.pdf].<br />
** Enumerative instantiation, as described in [http://homepage.divms.uiowa.edu/~ajreynol/tacas18.pdf].<br />
** Techniques for finding counterexamples for conjectures in the presence of recursive functions [http://homepage.cs.uiowa.edu/~ajreynol/ijcar16a.pdf].<br />
** Automated induction for datatypes [http://homepage.cs.uiowa.edu/~ajreynol/vmcai15.pdf].<br />
** A decision procedure for quantified linear integer and real arithmetic [http://homepage.divms.uiowa.edu/~ajreynol/fmsd17-instla.pdf].<br />
** A dedicated approach for quantified bit-vectors based on invertibility conditions, as described in [http://homepage.divms.uiowa.edu/~ajreynol/cav18.pdf].<br />
** Support for syntax-guided synthesis, as described in [http://homepage.cs.uiowa.edu/~ajreynol/cav15a.pdf].<br />
* Relations<br />
** An extension of the decision procedure for sets, as described in [http://homepage.cs.uiowa.edu/~tinelli/papers/MenEtAl-CADE-17.pdf].<br />
* SAT Solver<br />
** The main sat solver is based on [http://minisat.se/ minisat v2.2.0].<br />
** Additionally, we (optionally, and enabled by default for certain theories) use non-clausal analysis to cut down search space of minisat. For more details see the article [http://cs.nyu.edu/~kshitij/articles/cvc4-branching-heuristic.pdf A branching heuristic in CVC4].<br />
* Separation Logic<br />
** A decision procedure for a fragment quantifier-free separation logic containing negation, separation star and magic wand is implemented and can be composed with other decision procedures supported by CVC4. For details see [http://homepage.divms.uiowa.edu/~ajreynol/atva16.pdf A Decision Procedure for Separation Logic in SMT].<br />
* Sets<br />
** Adaptation of tableau-based decision procedure described [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.10.5176 here].<br />
* Strings<br />
** Original approach described in our [http://www.cs.stanford.edu/~barrett/pubs/LRT+14.pdf CAV 2014 paper: A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].<br />
** Decision procedure for regular memberships with length [http://homepage.cs.uiowa.edu/~ajreynol/frocos15.pdf].<br />
* Uninterpreted functions<br />
** UF (without cardinality) is handled in a manner inspired by [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.70.1745 Simplify's tech report].<br />
** UF + cardinality is described [http://www.divms.uiowa.edu/~ajreynol/pres-fmf12.pdf this presentation] and is used for finite model finding.<br />
<br />
=History of CVC=<br />
<br />
[[File:svc.gif|thumb|border|100px|The SVC logo.]]<br />
[[File:cvc3_logo.jpg|thumb|border|100px|The CVC3 logo.]]<br />
[[File:cvc3_night_logo.png|thumb|border|100px|The CVC3 "by night" logo, used for nightly builds and regressions.]]<br />
[[File:cvc3cvc4.png|thumb|border|100px|An early CVC4 logo.]]<br />
<br />
The Cooperating Validity Checker series has a long history. The<br />
Stanford Validity Checker (SVC) came first in 1996, incorporating<br />
theories and its own SAT solver. Its successor, the Cooperating<br />
Validity Checker (CVC), had a more optimized internal design, produced<br />
proofs, used the Chaff SAT solver, and featured a number of usability<br />
enhancements. Its name comes from the cooperative nature of decision<br />
procedures in Nelson-Oppen theory combination, which share amongst<br />
each other equalities between shared terms. CVC Lite, first made<br />
available in 2003, was a rewrite of CVC that attempted to make CVC<br />
more flexible (hence the "lite") while extending the feature set: CVC<br />
Lite supported quantifiers where its predecessors did not. CVC3 was a<br />
major overhaul of portions of CVC Lite: it added better decision<br />
procedure implementations, added support for using MiniSat in the<br />
core, and had generally better performance.<br />
<br />
[[File:cvc4-logo.png|thumb|border|100px|The CVC4 logo.]]<br />
CVC4 is the new version, the fifth generation of this validity checker<br />
line that is now celebrating sixteen years of heritage. It represents<br />
a complete re-evaluation of the core architecture to be both<br />
performant and to serve as a cutting-edge research vehicle for the<br />
next several years. Rather than taking CVC3 and redesigning problem<br />
parts, we've taken a clean-room approach, starting from scratch.<br />
Before using any designs from CVC3, we have thoroughly scrutinized,<br />
vetted, and updated them. Many parts of CVC4 bear only a superficial<br />
resemblance, if any, to their correspondent in CVC3.<br />
<br />
However, CVC4 is fundamentally similar to CVC3 and many other modern<br />
SMT solvers: it is a DPLL(T) solver, with a SAT solver at its core and<br />
a delegation path to different decision procedure implementations,<br />
each in charge of solving formulas in some background theory.<br />
<br />
The re-evaluation and ground-up rewrite was necessitated, we felt, by<br />
the performance characteristics of CVC3. CVC3 has many useful<br />
features, but some core aspects of the design led to high memory use,<br />
and the use of heavyweight computation (where more nimble engineering<br />
approaches could suffice) makes CVC3 a much slower prover than other<br />
tools. As these designs are central to CVC3, a new version was<br />
preferable to a selective re-engineering, which would have ballooned<br />
in short order.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5718Sets2018-05-08T13:56:15Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.'''mkSetType'''( em.'''mkTupleType'''( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5717Datatypes2018-05-08T13:55:27Z<p>Ajreynol: /* Syntax/API */</p>
<hr />
<div>=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))<br />
<br />
=Syntax/API=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''DT''')</code><br />
| <code>smt.setLogic("QF_'''DT'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Record Sort<br />
| [# f1:<Sort_1>, ..., fn:<Sort_n> #]<br />
| n/a<br />
| CVC4::ExprManager::mkRecordType(const Record& r)<br />
|-<br />
| <br />
| <code>t: '''[#''' fst:'''INT''', snd:'''INT]''';</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>vec.push_back(std::pair<std::string, Type>("fst",em.integerType());</code><br><br />
<code>vec.push_back(std::pair<std::string, Type>("snd",em.integerType());</code><br><br />
<code>Record r(vec);</code><br><br />
<code>em.'''mkRecordType'''(r);</code><br />
|-<br />
| Record constructor<br />
| <code>'''(# f1 := t1, ..., fn := tn #)'''</code><br />
| n/a<br />
| <code>Record r(vec);</code><br><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Record selector<br />
| <code>'''f1(t)'''</code><br />
| n/a<br />
| <code>Record r(vec);</code><br><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-}</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5716Datatypes2018-05-08T13:54:04Z<p>Ajreynol: </p>
<hr />
<div>=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))<br />
<br />
=Syntax/API=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''DT''')</code><br />
| <code>smt.setLogic("QF_'''DT'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>std::vector<Type> types;</code><br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>types.push_back(em.mkIntegerType());</code></br><br />
<code>em.'''mkTupleType'''( types );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_SELECTOR''', s, t);</code><br />
|-<br />
| Record Sort<br />
| [# f1:<Sort_1>, ..., fn:<Sort_n> #]<br />
| n/a<br />
| CVC4::ExprManager::mkRecordType(const Record& r)<br />
|-<br />
| <br />
| <code>t: '''[#''' fst:'''INT''', snd:'''INT]''';</code><br />
| <br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>vec.push_back(std::pair<std::string, Type>("fst",em.integerType());</code><br><br />
<code>vec.push_back(std::pair<std::string, Type>("snd",em.integerType());</code><br><br />
<code>Record r(vec);</code><br><br />
<code>em.'''mkRecordType'''(r);</code><br />
|-<br />
| Record constructor<br />
| <code>'''(# f1 := t1, ..., fn := tn #)'''</code><br />
| n/a<br />
| <code>Record r(vec);</code><br><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Record selector<br />
| <code>'''f1(t)'''</code><br />
| n/a<br />
| <code>Record r(vec);</code><br><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-}</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5715Datatypes2018-05-08T13:48:49Z<p>Ajreynol: </p>
<hr />
<div>=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))<br />
<br />
=Syntax/API=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''DT''')</code><br />
| <code>smt.setLogic("QF_'''DT'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>em.'''mkTupleType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-<br />
| Record Sort<br />
| [# f1:<Sort_1>, ..., fn:<Sort_n> #]<br />
| n/a<br />
| CVC4::ExprManager::mkRecordType(const Record& r)<br />
|-<br />
| <br />
| <code>t: '''[#''' f1:'''INT''', f2:'''INT]''';</code><br />
| <br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>vec.push_back(std::pair<std::string, Type>("f1",em.integerType());</code><br />
<code>vec.push_back(std::pair<std::string, Type>("f2",em.integerType());</code><br />
<code>Record r(vec);</code><br />
<code>em.'''mkRecordType'''(r);</code><br />
|-<br />
| Record constructor<br />
| <code>'''(# f1 := t1, ..., fn := tn #)'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Record selector<br />
| <code>'''t.i'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-}</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5714Datatypes2018-05-08T13:48:15Z<p>Ajreynol: /* Syntax */</p>
<hr />
<div>=Syntax/API=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''DT''')</code><br />
| <code>smt.setLogic("QF_'''DT'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>em.'''mkTupleType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-<br />
| Record Sort<br />
| [# f1:<Sort_1>, ..., fn:<Sort_n> #]<br />
| n/a<br />
| CVC4::ExprManager::mkRecordType(const Record& r)<br />
|-<br />
| <br />
| <code>t: '''[#''' f1:'''INT''', f2:'''INT]''';</code><br />
| <br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>vec.push_back(std::pair<std::string, Type>("f1",em.integerType());</code><br />
<code>vec.push_back(std::pair<std::string, Type>("f2",em.integerType());</code><br />
<code>Record r(vec);</code><br />
<code>em.'''mkRecordType'''(r);</code><br />
|-<br />
| Record constructor<br />
| <code>'''(# f1 := t1, ..., fn := tn #)'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Record selector<br />
| <code>'''t.i'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-}<br />
<br />
=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5713Datatypes2018-05-08T13:47:29Z<p>Ajreynol: /* Syntax */</p>
<hr />
<div>=Syntax=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''DT''')</code><br />
| <code>smt.setLogic("QF_'''DT'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>em.'''mkTupleType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-<br />
| Record Sort<br />
| [# f1:<Sort_1>, ..., fn:<Sort_n> #]<br />
| n/a<br />
| CVC4::ExprManager::mkRecordType(const Record& r)<br />
|-<br />
| <br />
| <code>t: '''[#''' f1:'''INT''', f2:'''INT]''';</code><br />
| <br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>vec.push_back(std::pair<std::string, Type>("f1",em.integerType());</code><br />
<code>vec.push_back(std::pair<std::string, Type>("f2",em.integerType());</code><br />
<code>Record r(vec);</code><br />
<code>em.'''mkRecordType'''(r);</code><br />
|-<br />
| Record constructor<br />
| <code>'''(# f1 := t1, ..., fn := tn #)'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Record selector<br />
| <code>'''t.i'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-}<br />
<br />
=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5712Datatypes2018-05-08T13:45:51Z<p>Ajreynol: </p>
<hr />
<div>=Syntax=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''DT''')</code><br />
| <code>smt.setLogic("QF_'''DT'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>em.'''mkTupleType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-<br />
| Record Sort<br />
| [# f1:<Sort_1>, ..., fn:<Sort_n> #]<br />
| n/a<br />
| CVC4::ExprManager::mkRecordType(const Record& r)<br />
|-<br />
| <br />
| <code>t: '''[#''' f1:'''INT''', f2:'''INT]''';</code><br />
| <br />
| <code>em.'''mkRecordType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Record constructor<br />
| <code>'''(# f1 := t1, ..., fn := tn #)'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Record selector<br />
| <code>'''t.i'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-<br />
<br />
=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5711Datatypes2018-05-08T13:44:59Z<p>Ajreynol: </p>
<hr />
<div><br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''DT''')</code><br />
| <code>smt.setLogic("QF_'''DT'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>em.'''mkTupleType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-<br />
| Record Sort<br />
| [# f1:<Sort_1>, ..., fn:<Sort_n> #]<br />
| n/a<br />
| CVC4::ExprManager::mkRecordType(const Record& r)<br />
|-<br />
| <br />
| <code>t: '''[#''' f1:'''INT''', f2:'''INT]''';</code><br />
| <br />
| <code>em.'''mkRecordType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Record constructor<br />
| <code>'''(# f1 := t1, ..., fn := tn #)'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Record selector<br />
| <code>'''t.i'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-<br />
<br />
=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5710Datatypes2018-05-08T13:44:22Z<p>Ajreynol: </p>
<hr />
<div>=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''DT''')</code><br />
| <code>smt.setLogic("QF_'''DT'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>em.'''mkTupleType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-<br />
| Record Sort<br />
| [# f1:<Sort_1>, ..., fn:<Sort_n> #]<br />
| n/a<br />
| CVC4::ExprManager::mkRecordType(const Record& r)<br />
|-<br />
| <br />
| <code>t: '''[#''' f1:'''INT''', f2:'''INT]''';</code><br />
| <br />
| <code>em.'''mkRecordType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Record constructor<br />
| <code>'''(# f1 := t1, ..., fn := tn #)'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Record selector<br />
| <code>'''t.i'''</code><br />
| n/a<br />
| <code>std::vector< std::pair<std::string, Type> > vec;</code><br />
<code>...</code><br />
<code>Record r(vec);</code><br />
<code>DatatypeType tt = em.mkRecordType(r);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-<br />
<br />
=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Datatypes&diff=5709Datatypes2018-05-01T20:01:49Z<p>Ajreynol: </p>
<hr />
<div>=Logic=<br />
To enable CVC4's decision procedure for datatypes, include "DT" in the logic:<br />
(set-logic QF_UFDT)<br />
Alternatively, use the "ALL_SUPPORTED" logic:<br />
(set-logic ALL_SUPPORTED)<br />
<br />
=Syntax=<br />
CVC4 supports the following syntax for declaring mutually recursive blocks of datatypes in *.smt2 input files in the smt lib 2.6 format:<br />
(declare-datatypes ((D1 n1)...(Dk nk)) <br />
(((C1 (S1 T1)....(Si Ti))...(Cj .... ))<br />
...<br />
((....) ... (....)))<br />
<br />
where D1...Dk are datatype types, C1...Cj are the constructors for datatype D1, S1....Si are the selectors (or "destructors") of constructor C1, and each T1...Ti is a previously declared type or one of D1...k. The symbols U1...Un are type parameters (fresh symbols). The numbers n1...nk denote the number of type parameters for the datatype, where 0 is used for non-parametric datatypes.<br />
<br />
In addition to declaring symbols for constructors and selectors, the above command also adds tester (or "discriminator") indexed symbols of the form (_ is C) for each constructor C, which are unary predicates which evaluate to true iff their argument has top-symbol C.<br />
<br />
CVC4 also supports datatypes in its native format [http://cvc4.cs.nyu.edu/wiki/CVC4%27s_native_language#Inductive_Data_Types].<br />
<br />
=Semantics=<br />
<br />
The decision procedure for inductive datatypes can be found [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf here].<br />
<br />
=Example Declarations=<br />
An enumeration:<br />
(declare-datatypes ((Color 0)) <br />
(((Red) (Black))))<br />
<br />
A List of Int with "cons" and "nil" as constructors:<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
<br />
A parametric List of T's:<br />
(declare-datatypes ((list 1)) <br />
((par (T) ((cons (head T) (tail (list T))) (nil)))))<br />
<br />
Mutual recursion:<br />
(declare-datatypes ((list 0) (tree 0)) <br />
(((cons (head tree) (tail list)) (nil))<br />
((node (data Int) (children list)))))<br />
<br />
A (non-recursive) record type:<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
<br />
=Examples=<br />
<br />
(declare-datatypes ((list 0)) <br />
(((cons (head Int) (tail list)) (nil))))<br />
(declare-fun a () list)<br />
(declare-fun b () list)<br />
(assert (and (= (tail a) b) (not ((_ is nil) b)) (> (head b) 0)))<br />
(check-sat)<br />
<br />
(declare-datatypes ((record 0))<br />
(((rec (fname String) (lname String) (id Int)))))<br />
(declare-const x record)<br />
(assert (and (= (fname x) "John") (= (lname x) "Smith")))<br />
(check-sat)<br />
<br />
=Parametric Datatypes=<br />
<br />
Instances of parametric datatypes must have their arguments instantiated with concrete types. For instance, in the example:<br />
(declare-datatypes ((list 1)) ((par (T) (cons (head T) (tail (list T))) (nil))))<br />
<br />
To declare a list of Int, use the command:<br />
(declare-fun f () (list Int))<br />
<br />
Use of constructors that are ambiguously typed must be cast to a concrete type, for instance all occurrences of "nil" for the above datatype must be cast with the syntax:<br />
(as nil (list Int))<br />
<br />
=Tuples=<br />
<br />
Tuples are a particular instance of an inductive datatype. CVC4 supports special syntax for tuples as an extension of the SMT-LIB version 2 format. For example:<br />
(declare-fun t () (Tuple Int Int))<br />
(assert (= ((_ tupSel 0) t) 3))<br />
(assert (not (= t (mkTuple 3 4))))<br />
<br />
=Codatatypes=<br />
<br />
CVC4 also supports co-inductive datatypes, as described [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf here]. The syntax for declaring mutually recursive coinductive datatype blocks is identical to inductive datatypes, except that "declare-datatypes" is replaced by "declare-codatatypes". For example, the following declares the type denote streams of Int:<br />
(declare-codatatypes ((stream 0)) <br />
(((cons (head Int) (tail stream)))))</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=About_CVC4&diff=5708About CVC42018-05-01T19:58:52Z<p>Ajreynol: /* Decision Procedures */</p>
<hr />
<div>CVC4 is an automatic theorem prover for [http://en.wikipedia.org/wiki/Satisfiability_Modulo_Theories Satisifiability Modulo Theories (SMT)] (for a more formal introduction to SMT see the following book chapter [https://cs.stanford.edu/~barrett/pubs/BSST09.pdf Satisfiability Modulo Theories] ). Technically, it is an automated validity checker for a many-sorted (i.e., typed) first-order logic with built-in theories.<br />
It can be used to prove the validity (or, dually, the satisfiability) of a formula with respect to several built-in logical theories and their combination.<br />
<br />
CVC4 currently has support for the following theories:<br />
* equality over free (aka uninterpreted) function and predicate symbols<br />
* real and integer linear arithmetic<br />
* bit-vectors<br />
* arrays<br />
* tuples<br />
* records<br />
* user-defined inductive [[Datatypes|datatypes]]<br />
* [[Strings|strings]]<br />
* [[Sets|finite sets and relations]]<br />
* [[Separation Logic|separation logic]]<br />
<br />
CVC4 has a wide variety of features including:<br />
<br />
* support for quantifiers through heuristic instantiation;<br />
* an interactive text-based interface;<br />
* a rich [http://cvc4.cs.stanford.edu/cvc4-builds/documentation/public/latest/ C++ API] for embedding in other systems;<br />
* model generation abilities;<br />
* source compatibility with much of the CVC3 API via a "compatibility library";<br />
* essentially no limit on its use for research or commercial purposes (see [https://github.com/CVC4/CVC4/blob/master/COPYING license]).<br />
<br />
=Web site=<br />
<br />
For more information and the latest news about CVC4, visit the [http://cvc4.cs.stanford.edu CVC4 web site].<br />
<br />
=Decision Procedures=<br />
* Architecture<br />
** See the [http://dl.acm.org/citation.cfm?id=2032319 CVC4 tool paper].<br />
* Arithmetic<br />
** CVC4 solves linear real arithmetic using an implementation of [http://link.springer.com/chapter/10.1007%2F11817963_11? Simplex for DPLL(T)]. For a more complete introduction see the [http://yices.csl.sri.com/sri-csl-06-01.pdf tech report].<br />
** The linear arithmetic module includes heuristics from [http://eprints-phd.biblio.unitn.it/166/2/thesis.pdf Section 2.5 of Alberto Griggio's thesis] and a few currently unpublished ones.<br />
** Integers are currently handled by first solving the real relaxation of the constraints, and then using a combination of [http://www.cs.wm.edu/~idillig/cav2009.pdf Cuts from Proofs] and branching to ensure integer solutions. This approach and the equational solver used are described in [https://es.fbk.eu/people/griggio/papers/jsat12.pdf A Practical Approach to Satisfiability Modulo Linear Integer Arithmetic].<br />
** A technical report is planned to explain a number of small details and extensions including analysis to improve simplex's conflicts, handling disequalities, supporting model generation in CVC4's combination framework, heuristically propagating equalities over sharing terms, tableau row based propagation, and terminating simplex with unknown.<br />
** A heuristic approach non-linear arithmetic is supported based on this paper [https://es-static.fbk.eu/people/griggio/papers/tacas17.pdf].<br />
* Arrays<br />
** Arrays are implemented in a manner inspired by the [http://research.microsoft.com/en-us/um/people/leonardo/files/fmcad09.pdf Generalized, efficient array decision procedures] paper with a few major modifications.<br />
* Bitvectors<br />
** Bitvectors is implemented primarily via a lazy schema for bitblasting. See [http://eprints-phd.biblio.unitn.it/345/ Anders Franzen's thesis chapter 3].<br />
* Combination<br />
** Theory combination is based on the care graph framework described in both [http://cs.nyu.edu/~dejan/papers/jovanovic-fmsd2012.pdf Being careful about theory combination] and [http://cs.nyu.edu/~dejan/papers/jovanovic-frocos2011.pdf Sharing is Caring: Combination of Theories].<br />
* Datatypes<br />
** CVC4 implements [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf An Abstract Decision Procedure for a Theory of Inductive Data Types].<br />
** This procedure has been extended to incorporate coinductive datatypes [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf].<br />
** The datatypes decision procedure is optimized via the use of shared selectors, described in this paper [http://homepage.divms.uiowa.edu/~ajreynol/ijcar18.pdf].<br />
* Quantifiers<br />
** E-matching and conflict-based quantifier instantiation [http://homepage.cs.uiowa.edu/~ajreynol/fmcad14.pdf].<br />
** Finite model finding [http://homepage.cs.uiowa.edu/~ajreynol/thesis.pdf].<br />
** Enumerative instantiation, as described in [http://homepage.divms.uiowa.edu/~ajreynol/tacas18.pdf].<br />
** Techniques for finding counterexamples for conjectures in the presence of recursive functions [http://homepage.cs.uiowa.edu/~ajreynol/ijcar16a.pdf].<br />
** Automated induction for datatypes [http://homepage.cs.uiowa.edu/~ajreynol/vmcai15.pdf].<br />
** A decision procedure for quantified linear integer and real arithmetic [http://homepage.divms.uiowa.edu/~ajreynol/fmsd17-instla.pdf].<br />
** A dedicated approach for quantified bit-vectors based on invertibility conditions, as described in [http://homepage.divms.uiowa.edu/~ajreynol/cav18.pdf].<br />
** Support for syntax-guided synthesis, as described in [http://homepage.cs.uiowa.edu/~ajreynol/cav15a.pdf].<br />
* Relations<br />
** An extension of the decision procedure for sets, as described in [http://homepage.cs.uiowa.edu/~tinelli/papers/MenEtAl-CADE-17.pdf].<br />
* SAT Solver<br />
** The main sat solver is based on [http://minisat.se/ minisat v2.2.0].<br />
** Additionally, we (optionally, and enabled by default for certain theories) use non-clausal analysis to cut down search space of minisat. For more details see the article [http://cs.nyu.edu/~kshitij/articles/cvc4-branching-heuristic.pdf A branching heuristic in CVC4].<br />
* Separation Logic<br />
** A decision procedure for a fragment quantifier-free separation logic containing negation, separation star and magic wand is implemented and can be composed with other decision procedures supported by CVC4. For details see [http://homepage.divms.uiowa.edu/~ajreynol/atva16.pdf A Decision Procedure for Separation Logic in SMT].<br />
* Sets<br />
** Adaptation of tableau-based decision procedure described [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.10.5176 here].<br />
* Strings<br />
** Original approach described in our [http://www.cs.stanford.edu/~barrett/pubs/LRT+14.pdf CAV 2014 paper: A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].<br />
** Decision procedure for regular memberships with length [http://homepage.cs.uiowa.edu/~ajreynol/frocos15.pdf].<br />
* Uninterpreted functions<br />
** UF (without cardinality) is handled in a manner inspired by [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.70.1745 Simplify's tech report].<br />
** UF + cardinality is described [http://www.divms.uiowa.edu/~ajreynol/pres-fmf12.pdf this presentation] and is used for finite model finding.<br />
<br />
=History of CVC=<br />
<br />
[[File:svc.gif|thumb|border|100px|The SVC logo.]]<br />
[[File:cvc3_logo.jpg|thumb|border|100px|The CVC3 logo.]]<br />
[[File:cvc3_night_logo.png|thumb|border|100px|The CVC3 "by night" logo, used for nightly builds and regressions.]]<br />
[[File:cvc3cvc4.png|thumb|border|100px|An early CVC4 logo.]]<br />
<br />
The Cooperating Validity Checker series has a long history. The<br />
Stanford Validity Checker (SVC) came first in 1996, incorporating<br />
theories and its own SAT solver. Its successor, the Cooperating<br />
Validity Checker (CVC), had a more optimized internal design, produced<br />
proofs, used the Chaff SAT solver, and featured a number of usability<br />
enhancements. Its name comes from the cooperative nature of decision<br />
procedures in Nelson-Oppen theory combination, which share amongst<br />
each other equalities between shared terms. CVC Lite, first made<br />
available in 2003, was a rewrite of CVC that attempted to make CVC<br />
more flexible (hence the "lite") while extending the feature set: CVC<br />
Lite supported quantifiers where its predecessors did not. CVC3 was a<br />
major overhaul of portions of CVC Lite: it added better decision<br />
procedure implementations, added support for using MiniSat in the<br />
core, and had generally better performance.<br />
<br />
[[File:cvc4-logo.png|thumb|border|100px|The CVC4 logo.]]<br />
CVC4 is the new version, the fifth generation of this validity checker<br />
line that is now celebrating sixteen years of heritage. It represents<br />
a complete re-evaluation of the core architecture to be both<br />
performant and to serve as a cutting-edge research vehicle for the<br />
next several years. Rather than taking CVC3 and redesigning problem<br />
parts, we've taken a clean-room approach, starting from scratch.<br />
Before using any designs from CVC3, we have thoroughly scrutinized,<br />
vetted, and updated them. Many parts of CVC4 bear only a superficial<br />
resemblance, if any, to their correspondent in CVC3.<br />
<br />
However, CVC4 is fundamentally similar to CVC3 and many other modern<br />
SMT solvers: it is a DPLL(T) solver, with a SAT solver at its core and<br />
a delegation path to different decision procedure implementations,<br />
each in charge of solving formulas in some background theory.<br />
<br />
The re-evaluation and ground-up rewrite was necessitated, we felt, by<br />
the performance characteristics of CVC3. CVC3 has many useful<br />
features, but some core aspects of the design led to high memory use,<br />
and the use of heavyweight computation (where more nimble engineering<br />
approaches could suffice) makes CVC3 a much slower prover than other<br />
tools. As these designs are central to CVC3, a new version was<br />
preferable to a selective re-engineering, which would have ballooned<br />
in short order.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=About_CVC4&diff=5707About CVC42018-05-01T19:57:58Z<p>Ajreynol: /* Decision Procedures */</p>
<hr />
<div>CVC4 is an automatic theorem prover for [http://en.wikipedia.org/wiki/Satisfiability_Modulo_Theories Satisifiability Modulo Theories (SMT)] (for a more formal introduction to SMT see the following book chapter [https://cs.stanford.edu/~barrett/pubs/BSST09.pdf Satisfiability Modulo Theories] ). Technically, it is an automated validity checker for a many-sorted (i.e., typed) first-order logic with built-in theories.<br />
It can be used to prove the validity (or, dually, the satisfiability) of a formula with respect to several built-in logical theories and their combination.<br />
<br />
CVC4 currently has support for the following theories:<br />
* equality over free (aka uninterpreted) function and predicate symbols<br />
* real and integer linear arithmetic<br />
* bit-vectors<br />
* arrays<br />
* tuples<br />
* records<br />
* user-defined inductive [[Datatypes|datatypes]]<br />
* [[Strings|strings]]<br />
* [[Sets|finite sets and relations]]<br />
* [[Separation Logic|separation logic]]<br />
<br />
CVC4 has a wide variety of features including:<br />
<br />
* support for quantifiers through heuristic instantiation;<br />
* an interactive text-based interface;<br />
* a rich [http://cvc4.cs.stanford.edu/cvc4-builds/documentation/public/latest/ C++ API] for embedding in other systems;<br />
* model generation abilities;<br />
* source compatibility with much of the CVC3 API via a "compatibility library";<br />
* essentially no limit on its use for research or commercial purposes (see [https://github.com/CVC4/CVC4/blob/master/COPYING license]).<br />
<br />
=Web site=<br />
<br />
For more information and the latest news about CVC4, visit the [http://cvc4.cs.stanford.edu CVC4 web site].<br />
<br />
=Decision Procedures=<br />
* Architecture<br />
** See the [http://dl.acm.org/citation.cfm?id=2032319 CVC4 tool paper].<br />
* Arithmetic<br />
** CVC4 solves linear real arithmetic using an implementation of [http://link.springer.com/chapter/10.1007%2F11817963_11? Simplex for DPLL(T)]. For a more complete introduction see the [http://yices.csl.sri.com/sri-csl-06-01.pdf tech report].<br />
** The linear arithmetic module includes heuristics from [http://eprints-phd.biblio.unitn.it/166/2/thesis.pdf Section 2.5 of Alberto Griggio's thesis] and a few currently unpublished ones.<br />
** Integers are currently handled by first solving the real relaxation of the constraints, and then using a combination of [http://www.cs.wm.edu/~idillig/cav2009.pdf Cuts from Proofs] and branching to ensure integer solutions. This approach and the equational solver used are described in [https://es.fbk.eu/people/griggio/papers/jsat12.pdf A Practical Approach to Satisfiability Modulo Linear Integer Arithmetic].<br />
** A technical report is planned to explain a number of small details and extensions including analysis to improve simplex's conflicts, handling disequalities, supporting model generation in CVC4's combination framework, heuristically propagating equalities over sharing terms, tableau row based propagation, and terminating simplex with unknown.<br />
** A heuristic approach non-linear arithmetic is supported based on this paper [https://es-static.fbk.eu/people/griggio/papers/tacas17.pdf].<br />
* Arrays<br />
** Arrays are implemented in a manner inspired by the [http://research.microsoft.com/en-us/um/people/leonardo/files/fmcad09.pdf Generalized, efficient array decision procedures] paper with a few major modifications.<br />
* Bitvectors<br />
** Bitvectors is implemented primarily via a lazy schema for bitblasting. See [http://eprints-phd.biblio.unitn.it/345/ Anders Franzen's thesis chapter 3].<br />
* Combination<br />
** Theory combination is based on the care graph framework described in both [http://cs.nyu.edu/~dejan/papers/jovanovic-fmsd2012.pdf Being careful about theory combination] and [http://cs.nyu.edu/~dejan/papers/jovanovic-frocos2011.pdf Sharing is Caring: Combination of Theories].<br />
* Datatypes<br />
** CVC4 implements [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf An Abstract Decision Procedure for a Theory of Inductive Data Types].<br />
** This procedure has been extended to incorporate coinductive datatypes [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf].<br />
** The datatypes decision procedure is optimized via the use of shared selectors, described in this paper [http://homepage.divms.uiowa.edu/~ajreynol/ijcar18.pdf].<br />
* Quantifiers<br />
** E-matching and conflict-based quantifier instantiation [http://homepage.cs.uiowa.edu/~ajreynol/fmcad14.pdf].<br />
** Finite model finding [http://homepage.cs.uiowa.edu/~ajreynol/thesis.pdf].<br />
** Enumerative instantiation, as described in [http://homepage.divms.uiowa.edu/~ajreynol/tacas18.pdf].<br />
** Techniques for finding counterexamples for conjectures in the presence of recursive functions [http://homepage.cs.uiowa.edu/~ajreynol/ijcar16a.pdf].<br />
** Automated induction for datatypes [http://homepage.cs.uiowa.edu/~ajreynol/vmcai15.pdf].<br />
** A decision procedure for quantified linear integer and real arithmetic [http://homepage.divms.uiowa.edu/~ajreynol/fmsd17-instla.pdf].<br />
** Support for syntax-guided synthesis, as described in [http://homepage.cs.uiowa.edu/~ajreynol/cav15a.pdf].<br />
* Relations<br />
** An extension of the decision procedure for sets, as described in [http://homepage.cs.uiowa.edu/~tinelli/papers/MenEtAl-CADE-17.pdf].<br />
* SAT Solver<br />
** The main sat solver is based on [http://minisat.se/ minisat v2.2.0].<br />
** Additionally, we (optionally, and enabled by default for certain theories) use non-clausal analysis to cut down search space of minisat. For more details see the article [http://cs.nyu.edu/~kshitij/articles/cvc4-branching-heuristic.pdf A branching heuristic in CVC4].<br />
* Separation Logic<br />
** A decision procedure for a fragment quantifier-free separation logic containing negation, separation star and magic wand is implemented and can be composed with other decision procedures supported by CVC4. For details see [http://homepage.divms.uiowa.edu/~ajreynol/atva16.pdf A Decision Procedure for Separation Logic in SMT].<br />
* Sets<br />
** Adaptation of tableau-based decision procedure described [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.10.5176 here].<br />
* Strings<br />
** Original approach described in our [http://www.cs.stanford.edu/~barrett/pubs/LRT+14.pdf CAV 2014 paper: A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].<br />
** Decision procedure for regular memberships with length [http://homepage.cs.uiowa.edu/~ajreynol/frocos15.pdf].<br />
* Uninterpreted functions<br />
** UF (without cardinality) is handled in a manner inspired by [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.70.1745 Simplify's tech report].<br />
** UF + cardinality is described [http://www.divms.uiowa.edu/~ajreynol/pres-fmf12.pdf this presentation] and is used for finite model finding.<br />
<br />
=History of CVC=<br />
<br />
[[File:svc.gif|thumb|border|100px|The SVC logo.]]<br />
[[File:cvc3_logo.jpg|thumb|border|100px|The CVC3 logo.]]<br />
[[File:cvc3_night_logo.png|thumb|border|100px|The CVC3 "by night" logo, used for nightly builds and regressions.]]<br />
[[File:cvc3cvc4.png|thumb|border|100px|An early CVC4 logo.]]<br />
<br />
The Cooperating Validity Checker series has a long history. The<br />
Stanford Validity Checker (SVC) came first in 1996, incorporating<br />
theories and its own SAT solver. Its successor, the Cooperating<br />
Validity Checker (CVC), had a more optimized internal design, produced<br />
proofs, used the Chaff SAT solver, and featured a number of usability<br />
enhancements. Its name comes from the cooperative nature of decision<br />
procedures in Nelson-Oppen theory combination, which share amongst<br />
each other equalities between shared terms. CVC Lite, first made<br />
available in 2003, was a rewrite of CVC that attempted to make CVC<br />
more flexible (hence the "lite") while extending the feature set: CVC<br />
Lite supported quantifiers where its predecessors did not. CVC3 was a<br />
major overhaul of portions of CVC Lite: it added better decision<br />
procedure implementations, added support for using MiniSat in the<br />
core, and had generally better performance.<br />
<br />
[[File:cvc4-logo.png|thumb|border|100px|The CVC4 logo.]]<br />
CVC4 is the new version, the fifth generation of this validity checker<br />
line that is now celebrating sixteen years of heritage. It represents<br />
a complete re-evaluation of the core architecture to be both<br />
performant and to serve as a cutting-edge research vehicle for the<br />
next several years. Rather than taking CVC3 and redesigning problem<br />
parts, we've taken a clean-room approach, starting from scratch.<br />
Before using any designs from CVC3, we have thoroughly scrutinized,<br />
vetted, and updated them. Many parts of CVC4 bear only a superficial<br />
resemblance, if any, to their correspondent in CVC3.<br />
<br />
However, CVC4 is fundamentally similar to CVC3 and many other modern<br />
SMT solvers: it is a DPLL(T) solver, with a SAT solver at its core and<br />
a delegation path to different decision procedure implementations,<br />
each in charge of solving formulas in some background theory.<br />
<br />
The re-evaluation and ground-up rewrite was necessitated, we felt, by<br />
the performance characteristics of CVC3. CVC3 has many useful<br />
features, but some core aspects of the design led to high memory use,<br />
and the use of heavyweight computation (where more nimble engineering<br />
approaches could suffice) makes CVC3 a much slower prover than other<br />
tools. As these designs are central to CVC3, a new version was<br />
preferable to a selective re-engineering, which would have ballooned<br />
in short order.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=About_CVC4&diff=5706About CVC42018-05-01T19:56:58Z<p>Ajreynol: /* Decision Procedures */</p>
<hr />
<div>CVC4 is an automatic theorem prover for [http://en.wikipedia.org/wiki/Satisfiability_Modulo_Theories Satisifiability Modulo Theories (SMT)] (for a more formal introduction to SMT see the following book chapter [https://cs.stanford.edu/~barrett/pubs/BSST09.pdf Satisfiability Modulo Theories] ). Technically, it is an automated validity checker for a many-sorted (i.e., typed) first-order logic with built-in theories.<br />
It can be used to prove the validity (or, dually, the satisfiability) of a formula with respect to several built-in logical theories and their combination.<br />
<br />
CVC4 currently has support for the following theories:<br />
* equality over free (aka uninterpreted) function and predicate symbols<br />
* real and integer linear arithmetic<br />
* bit-vectors<br />
* arrays<br />
* tuples<br />
* records<br />
* user-defined inductive [[Datatypes|datatypes]]<br />
* [[Strings|strings]]<br />
* [[Sets|finite sets and relations]]<br />
* [[Separation Logic|separation logic]]<br />
<br />
CVC4 has a wide variety of features including:<br />
<br />
* support for quantifiers through heuristic instantiation;<br />
* an interactive text-based interface;<br />
* a rich [http://cvc4.cs.stanford.edu/cvc4-builds/documentation/public/latest/ C++ API] for embedding in other systems;<br />
* model generation abilities;<br />
* source compatibility with much of the CVC3 API via a "compatibility library";<br />
* essentially no limit on its use for research or commercial purposes (see [https://github.com/CVC4/CVC4/blob/master/COPYING license]).<br />
<br />
=Web site=<br />
<br />
For more information and the latest news about CVC4, visit the [http://cvc4.cs.stanford.edu CVC4 web site].<br />
<br />
=Decision Procedures=<br />
* Architecture<br />
** See the [http://dl.acm.org/citation.cfm?id=2032319 CVC4 tool paper].<br />
* Arithmetic<br />
** CVC4 solves linear real arithmetic using an implementation of [http://link.springer.com/chapter/10.1007%2F11817963_11? Simplex for DPLL(T)]. For a more complete introduction see the [http://yices.csl.sri.com/sri-csl-06-01.pdf tech report].<br />
** The linear arithmetic module includes heuristics from [http://eprints-phd.biblio.unitn.it/166/2/thesis.pdf Section 2.5 of Alberto Griggio's thesis] and a few currently unpublished ones.<br />
** Integers are currently handled by first solving the real relaxation of the constraints, and then using a combination of [http://www.cs.wm.edu/~idillig/cav2009.pdf Cuts from Proofs] and branching to ensure integer solutions. This approach and the equational solver used are described in [https://es.fbk.eu/people/griggio/papers/jsat12.pdf A Practical Approach to Satisfiability Modulo Linear Integer Arithmetic].<br />
** A technical report is planned to explain a number of small details and extensions including analysis to improve simplex's conflicts, handling disequalities, supporting model generation in CVC4's combination framework, heuristically propagating equalities over sharing terms, tableau row based propagation, and terminating simplex with unknown.<br />
** A heuristic approach non-linear arithmetic is supported based on this paper [https://es-static.fbk.eu/people/griggio/papers/tacas17.pdf].<br />
* Arrays<br />
** Arrays are implemented in a manner inspired by the [http://research.microsoft.com/en-us/um/people/leonardo/files/fmcad09.pdf Generalized, efficient array decision procedures] paper with a few major modifications.<br />
* Bitvectors<br />
** Bitvectors is implemented primarily via a lazy schema for bitblasting. See [http://eprints-phd.biblio.unitn.it/345/ Anders Franzen's thesis chapter 3].<br />
* Combination<br />
** Theory combination is based on the care graph framework described in both [http://cs.nyu.edu/~dejan/papers/jovanovic-fmsd2012.pdf Being careful about theory combination] and [http://cs.nyu.edu/~dejan/papers/jovanovic-frocos2011.pdf Sharing is Caring: Combination of Theories].<br />
* Datatypes<br />
** CVC4 implements [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf An Abstract Decision Procedure for a Theory of Inductive Data Types].<br />
** This procedure has been extended to incorporate coinductive datatypes [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf].<br />
* Quantifiers<br />
** E-matching and conflict-based quantifier instantiation [http://homepage.cs.uiowa.edu/~ajreynol/fmcad14.pdf].<br />
** Finite model finding [http://homepage.cs.uiowa.edu/~ajreynol/thesis.pdf].<br />
** Enumerative instantiation, as described in [http://homepage.divms.uiowa.edu/~ajreynol/tacas18.pdf].<br />
** Techniques for finding counterexamples for conjectures in the presence of recursive functions [http://homepage.cs.uiowa.edu/~ajreynol/ijcar16a.pdf].<br />
** Automated induction for datatypes [http://homepage.cs.uiowa.edu/~ajreynol/vmcai15.pdf].<br />
** A decision procedure for quantified linear integer and real arithmetic [http://homepage.divms.uiowa.edu/~ajreynol/fmsd17-instla.pdf].<br />
** Support for syntax-guided synthesis, as described in [http://homepage.cs.uiowa.edu/~ajreynol/cav15a.pdf].<br />
* Relations<br />
** An extension of the decision procedure for sets, as described in [http://homepage.cs.uiowa.edu/~tinelli/papers/MenEtAl-CADE-17.pdf].<br />
* SAT Solver<br />
** The main sat solver is based on [http://minisat.se/ minisat v2.2.0].<br />
** Additionally, we (optionally, and enabled by default for certain theories) use non-clausal analysis to cut down search space of minisat. For more details see the article [http://cs.nyu.edu/~kshitij/articles/cvc4-branching-heuristic.pdf A branching heuristic in CVC4].<br />
* Separation Logic<br />
** A decision procedure for a fragment quantifier-free separation logic containing negation, separation star and magic wand is implemented and can be composed with other decision procedures supported by CVC4. For details see [http://homepage.divms.uiowa.edu/~ajreynol/atva16.pdf A Decision Procedure for Separation Logic in SMT].<br />
* Sets<br />
** Adaptation of tableau-based decision procedure described [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.10.5176 here].<br />
* Strings<br />
** Original approach described in our [http://www.cs.stanford.edu/~barrett/pubs/LRT+14.pdf CAV 2014 paper: A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].<br />
** Decision procedure for regular memberships with length [http://homepage.cs.uiowa.edu/~ajreynol/frocos15.pdf].<br />
* Uninterpreted functions<br />
** UF (without cardinality) is handled in a manner inspired by [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.70.1745 Simplify's tech report].<br />
** UF + cardinality is described [http://www.divms.uiowa.edu/~ajreynol/pres-fmf12.pdf this presentation] and is used for finite model finding.<br />
<br />
=History of CVC=<br />
<br />
[[File:svc.gif|thumb|border|100px|The SVC logo.]]<br />
[[File:cvc3_logo.jpg|thumb|border|100px|The CVC3 logo.]]<br />
[[File:cvc3_night_logo.png|thumb|border|100px|The CVC3 "by night" logo, used for nightly builds and regressions.]]<br />
[[File:cvc3cvc4.png|thumb|border|100px|An early CVC4 logo.]]<br />
<br />
The Cooperating Validity Checker series has a long history. The<br />
Stanford Validity Checker (SVC) came first in 1996, incorporating<br />
theories and its own SAT solver. Its successor, the Cooperating<br />
Validity Checker (CVC), had a more optimized internal design, produced<br />
proofs, used the Chaff SAT solver, and featured a number of usability<br />
enhancements. Its name comes from the cooperative nature of decision<br />
procedures in Nelson-Oppen theory combination, which share amongst<br />
each other equalities between shared terms. CVC Lite, first made<br />
available in 2003, was a rewrite of CVC that attempted to make CVC<br />
more flexible (hence the "lite") while extending the feature set: CVC<br />
Lite supported quantifiers where its predecessors did not. CVC3 was a<br />
major overhaul of portions of CVC Lite: it added better decision<br />
procedure implementations, added support for using MiniSat in the<br />
core, and had generally better performance.<br />
<br />
[[File:cvc4-logo.png|thumb|border|100px|The CVC4 logo.]]<br />
CVC4 is the new version, the fifth generation of this validity checker<br />
line that is now celebrating sixteen years of heritage. It represents<br />
a complete re-evaluation of the core architecture to be both<br />
performant and to serve as a cutting-edge research vehicle for the<br />
next several years. Rather than taking CVC3 and redesigning problem<br />
parts, we've taken a clean-room approach, starting from scratch.<br />
Before using any designs from CVC3, we have thoroughly scrutinized,<br />
vetted, and updated them. Many parts of CVC4 bear only a superficial<br />
resemblance, if any, to their correspondent in CVC3.<br />
<br />
However, CVC4 is fundamentally similar to CVC3 and many other modern<br />
SMT solvers: it is a DPLL(T) solver, with a SAT solver at its core and<br />
a delegation path to different decision procedure implementations,<br />
each in charge of solving formulas in some background theory.<br />
<br />
The re-evaluation and ground-up rewrite was necessitated, we felt, by<br />
the performance characteristics of CVC3. CVC3 has many useful<br />
features, but some core aspects of the design led to high memory use,<br />
and the use of heavyweight computation (where more nimble engineering<br />
approaches could suffice) makes CVC3 a much slower prover than other<br />
tools. As these designs are central to CVC3, a new version was<br />
preferable to a selective re-engineering, which would have ballooned<br />
in short order.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=About_CVC4&diff=5705About CVC42018-05-01T19:54:00Z<p>Ajreynol: /* Decision Procedures */</p>
<hr />
<div>CVC4 is an automatic theorem prover for [http://en.wikipedia.org/wiki/Satisfiability_Modulo_Theories Satisifiability Modulo Theories (SMT)] (for a more formal introduction to SMT see the following book chapter [https://cs.stanford.edu/~barrett/pubs/BSST09.pdf Satisfiability Modulo Theories] ). Technically, it is an automated validity checker for a many-sorted (i.e., typed) first-order logic with built-in theories.<br />
It can be used to prove the validity (or, dually, the satisfiability) of a formula with respect to several built-in logical theories and their combination.<br />
<br />
CVC4 currently has support for the following theories:<br />
* equality over free (aka uninterpreted) function and predicate symbols<br />
* real and integer linear arithmetic<br />
* bit-vectors<br />
* arrays<br />
* tuples<br />
* records<br />
* user-defined inductive [[Datatypes|datatypes]]<br />
* [[Strings|strings]]<br />
* [[Sets|finite sets and relations]]<br />
* [[Separation Logic|separation logic]]<br />
<br />
CVC4 has a wide variety of features including:<br />
<br />
* support for quantifiers through heuristic instantiation;<br />
* an interactive text-based interface;<br />
* a rich [http://cvc4.cs.stanford.edu/cvc4-builds/documentation/public/latest/ C++ API] for embedding in other systems;<br />
* model generation abilities;<br />
* source compatibility with much of the CVC3 API via a "compatibility library";<br />
* essentially no limit on its use for research or commercial purposes (see [https://github.com/CVC4/CVC4/blob/master/COPYING license]).<br />
<br />
=Web site=<br />
<br />
For more information and the latest news about CVC4, visit the [http://cvc4.cs.stanford.edu CVC4 web site].<br />
<br />
=Decision Procedures=<br />
* Architecture<br />
** See the [http://dl.acm.org/citation.cfm?id=2032319 CVC4 tool paper].<br />
* Arithmetic<br />
** CVC4 solves linear real arithmetic using an implementation of [http://link.springer.com/chapter/10.1007%2F11817963_11? Simplex for DPLL(T)]. For a more complete introduction see the [http://yices.csl.sri.com/sri-csl-06-01.pdf tech report].<br />
** The linear arithmetic module includes heuristics from [http://eprints-phd.biblio.unitn.it/166/2/thesis.pdf Section 2.5 of Alberto Griggio's thesis] and a few currently unpublished ones.<br />
** Integers are currently handled by first solving the real relaxation of the constraints, and then using a combination of [http://www.cs.wm.edu/~idillig/cav2009.pdf Cuts from Proofs] and branching to ensure integer solutions. This approach and the equational solver used are described in [https://es.fbk.eu/people/griggio/papers/jsat12.pdf A Practical Approach to Satisfiability Modulo Linear Integer Arithmetic].<br />
** A technical report is planned to explain a number of small details and extensions including analysis to improve simplex's conflicts, handling disequalities, supporting model generation in CVC4's combination framework, heuristically propagating equalities over sharing terms, tableau row based propagation, and terminating simplex with unknown.<br />
** Non-linear arithmetic support is currently rudimentary to non-existent. In CVC4 v1.0, non-linearity is handled by abstracting monomials as unique new variables. We plan on implementing [http://cs.nyu.edu/~dejan/papers/jovanovic-ijcar2012.pdf Solving Non-Linear Arithmetic] this spring.<br />
* Arrays<br />
** Arrays are implemented in a manner inspired by the [http://research.microsoft.com/en-us/um/people/leonardo/files/fmcad09.pdf Generalized, efficient array decision procedures] paper with a few major modifications.<br />
* Bitvectors<br />
** Bitvectors is implemented primarily via a lazy schema for bitblasting. See [http://eprints-phd.biblio.unitn.it/345/ Anders Franzen's thesis chapter 3].<br />
* Combination<br />
** Theory combination is based on the care graph framework described in both [http://cs.nyu.edu/~dejan/papers/jovanovic-fmsd2012.pdf Being careful about theory combination] and [http://cs.nyu.edu/~dejan/papers/jovanovic-frocos2011.pdf Sharing is Caring: Combination of Theories].<br />
* Datatypes<br />
** CVC4 implements [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf An Abstract Decision Procedure for a Theory of Inductive Data Types].<br />
** This procedure has been extended to incorporate coinductive datatypes [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf].<br />
* Quantifiers<br />
** E-matching and conflict-based quantifier instantiation [http://homepage.cs.uiowa.edu/~ajreynol/fmcad14.pdf].<br />
** Finite model finding [http://homepage.cs.uiowa.edu/~ajreynol/thesis.pdf].<br />
** Enumerative instantiation, as described in [http://homepage.divms.uiowa.edu/~ajreynol/tacas18.pdf].<br />
** Techniques for finding counterexamples for conjectures in the presence of recursive functions [http://homepage.cs.uiowa.edu/~ajreynol/ijcar16a.pdf].<br />
** Automated induction for datatypes [http://homepage.cs.uiowa.edu/~ajreynol/vmcai15.pdf].<br />
** A decision procedure for quantified linear integer and real arithmetic [http://homepage.divms.uiowa.edu/~ajreynol/fmsd17-instla.pdf].<br />
** Support for syntax-guided synthesis, as described in [http://homepage.cs.uiowa.edu/~ajreynol/cav15a.pdf].<br />
* Relations<br />
** An extension of the decision procedure for sets, as described in [http://homepage.cs.uiowa.edu/~tinelli/papers/MenEtAl-CADE-17.pdf].<br />
* SAT Solver<br />
** The main sat solver is based on [http://minisat.se/ minisat v2.2.0].<br />
** Additionally, we (optionally, and enabled by default for certain theories) use non-clausal analysis to cut down search space of minisat. For more details see the article [http://cs.nyu.edu/~kshitij/articles/cvc4-branching-heuristic.pdf A branching heuristic in CVC4].<br />
* Separation Logic<br />
** A decision procedure for a fragment quantifier-free separation logic containing negation, separation star and magic wand is implemented and can be composed with other decision procedures supported by CVC4. For details see [http://homepage.divms.uiowa.edu/~ajreynol/atva16.pdf A Decision Procedure for Separation Logic in SMT].<br />
* Sets<br />
** Adaptation of tableau-based decision procedure described [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.10.5176 here].<br />
* Strings<br />
** Original approach described in our [http://www.cs.stanford.edu/~barrett/pubs/LRT+14.pdf CAV 2014 paper: A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].<br />
** Decision procedure for regular memberships with length [http://homepage.cs.uiowa.edu/~ajreynol/frocos15.pdf].<br />
* Uninterpreted functions<br />
** UF (without cardinality) is handled in a manner inspired by [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.70.1745 Simplify's tech report].<br />
** UF + cardinality is described [http://www.divms.uiowa.edu/~ajreynol/pres-fmf12.pdf this presentation] and is used for finite model finding.<br />
<br />
=History of CVC=<br />
<br />
[[File:svc.gif|thumb|border|100px|The SVC logo.]]<br />
[[File:cvc3_logo.jpg|thumb|border|100px|The CVC3 logo.]]<br />
[[File:cvc3_night_logo.png|thumb|border|100px|The CVC3 "by night" logo, used for nightly builds and regressions.]]<br />
[[File:cvc3cvc4.png|thumb|border|100px|An early CVC4 logo.]]<br />
<br />
The Cooperating Validity Checker series has a long history. The<br />
Stanford Validity Checker (SVC) came first in 1996, incorporating<br />
theories and its own SAT solver. Its successor, the Cooperating<br />
Validity Checker (CVC), had a more optimized internal design, produced<br />
proofs, used the Chaff SAT solver, and featured a number of usability<br />
enhancements. Its name comes from the cooperative nature of decision<br />
procedures in Nelson-Oppen theory combination, which share amongst<br />
each other equalities between shared terms. CVC Lite, first made<br />
available in 2003, was a rewrite of CVC that attempted to make CVC<br />
more flexible (hence the "lite") while extending the feature set: CVC<br />
Lite supported quantifiers where its predecessors did not. CVC3 was a<br />
major overhaul of portions of CVC Lite: it added better decision<br />
procedure implementations, added support for using MiniSat in the<br />
core, and had generally better performance.<br />
<br />
[[File:cvc4-logo.png|thumb|border|100px|The CVC4 logo.]]<br />
CVC4 is the new version, the fifth generation of this validity checker<br />
line that is now celebrating sixteen years of heritage. It represents<br />
a complete re-evaluation of the core architecture to be both<br />
performant and to serve as a cutting-edge research vehicle for the<br />
next several years. Rather than taking CVC3 and redesigning problem<br />
parts, we've taken a clean-room approach, starting from scratch.<br />
Before using any designs from CVC3, we have thoroughly scrutinized,<br />
vetted, and updated them. Many parts of CVC4 bear only a superficial<br />
resemblance, if any, to their correspondent in CVC3.<br />
<br />
However, CVC4 is fundamentally similar to CVC3 and many other modern<br />
SMT solvers: it is a DPLL(T) solver, with a SAT solver at its core and<br />
a delegation path to different decision procedure implementations,<br />
each in charge of solving formulas in some background theory.<br />
<br />
The re-evaluation and ground-up rewrite was necessitated, we felt, by<br />
the performance characteristics of CVC3. CVC3 has many useful<br />
features, but some core aspects of the design led to high memory use,<br />
and the use of heavyweight computation (where more nimble engineering<br />
approaches could suffice) makes CVC3 a much slower prover than other<br />
tools. As these designs are central to CVC3, a new version was<br />
preferable to a selective re-engineering, which would have ballooned<br />
in short order.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=About_CVC4&diff=5704About CVC42018-05-01T19:52:08Z<p>Ajreynol: /* Decision Procedures */</p>
<hr />
<div>CVC4 is an automatic theorem prover for [http://en.wikipedia.org/wiki/Satisfiability_Modulo_Theories Satisifiability Modulo Theories (SMT)] (for a more formal introduction to SMT see the following book chapter [https://cs.stanford.edu/~barrett/pubs/BSST09.pdf Satisfiability Modulo Theories] ). Technically, it is an automated validity checker for a many-sorted (i.e., typed) first-order logic with built-in theories.<br />
It can be used to prove the validity (or, dually, the satisfiability) of a formula with respect to several built-in logical theories and their combination.<br />
<br />
CVC4 currently has support for the following theories:<br />
* equality over free (aka uninterpreted) function and predicate symbols<br />
* real and integer linear arithmetic<br />
* bit-vectors<br />
* arrays<br />
* tuples<br />
* records<br />
* user-defined inductive [[Datatypes|datatypes]]<br />
* [[Strings|strings]]<br />
* [[Sets|finite sets and relations]]<br />
* [[Separation Logic|separation logic]]<br />
<br />
CVC4 has a wide variety of features including:<br />
<br />
* support for quantifiers through heuristic instantiation;<br />
* an interactive text-based interface;<br />
* a rich [http://cvc4.cs.stanford.edu/cvc4-builds/documentation/public/latest/ C++ API] for embedding in other systems;<br />
* model generation abilities;<br />
* source compatibility with much of the CVC3 API via a "compatibility library";<br />
* essentially no limit on its use for research or commercial purposes (see [https://github.com/CVC4/CVC4/blob/master/COPYING license]).<br />
<br />
=Web site=<br />
<br />
For more information and the latest news about CVC4, visit the [http://cvc4.cs.stanford.edu CVC4 web site].<br />
<br />
=Decision Procedures=<br />
* Architecture<br />
** See the [http://dl.acm.org/citation.cfm?id=2032319 CVC4 tool paper].<br />
* Arithmetic<br />
** CVC4 solves linear real arithmetic using an implementation of [http://link.springer.com/chapter/10.1007%2F11817963_11? Simplex for DPLL(T)]. For a more complete introduction see the [http://yices.csl.sri.com/sri-csl-06-01.pdf tech report].<br />
** The linear arithmetic module includes heuristics from [http://eprints-phd.biblio.unitn.it/166/2/thesis.pdf Section 2.5 of Alberto Griggio's thesis] and a few currently unpublished ones.<br />
** Integers are currently handled by first solving the real relaxation of the constraints, and then using a combination of [http://www.cs.wm.edu/~idillig/cav2009.pdf Cuts from Proofs] and branching to ensure integer solutions. This approach and the equational solver used are described in [https://es.fbk.eu/people/griggio/papers/jsat12.pdf A Practical Approach to Satisfiability Modulo Linear Integer Arithmetic].<br />
** A technical report is planned to explain a number of small details and extensions including analysis to improve simplex's conflicts, handling disequalities, supporting model generation in CVC4's combination framework, heuristically propagating equalities over sharing terms, tableau row based propagation, and terminating simplex with unknown.<br />
** Non-linear arithmetic support is currently rudimentary to non-existent. In CVC4 v1.0, non-linearity is handled by abstracting monomials as unique new variables. We plan on implementing [http://cs.nyu.edu/~dejan/papers/jovanovic-ijcar2012.pdf Solving Non-Linear Arithmetic] this spring.<br />
* Arrays<br />
** Arrays are implemented in a manner inspired by the [http://research.microsoft.com/en-us/um/people/leonardo/files/fmcad09.pdf Generalized, efficient array decision procedures] paper with a few major modifications.<br />
* Bitvectors<br />
** Bitvectors is implemented primarily via a lazy schema for bitblasting. See [http://eprints-phd.biblio.unitn.it/345/ Anders Franzen's thesis chapter 3].<br />
* Combination<br />
** Theory combination is based on the care graph framework described in both [http://cs.nyu.edu/~dejan/papers/jovanovic-fmsd2012.pdf Being careful about theory combination] and [http://cs.nyu.edu/~dejan/papers/jovanovic-frocos2011.pdf Sharing is Caring: Combination of Theories].<br />
* Datatypes<br />
** CVC4 implements [http://homepage.cs.uiowa.edu/~tinelli/papers/BarST-JSAT-07.pdf An Abstract Decision Procedure for a Theory of Inductive Data Types].<br />
** This procedure has been extended to incorporate coinductive datatypes [http://homepage.cs.uiowa.edu/~ajreynol/cade15.pdf].<br />
* Quantifiers<br />
** E-matching and conflict-based quantifier instantiation [http://homepage.cs.uiowa.edu/~ajreynol/fmcad14.pdf].<br />
** Finite model finding [http://homepage.cs.uiowa.edu/~ajreynol/thesis.pdf].<br />
** Techniques for finding counterexamples for conjectures in the presence of recursive functions [http://homepage.cs.uiowa.edu/~ajreynol/ijcar16a.pdf].<br />
** Automated induction for datatypes [http://homepage.cs.uiowa.edu/~ajreynol/vmcai15.pdf].<br />
** A decision procedure for quantified linear arithmetic with one alternation [http://homepage.cs.uiowa.edu/~ajreynol/report-inst-la15.pdf].<br />
** Support for syntax-guided synthesis, as described in [http://homepage.cs.uiowa.edu/~ajreynol/cav15a.pdf].<br />
* Relations<br />
** An extension of the decision procedure for sets, as described in [http://homepage.cs.uiowa.edu/~tinelli/papers/MenEtAl-CADE-17.pdf].<br />
* SAT Solver<br />
** The main sat solver is based on [http://minisat.se/ minisat v2.2.0].<br />
** Additionally, we (optionally, and enabled by default for certain theories) use non-clausal analysis to cut down search space of minisat. For more details see the article [http://cs.nyu.edu/~kshitij/articles/cvc4-branching-heuristic.pdf A branching heuristic in CVC4].<br />
* Separation Logic<br />
** A decision procedure for a fragment quantifier-free separation logic containing negation, separation star and magic wand is implemented and can be composed with other decision procedures supported by CVC4. For details see [http://homepage.divms.uiowa.edu/~ajreynol/atva16.pdf A Decision Procedure for Separation Logic in SMT].<br />
* Sets<br />
** Adaptation of tableau-based decision procedure described [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.10.5176 here].<br />
* Strings<br />
** Original approach described in our [http://www.cs.stanford.edu/~barrett/pubs/LRT+14.pdf CAV 2014 paper: A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].<br />
** Decision procedure for regular memberships with length [http://homepage.cs.uiowa.edu/~ajreynol/frocos15.pdf].<br />
* Uninterpreted functions<br />
** UF (without cardinality) is handled in a manner inspired by [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.70.1745 Simplify's tech report].<br />
** UF + cardinality is described [http://www.divms.uiowa.edu/~ajreynol/pres-fmf12.pdf this presentation] and is used for finite model finding.<br />
<br />
=History of CVC=<br />
<br />
[[File:svc.gif|thumb|border|100px|The SVC logo.]]<br />
[[File:cvc3_logo.jpg|thumb|border|100px|The CVC3 logo.]]<br />
[[File:cvc3_night_logo.png|thumb|border|100px|The CVC3 "by night" logo, used for nightly builds and regressions.]]<br />
[[File:cvc3cvc4.png|thumb|border|100px|An early CVC4 logo.]]<br />
<br />
The Cooperating Validity Checker series has a long history. The<br />
Stanford Validity Checker (SVC) came first in 1996, incorporating<br />
theories and its own SAT solver. Its successor, the Cooperating<br />
Validity Checker (CVC), had a more optimized internal design, produced<br />
proofs, used the Chaff SAT solver, and featured a number of usability<br />
enhancements. Its name comes from the cooperative nature of decision<br />
procedures in Nelson-Oppen theory combination, which share amongst<br />
each other equalities between shared terms. CVC Lite, first made<br />
available in 2003, was a rewrite of CVC that attempted to make CVC<br />
more flexible (hence the "lite") while extending the feature set: CVC<br />
Lite supported quantifiers where its predecessors did not. CVC3 was a<br />
major overhaul of portions of CVC Lite: it added better decision<br />
procedure implementations, added support for using MiniSat in the<br />
core, and had generally better performance.<br />
<br />
[[File:cvc4-logo.png|thumb|border|100px|The CVC4 logo.]]<br />
CVC4 is the new version, the fifth generation of this validity checker<br />
line that is now celebrating sixteen years of heritage. It represents<br />
a complete re-evaluation of the core architecture to be both<br />
performant and to serve as a cutting-edge research vehicle for the<br />
next several years. Rather than taking CVC3 and redesigning problem<br />
parts, we've taken a clean-room approach, starting from scratch.<br />
Before using any designs from CVC3, we have thoroughly scrutinized,<br />
vetted, and updated them. Many parts of CVC4 bear only a superficial<br />
resemblance, if any, to their correspondent in CVC3.<br />
<br />
However, CVC4 is fundamentally similar to CVC3 and many other modern<br />
SMT solvers: it is a DPLL(T) solver, with a SAT solver at its core and<br />
a delegation path to different decision procedure implementations,<br />
each in charge of solving formulas in some background theory.<br />
<br />
The re-evaluation and ground-up rewrite was necessitated, we felt, by<br />
the performance characteristics of CVC3. CVC3 has many useful<br />
features, but some core aspects of the design led to high memory use,<br />
and the use of heavyweight computation (where more nimble engineering<br />
approaches could suffice) makes CVC3 a much slower prover than other<br />
tools. As these designs are central to CVC3, a new version was<br />
preferable to a selective re-engineering, which would have ballooned<br />
in short order.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5703Sets2018-05-01T19:46:34Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>t: '''[INT, INT]''';</code><br />
| <code> (declare-fun t () '''(Tuple Int Int)''') </code><br />
| <code>em.'''mkTupleType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(t1, ..., tn)'''</code><br />
| <code>('''mkTuple''' t1, ..., tn)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, t1, ..., tn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''t.i'''</code><br />
| <code>('''(_ tupSel i)''' t)</code><br />
| <code>DatatypeType tt = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = tt.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, t);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.'''mkSetType'''( em.'''mkTupleType'''( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5702Sets2018-05-01T19:45:15Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Tuple Int Int)''') </code><br />
| <code>em.'''mkTupleType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(X1, ..., Xn)'''</code><br />
| <code>('''mkTuple''' X1, ..., Xn)</code><br />
| <code>DatatypeType t = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = t.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, X1, ..., Xn);</code><br />
|-<br />
| Tuple selector<br />
| <code>'''X.i'''</code><br />
| <code>('''(_ tupSel i)''' X)</code><br />
| <code>DatatypeType t = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = t.getDatatype();</code><br><br />
<code>Expr s = dt[0][i].getSelector();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', s, X);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.'''mkSetType'''( em.'''mkTupleType'''( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Strings&diff=5701Strings2018-04-25T18:50:02Z<p>Ajreynol: </p>
<hr />
<div>This page describes support for the theory of strings in CVC4.<br />
<br />
=Syntax=<br />
This document focuses on input written in SMT-LIB 2 format. <br />
A frontend for CVC4's native syntax is not available yet.<br />
<br />
'''We highly recommend that users use SMT-LIB [http://smt-lib.org/language.shtml Version 2.5], <br />
instead of Version 2.0.''' <br />
The major difference is in the definition of escape sequences for string literals.<br />
<br />
'''The syntax below is for CVC4 version > 1.4.''' Version 1.3 has only<br />
''partial'' support for syntax in this document.<br />
<br />
Currently, the string solver supports string constants over a set of characters<br />
limited to the printable ASCII characters. Other characters ''must'' be encoded <br />
with escape sequences. <br />
For arbitry alphabets, we plan to provide later a separate solver <br />
for a theory of parametric sequences.<br />
<br />
To use the string solver it is important to declare initially <br />
(using the <code>set-logic</code> command) an SMT-LIB logic that includes strings.<br />
Since the SMT-LIB standard does not have an official theory of strings and <br />
related logics yet, the logic names described below are tentative and <br />
might change later.<br />
<br />
The basic logic is <code>QF_S</code> consisting of quantifier-free formulas <br />
over just the theory of strings, e.g.:<br />
(set-logic QF_S)<br />
<br />
A summary of the relevant syntax for strings in the SMT2, CVC, and API is below. Note that regular expressions are not yet supported in the CVC format. More details on these operators can be found later in this page.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| preappend "S" for strings<br />
| preappend "S" for strings<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_'''S'''LIA)</code><br />
| <code>smt.setLogic("QF_'''S'''LIA");</code><br />
|-<br />
| String Sort<br />
| <code>STRING</code><br />
| <code>String</code><br />
| <code>em.stringType();</code><br />
|-<br />
| String literals<br />
| <code>"abcdef"</code><br />
| <code>"abcdef"</code><br />
| <code>em.mkConst( '''::CVC4::String'''("abcdef") );</code><br />
|-<br />
| Concatenation<br />
| <code>'''CONCAT'''( X1, ..., Xn )</code><br />
| <code>('''str.++''' X1 ... Xn )</code><br />
| <code>em.mkExpr('''kind::STRING_CONCAT''', X1, ..., Xn);</code><br />
|-<br />
| Length<br />
| <code>'''LENGTH'''( x )</code><br />
| <code>('''str.len''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_LENGTH''', X);</code><br />
|-<br />
| String contains <br />
| <code>'''CONTAINS'''( X, Y )</code><br />
| <code>('''str.contains''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_STRCTN''', X, Y);</code><br />
|-<br />
| Index of<br />
| <code>'''INDEXOF'''( X, Y, N )</code><br />
| <code>('''str.indexof''' X Y N)</code><br />
| <code>em.mkExpr('''kind::STRING_STRIDOF''', X, Y, N);</code><br />
|-<br />
| Replace<br />
| <code>'''REPLACE'''( X, Y, Z )</code><br />
| <code>('''str.replace''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_STRREPL''', X, Y, Z);</code><br />
|-<br />
| Substring<br />
| <code>'''SUBSTR'''( X, Y, Z )</code><br />
| <code>('''str.substr''' X Y Z)</code><br />
| <code>em.mkExpr('''kind::STRING_SUBSTR''', X, Y, Z);</code><br />
|-<br />
| Prefix of <br />
| <code>'''PREFIXOF'''( X, Y )</code><br />
| <code>('''str.prefixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_PREFIX''', X, Y);</code><br />
|-<br />
| Suffix of<br />
| <code>'''SUFFIXOF'''( X, Y )</code><br />
| <code>('''str.suffixof''' X Y)</code><br />
| <code>em.mkExpr('''kind::STRING_SUFFIX''', X, Y);</code><br />
|-<br />
| String to Integer<br />
| <code>'''STRING_TO_INTEGER'''( X )</code><br />
| <code>('''str.to.int''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOI''', X);</code><br />
|-<br />
| Integer to String<br />
| <code>'''INTEGER_TO_STRING'''( X )</code><br />
| <code>('''int.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_ITOS''', X);</code><br />
|-<br />
| String to Integer (16-bit)<br />
| <code>'''STRING_TO_UINT16'''( X )</code><br />
| <code>('''str.to.u16''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU16''', X);</code><br />
|-<br />
| Integer (16-bit) to String<br />
| <code>'''UINT16_TO_STRING'''( X )</code><br />
| <code>('''u16.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U16TOS''', X);</code><br />
|-<br />
| String to Integer (32-bit)<br />
| <code>'''STRING_TO_UINT32'''( X )</code><br />
| <code>('''str.to.u32''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_STOU32''', X);</code><br />
|-<br />
| Integer (32-bit) to String<br />
| <code>'''UINT32_TO_STRING'''( X )</code><br />
| <code>('''u32.to.str''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_U32TOS''', X);</code><br />
|-<br />
| Character at <br />
| <code>'''CHARAT'''( X, N )</code><br />
| <code>('''str.at''' X N)</code><br />
| <code>em.mkExpr('''kind::STRING_CHARAT''', X, N);</code><br />
|-<br />
| Regular expression sort<br />
| <code>n/a</code><br />
| <code>RegExp</code><br />
| <code>em.regExpType();</code><br />
|-<br />
| Membership in regular expression<br />
| <code>n/a</code><br />
| <code>('''str.in.re''' X R)</code><br />
| <code>em.mkExpr('''kind::STRING_IN_REGEXP''', X, R);</code><br />
|-<br />
| String to regular expression<br />
| <code>n/a</code><br />
| <code>('''str.to.re''' X)</code><br />
| <code>em.mkExpr('''kind::STRING_TO_REGEXP''', X);</code><br />
|-<br />
| Regular expression concatenation<br />
| <code>n/a</code><br />
| <code>('''re.++''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_CONCAT''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression union<br />
| <code>n/a</code><br />
| <code>('''re.union''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_UNION''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression intersection<br />
| <code>n/a</code><br />
| <code>('''re.inter''' R1 ... Rn)</code><br />
| <code>em.mkExpr('''kind::REGEXP_INTER''', R1, ..., Rn);</code><br />
|-<br />
| Regular expression Kleene star<br />
| <code>n/a</code><br />
| <code>('''re.*''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_STAR''', R);</code><br />
|-<br />
| Regular expression plus<br />
| <code>n/a</code><br />
| <code>('''re.+''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_PLUS''', R);</code><br />
|-<br />
| Regular expression option<br />
| <code>n/a</code><br />
| <code>('''re.opt''' R)</code><br />
| <code>em.mkExpr('''kind::REGEXP_OPT''', R);</code><br />
|}<br />
<br />
==Options==<br />
Some functions in the theory are have only experimental support currently and <br />
are disabled by default (even in the <code>ALL_SUPPORTED</code> logic:<br />
To use them:<br />
(set-option :strings-exp true)<br />
<br />
The solver can be run in ''finite model finding mode'' which guarantees <br />
termination for satisfiable problems. <br />
This mode is disabled by default. To enable it:<br />
(set-option :strings-fmf true)<br />
Note that in this mode the solver is much '''slower''' than in default mode, <br />
so we recommend it only as a fall back option when the default mode fails <br />
to find a solution with a reasonably large timeout.<br />
<br />
To select the strategy of LB rule application: 0-lazy, 1-eager, 2-no (0 by default):<br />
(set-option :strings-lb 1)<br />
<br />
To set up string alphabet cardinality (256 by default, expert option):<br />
(set-option :strings-alphabet-card n)<br />
This is a reserved option for the extension of the sequence theory.<br />
<br />
==Alphabet==<br />
Currently, the solver's theory is based on an alphabet consisting of the 256 <br />
characters from (8-bit) Extended ASCII. <br />
Since there are several versions of Extended ASCII, we allow string constants <br />
to contain only ''printable US ASCII characters'', which are encoded <br />
in the same way in all Extended ASCII versions.<br />
<br />
'''Note:''' The alphabet will change to the one prescribed by the SMT-LIB standard<br />
once there is one.<br />
<br />
==Printable Characters==<br />
A ''printable'' character is any character with numerical value between 0x20 and 0x7e <br />
in the standard US ASCII encoding.<br />
<br />
==Escape Sequences in String Constants==<br />
String constants are denoted by SMT-LIB string literals consisting of sequences of printable characters delimited by double-quotes (<code>"</code>).<br />
<br />
We support escape sequences used in most programming languages <br />
to represent non-printable characters. <br />
<br />
{| border="1"<br />
|-<br />
| <code>\0</code> … <code>\9</code><br />
| represents ASCII character 0 … 9, respectively<br />
|-<br />
| <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code><br />
| represents its corresponding ASCII character (C++ convention)<br />
|-<br />
| <code>\</code>''ooo''<br />
| encodes a single ASCII character where ''ooo'' consists of exactly three digits in the octal encoding of the character (from 0 to 377). For example, <code>\101</code> represents <code>A</code>. '''Note:''' going beyond value 377 might give unexpected results. For instance, <code>\437</code> will be translated in the two-character string <code>#7</code>.<br />
|-<br />
| <code>\x</code>''NN''<br />
| encodes a single ASCII character, where ''NN'' consists of exactly two digits in the exadecimal encoding of the character.<br />
|}<br />
<br />
The backslash character (<code>\</code>) is silently ignored when it is followed by a sequence of characters not recognized as an escape sequence. For example, <code>\$ </code>, say, is parsed as if it was just <code>$</code>.<br />
<br />
When CVC4 outputs a string constant, a non-printable/extended ASCII character is printed in the exadecimal format <code>\x</code>''NN'', except for the character denoted by the escape sequences <code>\a</code>, <code>\b</code>, <code>\e</code>, <code>\f</code>, <code>\n</code>, <code>\r</code>, <code>\t</code>, <code>\v</code>, which are printed using those escape sequences.<br />
<br />
'''Note''': <br />
These escape sequences are specific to string constants in the theory of strings. They are 'not' escape sequences in SMT-LIB 2 per se.<br />
SMT-LIB 2.5 has only one escape sequence for string literals: <code>""</code>, <br />
which denotes the double quotes character. <br />
This means that a string literal like <code>"a""c"</code> is read by the solver as the string constant consisting of the characters <code>a</code>, <code>"</code>, and <code>c</code>.<br />
The same constant can be entered as <code>"a\042c"</code> or <code>"a\x22c"</code>.<br />
<br />
==Theory Signature==<br />
To define a string variable, i.e., a free string constant:<br />
(declare-fun x () String)<br />
Alternatively:<br />
(declare-const x () String)<br />
<br />
String Concatenation:<br />
(str.++ s1 s2 ... sn)<br />
where s1, s2, ..., and sn are string terms. String concatenation takes at least 2 arguments.<br />
<br />
String Length:<br />
(str.len s)<br />
where s is a string term.<br />
<br />
Character in String:<br />
(str.at s i)<br />
where s is a string term and i is an integer.<br />
The index is starting from 0.<br />
<br />
Sub-String:<br />
(str.substr s i j )<br />
where s is a string term, i and j are integers.<br />
<br />
==Escape Sequences for Regular Expressions==<br />
Currently, it is for CVC format only. (Coming soon.)<br />
<br />
==Symbolic Regular Expression==<br />
Membership Constraint:<br />
(str.in.re s r)<br />
where s is a string term and r is a regular expression.<br />
<br />
String to Regular Expression Conversion:<br />
(str.to.re s)<br />
where s is a string term. The statement turns a regular expression that only contains a string s.<br />
<br />
Regular Expression Concatenation:<br />
(re.++ r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions.<br />
<br />
Regular Expression Alternation:<br />
(re.union r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.or is for releases before March, 2014.<br />
<br />
Regular Expression Intersection:<br />
(re.inter r_1 r_2 ... r_n)<br />
where r_1, r_2, ..., r_n are regular expressions. re.itr is for releases before March, 2014.<br />
<br />
Regular Expression Kleene-Star:<br />
(re.* r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Kleene-Cross:<br />
(re.+ r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Option:<br />
(re.opt r)<br />
where r is a regular expression.<br />
<br />
Regular Expression Range:<br />
(re.range s t)<br />
where s, t are single characters in double quotes, e.g. "a", "b".<br />
It returns a regular expression that contains any character between s and t.<br />
<br />
Regular Expression Loop:<br />
(re.loop r l u)<br />
where r is a regular expression, l is a non-negative constant integer, and u is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r and at most u repetitions of r.<br />
If l >= u, it returns exactly l repetitions of r.<br />
<br />
Regular Expression Loop-2:<br />
(re.loop r l)<br />
where r is a regular expression, and l is a non-negative constant integer.<br />
It returns a regular expression that contains at least l repetitions of r.<br />
<br />
<br />
The Empty Regular Expression:<br />
re.nostr<br />
<br />
The Regular Expression that contains all characters:<br />
re.allchar<br />
<br />
==Extended Functions==<br />
Following functions are available when using the --strings-exp option. <br />
<br />
String Char-At:<br />
(str.at s i)<br />
where s is a string term and i is an integer term. i is the position. If i is negative or greater than or equal to the length of s, then (str.at s i) returns the empty string.<br />
<br />
String Sub-string:<br />
(str.substr s i j)<br />
where s is a string term and i, j are integer terms. i is the starting position, and j is the offset. If i is negative, it returns the empty string; otherwise, it returns the substring (of s) that begins at the specified index i and extends to the length j (or to the last character of s if the length of s is shorter than i + j).<br />
<br />
String Contain:<br />
(str.contains s t)<br />
where s and t are string terms. It returns true if the string s contains the string t.<br />
This function determines whether the string t can be found within the string s, returning true or false as appropriate.<br />
<br />
String IndexOf:<br />
(str.indexof s t i)<br />
where s is a string, t is a non-empty string and i is a non-negative integer.<br />
This function returns the position of the first occurrence of the specified value t in the string s after the index i.<br />
It returns -1 if the value to search for does not occur.<br />
<br />
String Replacement:<br />
(str.replace s t1 t2)<br />
where s, t1 and t2 are string terms, t1 is non-empty.<br />
This function searches the string s for the specified value t1, and returns a new string where the first occurrence of the specified value t1 is replaced by the string t2.<br />
<br />
String PrefixOf:<br />
(str.prefixof s t)<br />
where s and t are string terms. It returns true if the string s is a prefix of the string t.<br />
<br />
String SuffixOf:<br />
(str.suffixof s t)<br />
where s and t are string terms. It returns true if the string s is a suffix of the string t.<br />
<br />
String To Integer Conversion:<br />
(str.to.int s)<br />
where s is a string term. It returns the corresponding natural number if s is string of digits; otherwise, it returns -1.<br />
<br />
Integer To String Conversion:<br />
(int.to.str i)<br />
where i is an integer term. It returns the corresponding string if i is a natural number; otherwise, it returns an empty string.<br />
<br />
=Extensions=<br />
Together with other engine in CVC4, we can extend new functionality in the theory of strings. For example,<br />
(define-fun fun1 ((?x String) (?s String)) Bool<br />
(or (= ?x ?s)<br />
(> (str.len ?x) (str.len ?s))<br />
))<br />
Quantifiers over bounded Integers (with strings in the body) are supported in the experimental mode; however, quantifiers over strings are still under development.<br />
<br />
=Limitations=<br />
The decidability of this theory is unknown.<br />
For satisfiable problems (without extensions), our solver is sound, complete and terminating in the FMF mode (although the FMF mode will be slower than the default mode in general). For unsatisfiable problems, termination is not guaranteed; however, users can tune the options for termination.<br />
<br />
The current version of the solver supports ASCII characters only. We might move on to UNICODE in future versions.<br />
<br />
=Examples=<br />
Find an assignment for x, where x."ab"="ba".x and the length of x equals to 7.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
<br />
(assert (= (str.++ x "ab") (str.++ "ba" x)))<br />
(assert (= (str.len x) 7))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x and y are distinct and their lengths are equal.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
Find assignments for x and y, where x.y != y.x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(assert (not (= (str.++ x y) (str.++ y x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x, y and z, where x."ab".y=y."ba".z and z=x.y and x."a"!="a".x.<br />
(set-logic QF_S)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
(declare-fun z () String)<br />
<br />
(assert (= (str.++ x "ab" y) (str.++ y "ba" z)))<br />
(assert (= z (str.++ x y)))<br />
(assert (not (= (str.++ x "a") (str.++ "a" x))))<br />
<br />
(check-sat)<br />
<br />
Find a model for x and y, where both x and y are in the RegEx (a*b)* and they are different but have the same length.<br />
(set-logic QF_S)<br />
(set-option :strings-fmf true)<br />
<br />
(declare-fun x () String)<br />
(declare-fun y () String)<br />
<br />
(assert<br />
(str.in.re x<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
(assert (str.in.re y<br />
(re.* (re.++ (re.* (str.to.re "a") ) (str.to.re "b") ))))<br />
<br />
(assert (not (= x y)))<br />
(assert (= (str.len x) (str.len y)))<br />
<br />
(check-sat)<br />
<br />
=API=<br />
More details can be found in the [http://cvc4.cs.stanford.edu/wiki/Tutorials Tutorials].<br />
<br />
==C++==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/strings.cpp examples/api/strings.cpp].<br />
<br />
If setting the logic, use "S" to enable theory of strings.<br />
smt.setLogic("S");<br />
<br />
To create a string type, call <code>mkSetType</code> in the <code>ExprManager</code>.<br />
Type string = em.stringType();<br />
<br />
Make some string literals:<br />
// std::string<br />
std::string std_str_ab("ab");<br />
// CVC4::String<br />
CVC4::String cvc4_str_ab(std_str_ab);<br />
CVC4::String cvc4_str_abc("abc");<br />
// String constants<br />
Expr ab = em.mkConst(cvc4_str_ab);<br />
Expr abc = em.mkConst(CVC4::String("abc"));<br />
<br />
Make some string variables:<br />
Expr x = em.mkVar("x", string);<br />
Expr y = em.mkVar("y", string);<br />
Expr z = em.mkVar("z", string);<br />
<br />
Make some string constraints:<br />
// String concatenation: x.ab.y<br />
Expr lhs = em.mkExpr(kind::STRING_CONCAT, x, ab, y);<br />
// String concatenation: abc.z<br />
Expr rhs = em.mkExpr(kind::STRING_CONCAT, abc, z);<br />
// x.ab.y = abc.z<br />
Expr formula1 = em.mkExpr(kind::EQUAL, lhs, rhs);<br />
// Length of y: |y|<br />
Expr leny = em.mkExpr(kind::STRING_LENGTH, y);<br />
// |y| >= 0<br />
Expr formula2 = em.mkExpr(kind::GEQ, leny, em.mkConst(Rational(0)));<br />
// Regular expression: (ab[c-e]*f)|g|h<br />
Expr r = em.mkExpr(kind::REGEXP_UNION,<br />
em.mkExpr(kind::REGEXP_CONCAT,<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("ab"))),<br />
em.mkExpr(kind::REGEXP_STAR,<br />
em.mkExpr(kind::REGEXP_RANGE, em.mkConst(String("c")), em.mkConst(String("e")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("f")))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("g"))),<br />
em.mkExpr(kind::STRING_TO_REGEXP, em.mkConst(String("h"))));<br />
// String variables<br />
Expr s1 = em.mkVar("s1", string);<br />
Expr s2 = em.mkVar("s2", string);<br />
// String concatenation: s1.s2<br />
Expr s = em.mkExpr(kind::STRING_CONCAT, s1, s2);<br />
// s1.s2 in (ab[c-e]*f)|g|h<br />
Expr formula3 = em.mkExpr(kind::STRING_IN_REGEXP, s, r);<br />
<br />
Make a query:<br />
Expr q = em.mkExpr(kind::AND,<br />
formula1,<br />
formula2,<br />
formula3);<br />
<br />
Check the result:<br />
Result result = smt.checkSat(q);<br />
std::cout << "CVC4 reports: " << q << " is " << result << "." << std::endl;<br />
if(result == Result::SAT) {<br />
std::cout << " x = " << smt.getValue(x) << std::endl;<br />
std::cout << " s1.s2 = " << smt.getValue(s) << std::endl;<br />
}<br />
<br />
==Java==<br />
The example can be found in [https://github.com/CVC4/CVC4/blob/master/examples/api/java/Strings.java examples/api/java/Strings.java].<br />
<br />
==Unsat Cores==<br />
The string solver supports the generation of unsatisfiable cores. <br />
As with other subsolvers though, you must enable proofs at configuration time, <br />
and then run CVC with "--dump-unsat-cores" flag.<br />
<br />
=References=<br />
* Tianyi Liang, Andrew Reynolds, Nestan Tsiskaridze, Cesare Tinelli, Clark Barrett, and Morgan Deters. [http://dl.acm.org/citation.cfm?id=2994123 An efficient SMT solver for string constraints]. Formal Methods in System Design. 2016. <br />
* Tianyi Liang, Nestan Tsiskaridze, Andrew Reynolds, Cesare Tinelli, and Clark Barrett. [http://link.springer.com/chapter/10.1007/978-3-319-24246-0_9 A Decision Procedure for Regular Membership and Length Constraints over Unbounded Strings]. In Proceedings of the 10th International Symposium on Frontiers of Combining Systems (FroCoS'15), Wroclaw, Poland, 2015.<br />
* Tianyi Liang, Andrew Reynolds, Cesare Tinelli, Clark Barrett and Morgan Deters. [http://link.springer.com/chapter/10.1007%2F978-3-319-08867-9_43 A DPLL(T) Theory Solver for a Theory of Strings and Regular Expressions].In Proceedings of the 26th International Conference on Computer Aided Verification (CAV'14), Vienna, Austria, 2014.<br />
* Tianyi Liang. [http://ir.uiowa.edu/etd/1478/ Automated reasoning over string constraints]. PhD Dissertation, Department of Computer Science, The University of Iowa, Dec 2014.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5700Sets2018-04-25T17:52:10Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Tuple Int Int)''') </code><br />
| <code>em.'''mkTupleType'''( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(X1, ..., Xn)'''</code><br />
| <code>('''mkTuple''' X1, ..., Xn)</code><br />
| <code>DatatypeType t = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = t.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, X1, ..., Xn);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.'''mkSetType'''( em.'''mkTupleType'''( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5699Sets2018-04-25T17:51:21Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Tuple Int Int)''') </code><br />
| <code>em.mkTupleType( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(X1, ..., Xn)'''</code><br />
| <code>('''mkTuple''' X1, ..., Xn)</code><br />
| <code>DatatypeType t = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = t.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, X1, ..., Xn);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.mkSetType( em.mkTupleType( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5698Sets2018-04-25T17:50:26Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Tuple Int Int)''') </code><br />
| <code>em.mkTupleType( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(X1, ..., Xn)'''</code><br />
| <code>('''mkTuple''' X1, ..., Xn)</code><br />
| <code>DatatypeType t = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = t.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, X1, ..., Xn);</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.mkSetType( em.mkTupleType( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-<br />
<br />
Note: Currently, we only support encoding relational constraints in CVC4 native language. Support for SMT-LIB language is coming soon.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5697Sets2018-04-25T17:48:36Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.mkSetType( em.mkTupleType( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Tuple Int Int)''') </code><br />
| <code>em.mkTupleType( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>'''(X1, ..., Xn)'''</code><br />
| <code>('''mkTuple''' X1, ..., Xn)</code><br />
| <code>DatatypeType t = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = t.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, X1, ..., Xn);</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> em.mkExpr('''kind::TRANSPOSE''', X); </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> em.mkExpr('''kind::TCLOSURE''', X); </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> em.mkExpr('''kind::JOIN''', X); </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> em.mkExpr('''kind::PRODUCT''', X); </code><br />
|-<br />
<br />
Note: Currently, we only support encoding relational constraints in CVC4 native language. Support for SMT-LIB language is coming soon.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5696Sets2018-04-25T17:46:48Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.mkSetType( em.mkTupleType( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Tuple Int Int)''') </code><br />
| <code>em.mkTupleType( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>(X1, ..., Xn)</code><br />
| <code>(mkTuple X1, ..., Xn)</code><br />
| <code>DatatypeType t = em.mkTupleType(types);</code><br />
<code>const Datatype& dt = t.getDatatype();</code><br><br />
<code>Expr c = dt[0].getConstructor();</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', c, X1, ..., Xn);</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
<br />
Note: Currently, we only support encoding relational constraints in CVC4 native language. Support for SMT-LIB language is coming soon.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5695Sets2018-04-25T17:45:04Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.mkSetType( em.mkTupleType( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Tuple Int Int)''') </code><br />
| <code>em.mkTupleType( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>(X1, ..., Xn)</code><br />
| <code>(mkTuple X1, ..., Xn)</code><br />
| <code>A;</code><br />
<code>B;</code><br><br />
<code>c;</code><br><br />
<code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', X1, ..., Xn);</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
<br />
Note: Currently, we only support encoding relational constraints in CVC4 native language. Support for SMT-LIB language is coming soon.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5694Sets2018-04-25T17:42:17Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| (Set (Tuple <Sort_1>, ..., <Sort_n>))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Set (Tuple Int Int))''') </code><br />
| <code>em.mkSetType( em.mkTupleType( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| (Tuple <Sort_1>, ..., <Sort_n>)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () '''(Tuple Int Int)''') </code><br />
| <code>em.mkTupleType( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>(X1, ..., Xn)</code><br />
| <code>(mkTuple X1, ..., Xn)</code><br />
| <code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', X1, ..., Xn);</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
<br />
Note: Currently, we only support encoding relational constraints in CVC4 native language. Support for SMT-LIB language is coming soon.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5693Sets2018-04-25T17:41:24Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Relation Sort<br />
| SET OF [<Sort_1>, ..., <Sort_n>]<br />
| '''(Set (Tuple <Sort_1>, ..., <Sort_n>))'''<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () ('''Set''' ('''Tuple''' Int Int))) </code><br />
| <code>em.mkSetType( em.mkTupleType( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Tuple Sort<br />
| [<Sort_1>, ..., <Sort_n>]<br />
| '''(Tuple <Sort_1>, ..., <Sort_n>)'''<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& types)<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () ('''Tuple''' Int Int)) </code><br />
| <code>em.mkTupleType( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>(X1, ..., Xn)</code><br />
| <code>(mkTuple X1, ..., Xn)</code><br />
| <code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', X1, ..., Xn);</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
<br />
Note: Currently, we only support encoding relational constraints in CVC4 native language. Support for SMT-LIB language is coming soon.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5692Sets2018-04-25T17:38:01Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Relation Sort<br />
| SET OF [ElementSort_1, ..., ElementSort_n]<br />
| (Set (Tuple ElementSort_1, ..., ElementSort_n))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () (Set (Tuple Int Int))) </code><br />
| <code>em.mkSetType( em.mkTupleType( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Tuple Sort<br />
| [ElementSort_1, ..., ElementSort_n]<br />
| (Tuple ElementSort_1, ..., ElementSort_n)<br />
| CVC4::ExprManager::mkTupleType(std::vector<CVC4::Type>& elementTypes)<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () (Tuple Int Int)) </code><br />
| <code>em.mkTupleType( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>(X1, ..., Xn)</code><br />
| <code>(mkTuple X1, ..., Xn)</code><br />
| <code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', X1, ..., Xn);</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
<br />
Note: Currently, we only support encoding relational constraints in CVC4 native language. Support for SMT-LIB language is coming soon.</div>Ajreynolhttp://cvc4.stanford.edu/w/index.php?title=Sets&diff=5691Sets2018-04-25T17:35:54Z<p>Ajreynol: /* Finite Relations */</p>
<hr />
<div>=Finite Sets=<br />
<br />
As of July 2014 (CVC4 v1.4), we include support for theory of finite sets. The simplest way to get a sense of the syntax is to look at an example:<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/cvc-sample.cvc CVC language example]<br />
* [https://github.com/CVC4/CVC4/blob/1.4/test/regress/regress0/sets/sets-sample.smt2 SMT language example]<br />
* API example: [[Tutorials#Sets|tutorial]], [https://github.com/CVC4/CVC4/blob/1.4/examples/api/sets.cpp source code]<br />
<br />
<br />
For reference, below is a short summary of the sorts, constants, functions and predicates.<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| append "FS" for finite sets<br />
| append "FS" for finite sets<br />
|-<br />
|<br />
|<br />
| <code>(set-logic QF_UFLIA'''FS''')</code><br />
| <code>smt.setLogic("QF_UFLIA'''FS'''");</code><br />
|-<br />
| Sort<br />
| SET OF <Element Sort><br />
| (Set <Element Sort>) <br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF INT''';</code><br />
| <code>(declare-fun X () '''(Set Int)''')</code><br />
| <code>em.'''mkSetType'''( em.integerType() );</code><br />
|-<br />
| Union<br />
| <code>X '''<nowiki>|</nowiki>''' Y</code><br />
| <code>('''union''' X Y)</code><br />
| <code>em.mkExpr('''kind::UNION''', X, Y);</code><br />
|-<br />
| Intersection<br />
| <code>X '''<nowiki>&</nowiki>''' Y</code><br />
| <code>('''intersection''' X Y)</code><br />
| <code>em.mkExpr('''kind::INTERSECTION''', X, Y);</code><br />
|-<br />
| Set subtraction<br />
| <code>X '''<nowiki>–</nowiki>''' Y</code><br />
| <code>('''setminus''' X Y)</code><br />
| <code>em.mkExpr('''kind::SETMINUS''', X, Y);</code><br />
|-<br />
| Membership<br />
| <code>x '''<nowiki>IS_IN</nowiki>''' X</code><br />
| <code>('''member''' x X)</code><br />
| <code>em.mkExpr('''kind::MEMBER''', x, X);</code><br />
|-<br />
| Subset<br />
| <code>X '''<nowiki><=</nowiki>''' Y</code><br />
| <code>('''subset''' X Y)</code><br />
| <code>em.mkExpr('''kind::SUBSET''', X, Y);</code><br />
|-<br />
| Empty set<br />
| {} :: <Type Ascription><br />
| (as emptyset <Type Ascription>)<br />
| CVC4::EmptySet(CVC4::SetType setType)<br />
|-<br />
|<br />
| <code>'''{}''' :: SET OF INT</code><br />
| <code>(as '''emptyset''' (Set Int))</code><br />
| <code>em.mkConst('''EmptySet'''(em.mkSetType(em.integerType())));</code><br />
|-<br />
| Singleton set<br />
| <code>'''{1}'''</code><br />
| <code>('''singleton''' 1)</code><br />
| <code>em.mkExpr('''kind::SINGLETON''', oneExpr);</code><br />
|-<br />
| Cardinality<br />
| <code>'''<nowiki>CARD</nowiki>'''( X )</code><br />
| <code>('''card''' X)</code><br />
| <code>em.mkExpr('''kind::CARD''', X);</code><br />
|-<br />
| Insert/finite sets<br />
| <code>'''{1, 2, 3, 4}'''</code><br />
| <code>('''insert''' 1 2 3 (singleton 4))</code><br />
| <code>em.mkExpr('''kind::INSERT''', c1, c2, c3, sgl4);</code><br />
|-<br />
| Complement<br />
| <code>'''<nowiki>~</nowiki>''' X</code><br />
| <code>('''complement''' X)</code><br />
| <code>em.mkExpr('''kind::COMPLEMENT''', X);</code><br />
|-<br />
| Universe set<br />
| UNIVERSE :: <Type Ascription><br />
| (as univset <Type Ascription>)<br />
| <br />
|-<br />
|<br />
| <code>'''UNIVERSE''' :: SET OF INT</code><br />
| <code>(as '''univset''' (Set Int))</code><br />
| <code>em.mkNullaryOperator(em.mkSetType(em.integerType()),'''kind::UNIVERSE_SET''');</code><br />
|}<br />
<br />
<br />
Operator precedence for CVC language:<br />
<code><nowiki>&</nowiki></code><br />
<code><nowiki>|</nowiki></code><br />
<code><nowiki>–</nowiki></code><br />
<code><nowiki>IS_IN</nowiki></code><br />
<code><nowiki><=</nowiki></code><br />
<code><nowiki>=</nowiki></code>. For example, <code>A - B | A & C <= D</code> is read as <code>( A - ( B | (A & C) ) ) <= D</code>.<br />
<br />
<br />
=Finite Relations=<br />
<br />
{| class="wikitable" cellpadding="5" border="0" style="border-collapse:collapse"<br />
|-<br />
! <br />
! CVC language<br />
! SMTLIB language<br />
! C++ API<br />
|-<br />
| Logic string<br />
| Not needed<br />
| <code>(set-logic QF_'''ALL''')</code><br />
| <code>smt.setLogic("QF_'''ALL'''");</code><br />
|-<br />
| Relation Sort<br />
| SET OF [ElementSort_1, ..., ElementSort_n]<br />
| (Set (Tuple ElementSort_1, ..., ElementSort_n))<br />
| CVC4::ExprManager::mkSetType(CVC4::Type elementType)<br />
|-<br />
| <br />
| <code>X: '''SET OF [INT, INT]''';</code><br />
| <code> (declare-fun X () (Set (Tuple Int Int))) </code><br />
| <code>em.mkSetType( em.mkTupleType( em.integerType(), em.integerType() ) );</code><br />
|-<br />
| Tuple Sort<br />
| [ElementSort_1, ..., ElementSort_n]<br />
| (Tuple ElementSort_1, ..., ElementSort_n)<br />
| --<br />
|-<br />
| <br />
| <code>X: '''[INT, INT]''';</code><br />
| <code> (declare-fun X () (Tuple Int Int)) </code><br />
| <code>em.mkTupleType( em.integerType(), em.integerType() );</code><br />
|-<br />
| Tuple constructor<br />
| <code>(X1, ..., Xn)</code><br />
| <code>(mkTuple X1, ..., Xn)</code><br />
| <code>em.mkExpr('''kind::APPLY_CONSTRUCTOR''', X1, ..., Xn);</code><br />
|-<br />
| Transpose<br />
| <code>'''<nowiki>TRANSPOSE</nowiki>'''(X) </code><br />
| <code> ('''transpose''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Transitive Closure<br />
| <code>'''<nowiki>TCLOSURE</nowiki>'''(X) </code><br />
| <code> ('''tclosure''' X) </code><br />
| <code> -- </code><br />
|-<br />
| Join<br />
| <code> X '''<nowiki>JOIN</nowiki>''' Y </code><br />
| <code> ('''join''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
| Product<br />
| <code> X '''<nowiki>PRODUCT</nowiki>''' Y </code><br />
| <code> ('''product''' X Y) </code><br />
| <code> -- </code><br />
|-<br />
<br />
Note: Currently, we only support encoding relational constraints in CVC4 native language. Support for SMT-LIB language is coming soon.</div>Ajreynol