cvc3_compat.h
Go to the documentation of this file.
/********************* */
#include "cvc4_public.h"
#ifndef __CVC4__CVC3_COMPAT_H
#define __CVC4__CVC3_COMPAT_H
// keep the CVC3 include guard also
#if defined(_cvc3__include__vc_h_) || \
defined(_cvc3__expr_h_) || \
defined(_cvc3__command_line_flags_h_) || \
defined(_cvc3__include__queryresult_h_) || \
defined(_cvc3__include__formula_value_h_)
#error "A CVC3 header file was included before CVC4's cvc3_compat.h header. Please include cvc3_compat.h rather than any CVC3 headers."
#else
// define these so the files are skipped if the user #includes them too
#define _cvc3__expr_h_
#define _cvc3__include__vc_h_
#define _cvc3__command_line_flags_h_
#define _cvc3__include__queryresult_h_
#define _cvc3__include__formula_value_h_
#include "expr/expr_manager.h"
#include "expr/expr.h"
#include "expr/type.h"
#include "smt/smt_engine.h"
#include "util/rational.h"
#include "util/integer.h"
#include "util/exception.h"
#include "util/hash.h"
#include "parser/parser.h"
#include <stdlib.h>
#include <map>
#include <utility>
//class CInterface;
namespace CVC3 {
const CVC4::Kind EQ = CVC4::kind::EQUAL;
const CVC4::Kind LE = CVC4::kind::LEQ;
const CVC4::Kind GE = CVC4::kind::GEQ;
const CVC4::Kind DIVIDE = CVC4::kind::DIVISION;
const CVC4::Kind BVLT = CVC4::kind::BITVECTOR_ULT;
const CVC4::Kind BVLE = CVC4::kind::BITVECTOR_ULE;
const CVC4::Kind BVGT = CVC4::kind::BITVECTOR_UGT;
const CVC4::Kind BVGE = CVC4::kind::BITVECTOR_UGE;
const CVC4::Kind BVPLUS = CVC4::kind::BITVECTOR_PLUS;
const CVC4::Kind BVSUB = CVC4::kind::BITVECTOR_SUB;
const CVC4::Kind BVCONST = CVC4::kind::CONST_BITVECTOR;
const CVC4::Kind EXTRACT = CVC4::kind::BITVECTOR_EXTRACT;
const CVC4::Kind CONCAT = CVC4::kind::BITVECTOR_CONCAT;
std::string int2string(int n) CVC4_PUBLIC;
typedef enum CVC4_PUBLIC {
CLFLAG_NULL,
CLFLAG_BOOL,
CLFLAG_INT,
CLFLAG_STRING,
CLFLAG_STRVEC
} CLFlagType;
std::ostream& operator<<(std::ostream& out, CLFlagType clft) CVC4_PUBLIC;
class CVC4_PUBLIC CLFlag {
CLFlagType d_tp;
union {
bool b;
int i;
std::string* s;
std::vector<std::pair<std::string,bool> >* sv;
} d_data;
public:
CLFlag(bool b, const std::string& help, bool display = true);
CLFlag(int i, const std::string& help, bool display = true);
CLFlag(const std::string& s, const std::string& help, bool display = true);
CLFlag(const char* s, const std::string& help, bool display = true);
CLFlag(const std::vector<std::pair<std::string,bool> >& sv,
const std::string& help, bool display = true);
CLFlag();
CLFlag(const CLFlag& f);
~CLFlag();
CLFlag& operator=(const CLFlag& f);
CLFlag& operator=(bool b);
CLFlag& operator=(int i);
CLFlag& operator=(const std::string& s);
CLFlag& operator=(const char* s);
CLFlag& operator=(const std::pair<std::string,bool>& p);
CLFlag& operator=(const std::vector<std::pair<std::string,bool> >& sv);
// Accessor methods
CLFlagType getType() const;
bool modified() const;
bool display() const;
// The value accessors return a reference. For the system-wide
// flags, this reference will remain valid throughout the run of the
// program, even if the flag's value changes. So, the reference can
// be cached, and the value can be checked directly (which is more
// efficient).
const bool& getBool() const;
const int& getInt() const;
const std::string& getString() const;
const std::vector<std::pair<std::string,bool> >& getStrVec() const;
const std::string& getHelp() const;
};/* class CLFlag */
// Class CLFlag (for Command Line Flag)
//
// Author: Sergey Berezin
// Date: Fri May 30 14:10:48 2003
//
// Database of command line flags.
class CVC4_PUBLIC CLFlags {
typedef std::map<std::string, CLFlag> FlagMap;
FlagMap d_map;
public:
// Public methods
// Add a new flag. The name must be a complete flag name.
void addFlag(const std::string& name, const CLFlag& f);
// Count how many flags match the name prefix
size_t countFlags(const std::string& name) const;
// Match the name prefix and add all the matching names to the vector
size_t countFlags(const std::string& name,
std::vector<std::string>& names) const;
// Retrieve an existing flag. The 'name' must be a full name of an
// existing flag.
const CLFlag& getFlag(const std::string& name) const;
const CLFlag& operator[](const std::string& name) const;
// Setting the flag to a new value, but preserving the help string.
// The 'name' prefix must uniquely resolve to an existing flag.
void setFlag(const std::string& name, const CLFlag& f);
// Variants of setFlag for all the types
void setFlag(const std::string& name, bool b);
void setFlag(const std::string& name, int i);
void setFlag(const std::string& name, const std::string& s);
void setFlag(const std::string& name, const char* s);
void setFlag(const std::string& name, const std::pair<std::string, bool>& p);
void setFlag(const std::string& name,
const std::vector<std::pair<std::string, bool> >& sv);
};/* class CLFlags */
class CVC4_PUBLIC ExprManager;
class CVC4_PUBLIC Context;
class CVC4_PUBLIC Proof {};
class CVC4_PUBLIC Theorem {};
using CVC4::InputLanguage;
using CVC4::Integer;
using CVC4::Rational;
using CVC4::Exception;
using CVC4::Cardinality;
using namespace CVC4::kind;
typedef size_t ExprIndex;
typedef CVC4::TypeCheckingException TypecheckException;
typedef size_t Unsigned;
static const int READ = ::CVC4::kind::SELECT;
static const int WRITE = ::CVC4::kind::STORE;
// CVC4 has a more sophisticated Cardinality type;
// but we can support comparison against CVC3's more
// coarse-grained Cardinality.
enum CVC4_PUBLIC CVC3CardinalityKind {
CARD_FINITE,
CARD_INFINITE,
CARD_UNKNOWN
};/* enum CVC3CardinalityKind */
std::ostream& operator<<(std::ostream& out, CVC3CardinalityKind c) CVC4_PUBLIC;
bool operator==(const Cardinality& c, CVC3CardinalityKind d) CVC4_PUBLIC;
bool operator==(CVC3CardinalityKind d, const Cardinality& c) CVC4_PUBLIC;
bool operator!=(const Cardinality& c, CVC3CardinalityKind d) CVC4_PUBLIC;
bool operator!=(CVC3CardinalityKind d, const Cardinality& c) CVC4_PUBLIC;
class CVC4_PUBLIC Expr;
template <class T>
class CVC4_PUBLIC ExprMap : public std::map<Expr, T> {
};/* class ExprMap<T> */
template <class T>
class CVC4_PUBLIC ExprHashMap : public std::hash_map<Expr, T, CVC4::ExprHashFunction> {
public:
void insert(Expr a, Expr b);
};/* class ExprHashMap<T> */
class CVC4_PUBLIC Type : public CVC4::Type {
public:
Type();
Type(const CVC4::Type& type);
Type(const Type& type);
Expr getExpr() const;
// Reasoning about children
int arity() const;
Type operator[](int i) const;
// Core testers
bool isBool() const;
bool isSubtype() const;
Cardinality card() const;
Expr enumerateFinite(Unsigned n) const;
Unsigned sizeFinite() const;
// Core constructors
static Type typeBool(ExprManager* em);
static Type funType(const std::vector<Type>& typeDom, const Type& typeRan);
Type funType(const Type& typeRan) const;
};/* class CVC3::Type */
class CVC4_PUBLIC Expr;
typedef Expr Op;
class CVC4_PUBLIC Expr : public CVC4::Expr {
public:
typedef CVC4::Expr::const_iterator iterator;
Expr();
Expr(const Expr& e);
Expr(const CVC4::Expr& e);
Expr(CVC4::Kind k);
// Compound expression constructors
Expr eqExpr(const Expr& right) const;
Expr notExpr() const;
Expr negate() const; // avoid double-negatives
Expr andExpr(const Expr& right) const;
Expr orExpr(const Expr& right) const;
Expr iteExpr(const Expr& thenpart, const Expr& elsepart) const;
Expr iffExpr(const Expr& right) const;
Expr impExpr(const Expr& right) const;
Expr xorExpr(const Expr& right) const;
Expr substExpr(const std::vector<Expr>& oldTerms,
const std::vector<Expr>& newTerms) const;
Expr substExpr(const ExprHashMap<Expr>& oldToNew) const;
Expr operator!() const;
Expr operator&&(const Expr& right) const;
Expr operator||(const Expr& right) const;
static size_t hash(const Expr& e);
size_t hash() const;
// Core expression testers
bool isFalse() const;
bool isTrue() const;
bool isBoolConst() const;
bool isVar() const;
bool isBoundVar() const;
bool isString() const;
bool isSymbol() const;
bool isTerm() const;
bool isType() const;
bool isClosure() const;
bool isQuantifier() const;
bool isForall() const;
bool isExists() const;
bool isLambda() const;
bool isApply() const;
bool isTheorem() const;
bool isConstant() const;
bool isRawList() const;
bool isAtomic() const;
bool isAtomicFormula() const;
bool isAbsAtomicFormula() const;
bool isLiteral() const;
bool isAbsLiteral() const;
bool isBoolConnective() const;
bool isPropLiteral() const;
bool isPropAtom() const;
std::string getName() const;
std::string getUid() const;
std::string getString() const;
std::vector<Expr> getVars() const;
Expr getExistential() const;
int getBoundIndex() const;
Expr getBody() const;
Theorem getTheorem() const;
bool isEq() const;
bool isNot() const;
bool isAnd() const;
bool isOr() const;
bool isITE() const;
bool isIff() const;
bool isImpl() const;
bool isXor() const;
bool isRational() const;
bool isSkolem() const;
const Rational& getRational() const;
Op mkOp() const;
Op getOp() const;
Expr getOpExpr() const;
int getOpKind() const;
Expr getExpr() const;// since people are used to doing getOp().getExpr() in CVC3
std::vector< std::vector<Expr> > getTriggers() const;
// Get the expression manager. The expression must be non-null.
ExprManager* getEM() const;
// Return a ref to the vector of children.
std::vector<Expr> getKids() const;
// Get the index field
ExprIndex getIndex() const;
// Return the number of children. Note, that an application of a
// user-defined function has the arity of that function (the number
// of arguments), and the function name itself is part of the
// operator.
int arity() const;
// Return the ith child. As with arity, it's also the ith argument
// in function application.
Expr operator[](int i) const;
Expr unnegate() const;
// Check if Expr is not Null
bool isInitialized() const;
Type getType() const;
Type lookupType() const;
void pprint() const;
void pprintnodag() const;
};/* class CVC3::Expr */
bool isArrayLiteral(const Expr&) CVC4_PUBLIC;
class CVC4_PUBLIC ExprManager : public CVC4::ExprManager {
public:
std::string getKindName(int kind);
InputLanguage getInputLang() const;
InputLanguage getOutputLang() const;
};/* class CVC3::ExprManager */
typedef CVC4::Statistics Statistics;
#define PRESENTATION_LANG ::CVC4::language::input::LANG_CVC4
#define SMTLIB_LANG ::CVC4::language::input::LANG_SMTLIB_V1
#define SMTLIB_V2_LANG ::CVC4::language::input::LANG_SMTLIB_V2
#define TPTP_LANG ::CVC4::language::input::LANG_TPTP
#define AST_LANG ::CVC4::language::input::LANG_AST
/*****************************************************************************/
/*
* Type for result of queries. VALID and UNSATISFIABLE are treated as
* equivalent, as are SATISFIABLE and INVALID.
*/
/*****************************************************************************/
typedef enum CVC4_PUBLIC QueryResult {
SATISFIABLE = 0,
INVALID = 0,
VALID = 1,
UNSATISFIABLE = 1,
ABORT,
UNKNOWN
} QueryResult;
std::ostream& operator<<(std::ostream& out, QueryResult qr);
std::string QueryResultToString(QueryResult query_result);
/*****************************************************************************/
/*
* Type for truth value of formulas.
*/
/*****************************************************************************/
typedef enum CVC4_PUBLIC FormulaValue {
TRUE_VAL,
FALSE_VAL,
UNKNOWN_VAL
} FormulaValue;
std::ostream& operator<<(std::ostream& out, FormulaValue fv) CVC4_PUBLIC;
/*****************************************************************************/
/*****************************************************************************/
class CVC4_PUBLIC ValidityChecker {
CLFlags* d_clflags;
CVC4::Options d_options;
CVC3::ExprManager* d_em;
std::map<CVC4::ExprManager*, CVC4::ExprManagerMapCollection> d_emmc;
std::set<ValidityChecker*> d_reverseEmmc;
CVC4::SmtEngine* d_smt;
CVC4::parser::Parser* d_parserContext;
std::vector<Expr> d_exprTypeMapRemove;
unsigned d_stackLevel;
friend class Type; // to reach in to d_exprTypeMapRemove
typedef std::hash_map<std::string, const CVC4::Datatype*, CVC4::StringHashFunction> ConstructorMap;
typedef std::hash_map<std::string, std::pair<const CVC4::Datatype*, std::string>, CVC4::StringHashFunction> SelectorMap;
ConstructorMap d_constructors;
SelectorMap d_selectors;
ValidityChecker(const CLFlags& clflags);
void setUpOptions(CVC4::Options& options, const CLFlags& clflags);
// helper function for bitvectors
Expr bvpad(int len, const Expr& e);
public:
ValidityChecker();
virtual ~ValidityChecker();
virtual CLFlags& getFlags() const;
virtual void reprocessFlags();
/***************************************************************************/
/*
* Static methods
*/
/***************************************************************************/
static CLFlags createFlags();
static ValidityChecker* create(const CLFlags& flags);
static ValidityChecker* create();
/***************************************************************************/
/***************************************************************************/
// Basic types
virtual Type boolType();
virtual Type realType();
virtual Type intType();
virtual Type subrangeType(const Expr& l, const Expr& r);
virtual Type subtypeType(const Expr& pred, const Expr& witness);
// Tuple types
virtual Type tupleType(const Type& type0, const Type& type1);
virtual Type tupleType(const Type& type0, const Type& type1,
const Type& type2);
virtual Type tupleType(const std::vector<Type>& types);
// Record types
virtual Type recordType(const std::string& field, const Type& type);
virtual Type recordType(const std::string& field0, const Type& type0,
const std::string& field1, const Type& type1);
virtual Type recordType(const std::string& field0, const Type& type0,
const std::string& field1, const Type& type1,
const std::string& field2, const Type& type2);
virtual Type recordType(const std::vector<std::string>& fields,
const std::vector<Type>& types);
// Datatypes
virtual Type dataType(const std::string& name,
const std::string& constructor,
const std::vector<std::string>& selectors,
const std::vector<Expr>& types);
virtual Type dataType(const std::string& name,
const std::vector<std::string>& constructors,
const std::vector<std::vector<std::string> >& selectors,
const std::vector<std::vector<Expr> >& types);
virtual void dataType(const std::vector<std::string>& names,
const std::vector<std::vector<std::string> >& constructors,
const std::vector<std::vector<std::vector<std::string> > >& selectors,
const std::vector<std::vector<std::vector<Expr> > >& types,
std::vector<Type>& returnTypes);
virtual Type arrayType(const Type& typeIndex, const Type& typeData);
virtual Type bitvecType(int n);
virtual Type funType(const Type& typeDom, const Type& typeRan);
virtual Type funType(const std::vector<Type>& typeDom, const Type& typeRan);
virtual Type createType(const std::string& typeName);
virtual Type createType(const std::string& typeName, const Type& def);
virtual Type lookupType(const std::string& typeName);
// End of Type-related methods
/***************************************************************************/
/***************************************************************************/
virtual ExprManager* getEM();
virtual Expr varExpr(const std::string& name, const Type& type);
virtual Expr varExpr(const std::string& name, const Type& type,
const Expr& def);
virtual Expr lookupVar(const std::string& name, Type* type);
virtual Type getType(const Expr& e);
virtual Type getBaseType(const Expr& e);
virtual Type getBaseType(const Type& t);
virtual Expr getTypePred(const Type&t, const Expr& e);
virtual Expr stringExpr(const std::string& str);
virtual Expr idExpr(const std::string& name);
virtual Expr listExpr(const std::vector<Expr>& kids);
virtual Expr listExpr(const Expr& e1);
virtual Expr listExpr(const Expr& e1, const Expr& e2);
virtual Expr listExpr(const Expr& e1, const Expr& e2, const Expr& e3);
virtual Expr listExpr(const std::string& op,
const std::vector<Expr>& kids);
virtual Expr listExpr(const std::string& op, const Expr& e1);
virtual Expr listExpr(const std::string& op, const Expr& e1,
const Expr& e2);
virtual Expr listExpr(const std::string& op, const Expr& e1,
const Expr& e2, const Expr& e3);
virtual void printExpr(const Expr& e);
virtual void printExpr(const Expr& e, std::ostream& os);
virtual Expr parseExpr(const Expr& e);
virtual Type parseType(const Expr& e);
virtual Expr importExpr(const Expr& e);
virtual Type importType(const Type& t);
virtual void cmdsFromString(const std::string& s,
InputLanguage lang = PRESENTATION_LANG);
virtual Expr exprFromString(const std::string& e,
InputLanguage lang = PRESENTATION_LANG);
// End of General Expr Methods
/***************************************************************************/
/***************************************************************************/
virtual Expr trueExpr();
virtual Expr falseExpr();
virtual Expr notExpr(const Expr& child);
virtual Expr andExpr(const Expr& left, const Expr& right);
virtual Expr andExpr(const std::vector<Expr>& children);
virtual Expr orExpr(const Expr& left, const Expr& right);
virtual Expr orExpr(const std::vector<Expr>& children);
virtual Expr impliesExpr(const Expr& hyp, const Expr& conc);
virtual Expr iffExpr(const Expr& left, const Expr& right);
virtual Expr eqExpr(const Expr& child0, const Expr& child1);
virtual Expr iteExpr(const Expr& ifpart, const Expr& thenpart,
const Expr& elsepart);
virtual Expr distinctExpr(const std::vector<Expr>& children);
// End of Core expression methods
/***************************************************************************/
/***************************************************************************/
virtual Op createOp(const std::string& name, const Type& type);
virtual Op createOp(const std::string& name, const Type& type,
const Expr& def);
virtual Op lookupOp(const std::string& name, Type* type);
virtual Expr funExpr(const Op& op, const Expr& child);
virtual Expr funExpr(const Op& op, const Expr& left, const Expr& right);
virtual Expr funExpr(const Op& op, const Expr& child0,
const Expr& child1, const Expr& child2);
virtual Expr funExpr(const Op& op, const std::vector<Expr>& children);
// End of User-defined (uninterpreted) function methods
/***************************************************************************/
/***************************************************************************/
virtual bool addPairToArithOrder(const Expr& smaller, const Expr& bigger);
virtual Expr ratExpr(int n, int d = 1);
virtual Expr ratExpr(const std::string& n, const std::string& d, int base);
virtual Expr ratExpr(const std::string& n, int base = 10);
virtual Expr uminusExpr(const Expr& child);
virtual Expr plusExpr(const Expr& left, const Expr& right);
virtual Expr plusExpr(const std::vector<Expr>& children);
virtual Expr minusExpr(const Expr& left, const Expr& right);
virtual Expr multExpr(const Expr& left, const Expr& right);
virtual Expr powExpr(const Expr& x, const Expr& n);
virtual Expr divideExpr(const Expr& numerator, const Expr& denominator);
virtual Expr ltExpr(const Expr& left, const Expr& right);
virtual Expr leExpr(const Expr& left, const Expr& right);
virtual Expr gtExpr(const Expr& left, const Expr& right);
virtual Expr geExpr(const Expr& left, const Expr& right);
// End of Arithmetic expression methods
/***************************************************************************/
/***************************************************************************/
virtual Expr recordExpr(const std::string& field, const Expr& expr);
virtual Expr recordExpr(const std::string& field0, const Expr& expr0,
const std::string& field1, const Expr& expr1);
virtual Expr recordExpr(const std::string& field0, const Expr& expr0,
const std::string& field1, const Expr& expr1,
const std::string& field2, const Expr& expr2);
virtual Expr recordExpr(const std::vector<std::string>& fields,
const std::vector<Expr>& exprs);
virtual Expr recSelectExpr(const Expr& record, const std::string& field);
virtual Expr recUpdateExpr(const Expr& record, const std::string& field,
const Expr& newValue);
// End of Record expression methods
/***************************************************************************/
/***************************************************************************/
virtual Expr readExpr(const Expr& array, const Expr& index);
virtual Expr writeExpr(const Expr& array, const Expr& index,
const Expr& newValue);
// End of Array expression methods
/***************************************************************************/
/***************************************************************************/
// Bitvector constants
// From a string of digits in a given base
virtual Expr newBVConstExpr(const std::string& s, int base = 2);
// From a vector of bools
virtual Expr newBVConstExpr(const std::vector<bool>& bits);
// From a rational: bitvector is of length 'len', or the min. needed length when len=0.
virtual Expr newBVConstExpr(const Rational& r, int len = 0);
// Concat and extract
virtual Expr newConcatExpr(const Expr& t1, const Expr& t2);
virtual Expr newConcatExpr(const std::vector<Expr>& kids);
virtual Expr newBVExtractExpr(const Expr& e, int hi, int low);
// Bitwise Boolean operators: Negation, And, Nand, Or, Nor, Xor, Xnor
virtual Expr newBVNegExpr(const Expr& t1);
virtual Expr newBVAndExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVAndExpr(const std::vector<Expr>& kids);
virtual Expr newBVOrExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVOrExpr(const std::vector<Expr>& kids);
virtual Expr newBVXorExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVXorExpr(const std::vector<Expr>& kids);
virtual Expr newBVXnorExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVXnorExpr(const std::vector<Expr>& kids);
virtual Expr newBVNandExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVNorExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVCompExpr(const Expr& t1, const Expr& t2);
// Unsigned bitvector inequalities
virtual Expr newBVLTExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVLEExpr(const Expr& t1, const Expr& t2);
// Signed bitvector inequalities
virtual Expr newBVSLTExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVSLEExpr(const Expr& t1, const Expr& t2);
// Sign-extend t1 to a total of len bits
virtual Expr newSXExpr(const Expr& t1, int len);
// Bitvector arithmetic: unary minus, plus, subtract, multiply
virtual Expr newBVUminusExpr(const Expr& t1);
virtual Expr newBVSubExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVPlusExpr(int numbits, const std::vector<Expr>& k);
virtual Expr newBVPlusExpr(int numbits, const Expr& t1, const Expr& t2);
virtual Expr newBVMultExpr(int numbits,
const Expr& t1, const Expr& t2);
virtual Expr newBVUDivExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVURemExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVSDivExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVSRemExpr(const Expr& t1, const Expr& t2);
virtual Expr newBVSModExpr(const Expr& t1, const Expr& t2);
// Left shift by r bits: result is old size + r bits
virtual Expr newFixedLeftShiftExpr(const Expr& t1, int r);
// Left shift by r bits: result is same size as t1
virtual Expr newFixedConstWidthLeftShiftExpr(const Expr& t1, int r);
// Logical right shift by r bits: result is same size as t1
virtual Expr newFixedRightShiftExpr(const Expr& t1, int r);
// Left shift with shift parameter an arbitrary bit-vector expr
virtual Expr newBVSHL(const Expr& t1, const Expr& t2);
// Logical right shift with shift parameter an arbitrary bit-vector expr
virtual Expr newBVLSHR(const Expr& t1, const Expr& t2);
// Arithmetic right shift with shift parameter an arbitrary bit-vector expr
virtual Expr newBVASHR(const Expr& t1, const Expr& t2);
// Get value of BV Constant
virtual Rational computeBVConst(const Expr& e);
// End of Bitvector expression methods
/***************************************************************************/
/***************************************************************************/
virtual Expr tupleExpr(const std::vector<Expr>& exprs);
virtual Expr tupleSelectExpr(const Expr& tuple, int index);
virtual Expr tupleUpdateExpr(const Expr& tuple, int index,
const Expr& newValue);
virtual Expr datatypeConsExpr(const std::string& constructor, const std::vector<Expr>& args);
virtual Expr datatypeSelExpr(const std::string& selector, const Expr& arg);
virtual Expr datatypeTestExpr(const std::string& constructor, const Expr& arg);
virtual Expr boundVarExpr(const std::string& name,
const std::string& uid,
const Type& type);
virtual Expr forallExpr(const std::vector<Expr>& vars, const Expr& body);
virtual Expr forallExpr(const std::vector<Expr>& vars, const Expr& body,
const Expr& trigger);
virtual Expr forallExpr(const std::vector<Expr>& vars, const Expr& body,
const std::vector<Expr>& triggers);
virtual Expr forallExpr(const std::vector<Expr>& vars, const Expr& body,
const std::vector<std::vector<Expr> >& triggers);
virtual void setTriggers(const Expr& e, const std::vector<std::vector<Expr> > & triggers);
virtual void setTriggers(const Expr& e, const std::vector<Expr>& triggers);
virtual void setTrigger(const Expr& e, const Expr& trigger);
virtual void setMultiTrigger(const Expr& e, const std::vector<Expr>& multiTrigger);
virtual Expr existsExpr(const std::vector<Expr>& vars, const Expr& body);
virtual Op lambdaExpr(const std::vector<Expr>& vars, const Expr& body);
virtual Op transClosure(const Op& op);
virtual Expr simulateExpr(const Expr& f, const Expr& s0,
const std::vector<Expr>& inputs,
const Expr& n);
// End of Other expression methods
/***************************************************************************/
/***************************************************************************/
virtual void setResourceLimit(unsigned limit);
virtual void setTimeLimit(unsigned limit);
virtual void assertFormula(const Expr& e);
virtual void registerAtom(const Expr& e);
virtual Expr getImpliedLiteral();
virtual Expr simplify(const Expr& e);
virtual QueryResult query(const Expr& e);
virtual QueryResult checkUnsat(const Expr& e);
virtual QueryResult checkContinue();
virtual QueryResult restart(const Expr& e);
virtual void returnFromCheck();
virtual void getUserAssumptions(std::vector<Expr>& assumptions);
virtual void getInternalAssumptions(std::vector<Expr>& assumptions);
virtual void getAssumptions(std::vector<Expr>& assumptions);
virtual void getAssumptionsUsed(std::vector<Expr>& assumptions);
virtual Expr getProofQuery();
virtual void getCounterExample(std::vector<Expr>& assumptions,
bool inOrder=true);
virtual void getConcreteModel(ExprMap<Expr> & m);
virtual QueryResult tryModelGeneration();
//:ALEX: returns the current truth value of a formula
// returns UNKNOWN_VAL if e is not associated
// with a boolean variable in the SAT module,
// i.e. if its value can not determined without search.
virtual FormulaValue value(const Expr& e);
virtual bool inconsistent(std::vector<Expr>& assumptions);
virtual bool inconsistent();
virtual bool incomplete();
virtual bool incomplete(std::vector<std::string>& reasons);
virtual Proof getProof();
virtual Expr getValue(const Expr& e);
virtual Expr getTCC();
virtual void getAssumptionsTCC(std::vector<Expr>& assumptions);
virtual Proof getProofTCC();
virtual Expr getClosure();
virtual Proof getProofClosure();
// End of Validity checking methods
/***************************************************************************/
/***************************************************************************/
virtual int stackLevel();
virtual void push();
virtual void pop();
virtual void popto(int stackLevel);
virtual int scopeLevel();
virtual void pushScope();
virtual void popScope();
virtual void poptoScope(int scopeLevel);
virtual Context* getCurrentContext();
virtual void reset();
virtual void logAnnotation(const Expr& annot);
// End of Context methods
/***************************************************************************/
/***************************************************************************/
virtual void loadFile(const std::string& fileName,
InputLanguage lang = PRESENTATION_LANG,
bool interactive = false,
bool calledFromParser = false);
virtual void loadFile(std::istream& is,
InputLanguage lang = PRESENTATION_LANG,
bool interactive = false);
// End of methods for reading files
/***************************************************************************/
/***************************************************************************/
virtual Statistics getStatistics();
virtual void printStatistics();
// End of Statistics Methods
};/* class ValidityChecker */
template <class T>
void ExprHashMap<T>::insert(Expr a, Expr b) {
(*this)[a] = b;
}
// Comparison (the way that CVC3 does it)
int compare(const Expr& e1, const Expr& e2);
}/* CVC3 namespace */
#endif /* _cvc3__include__vc_h_ */
#endif /* __CVC4__CVC3_COMPAT_H */
Context
void * Context
Definition c_interface_defs.h:42
CVC3::CLFlag
Definition cvc3_compat.h:110
CVC3::CLFlag::~CLFlag
~CLFlag()
Destructor.
CVC3::CLFlag::s
std::string * s
Definition cvc3_compat.h:117
CVC3::CLFlag::getInt
const int & getInt() const
CVC3::CLFlag::getBool
const bool & getBool() const
CVC3::CLFlag::CLFlag
CLFlag(const char *s, const std::string &help, bool display=true)
Constructor for a string flag from char*.
CVC3::CLFlag::sv
std::vector< std::pair< std::string, bool > > * sv
Definition cvc3_compat.h:118
CVC3::CLFlag::b
bool b
Definition cvc3_compat.h:115
CVC3::CLFlag::CLFlag
CLFlag(int i, const std::string &help, bool display=true)
Constructor for an integer flag.
CVC3::CLFlag::getType
CLFlagType getType() const
Return the type of the flag.
CVC3::CLFlag::operator=
CLFlag & operator=(int i)
Assignment of an integer value.
CVC3::CLFlag::i
int i
Definition cvc3_compat.h:116
CVC3::CLFlag::operator=
CLFlag & operator=(const std::string &s)
Assignment of a string value.
CVC3::CLFlag::operator=
CLFlag & operator=(const std::vector< std::pair< std::string, bool > > &sv)
Assignment of a vector value.
CVC3::CLFlag::CLFlag
CLFlag()
Default constructor.
CVC3::CLFlag::operator=
CLFlag & operator=(bool b)
Assignment of a boolean value.
CVC3::CLFlag::getStrVec
const std::vector< std::pair< std::string, bool > > & getStrVec() const
CVC3::CLFlag::CLFlag
CLFlag(const std::vector< std::pair< std::string, bool > > &sv, const std::string &help, bool display=true)
Constructor for a vector flag.
CVC3::CLFlag::CLFlag
CLFlag(const CLFlag &f)
Copy constructor.
CVC3::CLFlag::display
bool display() const
Return true if flag should be displayed in regular help.
CVC3::CLFlag::CLFlag
CLFlag(bool b, const std::string &help, bool display=true)
Constructor for a boolean flag.
CVC3::CLFlag::getString
const std::string & getString() const
CVC3::CLFlag::operator=
CLFlag & operator=(const CLFlag &f)
Assignment from another flag.
CVC3::CLFlag::modified
bool modified() const
Return true if the flag was modified from the default value (e.g. set on the command line)
CVC3::CLFlag::operator=
CLFlag & operator=(const std::pair< std::string, bool > &p)
Assignment of a string value with a boolean tag to a vector flag.
CVC3::CLFlag::getHelp
const std::string & getHelp() const
CVC3::CLFlag::CLFlag
CLFlag(const std::string &s, const std::string &help, bool display=true)
Constructor for a string flag.
CVC3::CLFlag::operator=
CLFlag & operator=(const char *s)
Assignment of an string value from char*.
CVC3::CLFlags
Definition cvc3_compat.h:198
CVC3::CLFlags::setFlag
void setFlag(const std::string &name, const std::pair< std::string, bool > &p)
CVC3::CLFlags::setFlag
void setFlag(const std::string &name, const CLFlag &f)
CVC3::CLFlags::operator[]
const CLFlag & operator[](const std::string &name) const
CVC3::CLFlags::addFlag
void addFlag(const std::string &name, const CLFlag &f)
CVC3::CLFlags::setFlag
void setFlag(const std::string &name, const std::vector< std::pair< std::string, bool > > &sv)
CVC3::CLFlags::setFlag
void setFlag(const std::string &name, bool b)
CVC3::CLFlags::countFlags
size_t countFlags(const std::string &name, std::vector< std::string > &names) const
CVC3::CLFlags::countFlags
size_t countFlags(const std::string &name) const
CVC3::CLFlags::setFlag
void setFlag(const std::string &name, const char *s)
CVC3::CLFlags::getFlag
const CLFlag & getFlag(const std::string &name) const
CVC3::CLFlags::setFlag
void setFlag(const std::string &name, const std::string &s)
CVC3::CLFlags::setFlag
void setFlag(const std::string &name, int i)
CVC3::ExprHashMap
Definition cvc3_compat.h:274
CVC3::ExprHashMap::insert
void insert(Expr a, Expr b)
Definition cvc3_compat.h:1556
CVC3::ExprManager
Definition cvc3_compat.h:453
CVC3::ExprManager::getKindName
std::string getKindName(int kind)
CVC3::ExprManager::getOutputLang
InputLanguage getOutputLang() const
Get the output language for printing.
CVC3::ExprManager::getInputLang
InputLanguage getInputLang() const
Get the input language for printing.
CVC3::ExprMap
Definition cvc3_compat.h:270
CVC3::Expr
Expr class for CVC3 compatibility layer.
Definition cvc3_compat.h:319
CVC3::Expr::isAnd
bool isAnd() const
CVC3::Expr::getExistential
Expr getExistential() const
CVC3::Expr::isInitialized
bool isInitialized() const
CVC3::Expr::getRational
const Rational & getRational() const
CVC3::Expr::iteExpr
Expr iteExpr(const Expr &thenpart, const Expr &elsepart) const
CVC3::Expr::iterator
CVC4::Expr::const_iterator iterator
Definition cvc3_compat.h:321
CVC3::Expr::getOpExpr
Expr getOpExpr() const
CVC3::Expr::isLiteral
bool isLiteral() const
CVC3::Expr::isImpl
bool isImpl() const
CVC3::Expr::Expr
Expr(const CVC4::Expr &e)
CVC3::Expr::getType
Type getType() const
Get the type. Recursively compute if necessary.
CVC3::Expr::isEq
bool isEq() const
CVC3::Expr::getVars
std::vector< Expr > getVars() const
CVC3::Expr::isBoolConnective
bool isBoolConnective() const
CVC3::Expr::operator||
Expr operator||(const Expr &right) const
CVC3::Expr::isRational
bool isRational() const
CVC3::Expr::isString
bool isString() const
CVC3::Expr::isBoundVar
bool isBoundVar() const
CVC3::Expr::operator[]
Expr operator[](int i) const
CVC3::Expr::negate
Expr negate() const
CVC3::Expr::substExpr
Expr substExpr(const std::vector< Expr > &oldTerms, const std::vector< Expr > &newTerms) const
CVC3::Expr::isQuantifier
bool isQuantifier() const
CVC3::Expr::andExpr
Expr andExpr(const Expr &right) const
CVC3::Expr::isAtomicFormula
bool isAtomicFormula() const
CVC3::Expr::notExpr
Expr notExpr() const
CVC3::Expr::isForall
bool isForall() const
CVC3::Expr::operator&&
Expr operator&&(const Expr &right) const
CVC3::Expr::isFalse
bool isFalse() const
CVC3::Expr::getString
std::string getString() const
CVC3::Expr::isApply
bool isApply() const
CVC3::Expr::pprintnodag
void pprintnodag() const
Pretty-print without dagifying.
CVC3::Expr::getExpr
Expr getExpr() const
CVC3::Expr::isNot
bool isNot() const
CVC3::Expr::getName
std::string getName() const
CVC3::Expr::isRawList
bool isRawList() const
CVC3::Expr::isTheorem
bool isTheorem() const
CVC3::Expr::isPropLiteral
bool isPropLiteral() const
CVC3::Expr::getEM
ExprManager * getEM() const
CVC3::Expr::iffExpr
Expr iffExpr(const Expr &right) const
CVC3::Expr::isIff
bool isIff() const
CVC3::Expr::isClosure
bool isClosure() const
CVC3::Expr::hash
static size_t hash(const Expr &e)
CVC3::Expr::getTriggers
std::vector< std::vector< Expr > > getTriggers() const
Get the manual triggers of the closure Expr.
CVC3::Expr::isXor
bool isXor() const
CVC3::Expr::substExpr
Expr substExpr(const ExprHashMap< Expr > &oldToNew) const
CVC3::Expr::isPropAtom
bool isPropAtom() const
CVC3::Expr::getIndex
ExprIndex getIndex() const
CVC3::Expr::isSymbol
bool isSymbol() const
CVC3::Expr::lookupType
Type lookupType() const
Look up the current type. Do not recursively compute (i.e. may be NULL)
CVC3::Expr::isTrue
bool isTrue() const
CVC3::Expr::isAtomic
bool isAtomic() const
CVC3::Expr::Expr
Expr(const Expr &e)
CVC3::Expr::isAbsLiteral
bool isAbsLiteral() const
CVC3::Expr::xorExpr
Expr xorExpr(const Expr &right) const
CVC3::Expr::mkOp
Op mkOp() const
CVC3::Expr::isSkolem
bool isSkolem() const
CVC3::Expr::isOr
bool isOr() const
CVC3::Expr::getOp
Op getOp() const
CVC3::Expr::pprint
void pprint() const
Pretty-print the expression.
CVC3::Expr::getBoundIndex
int getBoundIndex() const
CVC3::Expr::isLambda
bool isLambda() const
CVC3::Expr::isBoolConst
bool isBoolConst() const
CVC3::Expr::unnegate
Expr unnegate() const
Remove leading NOT if any.
CVC3::Expr::isTerm
bool isTerm() const
CVC3::Expr::Expr
Expr(CVC4::Kind k)
CVC3::Expr::orExpr
Expr orExpr(const Expr &right) const
CVC3::Expr::getBody
Expr getBody() const
CVC3::Expr::getTheorem
Theorem getTheorem() const
CVC3::Expr::getKids
std::vector< Expr > getKids() const
CVC3::Expr::eqExpr
Expr eqExpr(const Expr &right) const
CVC3::Expr::isITE
bool isITE() const
CVC3::Expr::isAbsAtomicFormula
bool isAbsAtomicFormula() const
CVC3::Expr::arity
int arity() const
CVC3::Expr::getOpKind
int getOpKind() const
CVC3::Expr::isConstant
bool isConstant() const
CVC3::Expr::isVar
bool isVar() const
CVC3::Expr::getUid
std::string getUid() const
CVC3::Expr::isExists
bool isExists() const
CVC3::Expr::operator!
Expr operator!() const
CVC3::Expr::impExpr
Expr impExpr(const Expr &right) const
CVC3::Expr::isType
bool isType() const
CVC3::Expr::hash
size_t hash() const
CVC3::Expr::Expr
Expr()
CVC3::Proof
Definition cvc3_compat.h:234
CVC3::Theorem
Definition cvc3_compat.h:235
CVC3::Type
Definition cvc3_compat.h:279
CVC3::Type::operator[]
Type operator[](int i) const
CVC3::Type::Type
Type()
CVC3::Type::Type
Type(const Type &type)
CVC3::Type::getExpr
Expr getExpr() const
CVC3::Type::Type
Type(const CVC4::Type &type)
CVC3::Type::typeBool
static Type typeBool(ExprManager *em)
CVC3::Type::funType
static Type funType(const std::vector< Type > &typeDom, const Type &typeRan)
CVC3::Type::enumerateFinite
Expr enumerateFinite(Unsigned n) const
Return nth (starting with 0) element in a finite type.
CVC3::Type::isBool
bool isBool() const
CVC3::Type::funType
Type funType(const Type &typeRan) const
CVC3::Type::isSubtype
bool isSubtype() const
CVC3::Type::card
Cardinality card() const
Return cardinality of type.
CVC3::Type::arity
int arity() const
CVC3::Type::sizeFinite
Unsigned sizeFinite() const
Return size of a finite type; returns 0 if size cannot be determined.
CVC3::ValidityChecker
CVC3 API (compatibility layer for CVC4)
Definition cvc3_compat.h:514
CVC3::ValidityChecker::newBVCompExpr
virtual Expr newBVCompExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::stringExpr
virtual Expr stringExpr(const std::string &str)
Create a string Expr.
CVC3::ValidityChecker::ratExpr
virtual Expr ratExpr(const std::string &n, const std::string &d, int base)
Create a rational number with numerator n and denominator d.
CVC3::ValidityChecker::newBVExtractExpr
virtual Expr newBVExtractExpr(const Expr &e, int hi, int low)
CVC3::ValidityChecker::getFlags
virtual CLFlags & getFlags() const
Return the set of command-line flags.
CVC3::ValidityChecker::reprocessFlags
virtual void reprocessFlags()
Force reprocessing of all flags.
CVC3::ValidityChecker::newBVSDivExpr
virtual Expr newBVSDivExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::createType
virtual Type createType(const std::string &typeName, const Type &def)
Create named user-defined interpreted type (type abbreviation)
CVC3::ValidityChecker::datatypeTestExpr
virtual Expr datatypeTestExpr(const std::string &constructor, const Expr &arg)
Datatype tester expression.
CVC3::ValidityChecker::lookupVar
virtual Expr lookupVar(const std::string &name, Type *type)
Get the variable associated with a name, and its type.
CVC3::ValidityChecker::newBVNegExpr
virtual Expr newBVNegExpr(const Expr &t1)
CVC3::ValidityChecker::ValidityChecker
ValidityChecker()
Constructor.
CVC3::ValidityChecker::logAnnotation
virtual void logAnnotation(const Expr &annot)
Add an annotation to the current script - prints annot when translating.
CVC3::ValidityChecker::recordType
virtual Type recordType(const std::vector< std::string > &fields, const std::vector< Type > &types)
n-element record (fields and types must be of the same length)
CVC3::ValidityChecker::funExpr
virtual Expr funExpr(const Op &op, const Expr &child0, const Expr &child1, const Expr &child2)
Ternary function application (op must be of function type)
CVC3::ValidityChecker::falseExpr
virtual Expr falseExpr()
Return FALSE Expr.
CVC3::ValidityChecker::setTriggers
virtual void setTriggers(const Expr &e, const std::vector< std::vector< Expr > > &triggers)
Set triggers for quantifier instantiation.
CVC3::ValidityChecker::create
static ValidityChecker * create()
Create an instance of ValidityChecker using default flag values.
CVC3::ValidityChecker::registerAtom
virtual void registerAtom(const Expr &e)
Register an atomic formula of interest.
CVC3::ValidityChecker::popScope
virtual void popScope()
Restore the current context to its state at the last internal checkpoint. Do not use unless you know ...
CVC3::ValidityChecker::parseExpr
virtual Expr parseExpr(const Expr &e)
Parse an expression using a Theory-specific parser.
CVC3::ValidityChecker::setTimeLimit
virtual void setTimeLimit(unsigned limit)
Set a time limit in tenth of a second,.
CVC3::ValidityChecker::getTCC
virtual Expr getTCC()
Returns the TCC of the last assumption or query.
CVC3::ValidityChecker::dataType
virtual Type dataType(const std::string &name, const std::vector< std::string > &constructors, const std::vector< std::vector< std::string > > &selectors, const std::vector< std::vector< Expr > > &types)
Single datatype, multiple constructors.
CVC3::ValidityChecker::getConcreteModel
virtual void getConcreteModel(ExprMap< Expr > &m)
Will assign concrete values to all user created variables.
CVC3::ValidityChecker::checkContinue
virtual QueryResult checkContinue()
Get the next model.
CVC3::ValidityChecker::writeExpr
virtual Expr writeExpr(const Expr &array, const Expr &index, const Expr &newValue)
Array update; equivalent to "array WITH index := newValue".
CVC3::ValidityChecker::restart
virtual QueryResult restart(const Expr &e)
Restart the most recent query with e as an additional assertion.
CVC3::ValidityChecker::listExpr
virtual Expr listExpr(const std::vector< Expr > &kids)
Create a list Expr.
CVC3::ValidityChecker::arrayType
virtual Type arrayType(const Type &typeIndex, const Type &typeData)
Create an array type (ARRAY typeIndex OF typeData)
CVC3::ValidityChecker::andExpr
virtual Expr andExpr(const std::vector< Expr > &children)
Create n-element conjunction.
CVC3::ValidityChecker::multExpr
virtual Expr multExpr(const Expr &left, const Expr &right)
Create a product (left * right)
CVC3::ValidityChecker::newBVOrExpr
virtual Expr newBVOrExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::newBVPlusExpr
virtual Expr newBVPlusExpr(int numbits, const std::vector< Expr > &k)
'numbits' is the number of bits in the result
CVC3::ValidityChecker::listExpr
virtual Expr listExpr(const Expr &e1)
Overloaded version of listExpr with one argument.
CVC3::ValidityChecker::reset
virtual void reset()
Destroy and recreate validity checker: resets everything except for flags.
CVC3::ValidityChecker::poptoScope
virtual void poptoScope(int scopeLevel)
Restore the current context to the given scopeLevel.
CVC3::ValidityChecker::recordType
virtual Type recordType(const std::string &field0, const Type &type0, const std::string &field1, const Type &type1, const std::string &field2, const Type &type2)
3-element record
CVC3::ValidityChecker::newBVOrExpr
virtual Expr newBVOrExpr(const std::vector< Expr > &kids)
CVC3::ValidityChecker::inconsistent
virtual bool inconsistent()
Returns true if the current context is inconsistent.
CVC3::ValidityChecker::ratExpr
virtual Expr ratExpr(const std::string &n, int base=10)
Create a rational from a single string.
CVC3::ValidityChecker::getCounterExample
virtual void getCounterExample(std::vector< Expr > &assumptions, bool inOrder=true)
Return the internal assumptions that make the queried formula false.
CVC3::ValidityChecker::pop
virtual void pop()
Restore the current context to its state at the last checkpoint.
CVC3::ValidityChecker::lambdaExpr
virtual Op lambdaExpr(const std::vector< Expr > &vars, const Expr &body)
Lambda-expression.
CVC3::ValidityChecker::newBVSModExpr
virtual Expr newBVSModExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::newBVPlusExpr
virtual Expr newBVPlusExpr(int numbits, const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::forallExpr
virtual Expr forallExpr(const std::vector< Expr > &vars, const Expr &body, const std::vector< std::vector< Expr > > &triggers)
Universal quantifier with a set of multi-triggers.
CVC3::ValidityChecker::printStatistics
virtual void printStatistics()
Print collected statistics to stdout.
CVC3::ValidityChecker::minusExpr
virtual Expr minusExpr(const Expr &left, const Expr &right)
Make a difference (left - right)
CVC3::ValidityChecker::listExpr
virtual Expr listExpr(const std::string &op, const Expr &e1)
Overloaded version of listExpr with string operator and one argument.
CVC3::ValidityChecker::createOp
virtual Op createOp(const std::string &name, const Type &type)
Create a named uninterpreted function with a given type.
CVC3::ValidityChecker::newFixedConstWidthLeftShiftExpr
virtual Expr newFixedConstWidthLeftShiftExpr(const Expr &t1, int r)
CVC3::ValidityChecker::pushScope
virtual void pushScope()
Checkpoint the current context and increase the internal scope level. Do not use unless you know what...
CVC3::ValidityChecker::~ValidityChecker
virtual ~ValidityChecker()
Destructor.
CVC3::ValidityChecker::forallExpr
virtual Expr forallExpr(const std::vector< Expr > &vars, const Expr &body, const std::vector< Expr > &triggers)
Universal quantifier with a set of triggers.
CVC3::ValidityChecker::create
static ValidityChecker * create(const CLFlags &flags)
Create an instance of ValidityChecker.
CVC3::ValidityChecker::newBVConstExpr
virtual Expr newBVConstExpr(const std::string &s, int base=2)
CVC3::ValidityChecker::newBVSubExpr
virtual Expr newBVSubExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::uminusExpr
virtual Expr uminusExpr(const Expr &child)
Unary minus.
CVC3::ValidityChecker::incomplete
virtual bool incomplete(std::vector< std::string > &reasons)
Returns true if the invalid result from last query() is imprecise.
CVC3::ValidityChecker::subrangeType
virtual Type subrangeType(const Expr &l, const Expr &r)
Create a subrange type [l..r].
CVC3::ValidityChecker::varExpr
virtual Expr varExpr(const std::string &name, const Type &type, const Expr &def)
Create a variable with a given name, type, and value.
CVC3::ValidityChecker::newBVASHR
virtual Expr newBVASHR(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::dataType
virtual Type dataType(const std::string &name, const std::string &constructor, const std::vector< std::string > &selectors, const std::vector< Expr > &types)
Single datatype, single constructor.
CVC3::ValidityChecker::divideExpr
virtual Expr divideExpr(const Expr &numerator, const Expr &denominator)
Create expression x / y.
CVC3::ValidityChecker::createType
virtual Type createType(const std::string &typeName)
Create named user-defined uninterpreted type.
CVC3::ValidityChecker::idExpr
virtual Expr idExpr(const std::string &name)
Create an ID Expr.
CVC3::ValidityChecker::assertFormula
virtual void assertFormula(const Expr &e)
Assert a new formula in the current context.
CVC3::ValidityChecker::setTrigger
virtual void setTrigger(const Expr &e, const Expr &trigger)
Set a single trigger for quantifier instantiation.
CVC3::ValidityChecker::tupleType
virtual Type tupleType(const Type &type0, const Type &type1)
2-element tuple
CVC3::ValidityChecker::newBVXorExpr
virtual Expr newBVXorExpr(const std::vector< Expr > &kids)
CVC3::ValidityChecker::varExpr
virtual Expr varExpr(const std::string &name, const Type &type)
Create a variable with a given name and type.
CVC3::ValidityChecker::recordType
virtual Type recordType(const std::string &field0, const Type &type0, const std::string &field1, const Type &type1)
2-element record
CVC3::ValidityChecker::funType
virtual Type funType(const Type &typeDom, const Type &typeRan)
Create a function type typeDom -> typeRan.
CVC3::ValidityChecker::newBVSRemExpr
virtual Expr newBVSRemExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::recordExpr
virtual Expr recordExpr(const std::string &field, const Expr &expr)
Create a 1-element record value (# field := expr #)
CVC3::ValidityChecker::getProof
virtual Proof getProof()
Returns the proof term for the last proven query.
CVC3::ValidityChecker::listExpr
virtual Expr listExpr(const Expr &e1, const Expr &e2, const Expr &e3)
Overloaded version of listExpr with three arguments.
CVC3::ValidityChecker::tupleSelectExpr
virtual Expr tupleSelectExpr(const Expr &tuple, int index)
Tuple select; equivalent to "tuple.n", where n is an numeral (e.g. tup.5)
CVC3::ValidityChecker::newBVLTExpr
virtual Expr newBVLTExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::createOp
virtual Op createOp(const std::string &name, const Type &type, const Expr &def)
Create a named user-defined function with a given type.
CVC3::ValidityChecker::forallExpr
virtual Expr forallExpr(const std::vector< Expr > &vars, const Expr &body, const Expr &trigger)
Universal quantifier with a trigger.
CVC3::ValidityChecker::recordExpr
virtual Expr recordExpr(const std::vector< std::string > &fields, const std::vector< Expr > &exprs)
Create an n-element record value (# field_i := expr_i #)
CVC3::ValidityChecker::scopeLevel
virtual int scopeLevel()
Returns the current scope level. Initially, the scope level is 1.
CVC3::ValidityChecker::ltExpr
virtual Expr ltExpr(const Expr &left, const Expr &right)
Create (left < right)
CVC3::ValidityChecker::parseType
virtual Type parseType(const Expr &e)
Parse a type expression using a Theory-specific parser.
CVC3::ValidityChecker::newBVUDivExpr
virtual Expr newBVUDivExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::returnFromCheck
virtual void returnFromCheck()
Returns to context immediately before last invalid query.
CVC3::ValidityChecker::recSelectExpr
virtual Expr recSelectExpr(const Expr &record, const std::string &field)
Create record.field (field selection)
CVC3::ValidityChecker::listExpr
virtual Expr listExpr(const std::string &op, const Expr &e1, const Expr &e2, const Expr &e3)
Overloaded version of listExpr with string operator and three arguments.
CVC3::ValidityChecker::importExpr
virtual Expr importExpr(const Expr &e)
Import the Expr from another instance of ValidityChecker.
CVC3::ValidityChecker::loadFile
virtual void loadFile(std::istream &is, InputLanguage lang=PRESENTATION_LANG, bool interactive=false)
Read and execute the commands from a stream.
CVC3::ValidityChecker::newBVAndExpr
virtual Expr newBVAndExpr(const std::vector< Expr > &kids)
CVC3::ValidityChecker::newBVLSHR
virtual Expr newBVLSHR(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::getStatistics
virtual Statistics getStatistics()
Get statistics object.
CVC3::ValidityChecker::impliesExpr
virtual Expr impliesExpr(const Expr &hyp, const Expr &conc)
Create Boolean implication.
CVC3::ValidityChecker::leExpr
virtual Expr leExpr(const Expr &left, const Expr &right)
Create (left <= right)
CVC3::ValidityChecker::setMultiTrigger
virtual void setMultiTrigger(const Expr &e, const std::vector< Expr > &multiTrigger)
Set a single multi-trigger for quantifier instantiation.
CVC3::ValidityChecker::bitvecType
virtual Type bitvecType(int n)
Create a bitvector type of length n.
CVC3::ValidityChecker::lookupOp
virtual Op lookupOp(const std::string &name, Type *type)
Get the Op associated with a name, and its type.
CVC3::ValidityChecker::printExpr
virtual void printExpr(const Expr &e)
Prints e to the standard output.
CVC3::ValidityChecker::tupleExpr
virtual Expr tupleExpr(const std::vector< Expr > &exprs)
Tuple expression.
CVC3::ValidityChecker::getValue
virtual Expr getValue(const Expr &e)
Evaluate an expression and return a concrete value in the model.
CVC3::ValidityChecker::cmdsFromString
virtual void cmdsFromString(const std::string &s, InputLanguage lang=PRESENTATION_LANG)
Parse a sequence of commands from a presentation language string.
CVC3::ValidityChecker::getInternalAssumptions
virtual void getInternalAssumptions(std::vector< Expr > &assumptions)
Get assumptions made internally in this and all previous contexts.
CVC3::ValidityChecker::getTypePred
virtual Expr getTypePred(const Type &t, const Expr &e)
Get the subtype predicate.
CVC3::ValidityChecker::addPairToArithOrder
virtual bool addPairToArithOrder(const Expr &smaller, const Expr &bigger)
CVC3::ValidityChecker::readExpr
virtual Expr readExpr(const Expr &array, const Expr &index)
Create an expression array[index] (array access)
CVC3::ValidityChecker::exprFromString
virtual Expr exprFromString(const std::string &e, InputLanguage lang=PRESENTATION_LANG)
Parse an expression from a presentation language string.
CVC3::ValidityChecker::getBaseType
virtual Type getBaseType(const Type &t)
Get the largest supertype of the Type.
CVC3::ValidityChecker::dataType
virtual void dataType(const std::vector< std::string > &names, const std::vector< std::vector< std::string > > &constructors, const std::vector< std::vector< std::vector< std::string > > > &selectors, const std::vector< std::vector< std::vector< Expr > > > &types, std::vector< Type > &returnTypes)
Multiple datatypes.
CVC3::ValidityChecker::newBVConstExpr
virtual Expr newBVConstExpr(const std::vector< bool > &bits)
CVC3::ValidityChecker::newBVURemExpr
virtual Expr newBVURemExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::setResourceLimit
virtual void setResourceLimit(unsigned limit)
Set the resource limit (0==unlimited, 1==exhausted).
CVC3::ValidityChecker::getBaseType
virtual Type getBaseType(const Expr &e)
Get the largest supertype of the Expr.
CVC3::ValidityChecker::orExpr
virtual Expr orExpr(const Expr &left, const Expr &right)
Create 2-element disjunction.
CVC3::ValidityChecker::printExpr
virtual void printExpr(const Expr &e, std::ostream &os)
Prints e to the given ostream.
CVC3::ValidityChecker::newFixedRightShiftExpr
virtual Expr newFixedRightShiftExpr(const Expr &t1, int r)
CVC3::ValidityChecker::createFlags
static CLFlags createFlags()
Create the set of command line flags with default values;.
CVC3::ValidityChecker::newBVXorExpr
virtual Expr newBVXorExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::funExpr
virtual Expr funExpr(const Op &op, const Expr &child)
Unary function application (op must be of function type)
CVC3::ValidityChecker::newBVXnorExpr
virtual Expr newBVXnorExpr(const std::vector< Expr > &kids)
CVC3::ValidityChecker::datatypeSelExpr
virtual Expr datatypeSelExpr(const std::string &selector, const Expr &arg)
Datatype selector expression.
CVC3::ValidityChecker::transClosure
virtual Op transClosure(const Op &op)
Transitive closure of a binary predicate.
CVC3::ValidityChecker::recUpdateExpr
virtual Expr recUpdateExpr(const Expr &record, const std::string &field, const Expr &newValue)
Record update; equivalent to "record WITH .field := newValue".
CVC3::ValidityChecker::newBVAndExpr
virtual Expr newBVAndExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::gtExpr
virtual Expr gtExpr(const Expr &left, const Expr &right)
Create (left > right)
CVC3::ValidityChecker::funType
virtual Type funType(const std::vector< Type > &typeDom, const Type &typeRan)
Create a function type (t1,t2,...,tn) -> typeRan.
CVC3::ValidityChecker::newBVUminusExpr
virtual Expr newBVUminusExpr(const Expr &t1)
CVC3::ValidityChecker::newBVSLTExpr
virtual Expr newBVSLTExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::funExpr
virtual Expr funExpr(const Op &op, const std::vector< Expr > &children)
n-ary function application (op must be of function type)
CVC3::ValidityChecker::checkUnsat
virtual QueryResult checkUnsat(const Expr &e)
Check satisfiability of the expr in the current context.
CVC3::ValidityChecker::tupleUpdateExpr
virtual Expr tupleUpdateExpr(const Expr &tuple, int index, const Expr &newValue)
Tuple update; equivalent to "tuple WITH index := newValue".
CVC3::ValidityChecker::newBVConstExpr
virtual Expr newBVConstExpr(const Rational &r, int len=0)
CVC3::ValidityChecker::tupleType
virtual Type tupleType(const std::vector< Type > &types)
n-element tuple (from a vector of types)
CVC3::ValidityChecker::newBVMultExpr
virtual Expr newBVMultExpr(int numbits, const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::newSXExpr
virtual Expr newSXExpr(const Expr &t1, int len)
CVC3::ValidityChecker::getCurrentContext
virtual Context * getCurrentContext()
Get the current context.
CVC3::ValidityChecker::forallExpr
virtual Expr forallExpr(const std::vector< Expr > &vars, const Expr &body)
Universal quantifier.
CVC3::ValidityChecker::listExpr
virtual Expr listExpr(const Expr &e1, const Expr &e2)
Overloaded version of listExpr with two arguments.
CVC3::ValidityChecker::newBVNandExpr
virtual Expr newBVNandExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::getType
virtual Type getType(const Expr &e)
Get the type of the Expr.
CVC3::ValidityChecker::iteExpr
virtual Expr iteExpr(const Expr &ifpart, const Expr &thenpart, const Expr &elsepart)
Create IF ifpart THEN thenpart ELSE elsepart ENDIF.
CVC3::ValidityChecker::boundVarExpr
virtual Expr boundVarExpr(const std::string &name, const std::string &uid, const Type &type)
Create a bound variable with a given name, unique ID (uid) and type.
CVC3::ValidityChecker::getAssumptions
virtual void getAssumptions(std::vector< Expr > &assumptions)
Get all assumptions made in this and all previous contexts.
CVC3::ValidityChecker::stackLevel
virtual int stackLevel()
Returns the current stack level. Initial level is 0.
CVC3::ValidityChecker::getEM
virtual ExprManager * getEM()
Return the ExprManager.
CVC3::ValidityChecker::simulateExpr
virtual Expr simulateExpr(const Expr &f, const Expr &s0, const std::vector< Expr > &inputs, const Expr &n)
Symbolic simulation expression.
CVC3::ValidityChecker::tupleType
virtual Type tupleType(const Type &type0, const Type &type1, const Type &type2)
3-element tuple
CVC3::ValidityChecker::newConcatExpr
virtual Expr newConcatExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::newBVLEExpr
virtual Expr newBVLEExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::iffExpr
virtual Expr iffExpr(const Expr &left, const Expr &right)
Create left IFF right (boolean equivalence)
CVC3::ValidityChecker::existsExpr
virtual Expr existsExpr(const std::vector< Expr > &vars, const Expr &body)
Existential quantifier.
CVC3::ValidityChecker::value
virtual FormulaValue value(const Expr &e)
CVC3::ValidityChecker::recordExpr
virtual Expr recordExpr(const std::string &field0, const Expr &expr0, const std::string &field1, const Expr &expr1)
Create a 2-element record value (# field0 := expr0, field1 := expr1 #)
CVC3::ValidityChecker::query
virtual QueryResult query(const Expr &e)
Check validity of e in the current context.
CVC3::ValidityChecker::getAssumptionsTCC
virtual void getAssumptionsTCC(std::vector< Expr > &assumptions)
Return the set of assumptions used in the proof of the last TCC.
CVC3::ValidityChecker::notExpr
virtual Expr notExpr(const Expr &child)
Create negation.
CVC3::ValidityChecker::realType
virtual Type realType()
Create type REAL.
CVC3::ValidityChecker::andExpr
virtual Expr andExpr(const Expr &left, const Expr &right)
Create 2-element conjunction.
CVC3::ValidityChecker::getProofClosure
virtual Proof getProofClosure()
Construct a proof of the query closure |- Gamma => phi.
CVC3::ValidityChecker::plusExpr
virtual Expr plusExpr(const Expr &left, const Expr &right)
Create 2-element sum (left + right)
CVC3::ValidityChecker::distinctExpr
virtual Expr distinctExpr(const std::vector< Expr > &children)
Create an expression asserting that all the children are different.
CVC3::ValidityChecker::recordExpr
virtual Expr recordExpr(const std::string &field0, const Expr &expr0, const std::string &field1, const Expr &expr1, const std::string &field2, const Expr &expr2)
Create a 3-element record value (# field_i := expr_i #)
CVC3::ValidityChecker::listExpr
virtual Expr listExpr(const std::string &op, const Expr &e1, const Expr &e2)
Overloaded version of listExpr with string operator and two arguments.
CVC3::ValidityChecker::funExpr
virtual Expr funExpr(const Op &op, const Expr &left, const Expr &right)
Binary function application (op must be of function type)
CVC3::ValidityChecker::powExpr
virtual Expr powExpr(const Expr &x, const Expr &n)
Create a power expression (x ^ n); n must be integer.
CVC3::ValidityChecker::importType
virtual Type importType(const Type &t)
Import the Type from another instance of ValidityChecker.
CVC3::ValidityChecker::push
virtual void push()
Checkpoint the current context and increase the scope level.
CVC3::ValidityChecker::getClosure
virtual Expr getClosure()
After successful query, return its closure |- Gamma => phi.
CVC3::ValidityChecker::datatypeConsExpr
virtual Expr datatypeConsExpr(const std::string &constructor, const std::vector< Expr > &args)
Datatype constructor expression.
CVC3::ValidityChecker::listExpr
virtual Expr listExpr(const std::string &op, const std::vector< Expr > &kids)
Overloaded version of listExpr with string operator and many arguments.
CVC3::ValidityChecker::newBVNorExpr
virtual Expr newBVNorExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::plusExpr
virtual Expr plusExpr(const std::vector< Expr > &children)
Create n-element sum.
CVC3::ValidityChecker::boolType
virtual Type boolType()
Create type BOOLEAN.
CVC3::ValidityChecker::inconsistent
virtual bool inconsistent(std::vector< Expr > &assumptions)
Returns true if the current context is inconsistent.
CVC3::ValidityChecker::getUserAssumptions
virtual void getUserAssumptions(std::vector< Expr > &assumptions)
Get assumptions made by the user in this and all previous contexts.
CVC3::ValidityChecker::loadFile
virtual void loadFile(const std::string &fileName, InputLanguage lang=PRESENTATION_LANG, bool interactive=false, bool calledFromParser=false)
Read and execute the commands from a file given by name ("" means stdin)
CVC3::ValidityChecker::tryModelGeneration
virtual QueryResult tryModelGeneration()
If the result of the last query was UNKNOWN try to actually build the model to verify the result.
CVC3::ValidityChecker::ratExpr
virtual Expr ratExpr(int n, int d=1)
Create a rational number with numerator n and denominator d.
CVC3::ValidityChecker::popto
virtual void popto(int stackLevel)
Restore the current context to the given stackLevel.
CVC3::ValidityChecker::getProofQuery
virtual Expr getProofQuery()
CVC3::ValidityChecker::newBVXnorExpr
virtual Expr newBVXnorExpr(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::newBVSHL
virtual Expr newBVSHL(const Expr &t1, const Expr &t2)
CVC3::ValidityChecker::getProofTCC
virtual Proof getProofTCC()
Returns the proof of TCC of the last assumption or query.
CVC3::ValidityChecker::computeBVConst
virtual Rational computeBVConst(const Expr &e)
CVC3::ValidityChecker::setTriggers
virtual void setTriggers(const Expr &e, const std::vector< Expr > &triggers)
Set triggers for quantifier instantiation (no multi-triggers)
CVC3::ValidityChecker::getAssumptionsUsed
virtual void getAssumptionsUsed(std::vector< Expr > &assumptions)
Returns the set of assumptions used in the proof of queried formula.
CVC3::ValidityChecker::getImpliedLiteral
virtual Expr getImpliedLiteral()
Return next literal implied by last assertion. Null Expr if none.
CVC3::ValidityChecker::geExpr
virtual Expr geExpr(const Expr &left, const Expr &right)
Create (left >= right)
CVC3::ValidityChecker::orExpr
virtual Expr orExpr(const std::vector< Expr > &children)
Create n-element disjunction.
CVC3::ValidityChecker::recordType
virtual Type recordType(const std::string &field, const Type &type)
1-element record
CVC3::ValidityChecker::intType
virtual Type intType()
Create type INT.
CVC3::ValidityChecker::trueExpr
virtual Expr trueExpr()
Return TRUE Expr.
CVC3::ValidityChecker::subtypeType
virtual Type subtypeType(const Expr &pred, const Expr &witness)
Creates a subtype defined by the given predicate.
CVC3::ValidityChecker::newConcatExpr
virtual Expr newConcatExpr(const std::vector< Expr > &kids)
CVC3::ValidityChecker::eqExpr
virtual Expr eqExpr(const Expr &child0, const Expr &child1)
Create an equality expression.
CVC3::ValidityChecker::newFixedLeftShiftExpr
virtual Expr newFixedLeftShiftExpr(const Expr &t1, int r)
CVC3::ValidityChecker::lookupType
virtual Type lookupType(const std::string &typeName)
Lookup a user-defined (uninterpreted) type by name. Returns Null if none.
CVC3::ValidityChecker::incomplete
virtual bool incomplete()
Returns true if the invalid result from last query() is imprecise.
CVC3::ValidityChecker::simplify
virtual Expr simplify(const Expr &e)
Simplify e with respect to the current context.
CVC3::ValidityChecker::newBVSLEExpr
virtual Expr newBVSLEExpr(const Expr &t1, const Expr &t2)
CVC4::Cardinality
A simple representation of a cardinality.
Definition cardinality.h:65
CVC4::Exception
Definition exception.h:32
CVC4::ExprManager
Definition expr_manager.h:124
CVC4::Expr::const_iterator
Iterator type for the children of an Expr.
Definition expr.h:415
CVC4::Expr
Class encapsulating CVC4 expressions and methods for constructing new expressions.
Definition expr.h:227
CVC4::Integer
Definition integer_gmp_imp.h:34
CVC4::Options
Definition options.h:43
CVC4::Rational
A multi-precision rational constant.
Definition rational_gmp_imp.h:51
CVC4::SmtEngine
Definition smt_engine.h:113
CVC4::Statistics
Definition statistics.h:103
CVC4::TypeCheckingException
Exception thrown in the case of type-checking errors.
Definition expr.h:151
CVC4::Type
Class encapsulating CVC4 expression types.
Definition type.h:89
CVC4::parser::Parser
This class encapsulates all of the state of a parser, including the name of the file,...
Definition parser.h:106
PRESENTATION_LANG
#define PRESENTATION_LANG
Definition cvc3_compat.h:464
cvc4_public.h
Macros that should be defined everywhere during the building of the libraries and driver binary,...
CVC4_PUBLIC
#define CVC4_PUBLIC
Definition cvc4_public.h:30
exception.h
CVC4's exception base class and some associated utilities.
expr.h
expr_manager.h
hash.h
[[ Add one-line brief description here ]]
CVC3
Definition cvc3_compat.h:71
CVC3::DIVIDE
const CVC4::Kind DIVIDE
Definition cvc3_compat.h:76
CVC3::CVC3CardinalityKind
CVC3CardinalityKind
Definition cvc3_compat.h:254
CVC3::CARD_UNKNOWN
@ CARD_UNKNOWN
Definition cvc3_compat.h:257
CVC3::CARD_FINITE
@ CARD_FINITE
Definition cvc3_compat.h:255
CVC3::CARD_INFINITE
@ CARD_INFINITE
Definition cvc3_compat.h:256
CVC3::QueryResult
QueryResult
Definition cvc3_compat.h:476
CVC3::UNKNOWN
@ UNKNOWN
Definition cvc3_compat.h:482
CVC3::VALID
@ VALID
Definition cvc3_compat.h:479
CVC3::ABORT
@ ABORT
Definition cvc3_compat.h:481
CVC3::INVALID
@ INVALID
Definition cvc3_compat.h:478
CVC3::UNSATISFIABLE
@ UNSATISFIABLE
Definition cvc3_compat.h:480
CVC3::SATISFIABLE
@ SATISFIABLE
Definition cvc3_compat.h:477
CVC3::BVLT
const CVC4::Kind BVLT
Definition cvc3_compat.h:77
CVC3::CONCAT
const CVC4::Kind CONCAT
Definition cvc3_compat.h:85
CVC3::TypecheckException
CVC4::TypeCheckingException TypecheckException
Definition cvc3_compat.h:245
CVC3::LE
const CVC4::Kind LE
Definition cvc3_compat.h:74
CVC3::BVLE
const CVC4::Kind BVLE
Definition cvc3_compat.h:78
CVC3::BVGE
const CVC4::Kind BVGE
Definition cvc3_compat.h:80
CVC3::Op
Expr Op
Definition cvc3_compat.h:310
CVC3::QueryResultToString
std::string QueryResultToString(QueryResult query_result)
CVC3::Unsigned
size_t Unsigned
Definition cvc3_compat.h:246
CVC3::operator!=
bool operator!=(const Cardinality &c, CVC3CardinalityKind d)
CVC3::EXTRACT
const CVC4::Kind EXTRACT
Definition cvc3_compat.h:84
CVC3::EQ
const CVC4::Kind EQ
Definition cvc3_compat.h:73
CVC3::FormulaValue
FormulaValue
Definition cvc3_compat.h:493
CVC3::FALSE_VAL
@ FALSE_VAL
Definition cvc3_compat.h:495
CVC3::UNKNOWN_VAL
@ UNKNOWN_VAL
Definition cvc3_compat.h:496
CVC3::TRUE_VAL
@ TRUE_VAL
Definition cvc3_compat.h:494
CVC3::BVGT
const CVC4::Kind BVGT
Definition cvc3_compat.h:79
CVC3::BVSUB
const CVC4::Kind BVSUB
Definition cvc3_compat.h:82
CVC3::BVPLUS
const CVC4::Kind BVPLUS
Definition cvc3_compat.h:81
CVC3::GE
const CVC4::Kind GE
Definition cvc3_compat.h:75
CVC3::ExprIndex
size_t ExprIndex
Definition cvc3_compat.h:244
CVC3::operator==
bool operator==(const Cardinality &c, CVC3CardinalityKind d)
CVC3::compare
int compare(const Expr &e1, const Expr &e2)
CVC3::CLFlagType
CLFlagType
Different types of command line flags.
Definition cvc3_compat.h:90
CVC3::CLFLAG_STRVEC
@ CLFLAG_STRVEC
Vector of pair<string, bool>
Definition cvc3_compat.h:95
CVC3::CLFLAG_NULL
@ CLFLAG_NULL
Definition cvc3_compat.h:91
CVC3::CLFLAG_INT
@ CLFLAG_INT
Definition cvc3_compat.h:93
CVC3::CLFLAG_BOOL
@ CLFLAG_BOOL
Definition cvc3_compat.h:92
CVC3::CLFLAG_STRING
@ CLFLAG_STRING
Definition cvc3_compat.h:94
CVC3::Statistics
CVC4::Statistics Statistics
Definition cvc3_compat.h:462
CVC3::BVCONST
const CVC4::Kind BVCONST
Definition cvc3_compat.h:83
CVC3::isArrayLiteral
bool isArrayLiteral(const Expr &)
CVC3::int2string
std::string int2string(int n)
CVC4::kind
Definition kind.h:58
CVC4::kind::operator<<
std::ostream & operator<<(std::ostream &, CVC4::Kind)
Definition kind.h:284
CVC4::kind::Kind_t
Kind_t
Definition kind.h:60
CVC4::kind::BITVECTOR_PLUS
@ BITVECTOR_PLUS
addition of two or more bit-vectors (67)
Definition kind.h:139
CVC4::kind::BITVECTOR_CONCAT
@ BITVECTOR_CONCAT
concatenation of two or more bit-vectors (57)
Definition kind.h:129
CVC4::kind::STORE
@ STORE
array store; first parameter is an array term, second is the store index, third is the term to store ...
Definition kind.h:184
CVC4::kind::SELECT
@ SELECT
array select; first parameter is an array term, second is the selection index (109)
Definition kind.h:183
CVC4::kind::CONST_BITVECTOR
@ CONST_BITVECTOR
a fixed-width bit-vector constant; payload is an instance of the CVC4::BitVector class (56)
Definition kind.h:128
CVC4::kind::LEQ
@ LEQ
less than or equal, x <= y (49)
Definition kind.h:119
CVC4::kind::BITVECTOR_UGE
@ BITVECTOR_UGE
bit-vector unsigned greater than or equal (the two bit-vector parameters must have same width) (83)
Definition kind.h:155
CVC4::kind::DIVISION
@ DIVISION
real division, division by 0 undefined (user symbol) (36)
Definition kind.h:106
CVC4::kind::BITVECTOR_UGT
@ BITVECTOR_UGT
bit-vector unsigned greater than (the two bit-vector parameters must have same width) (82)
Definition kind.h:154
CVC4::kind::GEQ
@ GEQ
greater than or equal, x >= y (51)
Definition kind.h:121
CVC4::kind::BITVECTOR_ULE
@ BITVECTOR_ULE
bit-vector unsigned less than or equal (the two bit-vector parameters must have same width) (81)
Definition kind.h:153
CVC4::kind::EQUAL
@ EQUAL
equality (two parameters only, sorts must match) (8)
Definition kind.h:72
CVC4::kind::BITVECTOR_EXTRACT
@ BITVECTOR_EXTRACT
bit-vector extract; first parameter is a BITVECTOR_EXTRACT_OP, second is a bit-vector term (99)
Definition kind.h:171
CVC4::kind::BITVECTOR_SUB
@ BITVECTOR_SUB
subtraction of two bit-vectors (68)
Definition kind.h:140
CVC4::kind::BITVECTOR_ULT
@ BITVECTOR_ULT
bit-vector unsigned less than (the two bit-vector parameters must have same width) (80)
Definition kind.h:152
CVC4::language::input::Language
Language
Definition language.h:33
parser.h
A collection of state for use by parser implementations.
smt_engine.h
SmtEngine: the main public entry point of libcvc4.
CVC4::StringHashFunction
Definition hash.h:49
type.h
Interface for expression types.