Merge branch 'bvsls' of https://git01.codeplex.com/z3 into opt

Conflicts:
	scripts/mk_project.py
	src/duality/duality.h
	src/duality/duality_solver.cpp
	src/duality/duality_wrapper.h
	src/interp/iz3hash.h

Signed-off-by: Christoph M. Wintersteiger <cwinter@microsoft.com>

.gitattributes

@@ -1 +1,4 @@
+# Set default behaviour, in case users don't have core.autocrlf set.
+* text=auto
+
 src/api/dotnet/Properties/AssemblyInfo.cs text eol=crlf

.gitignore

@@ -56,6 +56,8 @@ src/api/api_log_macros.cpp
 src/api/dll/api_dll.def
 src/api/dotnet/Enumerations.cs
 src/api/dotnet/Native.cs
+src/api/dotnet/Properties/AssemblyInfo.cs
+src/api/dotnet/Microsoft.Z3.xml
 src/api/python/z3consts.py
 src/api/python/z3core.py
 src/ast/pattern/database.h

scripts/mk_project.py

@@ -43,17 +43,18 @@ def init_project_def():
     # Simplifier module will be deleted in the future.
     # It has been replaced with rewriter module.
     add_lib('simplifier', ['rewriter'], 'ast/simplifier')
+    add_lib('fpa', ['ast', 'util', 'simplifier'], 'ast/fpa')
     add_lib('macros', ['simplifier'], 'ast/macros')
     add_lib('pattern', ['normal_forms', 'smt2parser', 'simplifier'], 'ast/pattern')
     add_lib('bit_blaster', ['rewriter', 'simplifier'], 'ast/rewriter/bit_blaster')
     add_lib('smt_params', ['ast', 'simplifier', 'pattern', 'bit_blaster'], 'smt/params')
     add_lib('proto_model', ['model', 'simplifier', 'smt_params'], 'smt/proto_model')
     add_lib('smt', ['bit_blaster', 'macros', 'normal_forms', 'cmd_context', 'proto_model',
-                    'substitution', 'grobner', 'euclid', 'simplex', 'proof_checker', 'pattern', 'parser_util'])
+                    'substitution', 'grobner', 'euclid', 'simplex', 'proof_checker', 'pattern', 'parser_util', 'fpa'])
     add_lib('user_plugin', ['smt'], 'smt/user_plugin')
     add_lib('bv_tactics', ['tactic', 'bit_blaster'], 'tactic/bv')
     add_lib('fuzzing', ['ast'], 'test/fuzzing')
-    add_lib('fpa', ['core_tactics', 'bv_tactics', 'sat_tactic'], 'tactic/fpa')
+    add_lib('fpa_tactics', ['fpa', 'core_tactics', 'bv_tactics', 'sat_tactic'], 'tactic/fpa')
     add_lib('smt_tactic', ['smt'], 'smt/tactic')
     add_lib('sls_tactic', ['tactic', 'normal_forms', 'core_tactics', 'bv_tactics'], 'tactic/sls')
     add_lib('qe', ['smt','sat'], 'qe')
@@ -69,7 +70,7 @@ def init_project_def():
     add_lib('fp',  ['muz', 'pdr', 'clp', 'tab', 'rel', 'bmc', 'duality_intf'], 'muz/fp')
     add_lib('smtlogic_tactics', ['arith_tactics', 'bv_tactics', 'nlsat_tactic', 'smt_tactic', 'aig_tactic', 'fp', 'muz','qe'], 'tactic/smtlogics')
     add_lib('ufbv_tactic', ['normal_forms', 'core_tactics', 'macros', 'smt_tactic', 'rewriter'], 'tactic/ufbv')
-    add_lib('portfolio', ['smtlogic_tactics', 'ufbv_tactic', 'fpa', 'aig_tactic', 'fp',  'qe','sls_tactic', 'subpaving_tactic'], 'tactic/portfolio')
+    add_lib('portfolio', ['smtlogic_tactics', 'ufbv_tactic', 'fpa_tactics', 'aig_tactic', 'fp',  'qe','sls_tactic', 'subpaving_tactic'], 'tactic/portfolio')
     add_lib('smtparser', ['portfolio'], 'parsers/smt')
     add_lib('opt', ['smt', 'smtlogic_tactics', 'sls_tactic'], 'opt')
     API_files = ['z3_api.h', 'z3_algebraic.h', 'z3_polynomial.h', 'z3_rcf.h']

scripts/mk_util.py

@@ -54,6 +54,7 @@ CPP_COMPONENT='cpp'
 IS_WINDOWS=False
 IS_LINUX=False
 IS_OSX=False
+IS_FREEBSD=False
 VERBOSE=True
 DEBUG_MODE=False
 SHOW_CPPS = True
@@ -98,6 +99,9 @@ def is_windows():
 def is_linux():
     return IS_LINUX
 
+def is_freebsd():
+    return IS_FREEBSD
+
 def is_osx():
     return IS_OSX
 
@@ -426,6 +430,8 @@ elif os.name == 'posix':
         IS_OSX=True
     elif os.uname()[0] == 'Linux':
         IS_LINUX=True
+    elif os.uname()[0] == 'FreeBSD':
+        IS_FREEBSD=True
 
 def display_help(exit_code):
     print("mk_make.py: Z3 Makefile generator\n")
@@ -1181,6 +1187,8 @@ class JavaDLLComponent(Component):
                 t = t.replace('PLATFORM', 'darwin')
             elif IS_LINUX:
                 t = t.replace('PLATFORM', 'linux')
+            elif IS_FREEBSD:
+                t = t.replace('PLATFORM', 'freebsd')
             else:
                 t = t.replace('PLATFORM', 'win32')
             out.write(t)

scripts/mk_win_dist.py

@@ -144,7 +144,7 @@ def mk_z3_core(x64):
         cmds.append('call "%VCINSTALLDIR%vcvarsall.bat" amd64')
         cmds.append('cd %s' % BUILD_X64_DIR)    
     else:
-        cmds.append('"call %VCINSTALLDIR%vcvarsall.bat" x86')
+        cmds.append('call "%VCINSTALLDIR%vcvarsall.bat" x86')
         cmds.append('cd %s' % BUILD_X86_DIR)
     cmds.append('nmake')
     if exec_cmds(cmds) != 0:

src/api/api_bv.cpp

@@ -117,6 +117,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) {                \
         Z3_sort int_s = Z3_mk_int_sort(c);
         if (is_signed) {
             Z3_ast r = Z3_mk_bv2int(c, n, false);
+            Z3_inc_ref(c, r);
             Z3_sort s = Z3_get_sort(c, n);
             unsigned sz = Z3_get_bv_sort_size(c, s);
             rational max_bound = power(rational(2), sz);
@@ -135,6 +136,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) {                \
             Z3_dec_ref(c, pred);
             Z3_dec_ref(c, sub);
             Z3_dec_ref(c, zero);
+            Z3_dec_ref(c, r);
             RETURN_Z3(res);
         }
         else {

src/api/dotnet/Context.cs

@@ -302,11 +302,11 @@ namespace Microsoft.Z3
         }
 
         /// <summary>
-        /// Create a new finite domain sort.
+        /// Create a new finite domain sort.	    
-	/// <param name="name">The name used to identify the sort</param>
+	    /// <returns>The result is a sort</returns>
-	/// <param size="size">The size of the sort</param>
-	/// <returns>The result is a sort</returns>
         /// </summary>
+        /// <param name="name">The name used to identify the sort</param>
+        /// <param name="size">The size of the sort</param>
         public FiniteDomainSort MkFiniteDomainSort(Symbol name, ulong size)
         {
             Contract.Requires(name != null);
@@ -317,13 +317,13 @@ namespace Microsoft.Z3
         }
 
         /// <summary>
-        /// Create a new finite domain sort.
+        /// Create a new finite domain sort.	    
-	/// <param name="name">The name used to identify the sort</param>
+	    /// <returns>The result is a sort</returns>
-	/// <param size="size">The size of the sort</param>
+	    /// Elements of the sort are created using <seealso cref="MkNumeral(ulong, Sort)"/>, 
-	/// <returns>The result is a sort</returns>
+	    /// and the elements range from 0 to <tt>size-1</tt>.
-	/// Elements of the sort are created using <seealso cref="MkNumeral"/>, 
-	/// and the elements range from 0 to <tt>size-1</tt>.
         /// </summary>
+        /// <param name="name">The name used to identify the sort</param>
+        /// <param name="size">The size of the sort</param>
         public FiniteDomainSort MkFiniteDomainSort(string name, ulong size)
         {
             Contract.Ensures(Contract.Result<FiniteDomainSort>() != null);

src/api/dotnet/Expr.cs

@@ -99,7 +99,7 @@ namespace Microsoft.Z3
             Contract.Requires(Contract.ForAll(args, a => a != null));
 
             Context.CheckContextMatch(args);
-            if (args.Length != NumArgs)
+            if (IsApp && args.Length != NumArgs)
                 throw new Z3Exception("Number of arguments does not match");
             NativeObject = Native.Z3_update_term(Context.nCtx, NativeObject, (uint)args.Length, Expr.ArrayToNative(args));
         }
@@ -269,57 +269,57 @@ namespace Microsoft.Z3
         /// <summary>
         /// Indicates whether the term is the constant true.
         /// </summary>
-        public bool IsTrue { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_TRUE; } }
+        public bool IsTrue { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_TRUE; } }
 
         /// <summary>
         /// Indicates whether the term is the constant false.
         /// </summary>
-        public bool IsFalse { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_FALSE; } }
+        public bool IsFalse { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_FALSE; } }
 
         /// <summary>
         /// Indicates whether the term is an equality predicate.
         /// </summary>
-        public bool IsEq { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_EQ; } }
+        public bool IsEq { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_EQ; } }
 
         /// <summary>
         /// Indicates whether the term is an n-ary distinct predicate (every argument is mutually distinct).
         /// </summary>
-        public bool IsDistinct { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_DISTINCT; } }
+        public bool IsDistinct { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_DISTINCT; } }
 
         /// <summary>
         /// Indicates whether the term is a ternary if-then-else term
         /// </summary>
-        public bool IsITE { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ITE; } }
+        public bool IsITE { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ITE; } }
 
         /// <summary>
         /// Indicates whether the term is an n-ary conjunction
         /// </summary>
-        public bool IsAnd { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_AND; } }
+        public bool IsAnd { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_AND; } }
 
         /// <summary>
         /// Indicates whether the term is an n-ary disjunction
         /// </summary>
-        public bool IsOr { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_OR; } }
+        public bool IsOr { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_OR; } }
 
         /// <summary>
         /// Indicates whether the term is an if-and-only-if (Boolean equivalence, binary)
         /// </summary>
-        public bool IsIff { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_IFF; } }
+        public bool IsIff { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_IFF; } }
 
         /// <summary>
         /// Indicates whether the term is an exclusive or
         /// </summary>
-        public bool IsXor { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_XOR; } }
+        public bool IsXor { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_XOR; } }
 
         /// <summary>
         /// Indicates whether the term is a negation
         /// </summary>
-        public bool IsNot { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_NOT; } }
+        public bool IsNot { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_NOT; } }
 
         /// <summary>
         /// Indicates whether the term is an implication
         /// </summary>
-        public bool IsImplies { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_IMPLIES; } }
+        public bool IsImplies { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_IMPLIES; } }
 
         #endregion
 
@@ -347,82 +347,82 @@ namespace Microsoft.Z3
         /// <summary>
         /// Indicates whether the term is an arithmetic numeral.
         /// </summary>
-        public bool IsArithmeticNumeral { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ANUM; } }
+        public bool IsArithmeticNumeral { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ANUM; } }
 
         /// <summary>
         /// Indicates whether the term is a less-than-or-equal
         /// </summary>
-        public bool IsLE { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_LE; } }
+        public bool IsLE { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_LE; } }
 
         /// <summary>
         /// Indicates whether the term is a greater-than-or-equal
         /// </summary>
-        public bool IsGE { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_GE; } }
+        public bool IsGE { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_GE; } }
 
         /// <summary>
         /// Indicates whether the term is a less-than
         /// </summary>
-        public bool IsLT { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_LT; } }
+        public bool IsLT { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_LT; } }
 
         /// <summary>
         /// Indicates whether the term is a greater-than
         /// </summary>
-        public bool IsGT { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_GT; } }
+        public bool IsGT { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_GT; } }
 
         /// <summary>
         /// Indicates whether the term is addition (binary)
         /// </summary>
-        public bool IsAdd { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ADD; } }
+        public bool IsAdd { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ADD; } }
 
         /// <summary>
         /// Indicates whether the term is subtraction (binary)
         /// </summary>
-        public bool IsSub { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SUB; } }
+        public bool IsSub { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SUB; } }
 
         /// <summary>
         /// Indicates whether the term is a unary minus
         /// </summary>
-        public bool IsUMinus { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_UMINUS; } }
+        public bool IsUMinus { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_UMINUS; } }
 
         /// <summary>
         /// Indicates whether the term is multiplication (binary)
         /// </summary>
-        public bool IsMul { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_MUL; } }
+        public bool IsMul { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_MUL; } }
 
         /// <summary>
         /// Indicates whether the term is division (binary)
         /// </summary>
-        public bool IsDiv { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_DIV; } }
+        public bool IsDiv { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_DIV; } }
 
         /// <summary>
         /// Indicates whether the term is integer division (binary)
         /// </summary>
-        public bool IsIDiv { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_IDIV; } }
+        public bool IsIDiv { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_IDIV; } }
 
         /// <summary>
         /// Indicates whether the term is remainder (binary)
         /// </summary>
-        public bool IsRemainder { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_REM; } }
+        public bool IsRemainder { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_REM; } }
 
         /// <summary>
         /// Indicates whether the term is modulus (binary)
         /// </summary>
-        public bool IsModulus { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_MOD; } }
+        public bool IsModulus { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_MOD; } }
 
         /// <summary>
         /// Indicates whether the term is a coercion of integer to real (unary)
         /// </summary>
-        public bool IsIntToReal { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_TO_REAL; } }
+        public bool IsIntToReal { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_TO_REAL; } }
 
         /// <summary>
         /// Indicates whether the term is a coercion of real to integer (unary)
         /// </summary>
-        public bool IsRealToInt { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_TO_INT; } }
+        public bool IsRealToInt { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_TO_INT; } }
 
         /// <summary>
         /// Indicates whether the term is a check that tests whether a real is integral (unary)
         /// </summary>
-        public bool IsRealIsInt { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_IS_INT; } }
+        public bool IsRealIsInt { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_IS_INT; } }
         #endregion
 
         #region Array Terms
@@ -444,64 +444,64 @@ namespace Microsoft.Z3
         /// </summary>
         /// <remarks>It satisfies select(store(a,i,v),j) = if i = j then v else select(a,j). 
         /// Array store takes at least 3 arguments. </remarks>
-        public bool IsStore { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_STORE; } }
+        public bool IsStore { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_STORE; } }
 
         /// <summary>
         /// Indicates whether the term is an array select.
         /// </summary>
-        public bool IsSelect { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SELECT; } }
+        public bool IsSelect { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SELECT; } }
 
         /// <summary>
         /// Indicates whether the term is a constant array.
         /// </summary>
         /// <remarks>For example, select(const(v),i) = v holds for every v and i. The function is unary.</remarks>
-        public bool IsConstantArray { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_CONST_ARRAY; } }
+        public bool IsConstantArray { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_CONST_ARRAY; } }
 
         /// <summary>
         /// Indicates whether the term is a default array.
         /// </summary>
         /// <remarks>For example default(const(v)) = v. The function is unary.</remarks>
-        public bool IsDefaultArray { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ARRAY_DEFAULT; } }
+        public bool IsDefaultArray { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ARRAY_DEFAULT; } }
 
         /// <summary>
         /// Indicates whether the term is an array map.
         /// </summary>
         /// <remarks>It satisfies map[f](a1,..,a_n)[i] = f(a1[i],...,a_n[i]) for every i.</remarks>
-        public bool IsArrayMap { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ARRAY_MAP; } }
+        public bool IsArrayMap { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ARRAY_MAP; } }
 
         /// <summary>
         /// Indicates whether the term is an as-array term.
         /// </summary>
         /// <remarks>An as-array term is n array value that behaves as the function graph of the 
         /// function passed as parameter.</remarks>
-        public bool IsAsArray { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_AS_ARRAY; } }
+        public bool IsAsArray { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_AS_ARRAY; } }
         #endregion
 
         #region Set Terms
         /// <summary>
         /// Indicates whether the term is set union
         /// </summary>
-        public bool IsSetUnion { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SET_UNION; } }
+        public bool IsSetUnion { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SET_UNION; } }
 
         /// <summary>
         /// Indicates whether the term is set intersection
         /// </summary>
-        public bool IsSetIntersect { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SET_INTERSECT; } }
+        public bool IsSetIntersect { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SET_INTERSECT; } }
 
         /// <summary>
         /// Indicates whether the term is set difference
         /// </summary>
-        public bool IsSetDifference { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SET_DIFFERENCE; } }
+        public bool IsSetDifference { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SET_DIFFERENCE; } }
 
         /// <summary>
         /// Indicates whether the term is set complement
         /// </summary>
-        public bool IsSetComplement { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SET_COMPLEMENT; } }
+        public bool IsSetComplement { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SET_COMPLEMENT; } }
 
         /// <summary>
         /// Indicates whether the term is set subset
         /// </summary>
-        public bool IsSetSubset { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SET_SUBSET; } }
+        public bool IsSetSubset { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SET_SUBSET; } }
         #endregion
 
         #region Bit-vector terms
@@ -516,266 +516,266 @@ namespace Microsoft.Z3
         /// <summary>
         /// Indicates whether the term is a bit-vector numeral
         /// </summary>
-        public bool IsBVNumeral { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BNUM; } }
+        public bool IsBVNumeral { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BNUM; } }
 
         /// <summary>
         /// Indicates whether the term is a one-bit bit-vector with value one
         /// </summary>
-        public bool IsBVBitOne { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BIT1; } }
+        public bool IsBVBitOne { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BIT1; } }
 
         /// <summary>
         /// Indicates whether the term is a one-bit bit-vector with value zero
         /// </summary>
-        public bool IsBVBitZero { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BIT0; } }
+        public bool IsBVBitZero { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BIT0; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector unary minus
         /// </summary>
-        public bool IsBVUMinus { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BNEG; } }
+        public bool IsBVUMinus { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BNEG; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector addition (binary)
         /// </summary>
-        public bool IsBVAdd { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BADD; } }
+        public bool IsBVAdd { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BADD; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector subtraction (binary)
         /// </summary>
-        public bool IsBVSub { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSUB; } }
+        public bool IsBVSub { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSUB; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector multiplication (binary)
         /// </summary>
-        public bool IsBVMul { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BMUL; } }
+        public bool IsBVMul { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BMUL; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector signed division (binary)
         /// </summary>
-        public bool IsBVSDiv { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSDIV; } }
+        public bool IsBVSDiv { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSDIV; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector unsigned division (binary)
         /// </summary>
-        public bool IsBVUDiv { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BUDIV; } }
+        public bool IsBVUDiv { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BUDIV; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector signed remainder (binary)
         /// </summary>
-        public bool IsBVSRem { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSREM; } }
+        public bool IsBVSRem { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSREM; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector unsigned remainder (binary)
         /// </summary>
-        public bool IsBVURem { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BUREM; } }
+        public bool IsBVURem { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BUREM; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector signed modulus
         /// </summary>
-        public bool IsBVSMod { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSMOD; } }
+        public bool IsBVSMod { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSMOD; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector signed division by zero
         /// </summary>
-        internal bool IsBVSDiv0 { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSDIV0; } }
+        internal bool IsBVSDiv0 { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSDIV0; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector unsigned division by zero
         /// </summary>
-        internal bool IsBVUDiv0 { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BUDIV0; } }
+        internal bool IsBVUDiv0 { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BUDIV0; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector signed remainder by zero
         /// </summary>
-        internal bool IsBVSRem0 { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSREM0; } }
+        internal bool IsBVSRem0 { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSREM0; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector unsigned remainder by zero
         /// </summary>
-        internal bool IsBVURem0 { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BUREM0; } }
+        internal bool IsBVURem0 { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BUREM0; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector signed modulus by zero
         /// </summary>
-        internal bool IsBVSMod0 { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSMOD0; } }
+        internal bool IsBVSMod0 { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSMOD0; } }
 
         /// <summary>
         /// Indicates whether the term is an unsigned bit-vector less-than-or-equal
         /// </summary>
-        public bool IsBVULE { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ULEQ; } }
+        public bool IsBVULE { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ULEQ; } }
 
         /// <summary>
         /// Indicates whether the term is a signed bit-vector less-than-or-equal
         /// </summary>
-        public bool IsBVSLE { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SLEQ; } }
+        public bool IsBVSLE { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SLEQ; } }
 
         /// <summary>
         /// Indicates whether the term is an unsigned bit-vector greater-than-or-equal
         /// </summary>
-        public bool IsBVUGE { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_UGEQ; } }
+        public bool IsBVUGE { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_UGEQ; } }
 
         /// <summary>
         /// Indicates whether the term is a signed bit-vector greater-than-or-equal
         /// </summary>
-        public bool IsBVSGE { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SGEQ; } }
+        public bool IsBVSGE { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SGEQ; } }
 
         /// <summary>
         /// Indicates whether the term is an unsigned bit-vector less-than
         /// </summary>
-        public bool IsBVULT { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ULT; } }
+        public bool IsBVULT { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ULT; } }
 
         /// <summary>
         /// Indicates whether the term is a signed bit-vector less-than
         /// </summary>
-        public bool IsBVSLT { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SLT; } }
+        public bool IsBVSLT { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SLT; } }
 
         /// <summary>
         /// Indicates whether the term is an unsigned bit-vector greater-than
         /// </summary>
-        public bool IsBVUGT { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_UGT; } }
+        public bool IsBVUGT { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_UGT; } }
 
         /// <summary>
         /// Indicates whether the term is a signed bit-vector greater-than
         /// </summary>
-        public bool IsBVSGT { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SGT; } }
+        public bool IsBVSGT { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SGT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-wise AND
         /// </summary>
-        public bool IsBVAND { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BAND; } }
+        public bool IsBVAND { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BAND; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-wise OR
         /// </summary>
-        public bool IsBVOR { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BOR; } }
+        public bool IsBVOR { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BOR; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-wise NOT
         /// </summary>
-        public bool IsBVNOT { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BNOT; } }
+        public bool IsBVNOT { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BNOT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-wise XOR
         /// </summary>
-        public bool IsBVXOR { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BXOR; } }
+        public bool IsBVXOR { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BXOR; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-wise NAND
         /// </summary>
-        public bool IsBVNAND { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BNAND; } }
+        public bool IsBVNAND { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BNAND; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-wise NOR
         /// </summary>
-        public bool IsBVNOR { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BNOR; } }
+        public bool IsBVNOR { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BNOR; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-wise XNOR
         /// </summary>
-        public bool IsBVXNOR { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BXNOR; } }
+        public bool IsBVXNOR { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BXNOR; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector concatenation (binary)
         /// </summary>
-        public bool IsBVConcat { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_CONCAT; } }
+        public bool IsBVConcat { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_CONCAT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector sign extension
         /// </summary>
-        public bool IsBVSignExtension { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SIGN_EXT; } }
+        public bool IsBVSignExtension { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SIGN_EXT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector zero extension
         /// </summary>
-        public bool IsBVZeroExtension { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ZERO_EXT; } }
+        public bool IsBVZeroExtension { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ZERO_EXT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector extraction
         /// </summary>
-        public bool IsBVExtract { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_EXTRACT; } }
+        public bool IsBVExtract { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_EXTRACT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector repetition
         /// </summary>
-        public bool IsBVRepeat { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_REPEAT; } }
+        public bool IsBVRepeat { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_REPEAT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector reduce OR
         /// </summary>
-        public bool IsBVReduceOR { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BREDOR; } }
+        public bool IsBVReduceOR { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BREDOR; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector reduce AND
         /// </summary>
-        public bool IsBVReduceAND { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BREDAND; } }
+        public bool IsBVReduceAND { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BREDAND; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector comparison
         /// </summary>
-        public bool IsBVComp { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BCOMP; } }
+        public bool IsBVComp { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BCOMP; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector shift left
         /// </summary>
-        public bool IsBVShiftLeft { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSHL; } }
+        public bool IsBVShiftLeft { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BSHL; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector logical shift right
         /// </summary>
-        public bool IsBVShiftRightLogical { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BLSHR; } }
+        public bool IsBVShiftRightLogical { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BLSHR; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector arithmetic shift left
         /// </summary>
-        public bool IsBVShiftRightArithmetic { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BASHR; } }
+        public bool IsBVShiftRightArithmetic { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BASHR; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector rotate left
         /// </summary>
-        public bool IsBVRotateLeft { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ROTATE_LEFT; } }
+        public bool IsBVRotateLeft { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ROTATE_LEFT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector rotate right
         /// </summary>
-        public bool IsBVRotateRight { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ROTATE_RIGHT; } }
+        public bool IsBVRotateRight { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_ROTATE_RIGHT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector rotate left (extended)
         /// </summary>
         /// <remarks>Similar to Z3_OP_ROTATE_LEFT, but it is a binary operator instead of a parametric one.</remarks>
-        public bool IsBVRotateLeftExtended { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_EXT_ROTATE_LEFT; } }
+        public bool IsBVRotateLeftExtended { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_EXT_ROTATE_LEFT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector rotate right (extended)
         /// </summary>
         /// <remarks>Similar to Z3_OP_ROTATE_RIGHT, but it is a binary operator instead of a parametric one.</remarks>
-        public bool IsBVRotateRightExtended { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_EXT_ROTATE_RIGHT; } }
+        public bool IsBVRotateRightExtended { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_EXT_ROTATE_RIGHT; } }
 
         /// <summary>
         /// Indicates whether the term is a coercion from integer to bit-vector
         /// </summary>
         /// <remarks>This function is not supported by the decision procedures. Only the most 
         /// rudimentary simplification rules are applied to this function.</remarks>
-        public bool IsIntToBV { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_INT2BV; } }
+        public bool IsIntToBV { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_INT2BV; } }
 
         /// <summary>
         /// Indicates whether the term is a coercion from bit-vector to integer
         /// </summary>
         /// <remarks>This function is not supported by the decision procedures. Only the most 
         /// rudimentary simplification rules are applied to this function.</remarks>
-        public bool IsBVToInt { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BV2INT; } }
+        public bool IsBVToInt { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_BV2INT; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector carry
         /// </summary>
         /// <remarks>Compute the carry bit in a full-adder.  The meaning is given by the 
         /// equivalence (carry l1 l2 l3) &lt;=&gt; (or (and l1 l2) (and l1 l3) (and l2 l3)))</remarks>
-        public bool IsBVCarry { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_CARRY; } }
+        public bool IsBVCarry { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_CARRY; } }
 
         /// <summary>
         /// Indicates whether the term is a bit-vector ternary XOR
         /// </summary>
         /// <remarks>The meaning is given by the equivalence (xor3 l1 l2 l3) &lt;=&gt; (xor (xor l1 l2) l3)</remarks>
-        public bool IsBVXOR3 { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_XOR3; } }
+        public bool IsBVXOR3 { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_XOR3; } }
 
         #endregion
 
@@ -784,13 +784,13 @@ namespace Microsoft.Z3
         /// Indicates whether the term is a label (used by the Boogie Verification condition generator).
         /// </summary>
         /// <remarks>The label has two parameters, a string and a Boolean polarity. It takes one argument, a formula.</remarks>
-        public bool IsLabel { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_LABEL; } }
+        public bool IsLabel { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_LABEL; } }
 
         /// <summary>
         /// Indicates whether the term is a label literal (used by the Boogie Verification condition generator).                     
         /// </summary>
         /// <remarks>A label literal has a set of string parameters. It takes no arguments.</remarks>
-        public bool IsLabelLit { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_LABEL_LIT; } }
+        public bool IsLabelLit { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_LABEL_LIT; } }
         #endregion
 
         #region Proof Terms
@@ -799,22 +799,22 @@ namespace Microsoft.Z3
         /// </summary>
         /// <remarks>This binary predicate is used in proof terms.
         /// It captures equisatisfiability and equivalence modulo renamings.</remarks>
-        public bool IsOEQ { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_OEQ; } }
+        public bool IsOEQ { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_OEQ; } }
 
         /// <summary>
         /// Indicates whether the term is a Proof for the expression 'true'.
         /// </summary>
-        public bool IsProofTrue { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_TRUE; } }
+        public bool IsProofTrue { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_TRUE; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for a fact asserted by the user.
         /// </summary>
-        public bool IsProofAsserted { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_ASSERTED; } }
+        public bool IsProofAsserted { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_ASSERTED; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for a fact (tagged as goal) asserted by the user.
         /// </summary>
-        public bool IsProofGoal { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_GOAL; } }
+        public bool IsProofGoal { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_GOAL; } }
 
         /// <summary>
         /// Indicates whether the term is proof via modus ponens
@@ -825,7 +825,7 @@ namespace Microsoft.Z3
         /// T2: (implies p q)
         /// [mp T1 T2]: q
         /// The second antecedents may also be a proof for (iff p q).</remarks>
-        public bool IsProofModusPonens { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_MODUS_PONENS; } }
+        public bool IsProofModusPonens { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_MODUS_PONENS; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for (R t t), where R is a reflexive relation.
@@ -834,7 +834,7 @@ namespace Microsoft.Z3
         /// The only reflexive relations that are used are 
         /// equivalence modulo namings, equality and equivalence.
         /// That is, R is either '~', '=' or 'iff'.</remarks>
-        public bool IsProofReflexivity { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_REFLEXIVITY; } }
+        public bool IsProofReflexivity { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_REFLEXIVITY; } }
 
         /// <summary>
         /// Indicates whether the term is proof by symmetricity of a relation
@@ -845,7 +845,7 @@ namespace Microsoft.Z3
         /// [symmetry T1]: (R s t)
         /// T1 is the antecedent of this proof object.
         /// </remarks>
-        public bool IsProofSymmetry { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_SYMMETRY; } }
+        public bool IsProofSymmetry { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_SYMMETRY; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by transitivity of a relation
@@ -857,7 +857,7 @@ namespace Microsoft.Z3
         /// T2: (R s u)
         /// [trans T1 T2]: (R t u)
         /// </remarks>
-        public bool IsProofTransitivity { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_TRANSITIVITY; } }
+        public bool IsProofTransitivity { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_TRANSITIVITY; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by condensed transitivity of a relation
@@ -878,7 +878,7 @@ namespace Microsoft.Z3
         /// if there is a path from s to t, if we view every
         /// antecedent (R a b) as an edge between a and b.
         /// </remarks>
-        public bool IsProofTransitivityStar { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_TRANSITIVITY_STAR; } }
+        public bool IsProofTransitivityStar { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_TRANSITIVITY_STAR; } }
 
 
         /// <summary>
@@ -892,7 +892,7 @@ namespace Microsoft.Z3
         /// Remark: if t_i == s_i, then the antecedent Ti is suppressed.
         /// That is, reflexivity proofs are supressed to save space.
         /// </remarks>
-        public bool IsProofMonotonicity { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_MONOTONICITY; } }
+        public bool IsProofMonotonicity { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_MONOTONICITY; } }
 
         /// <summary>
         /// Indicates whether the term is a quant-intro proof 
@@ -902,7 +902,7 @@ namespace Microsoft.Z3
         /// T1: (~ p q)
         /// [quant-intro T1]: (~ (forall (x) p) (forall (x) q))
         /// </remarks>
-        public bool IsProofQuantIntro { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_QUANT_INTRO; } }
+        public bool IsProofQuantIntro { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_QUANT_INTRO; } }
 
         /// <summary>
         /// Indicates whether the term is a distributivity proof object.  
@@ -920,7 +920,7 @@ namespace Microsoft.Z3
         /// Remark. This rule is used by the CNF conversion pass and 
         /// instantiated by f = or, and g = and.
         /// </remarks>
-        public bool IsProofDistributivity { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_DISTRIBUTIVITY; } }
+        public bool IsProofDistributivity { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_DISTRIBUTIVITY; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by elimination of AND
@@ -930,7 +930,7 @@ namespace Microsoft.Z3
         /// T1: (and l_1 ... l_n)
         /// [and-elim T1]: l_i
         /// </remarks>
-        public bool IsProofAndElimination { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_AND_ELIM; } }
+        public bool IsProofAndElimination { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_AND_ELIM; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by eliminiation of not-or
@@ -940,7 +940,7 @@ namespace Microsoft.Z3
         /// T1: (not (or l_1 ... l_n))
         /// [not-or-elim T1]: (not l_i)       
         /// </remarks>
-        public bool IsProofOrElimination { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_NOT_OR_ELIM; } }
+        public bool IsProofOrElimination { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_NOT_OR_ELIM; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by rewriting
@@ -959,7 +959,7 @@ namespace Microsoft.Z3
         /// (= (+ x 1 2) (+ 3 x))
         /// (iff (or x false) x)          
         /// </remarks>
-        public bool IsProofRewrite { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_REWRITE; } }
+        public bool IsProofRewrite { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_REWRITE; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by rewriting
@@ -975,7 +975,7 @@ namespace Microsoft.Z3
         /// - When converting bit-vectors to Booleans (BIT2BOOL=true)
         /// - When pulling ite expression up (PULL_CHEAP_ITE_TREES=true)
         /// </remarks>
-        public bool IsProofRewriteStar { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_REWRITE_STAR; } }
+        public bool IsProofRewriteStar { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_REWRITE_STAR; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for pulling quantifiers out.
@@ -983,7 +983,7 @@ namespace Microsoft.Z3
         /// <remarks>
         /// A proof for (iff (f (forall (x) q(x)) r) (forall (x) (f (q x) r))). This proof object has no antecedents.
         /// </remarks>
-        public bool IsProofPullQuant { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_PULL_QUANT; } }
+        public bool IsProofPullQuant { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_PULL_QUANT; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for pulling quantifiers out.
@@ -993,7 +993,7 @@ namespace Microsoft.Z3
         /// This proof object is only used if the parameter PROOF_MODE is 1.       
         /// This proof object has no antecedents
         /// </remarks>
-        public bool IsProofPullQuantStar { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_PULL_QUANT_STAR; } }
+        public bool IsProofPullQuantStar { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_PULL_QUANT_STAR; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for pushing quantifiers in.
@@ -1006,7 +1006,7 @@ namespace Microsoft.Z3
         ///      (forall (x_1 ... x_m) p_n[x_1 ... x_m])))               
         ///  This proof object has no antecedents
         /// </remarks>
-        public bool IsProofPushQuant { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_PUSH_QUANT; } }
+        public bool IsProofPushQuant { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_PUSH_QUANT; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for elimination of unused variables.
@@ -1018,7 +1018,7 @@ namespace Microsoft.Z3
         /// It is used to justify the elimination of unused variables.
         /// This proof object has no antecedents.
         /// </remarks>
-        public bool IsProofElimUnusedVars { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_ELIM_UNUSED_VARS; } }
+        public bool IsProofElimUnusedVars { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_ELIM_UNUSED_VARS; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for destructive equality resolution
@@ -1032,7 +1032,7 @@ namespace Microsoft.Z3
         /// 
         /// Several variables can be eliminated simultaneously.
         /// </remarks>
-        public bool IsProofDER { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_DER; } }
+        public bool IsProofDER { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_DER; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for quantifier instantiation
@@ -1040,13 +1040,13 @@ namespace Microsoft.Z3
         /// <remarks>
         /// A proof of (or (not (forall (x) (P x))) (P a))
         /// </remarks>
-        public bool IsProofQuantInst { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_QUANT_INST; } }
+        public bool IsProofQuantInst { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_QUANT_INST; } }
 
         /// <summary>
         /// Indicates whether the term is a hypthesis marker.
         /// </summary>
         /// <remarks>Mark a hypothesis in a natural deduction style proof.</remarks>
-        public bool IsProofHypothesis { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_HYPOTHESIS; } }
+        public bool IsProofHypothesis { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_HYPOTHESIS; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by lemma
@@ -1059,7 +1059,7 @@ namespace Microsoft.Z3
         /// It converts the proof in a proof for (or (not l_1) ... (not l_n)),
         /// when T1 contains the hypotheses: l_1, ..., l_n.
         /// </remarks>
-        public bool IsProofLemma { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_LEMMA; } }
+        public bool IsProofLemma { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_LEMMA; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by unit resolution
@@ -1071,7 +1071,7 @@ namespace Microsoft.Z3
         /// T(n+1):  (not l_n)
         /// [unit-resolution T1 ... T(n+1)]: (or l_1' ... l_m')
         /// </remarks>
-        public bool IsProofUnitResolution { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_UNIT_RESOLUTION; } }
+        public bool IsProofUnitResolution { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_UNIT_RESOLUTION; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by iff-true
@@ -1080,7 +1080,7 @@ namespace Microsoft.Z3
         /// T1: p
         /// [iff-true T1]: (iff p true)
         /// </remarks>
-        public bool IsProofIFFTrue { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_IFF_TRUE; } }
+        public bool IsProofIFFTrue { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_IFF_TRUE; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by iff-false
@@ -1089,7 +1089,7 @@ namespace Microsoft.Z3
         /// T1: (not p)
         /// [iff-false T1]: (iff p false)
         /// </remarks>
-        public bool IsProofIFFFalse { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_IFF_FALSE; } }
+        public bool IsProofIFFFalse { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_IFF_FALSE; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by commutativity
@@ -1102,7 +1102,7 @@ namespace Microsoft.Z3
         /// This proof object has no antecedents.
         /// Remark: if f is bool, then = is iff.
         /// </remarks>
-        public bool IsProofCommutativity { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_COMMUTATIVITY; } }
+        public bool IsProofCommutativity { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_COMMUTATIVITY; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for Tseitin-like axioms
@@ -1138,7 +1138,7 @@ namespace Microsoft.Z3
         /// unfolding the Boolean connectives in the axioms a small
         /// bounded number of steps (=3).
         /// </remarks>
-        public bool IsProofDefAxiom { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_DEF_AXIOM; } }
+        public bool IsProofDefAxiom { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_DEF_AXIOM; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for introduction of a name
@@ -1161,7 +1161,7 @@ namespace Microsoft.Z3
         /// Otherwise:
         /// [def-intro]: (= n e)       
         /// </remarks>
-        public bool IsProofDefIntro { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_DEF_INTRO; } }
+        public bool IsProofDefIntro { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_DEF_INTRO; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for application of a definition
@@ -1171,7 +1171,7 @@ namespace Microsoft.Z3
         ///  F is 'equivalent' to n, given that T1 is a proof that
         ///  n is a name for F.
         /// </remarks>
-        public bool IsProofApplyDef { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_APPLY_DEF; } }
+        public bool IsProofApplyDef { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_APPLY_DEF; } }
 
         /// <summary>
         /// Indicates whether the term is a proof iff-oeq
@@ -1180,7 +1180,7 @@ namespace Microsoft.Z3
         /// T1: (iff p q)
         /// [iff~ T1]: (~ p q)
         /// </remarks>
-        public bool IsProofIFFOEQ { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_IFF_OEQ; } }
+        public bool IsProofIFFOEQ { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_IFF_OEQ; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for a positive NNF step
@@ -1208,7 +1208,7 @@ namespace Microsoft.Z3
         /// NNF_NEG furthermore handles the case where negation is pushed
         /// over Boolean connectives 'and' and 'or'.
         /// </remarks>
-        public bool IsProofNNFPos { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_NNF_POS; } }
+        public bool IsProofNNFPos { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_NNF_POS; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for a negative NNF step
@@ -1233,7 +1233,7 @@ namespace Microsoft.Z3
         ///   [nnf-neg T1 T2 T3 T4]: (~ (not (iff s_1 s_2))
         ///                             (and (or r_1 r_2) (or r_1' r_2')))
         /// </remarks>
-        public bool IsProofNNFNeg { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_NNF_NEG; } }
+        public bool IsProofNNFNeg { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_NNF_NEG; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for (~ P Q) here Q is in negation normal form.
@@ -1245,7 +1245,7 @@ namespace Microsoft.Z3
         /// 
         /// This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO.
         /// </remarks>
-        public bool IsProofNNFStar { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_NNF_STAR; } }
+        public bool IsProofNNFStar { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_NNF_STAR; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for (~ P Q) where Q is in conjunctive normal form.
@@ -1255,7 +1255,7 @@ namespace Microsoft.Z3
         /// This proof object is only used if the parameter PROOF_MODE is 1.       
         /// This proof object may have n antecedents. Each antecedent is a PR_DEF_INTRO.          
         /// </remarks>
-        public bool IsProofCNFStar { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_CNF_STAR; } }
+        public bool IsProofCNFStar { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_CNF_STAR; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for a Skolemization step
@@ -1268,7 +1268,7 @@ namespace Microsoft.Z3
         ///   
         /// This proof object has no antecedents.
         /// </remarks>
-        public bool IsProofSkolemize { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_SKOLEMIZE; } }
+        public bool IsProofSkolemize { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_SKOLEMIZE; } }
 
         /// <summary>
         /// Indicates whether the term is a proof by modus ponens for equi-satisfiability.
@@ -1279,7 +1279,7 @@ namespace Microsoft.Z3
         /// T2: (~ p q)
         /// [mp~ T1 T2]: q  
         /// </remarks>
-        public bool IsProofModusPonensOEQ { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_MODUS_PONENS_OEQ; } }
+        public bool IsProofModusPonensOEQ { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_MODUS_PONENS_OEQ; } }
 
         /// <summary>
         /// Indicates whether the term is a proof for theory lemma
@@ -1298,7 +1298,7 @@ namespace Microsoft.Z3
         ///   (iff (= t1 t2) (and (&lt;= t1 t2) (&lt;= t2 t1)))
         /// - gcd-test - Indicates an integer linear arithmetic lemma that uses a gcd test.
         /// </remarks>
-        public bool IsProofTheoryLemma { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_TH_LEMMA; } }
+        public bool IsProofTheoryLemma { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_PR_TH_LEMMA; } }
         #endregion
 
         #region Relational Terms
@@ -1323,40 +1323,40 @@ namespace Microsoft.Z3
         /// The function takes <c>n+1</c> arguments, where the first argument is the relation and the remaining <c>n</c> elements 
         /// correspond to the <c>n</c> columns of the relation.
         /// </remarks>
-        public bool IsRelationStore { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_STORE; } }
+        public bool IsRelationStore { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_STORE; } }
 
         /// <summary>
         /// Indicates whether the term is an empty relation
         /// </summary>
-        public bool IsEmptyRelation { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_EMPTY; } }
+        public bool IsEmptyRelation { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_EMPTY; } }
 
         /// <summary>
         /// Indicates whether the term is a test for the emptiness of a relation
         /// </summary>
-        public bool IsIsEmptyRelation { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_IS_EMPTY; } }
+        public bool IsIsEmptyRelation { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_IS_EMPTY; } }
 
         /// <summary>
         /// Indicates whether the term is a relational join
         /// </summary>
-        public bool IsRelationalJoin { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_JOIN; } }
+        public bool IsRelationalJoin { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_JOIN; } }
 
         /// <summary>
         /// Indicates whether the term is the union or convex hull of two relations. 
         /// </summary>
         /// <remarks>The function takes two arguments.</remarks>
-        public bool IsRelationUnion { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_UNION; } }
+        public bool IsRelationUnion { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_UNION; } }
 
         /// <summary>
         /// Indicates whether the term is the widening of two relations
         /// </summary>
         /// <remarks>The function takes two arguments.</remarks>
-        public bool IsRelationWiden { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_WIDEN; } }
+        public bool IsRelationWiden { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_WIDEN; } }
 
         /// <summary>
         /// Indicates whether the term is a projection of columns (provided as numbers in the parameters).
         /// </summary>
         /// <remarks>The function takes one argument.</remarks>
-        public bool IsRelationProject { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_PROJECT; } }
+        public bool IsRelationProject { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_PROJECT; } }
 
         /// <summary>
         /// Indicates whether the term is a relation filter
@@ -1368,7 +1368,7 @@ namespace Microsoft.Z3
         /// corresponding to the columns of the relation.
         /// So the first column in the relation has index 0.
         /// </remarks>
-        public bool IsRelationFilter { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_FILTER; } }
+        public bool IsRelationFilter { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_FILTER; } }
 
         /// <summary>
         /// Indicates whether the term is an intersection of a relation with the negation of another.
@@ -1384,7 +1384,7 @@ namespace Microsoft.Z3
         /// target are elements in x in pos, such that there is no y in neg that agrees with
         /// x on the columns c1, d1, .., cN, dN.
         /// </remarks>
-        public bool IsRelationNegationFilter { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_NEGATION_FILTER; } }
+        public bool IsRelationNegationFilter { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_NEGATION_FILTER; } }
 
         /// <summary>
         /// Indicates whether the term is the renaming of a column in a relation
@@ -1393,12 +1393,12 @@ namespace Microsoft.Z3
         /// The function takes one argument.
         /// The parameters contain the renaming as a cycle.
         /// </remarks>
-        public bool IsRelationRename { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_RENAME; } }
+        public bool IsRelationRename { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_RENAME; } }
 
         /// <summary>
         /// Indicates whether the term is the complement of a relation
         /// </summary>
-        public bool IsRelationComplement { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_COMPLEMENT; } }
+        public bool IsRelationComplement { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_COMPLEMENT; } }
 
         /// <summary>
         /// Indicates whether the term is a relational select
@@ -1408,7 +1408,7 @@ namespace Microsoft.Z3
         /// The function takes <c>n+1</c> arguments, where the first argument is a relation,
         /// and the remaining <c>n</c> arguments correspond to a record.
         /// </remarks>
-        public bool IsRelationSelect { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_SELECT; } }
+        public bool IsRelationSelect { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_SELECT; } }
 
         /// <summary>
         /// Indicates whether the term is a relational clone (copy)
@@ -1420,7 +1420,7 @@ namespace Microsoft.Z3
         /// for terms of kind <seealso cref="IsRelationUnion"/> 
         /// to perform destructive updates to the first argument.
         /// </remarks>
-        public bool IsRelationClone { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_CLONE; } }
+        public bool IsRelationClone { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_RA_CLONE; } }
         #endregion
 
         #region Finite domain terms
@@ -1439,7 +1439,7 @@ namespace Microsoft.Z3
         /// <summary>
         /// Indicates whether the term is a less than predicate over a finite domain.
         /// </summary>
-        public bool IsFiniteDomainLT { get { return FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_FD_LT; } }
+        public bool IsFiniteDomainLT { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_FD_LT; } }
         #endregion
         #endregion
 

src/api/dotnet/Global.cs

@@ -43,7 +43,7 @@ namespace Microsoft.Z3
         /// The parameter names are case-insensitive. The character '-' should be viewed as an "alias" for '_'.
         /// Thus, the following parameter names are considered equivalent: "pp.decimal-precision"  and "PP.DECIMAL_PRECISION".
         /// This function can be used to set parameters for a specific Z3 module.
-        /// This can be done by using <module-name>.<parameter-name>.
+        /// This can be done by using [module-name].[parameter-name].
         /// For example:
         /// Z3_global_param_set('pp.decimal', 'true')
         /// will set the parameter "decimal" in the module "pp" to true.

src/api/dotnet/Microsoft.Z3.csproj

@@ -24,8 +24,7 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DocumentationFile>
+    <DocumentationFile>..\Debug\Microsoft.Z3.XML</DocumentationFile>
-    </DocumentationFile>
     <CodeContractsEnableRuntimeChecking>False</CodeContractsEnableRuntimeChecking>
     <CodeContractsRuntimeOnlyPublicSurface>False</CodeContractsRuntimeOnlyPublicSurface>
     <CodeContractsRuntimeThrowOnFailure>True</CodeContractsRuntimeThrowOnFailure>
@@ -140,6 +139,7 @@
     <CodeContractsRuntimeCheckingLevel>Full</CodeContractsRuntimeCheckingLevel>
     <CodeContractsReferenceAssembly>%28none%29</CodeContractsReferenceAssembly>
     <CodeContractsAnalysisWarningLevel>0</CodeContractsAnalysisWarningLevel>
+    <DocumentationFile>..\x64\Debug\Microsoft.Z3.XML</DocumentationFile>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
     <OutputPath>..\x64\external_64\</OutputPath>
@@ -193,7 +193,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'external|x64'">
     <OutputPath>..\x64\external\</OutputPath>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DocumentationFile>..\external\Microsoft.Z3.xml</DocumentationFile>
+    <DocumentationFile>..\x64\external\Microsoft.Z3.XML</DocumentationFile>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
     <PlatformTarget>x64</PlatformTarget>
@@ -220,7 +220,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release_delaysign|AnyCPU'">
     <OutputPath>..\Release_delaysign\</OutputPath>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DocumentationFile>..\Release_delaysign\Microsoft.Z3.xml</DocumentationFile>
+    <DocumentationFile>..\Release_delaysign\Microsoft.Z3.XML</DocumentationFile>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -238,7 +238,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release_delaysign|x64'">
     <OutputPath>bin\x64\Release_delaysign\</OutputPath>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DocumentationFile>..\x64\external_64\Microsoft.Z3.xml</DocumentationFile>
+    <DocumentationFile>bin\x64\Release_delaysign\Microsoft.Z3.XML</DocumentationFile>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
     <PlatformTarget>x64</PlatformTarget>
@@ -266,11 +266,12 @@
     <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
     <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
     <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <DocumentationFile>bin\x86\Debug\Microsoft.Z3.XML</DocumentationFile>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
     <OutputPath>bin\x86\Release\</OutputPath>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DocumentationFile>..\external\Microsoft.Z3.xml</DocumentationFile>
+    <DocumentationFile>bin\x86\Release\Microsoft.Z3.xml</DocumentationFile>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
     <PlatformTarget>x86</PlatformTarget>
@@ -285,7 +286,7 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'external|x86'">
     <OutputPath>bin\x86\external\</OutputPath>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DocumentationFile>..\external\Microsoft.Z3.xml</DocumentationFile>
+    <DocumentationFile>bin\x86\external\Microsoft.Z3.XML</DocumentationFile>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
     <PlatformTarget>x86</PlatformTarget>
@@ -303,7 +304,7 @@
     <OutputPath>bin\x86\Release_delaysign\</OutputPath>
     <DefineConstants>DELAYSIGN</DefineConstants>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <DocumentationFile>..\Release_delaysign\Microsoft.Z3.xml</DocumentationFile>
+    <DocumentationFile>bin\x86\Release_delaysign\Microsoft.Z3.XML</DocumentationFile>
     <Optimize>true</Optimize>
     <DebugType>pdbonly</DebugType>
     <PlatformTarget>x86</PlatformTarget>
@@ -399,4 +400,4 @@
   <Target Name="AfterBuild">
   </Target>
   -->
-</Project>
+</Project>

src/api/dotnet/Solver.cs

@@ -132,7 +132,8 @@ namespace Microsoft.Z3
         /// <remarks>
         /// This API is an alternative to <see cref="Check"/> with assumptions for extracting unsat cores.
         /// Both APIs can be used in the same solver. The unsat core will contain a combination
-        /// of the Boolean variables provided using <see cref="AssertAndTrack"/> and the Boolean literals
+        /// of the Boolean variables provided using <see cref="AssertAndTrack(BoolExpr[],BoolExpr[])"/> 
+        /// and the Boolean literals
         /// provided using <see cref="Check"/> with assumptions.
         /// </remarks>        
         public void AssertAndTrack(BoolExpr[] constraints, BoolExpr[] ps)
@@ -156,7 +157,8 @@ namespace Microsoft.Z3
         /// <remarks>
         /// This API is an alternative to <see cref="Check"/> with assumptions for extracting unsat cores.
         /// Both APIs can be used in the same solver. The unsat core will contain a combination
-        /// of the Boolean variables provided using <see cref="AssertAndTrack"/> and the Boolean literals
+        /// of the Boolean variables provided using <see cref="AssertAndTrack(BoolExpr[],BoolExpr[])"/> 
+        /// and the Boolean literals
         /// provided using <see cref="Check"/> with assumptions.
         /// </remarks>        
         public void AssertAndTrack(BoolExpr constraint, BoolExpr p)

src/ast/fpa/fpa2bv_converter.cpp

@@ -872,8 +872,19 @@ void fpa2bv_converter::mk_div(func_decl * f, unsigned num, expr * const * args,
     sticky = m.mk_app(m_bv_util.get_fid(), OP_BREDOR, m_bv_util.mk_extract(extra_bits-2, 0, quotient));
     res_sig = m_bv_util.mk_concat(m_bv_util.mk_extract(extra_bits+sbits+1, extra_bits-1, quotient), sticky);
 
-    SASSERT(m_bv_util.get_bv_size(res_sig) == (sbits + 4));   
+    SASSERT(m_bv_util.get_bv_size(res_sig) == (sbits + 4));
 
+    expr_ref res_sig_lz(m);
+    mk_leading_zeros(res_sig, sbits + 4, res_sig_lz);
+    dbg_decouple("fpa2bv_div_res_sig_lz", res_sig_lz);    
+    expr_ref res_sig_shift_amount(m);
+    res_sig_shift_amount = m_bv_util.mk_bv_sub(res_sig_lz, m_bv_util.mk_numeral(1, sbits + 4));
+    dbg_decouple("fpa2bv_div_res_sig_shift_amount", res_sig_shift_amount);
+    expr_ref shift_cond(m);
+    shift_cond = m_bv_util.mk_ule(res_sig_lz, m_bv_util.mk_numeral(1, sbits + 4));
+    m_simp.mk_ite(shift_cond, res_sig, m_bv_util.mk_bv_shl(res_sig, res_sig_shift_amount), res_sig);
+    m_simp.mk_ite(shift_cond, res_exp, m_bv_util.mk_bv_sub(res_exp, m_bv_util.mk_extract(ebits+1, 0, res_sig_shift_amount)), res_exp);
+    
     round(f->get_range(), rm, res_sgn, res_sig, res_exp, v8);
 
     // And finally, we tie them together.    
@@ -2743,215 +2754,3 @@ void fpa2bv_converter::round(sort * s, expr_ref & rm, expr_ref & sgn, expr_ref &
 
     TRACE("fpa2bv_round", tout << "ROUND = " << mk_ismt2_pp(result, m) << std::endl; );
 }
-
-void fpa2bv_model_converter::display(std::ostream & out) {
-    out << "(fpa2bv-model-converter";
-    for (obj_map<func_decl, expr*>::iterator it = m_const2bv.begin();
-         it != m_const2bv.end();
-         it++) {
-             const symbol & n = it->m_key->get_name();
-             out << "\n  (" << n << " ";
-             unsigned indent = n.size() + 4;
-             out << mk_ismt2_pp(it->m_value, m, indent) << ")";
-    }
-    for (obj_map<func_decl, expr*>::iterator it = m_rm_const2bv.begin();
-         it != m_rm_const2bv.end();
-         it++) {
-             const symbol & n = it->m_key->get_name();
-             out << "\n  (" << n << " ";
-             unsigned indent = n.size() + 4;
-             out << mk_ismt2_pp(it->m_value, m, indent) << ")";
-    }
-    for (obj_map<func_decl, func_decl*>::iterator it = m_uf2bvuf.begin();
-         it != m_uf2bvuf.end();
-         it++) {
-             const symbol & n = it->m_key->get_name();
-             out << "\n  (" << n << " ";
-             unsigned indent = n.size() + 4;
-             out << mk_ismt2_pp(it->m_value, m, indent) << ")";
-    }
-    for (obj_map<func_decl, func_decl_triple>::iterator it = m_uf23bvuf.begin();
-         it != m_uf23bvuf.end();
-         it++) {
-             const symbol & n = it->m_key->get_name();
-             out << "\n  (" << n << " ";
-             unsigned indent = n.size() + 4;
-             out << mk_ismt2_pp(it->m_value.f_sgn, m, indent) << " ; " << 
-             mk_ismt2_pp(it->m_value.f_sig, m, indent) << " ; " << 
-             mk_ismt2_pp(it->m_value.f_exp, m, indent) << " ; " <<
-             ")";
-    }
-    out << ")" << std::endl;
-}
-
-model_converter * fpa2bv_model_converter::translate(ast_translation & translator) {
-    fpa2bv_model_converter * res = alloc(fpa2bv_model_converter, translator.to());
-    for (obj_map<func_decl, expr*>::iterator it = m_const2bv.begin();
-         it != m_const2bv.end();
-         it++)
-    {
-        func_decl * k = translator(it->m_key);
-        expr * v = translator(it->m_value);
-        res->m_const2bv.insert(k, v);
-        translator.to().inc_ref(k);
-        translator.to().inc_ref(v);
-    }
-    for (obj_map<func_decl, expr*>::iterator it = m_rm_const2bv.begin();
-         it != m_rm_const2bv.end();
-         it++)
-    {
-        func_decl * k = translator(it->m_key);
-        expr * v = translator(it->m_value);
-        res->m_rm_const2bv.insert(k, v);
-        translator.to().inc_ref(k);
-        translator.to().inc_ref(v);        
-    }
-    return res;
-}
-
-void fpa2bv_model_converter::convert(model * bv_mdl, model * float_mdl) {
-    float_util fu(m);
-    bv_util bu(m);
-    mpf fp_val;
-    unsynch_mpz_manager & mpzm = fu.fm().mpz_manager();
-    unsynch_mpq_manager & mpqm = fu.fm().mpq_manager();
-
-    TRACE("fpa2bv_mc", tout << "BV Model: " << std::endl;
-        for (unsigned i = 0 ; i < bv_mdl->get_num_constants(); i++)
-            tout << bv_mdl->get_constant(i)->get_name() << " --> " << 
-                mk_ismt2_pp(bv_mdl->get_const_interp(bv_mdl->get_constant(i)), m) << std::endl;
-        );
-    
-    obj_hashtable<func_decl> seen;
-
-    for (obj_map<func_decl, expr*>::iterator it = m_const2bv.begin();
-         it != m_const2bv.end();
-         it++) 
-    {
-        func_decl * var = it->m_key;
-        app * a = to_app(it->m_value);
-        SASSERT(fu.is_float(var->get_range()));
-        SASSERT(var->get_range()->get_num_parameters() == 2);
-        
-        unsigned ebits = fu.get_ebits(var->get_range());
-        unsigned sbits = fu.get_sbits(var->get_range());
-
-        expr_ref sgn(m), sig(m), exp(m);
-        sgn = bv_mdl->get_const_interp(to_app(a->get_arg(0))->get_decl());
-        sig = bv_mdl->get_const_interp(to_app(a->get_arg(1))->get_decl());
-        exp = bv_mdl->get_const_interp(to_app(a->get_arg(2))->get_decl());
-
-        seen.insert(to_app(a->get_arg(0))->get_decl());
-        seen.insert(to_app(a->get_arg(1))->get_decl());
-        seen.insert(to_app(a->get_arg(2))->get_decl());
-
-        if (!sgn && !sig && !exp)
-            continue;
-        
-        unsigned sgn_sz = bu.get_bv_size(m.get_sort(a->get_arg(0)));
-        unsigned sig_sz = bu.get_bv_size(m.get_sort(a->get_arg(1))) - 1;
-        unsigned exp_sz = bu.get_bv_size(m.get_sort(a->get_arg(2)));
-
-        rational sgn_q(0), sig_q(0), exp_q(0);
-
-        if (sgn) bu.is_numeral(sgn, sgn_q, sgn_sz);
-        if (sig) bu.is_numeral(sig, sig_q, sig_sz);
-        if (exp) bu.is_numeral(exp, exp_q, exp_sz);        
-
-        // un-bias exponent
-        rational exp_unbiased_q;
-        exp_unbiased_q = exp_q - fu.fm().m_powers2.m1(ebits-1);
-        
-        mpz sig_z; mpf_exp_t exp_z;
-        mpzm.set(sig_z, sig_q.to_mpq().numerator());
-        exp_z = mpzm.get_int64(exp_unbiased_q.to_mpq().numerator());
-
-        TRACE("fpa2bv_mc", tout << var->get_name() << " == [" << sgn_q.to_string() << " " << 
-            mpzm.to_string(sig_z) << " " << exp_z << "(" << exp_q.to_string() << ")]" << std::endl; );
-        
-        fu.fm().set(fp_val, ebits, sbits, !mpqm.is_zero(sgn_q.to_mpq()), sig_z, exp_z);
-
-        float_mdl->register_decl(var, fu.mk_value(fp_val));
-        
-        mpzm.del(sig_z);
-    }
-
-    for (obj_map<func_decl, expr*>::iterator it = m_rm_const2bv.begin();
-         it != m_rm_const2bv.end();
-         it++) 
-    {
-        func_decl * var = it->m_key;
-        app * a = to_app(it->m_value);
-        SASSERT(fu.is_rm(var->get_range()));        
-        rational val(0);
-        unsigned sz = 0;
-        if (a && bu.is_numeral(a, val, sz)) {
-            TRACE("fpa2bv_mc", tout << var->get_name() << " == " << val.to_string() << std::endl; );
-            SASSERT(val.is_uint64());
-            switch (val.get_uint64())
-            {
-            case BV_RM_TIES_TO_AWAY: float_mdl->register_decl(var, fu.mk_round_nearest_ties_to_away()); break;
-            case BV_RM_TIES_TO_EVEN: float_mdl->register_decl(var, fu.mk_round_nearest_ties_to_even()); break;
-            case BV_RM_TO_NEGATIVE: float_mdl->register_decl(var, fu.mk_round_toward_negative()); break;
-            case BV_RM_TO_POSITIVE: float_mdl->register_decl(var, fu.mk_round_toward_positive()); break;
-            case BV_RM_TO_ZERO: 
-            default: float_mdl->register_decl(var, fu.mk_round_toward_zero());
-            }
-            seen.insert(var);
-        }        
-    }
-
-    for (obj_map<func_decl, func_decl*>::iterator it = m_uf2bvuf.begin();
-         it != m_uf2bvuf.end();
-         it++) 
-        seen.insert(it->m_value);
-
-    for (obj_map<func_decl, func_decl_triple>::iterator it = m_uf23bvuf.begin();
-         it != m_uf23bvuf.end();
-         it++) 
-    {
-        seen.insert(it->m_value.f_sgn);
-        seen.insert(it->m_value.f_sig);
-        seen.insert(it->m_value.f_exp);
-    }
-
-    fu.fm().del(fp_val);
-
-    // Keep all the non-float constants.
-    unsigned sz = bv_mdl->get_num_constants();
-    for (unsigned i = 0; i < sz; i++)
-    {
-        func_decl * c = bv_mdl->get_constant(i);
-        if (!seen.contains(c))
-            float_mdl->register_decl(c, bv_mdl->get_const_interp(c));
-    }
-
-    // And keep everything else
-    sz = bv_mdl->get_num_functions();
-    for (unsigned i = 0; i < sz; i++)
-    {
-        func_decl * f = bv_mdl->get_function(i);
-        if (!seen.contains(f))
-        {
-            TRACE("fpa2bv_mc", tout << "Keeping: " << mk_ismt2_pp(f, m) << std::endl; );
-            func_interp * val = bv_mdl->get_func_interp(f);
-            float_mdl->register_decl(f, val);
-        }
-    }
-
-    sz = bv_mdl->get_num_uninterpreted_sorts();
-    for (unsigned i = 0; i < sz; i++)
-    {
-        sort * s = bv_mdl->get_uninterpreted_sort(i);
-        ptr_vector<expr> u = bv_mdl->get_universe(s);
-        float_mdl->register_usort(s, u.size(), u.c_ptr());
-    }
-}
-
-model_converter * mk_fpa2bv_model_converter(ast_manager & m, 
-                                            obj_map<func_decl, expr*> const & const2bv,
-                                            obj_map<func_decl, expr*> const & rm_const2bv,
-                                            obj_map<func_decl, func_decl*> const & uf2bvuf,      
-                                            obj_map<func_decl, func_decl_triple> const & uf23bvuf) {
-    return alloc(fpa2bv_model_converter, m, const2bv, rm_const2bv, uf2bvuf, uf23bvuf);
-}

src/ast/fpa/fpa2bv_converter.h

@@ -24,13 +24,10 @@ Notes:
 #include"ref_util.h"
 #include"float_decl_plugin.h"
 #include"bv_decl_plugin.h"
-#include"model_converter.h"
 #include"basic_simplifier_plugin.h"
 
 typedef enum { BV_RM_TIES_TO_AWAY=0, BV_RM_TIES_TO_EVEN=1, BV_RM_TO_NEGATIVE=2, BV_RM_TO_POSITIVE=3, BV_RM_TO_ZERO=4 } BV_RM_VAL;
 
-class fpa2bv_model_converter;
-
 struct func_decl_triple {
         func_decl_triple () { f_sgn = 0; f_sig = 0; f_exp = 0; }
         func_decl_triple (func_decl * sgn, func_decl * sig, func_decl * exp)
@@ -173,86 +170,4 @@ protected:
         expr_ref & res_sgn, expr_ref & res_sig, expr_ref & res_exp);
 };
 
-
-class fpa2bv_model_converter : public model_converter {
-    ast_manager               & m;
-    obj_map<func_decl, expr*>   m_const2bv;
-    obj_map<func_decl, expr*>   m_rm_const2bv;
-    obj_map<func_decl, func_decl*>  m_uf2bvuf;        
-    obj_map<func_decl, func_decl_triple>  m_uf23bvuf;
-
-public:
-    fpa2bv_model_converter(ast_manager & m, obj_map<func_decl, expr*> const & const2bv,
-                                            obj_map<func_decl, expr*> const & rm_const2bv,
-                                            obj_map<func_decl, func_decl*> const & uf2bvuf,      
-                                            obj_map<func_decl, func_decl_triple> const & uf23bvuf) : 
-      m(m) {
-          // Just create a copy?
-          for (obj_map<func_decl, expr*>::iterator it = const2bv.begin();
-               it != const2bv.end();
-               it++) 
-          {
-               m_const2bv.insert(it->m_key, it->m_value);
-               m.inc_ref(it->m_key);
-               m.inc_ref(it->m_value);
-          }
-          for (obj_map<func_decl, expr*>::iterator it = rm_const2bv.begin();
-               it != rm_const2bv.end();
-               it++) 
-          {
-               m_rm_const2bv.insert(it->m_key, it->m_value);
-               m.inc_ref(it->m_key);
-               m.inc_ref(it->m_value);
-          }
-          for (obj_map<func_decl, func_decl*>::iterator it = uf2bvuf.begin();
-               it != uf2bvuf.end();
-               it++) 
-          {
-               m_uf2bvuf.insert(it->m_key, it->m_value);
-               m.inc_ref(it->m_key);
-               m.inc_ref(it->m_value);
-          }
-          for (obj_map<func_decl, func_decl_triple>::iterator it = uf23bvuf.begin();
-               it != uf23bvuf.end();
-               it++) 
-          {
-               m_uf23bvuf.insert(it->m_key, it->m_value);
-               m.inc_ref(it->m_key);               
-          }
-      }
-
-    virtual ~fpa2bv_model_converter() {
-        dec_ref_map_key_values(m, m_const2bv);
-        dec_ref_map_key_values(m, m_rm_const2bv);
-    }
-
-    virtual void operator()(model_ref & md, unsigned goal_idx) {
-        SASSERT(goal_idx == 0);
-        model * new_model = alloc(model, m);
-        obj_hashtable<func_decl> bits;
-        convert(md.get(), new_model);
-        md = new_model;
-    }
-
-    virtual void operator()(model_ref & md) {
-        operator()(md, 0);
-    }
-
-    void display(std::ostream & out);
-
-    virtual model_converter * translate(ast_translation & translator);
-
-protected:
-    fpa2bv_model_converter(ast_manager & m) : m(m) { }
-    
-    void convert(model * bv_mdl, model * float_mdl);
-};
-
-
-model_converter * mk_fpa2bv_model_converter(ast_manager & m, 
-                                            obj_map<func_decl, expr*> const & const2bv,
-                                            obj_map<func_decl, expr*> const & rm_const2bv,
-                                            obj_map<func_decl, func_decl*> const & uf2bvuf,      
-                                            obj_map<func_decl, func_decl_triple> const & uf23bvuf);
-
 #endif

src/duality/duality_profiling.cpp

@@ -1,134 +1,134 @@
-/*++
+/*++
-Copyright (c) 2011 Microsoft Corporation
+Copyright (c) 2011 Microsoft Corporation
-
+
-Module Name:
+Module Name:
-
+
-    duality_profiling.cpp
+    duality_profiling.cpp
-
+
-Abstract:
+Abstract:
-
+
-   collection performance information for duality
+   collection performance information for duality
-
+
-Author:
+Author:
-
+
-    Ken McMillan (kenmcmil)
+    Ken McMillan (kenmcmil)
-
+
-Revision History:
+Revision History:
-
+
-
+
---*/
+--*/
-
+
-
+
-#include <map>
+#include <map>
-#include <iostream>
+#include <iostream>
-#include <string>
+#include <string>
-#include <string.h>
+#include <string.h>
-#include <stdlib.h>
+#include <stdlib.h>
-
+
-#ifdef _WINDOWS
+#ifdef _WINDOWS
-#pragma warning(disable:4996)
+#pragma warning(disable:4996)
-#pragma warning(disable:4800)
+#pragma warning(disable:4800)
-#pragma warning(disable:4267)
+#pragma warning(disable:4267)
-#endif
+#endif
-
+
-#include "duality_wrapper.h"
+#include "duality_wrapper.h"
-#include "iz3profiling.h"
+#include "iz3profiling.h"
-
+
-namespace Duality {
+namespace Duality {
-  
+  
-  void show_time(){
+  void show_time(){
-    output_time(std::cout,current_time());
+    output_time(std::cout,current_time());
-    std::cout << "\n";
+    std::cout << "\n";
-  }
+  }
-
+
-  typedef std::map<const char*, struct node> nmap;
+  typedef std::map<const char*, struct node> nmap;
-  
+  
-  struct node {
+  struct node {
-    std::string name;
+    std::string name;
-    clock_t time;
+    clock_t time;
-    clock_t start_time;
+    clock_t start_time;
-    nmap sub;
+    nmap sub;
-    struct node *parent;
+    struct node *parent;
-    
+    
-    node();
+    node();
-  } top;
+  } top;
-  
+  
-  node::node(){
+  node::node(){
-    time =  0;
+    time =  0;
-    parent = 0;
+    parent = 0;
-  }
+  }
-  
+  
-  struct node *current;
+  struct node *current;
-  
+  
-  struct init {
+  struct init {
-    init(){
+    init(){
-      top.name = "TOTAL";
+      top.name = "TOTAL";
-      current = &top;
+      current = &top;
-    }
+    }
-  } initializer;
+  } initializer;
-  
+  
-  struct time_entry {
+  struct time_entry {
-    clock_t t;
+    clock_t t;
-    time_entry(){t = 0;};
+    time_entry(){t = 0;};
-    void add(clock_t incr){t += incr;}
+    void add(clock_t incr){t += incr;}
-  };
+  };
-  
+  
-  struct ltstr
+  struct ltstr
-  {
+  {
-    bool operator()(const char* s1, const char* s2) const
+    bool operator()(const char* s1, const char* s2) const
-    {
+    {
-      return strcmp(s1, s2) < 0;
+      return strcmp(s1, s2) < 0;
-    }
+    }
-  };
+  };
-  
+  
-  typedef  std::map<const char*, time_entry, ltstr> tmap;
+  typedef  std::map<const char*, time_entry, ltstr> tmap;
-
+
-  static std::ostream *pfs;
+  static std::ostream *pfs;
-
+
-  void print_node(node &top, int indent, tmap &totals){
+  void print_node(node &top, int indent, tmap &totals){
-    for(int i = 0; i < indent; i++) (*pfs) << "  ";
+    for(int i = 0; i < indent; i++) (*pfs) << "  ";
-    (*pfs) << top.name;
+    (*pfs) << top.name;
-    int dots = 70 - 2 * indent - top.name.size();
+    int dots = 70 - 2 * indent - top.name.size();
-    for(int i = 0; i <dots; i++) (*pfs) << ".";
+    for(int i = 0; i <dots; i++) (*pfs) << ".";
-    output_time(*pfs, top.time);
+    output_time(*pfs, top.time);
-    (*pfs) << std::endl;
+    (*pfs) << std::endl;
-    if(indent != 0)totals[top.name.c_str()].add(top.time);
+    if(indent != 0)totals[top.name.c_str()].add(top.time);
-    for(nmap::iterator it = top.sub.begin(); it != top.sub.end(); it++)
+    for(nmap::iterator it = top.sub.begin(); it != top.sub.end(); it++)
-      print_node(it->second,indent+1,totals);
+      print_node(it->second,indent+1,totals);
-  }
+  }
-  
+  
-  void print_profile(std::ostream &os) {
+  void print_profile(std::ostream &os) {
-    pfs = &os;
+    pfs = &os;
-    top.time = 0;
+    top.time = 0;
-    for(nmap::iterator it = top.sub.begin(); it != top.sub.end(); it++)
+    for(nmap::iterator it = top.sub.begin(); it != top.sub.end(); it++)
-      top.time += it->second.time;
+      top.time += it->second.time;
-    tmap totals;
+    tmap totals;
-    print_node(top,0,totals);
+    print_node(top,0,totals);
-    (*pfs) << "TOTALS:" << std::endl;
+    (*pfs) << "TOTALS:" << std::endl;
-    for(tmap::iterator it = totals.begin(); it != totals.end(); it++){
+    for(tmap::iterator it = totals.begin(); it != totals.end(); it++){
-      (*pfs) << (it->first) << " ";
+      (*pfs) << (it->first) << " ";
-      output_time(*pfs, it->second.t);
+      output_time(*pfs, it->second.t);
-      (*pfs) << std::endl;
+      (*pfs) << std::endl;
-    }
+    }
-    profiling::print(os); // print the interpolation stats
+    profiling::print(os); // print the interpolation stats
-  }
+  }
-  
+  
-  void timer_start(const char *name){
+  void timer_start(const char *name){
-    node &child = current->sub[name];
+    node &child = current->sub[name];
-    if(child.name.empty()){ // a new node
+    if(child.name.empty()){ // a new node
-      child.parent = current;
+      child.parent = current;
-      child.name = name;
+      child.name = name;
-    }
+    }
-    child.start_time = current_time();
+    child.start_time = current_time();
-    current = &child;
+    current = &child;
-  }
+  }
-
+
-  void timer_stop(const char *name){
+  void timer_stop(const char *name){
-    if(current->name != name || !current->parent){
+    if(current->name != name || !current->parent){
-      std::cerr << "imbalanced timer_start and timer_stop";
+      std::cerr << "imbalanced timer_start and timer_stop";
-      exit(1);
+      exit(1);
-    }
+    }
-    current->time += (current_time() - current->start_time);
+    current->time += (current_time() - current->start_time);
-    current = current->parent;
+    current = current->parent;
-  }
+  }
-}
+}

src/duality/duality_profiling.h

@@ -1,38 +1,38 @@
-/*++
+/*++
-Copyright (c) 2011 Microsoft Corporation
+Copyright (c) 2011 Microsoft Corporation
-
+
-Module Name:
+Module Name:
-
+
-    duality_profiling.h
+    duality_profiling.h
-
+
-Abstract:
+Abstract:
-
+
-   collection performance information for duality
+   collection performance information for duality
-
+
-Author:
+Author:
-
+
-    Ken McMillan (kenmcmil)
+    Ken McMillan (kenmcmil)
-
+
-Revision History:
+Revision History:
-
+
-
+
---*/
+--*/
-
+
-#ifndef DUALITYPROFILING_H
+#ifndef DUALITYPROFILING_H
-#define DUALITYPROFILING_H
+#define DUALITYPROFILING_H
-
+
-#include <ostream>
+#include <ostream>
-
+
-namespace Duality {
+namespace Duality {
-  /** Start a timer with given name */
+  /** Start a timer with given name */
-  void timer_start(const char *);
+  void timer_start(const char *);
-  /** Stop a timer with given name */
+  /** Stop a timer with given name */
-  void timer_stop(const char *);
+  void timer_stop(const char *);
-  /** Print out timings */
+  /** Print out timings */
-  void print_profile(std::ostream &s);
+  void print_profile(std::ostream &s);
-  /** Show the current time. */
+  /** Show the current time. */
-  void show_time();
+  void show_time();
-}
+}
-
+
-#endif
+#endif
-
+

src/duality/duality_wrapper.cpp

@@ -340,6 +340,12 @@ expr context::make_quant(decl_kind op, const std::vector<sort> &_sorts, const st
     params p;
     return simplify(p);
   }
+  
+  expr context::make_var(int idx, const sort &s){
+    ::sort * a = to_sort(s.raw());
+    return cook(m().mk_var(idx,a));
+  }
+
 
   expr expr::qe_lite() const {
     ::qe_lite qe(m());
@@ -374,6 +380,12 @@ expr context::make_quant(decl_kind op, const std::vector<sort> &_sorts, const st
     return q.ctx().cook(q.m().update_quantifier(thing, is_forall, num_patterns, &_patterns[0], to_expr(b.raw())));
   }
 
+  expr clone_quantifier(decl_kind dk, const expr &q, const expr &b){
+    quantifier *thing = to_quantifier(q.raw());
+    bool is_forall = dk == Forall;
+    return q.ctx().cook(q.m().update_quantifier(thing, is_forall, to_expr(b.raw())));
+  }
+
   void expr::get_patterns(std::vector<expr> &pats) const {
     quantifier *thing = to_quantifier(raw());
     unsigned num_patterns = thing->get_num_patterns();

src/interp/iz3base.h

@@ -1,195 +1,195 @@
-/*++
+/*++
-Copyright (c) 2011 Microsoft Corporation
+Copyright (c) 2011 Microsoft Corporation
-
+
-Module Name:
+Module Name:
-
+
-    iz3base.h
+    iz3base.h
-
+
-Abstract:
+Abstract:
-
+
-   Base class for interpolators. Includes an AST manager and a scoping
+   Base class for interpolators. Includes an AST manager and a scoping
-   object as bases.
+   object as bases.
-
+
-Author:
+Author:
-
+
-    Ken McMillan (kenmcmil)
+    Ken McMillan (kenmcmil)
-
+
-Revision History:
+Revision History:
-
+
---*/
+--*/
-
+
-#ifndef IZ3BASE_H
+#ifndef IZ3BASE_H
-#define IZ3BASE_H
+#define IZ3BASE_H
-
+
-#include "iz3mgr.h"
+#include "iz3mgr.h"
-#include "iz3scopes.h"
+#include "iz3scopes.h"
-
+
-namespace hash_space {
+namespace hash_space {
-  template <>
+  template <>
-    class hash<func_decl *> {
+    class hash<func_decl *> {
-  public:
+  public:
-    size_t operator()(func_decl * const &s) const {
+    size_t operator()(func_decl * const &s) const {
-      return (size_t) s;
+      return (size_t) s;
-    }
+    }
-  };
+  };
-}
+}
-
+
-/* Base class for interpolators. Includes an AST manager and a scoping
+/* Base class for interpolators. Includes an AST manager and a scoping
-   object as bases. */
+   object as bases. */
- 
+ 
-class iz3base : public iz3mgr, public scopes {
+class iz3base : public iz3mgr, public scopes {
-
+
- public:
+ public:
-
+
-  /** Get the range in which an expression occurs. This is the
+  /** Get the range in which an expression occurs. This is the
-      smallest subtree containing all occurrences of the
+      smallest subtree containing all occurrences of the
-      expression. */
+      expression. */
-  range &ast_range(ast);
+  range &ast_range(ast);
-
+
-  /** Get the scope of an expression. This is the set of tree nodes in
+  /** Get the scope of an expression. This is the set of tree nodes in
-      which all of the expression's symbols are in scope. */
+      which all of the expression's symbols are in scope. */
-  range &ast_scope(ast);
+  range &ast_scope(ast);
-
+
-  /** Get the range of a symbol. This is the smallest subtree containing
+  /** Get the range of a symbol. This is the smallest subtree containing
-      all occurrences of the symbol. */ 
+      all occurrences of the symbol. */ 
-  range &sym_range(symb);
+  range &sym_range(symb);
-
+
-  /** Is an expression local (in scope in some frame)? */
+  /** Is an expression local (in scope in some frame)? */
-
+
-  bool is_local(ast node){
+  bool is_local(ast node){
-    return !range_is_empty(ast_scope(node));
+    return !range_is_empty(ast_scope(node));
-  }
+  }
-
+
-  /** Simplify an expression */
+  /** Simplify an expression */
-
+
-  ast simplify(ast);
+  ast simplify(ast);
-
+
-  /** Constructor */
+  /** Constructor */
-
+
-  iz3base(ast_manager &_m_manager,
+  iz3base(ast_manager &_m_manager,
-	 const std::vector<ast> &_cnsts,
+	 const std::vector<ast> &_cnsts,
-	 const std::vector<int> &_parents,
+	 const std::vector<int> &_parents,
-	 const std::vector<ast> &_theory)
+	 const std::vector<ast> &_theory)
-    : iz3mgr(_m_manager), scopes(_parents)  {
+    : iz3mgr(_m_manager), scopes(_parents)  {
-    initialize(_cnsts,_parents,_theory);
+    initialize(_cnsts,_parents,_theory);
-    weak = false;
+    weak = false;
-  }
+  }
-
+
-  iz3base(const iz3mgr& other,
+  iz3base(const iz3mgr& other,
-	 const std::vector<ast> &_cnsts,
+	 const std::vector<ast> &_cnsts,
-	 const std::vector<int> &_parents,
+	 const std::vector<int> &_parents,
-	 const std::vector<ast> &_theory)
+	 const std::vector<ast> &_theory)
-   : iz3mgr(other), scopes(_parents)  {
+   : iz3mgr(other), scopes(_parents)  {
-    initialize(_cnsts,_parents,_theory);
+    initialize(_cnsts,_parents,_theory);
-    weak = false;
+    weak = false;
-  }
+  }
-
+
-  iz3base(const iz3mgr& other,
+  iz3base(const iz3mgr& other,
-	  const std::vector<std::vector<ast> > &_cnsts,
+	  const std::vector<std::vector<ast> > &_cnsts,
-	 const std::vector<int> &_parents,
+	 const std::vector<int> &_parents,
-	 const std::vector<ast> &_theory)
+	 const std::vector<ast> &_theory)
-   : iz3mgr(other), scopes(_parents)  {
+   : iz3mgr(other), scopes(_parents)  {
-    initialize(_cnsts,_parents,_theory);
+    initialize(_cnsts,_parents,_theory);
-    weak = false;
+    weak = false;
-  }
+  }
-
+
-  iz3base(const iz3mgr& other)
+  iz3base(const iz3mgr& other)
-   : iz3mgr(other), scopes()  {
+   : iz3mgr(other), scopes()  {
-    weak = false;
+    weak = false;
-  }
+  }
-
+
-  /* Set our options */
+  /* Set our options */
-  void set_option(const std::string &name, const std::string &value){
+  void set_option(const std::string &name, const std::string &value){
-    if(name == "weak" && value == "1") weak = true;
+    if(name == "weak" && value == "1") weak = true;
-  }
+  }
-  
+  
-  /* Are we doing weak interpolants? */
+  /* Are we doing weak interpolants? */
-  bool weak_mode(){return weak;}
+  bool weak_mode(){return weak;}
-
+
-  /** Print interpolation problem to an SMTLIB format file */
+  /** Print interpolation problem to an SMTLIB format file */
-  void print(const std::string &filename);
+  void print(const std::string &filename);
-
+
-  /** Check correctness of a solutino to this problem. */
+  /** Check correctness of a solutino to this problem. */
-  void check_interp(const std::vector<ast> &itps, std::vector<ast> &theory);
+  void check_interp(const std::vector<ast> &itps, std::vector<ast> &theory);
-
+
-  /** For convenience -- is this formula SAT? */
+  /** For convenience -- is this formula SAT? */
-  bool is_sat(const std::vector<ast> &consts, ast &_proof);
+  bool is_sat(const std::vector<ast> &consts, ast &_proof);
-
+
-  /** Interpolator for clauses, to be implemented */
+  /** Interpolator for clauses, to be implemented */
-  virtual void interpolate_clause(std::vector<ast> &lits, std::vector<ast> &itps){
+  virtual void interpolate_clause(std::vector<ast> &lits, std::vector<ast> &itps){
-    throw "no interpolator";
+    throw "no interpolator";
-  }
+  }
-
+
-  ast get_proof_check_assump(range &rng){
+  ast get_proof_check_assump(range &rng){
-    std::vector<ast> cs(theory);
+    std::vector<ast> cs(theory);
-    cs.push_back(cnsts[rng.hi]);
+    cs.push_back(cnsts[rng.hi]);
-    return make(And,cs);
+    return make(And,cs);
-  }
+  }
-  
+  
-  int frame_of_assertion(const ast &ass){
+  int frame_of_assertion(const ast &ass){
-    stl_ext::hash_map<ast,int>::iterator it = frame_map.find(ass);
+    stl_ext::hash_map<ast,int>::iterator it = frame_map.find(ass);
-    if(it == frame_map.end())
+    if(it == frame_map.end())
-      throw "unknown assertion";
+      throw "unknown assertion";
-    return it->second;
+    return it->second;
-  }
+  }
-  
+  
-
+
-  void to_parents_vec_representation(const std::vector<ast> &_cnsts,
+  void to_parents_vec_representation(const std::vector<ast> &_cnsts,
-				     const ast &tree,
+				     const ast &tree,
-				     std::vector<ast> &cnsts,
+				     std::vector<ast> &cnsts,
-				     std::vector<int> &parents,
+				     std::vector<int> &parents,
-				     std::vector<ast> &theory,
+				     std::vector<ast> &theory,
-				     std::vector<int> &pos_map,
+				     std::vector<int> &pos_map,
-				     bool merge = false
+				     bool merge = false
-				   );
+				   );
-
+
- protected:
+ protected:
-  std::vector<ast> cnsts;
+  std::vector<ast> cnsts;
-  std::vector<ast> theory;
+  std::vector<ast> theory;
-
+
- private:
+ private:
-
+
-  struct ranges {
+  struct ranges {
-    range rng;
+    range rng;
-    range scp;
+    range scp;
-    bool scope_computed;
+    bool scope_computed;
-    ranges(){scope_computed = false;}
+    ranges(){scope_computed = false;}
-  };
+  };
-
+
-  stl_ext::hash_map<symb,range> sym_range_hash;
+  stl_ext::hash_map<symb,range> sym_range_hash;
-  stl_ext::hash_map<ast,ranges> ast_ranges_hash;
+  stl_ext::hash_map<ast,ranges> ast_ranges_hash;
-  stl_ext::hash_map<ast,ast> simplify_memo;
+  stl_ext::hash_map<ast,ast> simplify_memo;
-  stl_ext::hash_map<ast,int> frame_map;                      // map assertions to frames
+  stl_ext::hash_map<ast,int> frame_map;                      // map assertions to frames
-
+
-  int frames;                               // number of frames
+  int frames;                               // number of frames
-
+
- protected:
+ protected:
-  void add_frame_range(int frame, ast t);
+  void add_frame_range(int frame, ast t);
-
+
- private:
+ private:
-  void initialize(const std::vector<ast> &_parts, const std::vector<int> &_parents, const std::vector<ast> &_theory);
+  void initialize(const std::vector<ast> &_parts, const std::vector<int> &_parents, const std::vector<ast> &_theory);
-
+
-  void initialize(const std::vector<std::vector<ast> > &_parts, const std::vector<int> &_parents, const std::vector<ast> &_theory);
+  void initialize(const std::vector<std::vector<ast> > &_parts, const std::vector<int> &_parents, const std::vector<ast> &_theory);
-
+
-  bool is_literal(ast n);
+  bool is_literal(ast n);
-  void gather_conjuncts_rec(ast n, std::vector<ast> &conjuncts, stl_ext::hash_set<ast> &memo);
+  void gather_conjuncts_rec(ast n, std::vector<ast> &conjuncts, stl_ext::hash_set<ast> &memo);
-  void gather_conjuncts(ast n, std::vector<ast> &conjuncts);
+  void gather_conjuncts(ast n, std::vector<ast> &conjuncts);
-  ast simplify_and(std::vector<ast> &conjuncts);
+  ast simplify_and(std::vector<ast> &conjuncts);
-  ast simplify_with_lit_rec(ast n, ast lit, stl_ext::hash_map<ast,ast> &memo, int depth);
+  ast simplify_with_lit_rec(ast n, ast lit, stl_ext::hash_map<ast,ast> &memo, int depth);
-  ast simplify_with_lit(ast n, ast lit);  
+  ast simplify_with_lit(ast n, ast lit);  
-  void find_children(const stl_ext::hash_set<ast> &cnsts_set,
+  void find_children(const stl_ext::hash_set<ast> &cnsts_set,
-		     const ast &tree,
+		     const ast &tree,
-		     std::vector<ast> &cnsts,
+		     std::vector<ast> &cnsts,
-		     std::vector<int> &parents,
+		     std::vector<int> &parents,
-		     std::vector<ast> &conjuncts,
+		     std::vector<ast> &conjuncts,
-		     std::vector<int> &children,
+		     std::vector<int> &children,
-		     std::vector<int> &pos_map,
+		     std::vector<int> &pos_map,
-		     bool merge
+		     bool merge
-		     );
+		     );
-  bool weak;
+  bool weak;
-
+
-};
+};
-
+
-
+
-
+
-#endif
+#endif

src/interp/iz3hash.h

@@ -464,7 +464,9 @@ namespace hash_space {
 
       Value &operator[](const Key& key) {
 	std::pair<Key,Value> kvp(key,Value());
-	return this->lookup(kvp,true)->val.second;
+	return 
+	hashtable<std::pair<Key,Value>,Key,HashFun,proj1<Key,Value>,EqFun>::
+         lookup(kvp,true)->val.second;
       }
   };
 

src/interp/iz3proof_itp.cpp

@@ -814,6 +814,10 @@ class iz3proof_itp_impl : public iz3proof_itp {
       ast equa = sep_cond(arg(pf,0),cond);
       if(is_equivrel_chain(equa)){
 	ast lhs,rhs; eq_from_ineq(arg(neg_equality,0),lhs,rhs); // get inequality we need to prove
+	if(!rewrites_from_to(equa,lhs,rhs)){
+	  lhs = arg(arg(neg_equality,0),0); // the equality proved is ambiguous, sadly
+	  rhs = arg(arg(neg_equality,0),1);
+	}
 	LitType lhst = get_term_type(lhs), rhst = get_term_type(rhs);
 	if(lhst != LitMixed && rhst != LitMixed)
 	  return unmixed_eq2ineq(lhs, rhs, op(arg(neg_equality,0)), equa, cond);
@@ -1671,9 +1675,20 @@ class iz3proof_itp_impl : public iz3proof_itp {
     return head;
   }
 
-  // split a rewrite chain into head and tail at last non-mixed term
+  bool has_mixed_summands(const ast &e){
+    if(op(e) == Plus){
+      int nargs = num_args(e);
+      for(int i = 0; i < nargs; i++)
+	if(has_mixed_summands(arg(e,i)))
+	  return true;
+      return false;
+    }
+    return get_term_type(e) == LitMixed;
+  }
+  
+  // split a rewrite chain into head and tail at last sum with no mixed sumands
   ast get_right_movers(const ast &chain, const ast &rhs, ast &tail, ast &mid){
-    if(is_true(chain) || get_term_type(rhs) != LitMixed){
+    if(is_true(chain) || !has_mixed_summands(rhs)){
       mid = rhs;
       tail = mk_true();
       return chain;
@@ -1686,11 +1701,11 @@ class iz3proof_itp_impl : public iz3proof_itp {
     return res;
   }
   
-  // split a rewrite chain into head and tail at first non-mixed term
+  // split a rewrite chain into head and tail at first sum with no mixed sumands
   ast get_left_movers(const ast &chain, const ast &lhs, ast &tail, ast &mid){
     if(is_true(chain)){
       mid = lhs; 
-      if(get_term_type(lhs) != LitMixed){
+      if(!has_mixed_summands(lhs)){
 	tail = mk_true();
 	return chain;
       }
@@ -1790,10 +1805,21 @@ class iz3proof_itp_impl : public iz3proof_itp {
   }
 
 
+  bool rewrites_from_to(const ast &chain, const ast &lhs, const ast &rhs){
+    if(is_true(chain))
+      return lhs == rhs;
+    ast last = chain_last(chain);
+    ast rest = chain_rest(chain);
+    ast mid = subst_in_pos(rhs,rewrite_pos(last),rewrite_lhs(last));
+    return rewrites_from_to(rest,lhs,mid);
+  }
+
+  struct bad_ineq_inference {};
+
   ast chain_ineqs(opr comp_op, LitType t, const ast &chain, const ast &lhs, const ast &rhs){
     if(is_true(chain)){
       if(lhs != rhs)
-	throw "bad ineq inference";
+	throw bad_ineq_inference();
       return make(Leq,make_int(rational(0)),make_int(rational(0)));
     }
     ast last = chain_last(chain);
@@ -2656,9 +2682,11 @@ class iz3proof_itp_impl : public iz3proof_itp {
     pf = make_refl(e);  // proof that e = e
 
     prover::range erng = pv->ast_scope(e);
+#if 0
     if(!(erng.lo > erng.hi) && pv->ranges_intersect(pv->ast_scope(e),rng)){
       return e; // this term occurs in range, so it's O.K.
     }
+#endif
 
     hash_map<ast,ast>::iterator it = localization_map.find(e);
 

src/interp/iz3scopes.cpp

@@ -1,321 +1,321 @@
-/*++
+/*++
-Copyright (c) 2011 Microsoft Corporation
+Copyright (c) 2011 Microsoft Corporation
-
+
-Module Name:
+Module Name:
-
+
-    iz3scopes.cpp
+    iz3scopes.cpp
-
+
-Abstract:
+Abstract:
-
+
-   Calculations with scopes, for both sequence and tree interpolation.
+   Calculations with scopes, for both sequence and tree interpolation.
-
+
-Author:
+Author:
-
+
-    Ken McMillan (kenmcmil)
+    Ken McMillan (kenmcmil)
-
+
-Revision History:
+Revision History:
-
+
---*/
+--*/
-
+
-#include <assert.h>
+#include <assert.h>
-
+
-#include <algorithm>
+#include <algorithm>
-
+
-#include "iz3scopes.h"
+#include "iz3scopes.h"
-
+
-
+
-/** computes the least common ancestor of two nodes in the tree, or SHRT_MAX if none */
+/** computes the least common ancestor of two nodes in the tree, or SHRT_MAX if none */
-int scopes::tree_lca(int n1, int n2){
+int scopes::tree_lca(int n1, int n2){
-  if(!tree_mode())
+  if(!tree_mode())
-    return std::max(n1,n2);
+    return std::max(n1,n2);
-  if(n1 == SHRT_MIN) return n2;
+  if(n1 == SHRT_MIN) return n2;
-  if(n2 == SHRT_MIN) return n1;
+  if(n2 == SHRT_MIN) return n1;
-  if(n1 == SHRT_MAX || n2 == SHRT_MAX) return SHRT_MAX;
+  if(n1 == SHRT_MAX || n2 == SHRT_MAX) return SHRT_MAX;
-  while(n1 != n2){
+  while(n1 != n2){
-    if(n1 == SHRT_MAX || n2 == SHRT_MAX) return SHRT_MAX;
+    if(n1 == SHRT_MAX || n2 == SHRT_MAX) return SHRT_MAX;
-    assert(n1 >= 0 && n2 >= 0 && n1 < (int)parents.size() && n2 < (int)parents.size());
+    assert(n1 >= 0 && n2 >= 0 && n1 < (int)parents.size() && n2 < (int)parents.size());
-    if(n1 < n2) n1 = parents[n1];
+    if(n1 < n2) n1 = parents[n1];
-    else n2 = parents[n2];
+    else n2 = parents[n2];
-  }
+  }
-  return n1;
+  return n1;
-}
+}
-
+
-/** computes the greatest common descendant two nodes in the tree, or SHRT_MIN if none */
+/** computes the greatest common descendant two nodes in the tree, or SHRT_MIN if none */
-int scopes::tree_gcd(int n1, int n2){
+int scopes::tree_gcd(int n1, int n2){
-  if(!tree_mode())
+  if(!tree_mode())
-    return std::min(n1,n2);
+    return std::min(n1,n2);
-  int foo = tree_lca(n1,n2);
+  int foo = tree_lca(n1,n2);
-  if(foo == n1) return n2;
+  if(foo == n1) return n2;
-  if(foo == n2) return n1;
+  if(foo == n2) return n1;
-  return SHRT_MIN;
+  return SHRT_MIN;
-}
+}
-
+
-#ifndef FULL_TREE
+#ifndef FULL_TREE
-
+
-/** test whether a tree node is contained in a range */
+/** test whether a tree node is contained in a range */
-bool scopes::in_range(int n, const range &rng){
+bool scopes::in_range(int n, const range &rng){
-  return tree_lca(rng.lo,n) == n && tree_gcd(rng.hi,n) == n;
+  return tree_lca(rng.lo,n) == n && tree_gcd(rng.hi,n) == n;
-}
+}
-
+
-/** test whether two ranges of tree nodes intersect */
+/** test whether two ranges of tree nodes intersect */
-bool scopes::ranges_intersect(const range &rng1, const range &rng2){
+bool scopes::ranges_intersect(const range &rng1, const range &rng2){
-  return tree_lca(rng1.lo,rng2.hi) == rng2.hi && tree_lca(rng1.hi,rng2.lo) == rng1.hi;
+  return tree_lca(rng1.lo,rng2.hi) == rng2.hi && tree_lca(rng1.hi,rng2.lo) == rng1.hi;
-}
+}
-
+
-
+
-bool scopes::range_contained(const range &rng1, const range &rng2){
+bool scopes::range_contained(const range &rng1, const range &rng2){
-  return tree_lca(rng2.lo,rng1.lo) == rng1.lo
+  return tree_lca(rng2.lo,rng1.lo) == rng1.lo
-  && tree_lca(rng1.hi,rng2.hi) == rng2.hi;
+  && tree_lca(rng1.hi,rng2.hi) == rng2.hi;
-}
+}
-
+
-scopes::range scopes::range_lub(const range &rng1, const range &rng2){
+scopes::range scopes::range_lub(const range &rng1, const range &rng2){
-	range res;
+	range res;
-	res.lo = tree_gcd(rng1.lo,rng2.lo);
+	res.lo = tree_gcd(rng1.lo,rng2.lo);
-	res.hi = tree_lca(rng1.hi,rng2.hi);
+	res.hi = tree_lca(rng1.hi,rng2.hi);
-	return res;
+	return res;
-}
+}
-  
+  
-scopes::range scopes::range_glb(const range &rng1, const range &rng2){
+scopes::range scopes::range_glb(const range &rng1, const range &rng2){
-	range res;
+	range res;
-	res.lo = tree_lca(rng1.lo,rng2.lo);
+	res.lo = tree_lca(rng1.lo,rng2.lo);
-	res.hi = tree_gcd(rng1.hi,rng2.hi);
+	res.hi = tree_gcd(rng1.hi,rng2.hi);
-	return res;
+	return res;
-}
+}
-
+
-#else
+#else
-  
+  
-
+
-  namespace std {
+  namespace std {
-    template <>
+    template <>
-      class hash<scopes::range_lo > {
+      class hash<scopes::range_lo > {
-       public:
+       public:
-          size_t operator()(const scopes::range_lo &p) const {
+          size_t operator()(const scopes::range_lo &p) const {
-            return p.lo + (size_t)p.next;
+            return p.lo + (size_t)p.next;
-          }
+          }
-      };
+      };
-  }
+  }
-
+
-  template <> inline
+  template <> inline
-  size_t stdext::hash_value<scopes::range_lo >(const scopes::range_lo& p)
+  size_t stdext::hash_value<scopes::range_lo >(const scopes::range_lo& p)
-  {	
+  {	
-	std::hash<scopes::range_lo> h;
+	std::hash<scopes::range_lo> h;
-	return h(p);
+	return h(p);
-  }
+  }
-
+
-  namespace std {
+  namespace std {
-    template <>
+    template <>
-	   class less<scopes::range_lo > {
+	   class less<scopes::range_lo > {
-	   public:
+	   public:
-		   bool operator()(const scopes::range_lo &x, const scopes::range_lo &y) const {
+		   bool operator()(const scopes::range_lo &x, const scopes::range_lo &y) const {
-		      return x.lo < y.lo || x.lo == y.lo && (size_t)x.next < (size_t)y.next;
+		      return x.lo < y.lo || x.lo == y.lo && (size_t)x.next < (size_t)y.next;
-		   }
+		   }
-	   };
+	   };
-  }
+  }
- 
+ 
-
+
-  struct range_op {
+  struct range_op {
-	scopes::range_lo *x, *y;
+	scopes::range_lo *x, *y;
-	int hi;
+	int hi;
-	range_op(scopes::range_lo *_x, scopes::range_lo *_y, int _hi){
+	range_op(scopes::range_lo *_x, scopes::range_lo *_y, int _hi){
-		x = _x; y = _y; hi = _hi;
+		x = _x; y = _y; hi = _hi;
-	}
+	}
-  };
+  };
-
+
-   namespace std {
+   namespace std {
-    template <>
+    template <>
-      class hash<range_op > {
+      class hash<range_op > {
-       public:
+       public:
-          size_t operator()(const range_op &p) const {
+          size_t operator()(const range_op &p) const {
-            return (size_t) p.x + (size_t)p.y + p.hi;
+            return (size_t) p.x + (size_t)p.y + p.hi;
-          }
+          }
-      };
+      };
-  }
+  }
-
+
-  template <> inline
+  template <> inline
-  size_t stdext::hash_value<range_op >(const range_op& p)
+  size_t stdext::hash_value<range_op >(const range_op& p)
-  {	
+  {	
-	std::hash<range_op> h;
+	std::hash<range_op> h;
-	return h(p);
+	return h(p);
-  }
+  }
-
+
-  namespace std {
+  namespace std {
-    template <>
+    template <>
-	   class less<range_op > {
+	   class less<range_op > {
-	   public:
+	   public:
-		   bool operator()(const range_op &x, const range_op &y) const {
+		   bool operator()(const range_op &x, const range_op &y) const {
-		      return (size_t)x.x < (size_t)y.x || x.x == y.x &&
+		      return (size_t)x.x < (size_t)y.x || x.x == y.x &&
-				        ((size_t)x.y < (size_t)y.y || x.y == y.y && x.hi < y.hi);
+				        ((size_t)x.y < (size_t)y.y || x.y == y.y && x.hi < y.hi);
-		   }
+		   }
-	   };
+	   };
-  }
+  }
-
+
-  struct range_tables {
+  struct range_tables {
-	  hash_map<scopes::range_lo, scopes::range_lo *> unique;
+	  hash_map<scopes::range_lo, scopes::range_lo *> unique;
-	  hash_map<range_op,scopes::range_lo *> lub;
+	  hash_map<range_op,scopes::range_lo *> lub;
-	  hash_map<range_op,scopes::range_lo *> glb;
+	  hash_map<range_op,scopes::range_lo *> glb;
-  };
+  };
-
+
-
+
-  scopes::range_lo *scopes::find_range_lo(int lo, range_lo *next){
+  scopes::range_lo *scopes::find_range_lo(int lo, range_lo *next){
-	  range_lo foo(lo,next);
+	  range_lo foo(lo,next);
-	  std::pair<range_lo,range_lo *> baz(foo,(range_lo *)0);
+	  std::pair<range_lo,range_lo *> baz(foo,(range_lo *)0);
-	  std::pair<hash_map<range_lo,scopes::range_lo *>::iterator,bool> bar = rt->unique.insert(baz);
+	  std::pair<hash_map<range_lo,scopes::range_lo *>::iterator,bool> bar = rt->unique.insert(baz);
-	  if(bar.second)
+	  if(bar.second)
-		  bar.first->second = new range_lo(lo,next);
+		  bar.first->second = new range_lo(lo,next);
-	  return bar.first->second;
+	  return bar.first->second;
-	  //std::pair<hash_set<scopes::range_lo>::iterator,bool> bar = rt->unique.insert(foo);
+	  //std::pair<hash_set<scopes::range_lo>::iterator,bool> bar = rt->unique.insert(foo);
-	  // const range_lo *baz = &*(bar.first); 
+	  // const range_lo *baz = &*(bar.first); 
-	  // return (range_lo *)baz; // exit const hell
+	  // return (range_lo *)baz; // exit const hell
-  }
+  }
-
+
-  scopes::range_lo *scopes::range_lub_lo(range_lo *rng1, range_lo *rng2){
+  scopes::range_lo *scopes::range_lub_lo(range_lo *rng1, range_lo *rng2){
-    if(!rng1) return rng2;
+    if(!rng1) return rng2;
-    if(!rng2) return rng1;
+    if(!rng2) return rng1;
-    if(rng1->lo > rng2->lo)
+    if(rng1->lo > rng2->lo)
-      std::swap(rng1,rng2);
+      std::swap(rng1,rng2);
-	std::pair<range_op,range_lo *> foo(range_op(rng1,rng2,0),(range_lo *)0);
+	std::pair<range_op,range_lo *> foo(range_op(rng1,rng2,0),(range_lo *)0);
-	std::pair<hash_map<range_op,scopes::range_lo *>::iterator,bool> bar = rt->lub.insert(foo);
+	std::pair<hash_map<range_op,scopes::range_lo *>::iterator,bool> bar = rt->lub.insert(foo);
-	range_lo *&res = bar.first->second;
+	range_lo *&res = bar.first->second;
-	if(!bar.second) return res;
+	if(!bar.second) return res;
-    if(!(rng1->next && rng1->next->lo <= rng2->lo)){
+    if(!(rng1->next && rng1->next->lo <= rng2->lo)){
-      for(int lo = rng1->lo; lo <= rng2->lo; lo = parents[lo])
+      for(int lo = rng1->lo; lo <= rng2->lo; lo = parents[lo])
-		  if(lo == rng2->lo)
+		  if(lo == rng2->lo)
-		    {rng2 = rng2->next; break;}
+		    {rng2 = rng2->next; break;}
-    }
+    }
-    range_lo *baz = range_lub_lo(rng1->next,rng2);
+    range_lo *baz = range_lub_lo(rng1->next,rng2);
-    res = find_range_lo(rng1->lo,baz);
+    res = find_range_lo(rng1->lo,baz);
-	return res;
+	return res;
-  }
+  }
-  
+  
-
+
-  scopes::range_lo *scopes::range_glb_lo(range_lo *rng1, range_lo *rng2, int hi){
+  scopes::range_lo *scopes::range_glb_lo(range_lo *rng1, range_lo *rng2, int hi){
-	  if(!rng1) return rng1;
+	  if(!rng1) return rng1;
-	  if(!rng2) return rng2;
+	  if(!rng2) return rng2;
-	  if(rng1->lo > rng2->lo)
+	  if(rng1->lo > rng2->lo)
-		  std::swap(rng1,rng2);
+		  std::swap(rng1,rng2);
-	  std::pair<range_op,range_lo *> cand(range_op(rng1,rng2,hi),(range_lo *)0);
+	  std::pair<range_op,range_lo *> cand(range_op(rng1,rng2,hi),(range_lo *)0);
-	  std::pair<hash_map<range_op,scopes::range_lo *>::iterator,bool> bar = rt->glb.insert(cand);
+	  std::pair<hash_map<range_op,scopes::range_lo *>::iterator,bool> bar = rt->glb.insert(cand);
-	  range_lo *&res = bar.first->second;
+	  range_lo *&res = bar.first->second;
-	  if(!bar.second) return res;
+	  if(!bar.second) return res;
-	  range_lo *foo;
+	  range_lo *foo;
-	  if(!(rng1->next && rng1->next->lo <= rng2->lo)){
+	  if(!(rng1->next && rng1->next->lo <= rng2->lo)){
-		  int lim = hi;
+		  int lim = hi;
-		  if(rng1->next) lim = std::min(lim,rng1->next->lo);
+		  if(rng1->next) lim = std::min(lim,rng1->next->lo);
-		  int a = rng1->lo, b = rng2->lo;
+		  int a = rng1->lo, b = rng2->lo;
-		  while(a != b && b <= lim){
+		  while(a != b && b <= lim){
-			  a = parents[a];
+			  a = parents[a];
-			  if(a > b)std::swap(a,b);
+			  if(a > b)std::swap(a,b);
-		  }
+		  }
-		  if(a == b && b <= lim){
+		  if(a == b && b <= lim){
-			  foo = range_glb_lo(rng1->next,rng2->next,hi);
+			  foo = range_glb_lo(rng1->next,rng2->next,hi);
-			  foo = find_range_lo(b,foo);
+			  foo = find_range_lo(b,foo);
-		  }
+		  }
-		  else
+		  else
-			  foo = range_glb_lo(rng2,rng1->next,hi);
+			  foo = range_glb_lo(rng2,rng1->next,hi);
-	  }
+	  }
-	  else foo = range_glb_lo(rng1->next,rng2,hi);
+	  else foo = range_glb_lo(rng1->next,rng2,hi);
-	  res = foo;
+	  res = foo;
-	  return res;
+	  return res;
-  }
+  }
-
+
-  /** computes the lub (smallest containing subtree) of two ranges */
+  /** computes the lub (smallest containing subtree) of two ranges */
-  scopes::range scopes::range_lub(const range &rng1, const range &rng2){
+  scopes::range scopes::range_lub(const range &rng1, const range &rng2){
-    int hi = tree_lca(rng1.hi,rng2.hi);
+    int hi = tree_lca(rng1.hi,rng2.hi);
-	if(hi == SHRT_MAX) return range_full();
+	if(hi == SHRT_MAX) return range_full();
-    range_lo *lo = range_lub_lo(rng1.lo,rng2.lo);
+    range_lo *lo = range_lub_lo(rng1.lo,rng2.lo);
-    return range(hi,lo);
+    return range(hi,lo);
-  }
+  }
-
+
-  /** computes the glb (intersection) of two ranges */
+  /** computes the glb (intersection) of two ranges */
-  scopes::range scopes::range_glb(const range &rng1, const range &rng2){
+  scopes::range scopes::range_glb(const range &rng1, const range &rng2){
-	if(rng1.hi == SHRT_MAX) return rng2;
+	if(rng1.hi == SHRT_MAX) return rng2;
-	if(rng2.hi == SHRT_MAX) return rng1;
+	if(rng2.hi == SHRT_MAX) return rng1;
-    int hi = tree_gcd(rng1.hi,rng2.hi);
+    int hi = tree_gcd(rng1.hi,rng2.hi);
-    range_lo *lo = hi == SHRT_MIN ? 0 : range_glb_lo(rng1.lo,rng2.lo,hi);
+    range_lo *lo = hi == SHRT_MIN ? 0 : range_glb_lo(rng1.lo,rng2.lo,hi);
-	if(!lo) hi = SHRT_MIN;
+	if(!lo) hi = SHRT_MIN;
-    return range(hi,lo);
+    return range(hi,lo);
-  }
+  }
-
+
-  /** is this range empty? */
+  /** is this range empty? */
-  bool scopes::range_is_empty(const range &rng){
+  bool scopes::range_is_empty(const range &rng){
-    return rng.hi == SHRT_MIN;
+    return rng.hi == SHRT_MIN;
-  }
+  }
-
+
-  /** return an empty range */
+  /** return an empty range */
-  scopes::range scopes::range_empty(){
+  scopes::range scopes::range_empty(){
-    return range(SHRT_MIN,0);
+    return range(SHRT_MIN,0);
-  }
+  }
-
+
-  /** return a full range */
+  /** return a full range */
-  scopes::range scopes::range_full(){
+  scopes::range scopes::range_full(){
-    return range(SHRT_MAX,0);
+    return range(SHRT_MAX,0);
-  }
+  }
-
+
-  /** return the maximal element of a range */
+  /** return the maximal element of a range */
-  int scopes::range_max(const range &rng){
+  int scopes::range_max(const range &rng){
-    return rng.hi;
+    return rng.hi;
-  }
+  }
-
+
-  /** return a minimal (not necessarily unique) element of a range */
+  /** return a minimal (not necessarily unique) element of a range */
-  int scopes::range_min(const range &rng){
+  int scopes::range_min(const range &rng){
-	if(rng.hi == SHRT_MAX) return SHRT_MIN;
+	if(rng.hi == SHRT_MAX) return SHRT_MIN;
-    return rng.lo ? rng.lo->lo : SHRT_MAX;
+    return rng.lo ? rng.lo->lo : SHRT_MAX;
-  }
+  }
-
+
-
+
-  /** return range consisting of downward closure of a point */
+  /** return range consisting of downward closure of a point */
-  scopes::range scopes::range_downward(int _hi){
+  scopes::range scopes::range_downward(int _hi){
-    std::vector<bool> descendants(parents.size());
+    std::vector<bool> descendants(parents.size());
-    for(int i = descendants.size() - 1; i >= 0 ; i--)
+    for(int i = descendants.size() - 1; i >= 0 ; i--)
-      descendants[i] = i == _hi || parents[i] < parents.size() && descendants[parents[i]];
+      descendants[i] = i == _hi || parents[i] < parents.size() && descendants[parents[i]];
-    for(unsigned i = 0; i < descendants.size() - 1; i++)
+    for(unsigned i = 0; i < descendants.size() - 1; i++)
-      if(parents[i] < parents.size())
+      if(parents[i] < parents.size())
-	descendants[parents[i]] = false;
+	descendants[parents[i]] = false;
-    range_lo *foo = 0;
+    range_lo *foo = 0;
-    for(int i = descendants.size() - 1; i >= 0; --i)
+    for(int i = descendants.size() - 1; i >= 0; --i)
-      if(descendants[i]) foo = find_range_lo(i,foo);
+      if(descendants[i]) foo = find_range_lo(i,foo);
-    return range(_hi,foo);
+    return range(_hi,foo);
-  }
+  }
-
+
-  /** add an element to a range */
+  /** add an element to a range */
-  void scopes::range_add(int i, range &n){
+  void scopes::range_add(int i, range &n){
-    range foo = range(i, find_range_lo(i,0));
+    range foo = range(i, find_range_lo(i,0));
-    n = range_lub(foo,n);
+    n = range_lub(foo,n);
-  }
+  }
-
+
-  /** Choose an element of rng1 that is near to rng2 */
+  /** Choose an element of rng1 that is near to rng2 */
-  int scopes::range_near(const range &rng1, const range &rng2){
+  int scopes::range_near(const range &rng1, const range &rng2){
-
+
-    int frame;
+    int frame;
-    int thing = tree_lca(rng1.hi,rng2.hi);
+    int thing = tree_lca(rng1.hi,rng2.hi);
-	if(thing != rng1.hi) return rng1.hi;
+	if(thing != rng1.hi) return rng1.hi;
-	range line = range(rng1.hi,find_range_lo(rng2.hi,(range_lo *)0));
+	range line = range(rng1.hi,find_range_lo(rng2.hi,(range_lo *)0));
-	line = range_glb(line,rng1);
+	line = range_glb(line,rng1);
-	return range_min(line);
+	return range_min(line);
-  }
+  }
-
+
-
+
-  /** test whether a tree node is contained in a range */
+  /** test whether a tree node is contained in a range */
-  bool scopes::in_range(int n, const range &rng){
+  bool scopes::in_range(int n, const range &rng){
-	  range r = range_empty();
+	  range r = range_empty();
-	  range_add(n,r);
+	  range_add(n,r);
-	  r = range_glb(rng,r);
+	  r = range_glb(rng,r);
-	  return !range_is_empty(r);
+	  return !range_is_empty(r);
-  }
+  }
-
+
-  /** test whether two ranges of tree nodes intersect */
+  /** test whether two ranges of tree nodes intersect */
-  bool scopes::ranges_intersect(const range &rng1, const range &rng2){
+  bool scopes::ranges_intersect(const range &rng1, const range &rng2){
-	  range r = range_glb(rng1,rng2);
+	  range r = range_glb(rng1,rng2);
-	  return !range_is_empty(r);
+	  return !range_is_empty(r);
-  }
+  }
-
+
-
+
-  bool scopes::range_contained(const range &rng1, const range &rng2){
+  bool scopes::range_contained(const range &rng1, const range &rng2){
-	  range r = range_glb(rng1,rng2);
+	  range r = range_glb(rng1,rng2);
-	  return r.hi == rng1.hi && r.lo == rng1.lo;
+	  return r.hi == rng1.hi && r.lo == rng1.lo;
-  }
+  }
-
+
-
+
-#endif
+#endif
-
+
-
+

src/interp/iz3scopes.h

@@ -1,197 +1,197 @@
-/*++
+/*++
-Copyright (c) 2011 Microsoft Corporation
+Copyright (c) 2011 Microsoft Corporation
-
+
-Module Name:
+Module Name:
-
+
-    iz3scopes.h
+    iz3scopes.h
-
+
-Abstract:
+Abstract:
-
+
-   Calculations with scopes, for both sequence and tree interpolation.
+   Calculations with scopes, for both sequence and tree interpolation.
-
+
-Author:
+Author:
-
+
-    Ken McMillan (kenmcmil)
+    Ken McMillan (kenmcmil)
-
+
-Revision History:
+Revision History:
-
+
---*/
+--*/
-
+
-
+
-#ifndef IZ3SOPES_H
+#ifndef IZ3SOPES_H
-#define IZ3SOPES_H
+#define IZ3SOPES_H
-
+
-#include <vector>
+#include <vector>
-#include <limits.h>
+#include <limits.h>
-
+
-class scopes {
+class scopes {
-
+
- public:
+ public:
-  /** Construct from parents vector. */
+  /** Construct from parents vector. */
-  scopes(const std::vector<int> &_parents){
+  scopes(const std::vector<int> &_parents){
-    parents = _parents;
+    parents = _parents;
-  }
+  }
-
+
-  scopes(){
+  scopes(){
-  }
+  }
-  
+  
-  void initialize(const std::vector<int> &_parents){
+  void initialize(const std::vector<int> &_parents){
-    parents = _parents;
+    parents = _parents;
-  }
+  }
-
+
-  /** The parents vector defining the tree structure */
+  /** The parents vector defining the tree structure */
-  std::vector<int> parents;
+  std::vector<int> parents;
-
+
-  // #define FULL_TREE
+  // #define FULL_TREE
-#ifndef FULL_TREE
+#ifndef FULL_TREE
-  struct range {
+  struct range {
-    range(){
+    range(){
-      lo = SHRT_MAX;
+      lo = SHRT_MAX;
-      hi = SHRT_MIN;
+      hi = SHRT_MIN;
-    }
+    }
-    short lo, hi;
+    short lo, hi;
-  };
+  };
-
+
-  /** computes the lub (smallest containing subtree) of two ranges */
+  /** computes the lub (smallest containing subtree) of two ranges */
-  range range_lub(const range &rng1, const range &rng2);
+  range range_lub(const range &rng1, const range &rng2);
-  
+  
-  /** computes the glb (intersection) of two ranges */
+  /** computes the glb (intersection) of two ranges */
-  range range_glb(const range &rng1, const range &rng2);
+  range range_glb(const range &rng1, const range &rng2);
-
+
-  /** is this range empty? */
+  /** is this range empty? */
-  bool range_is_empty(const range &rng){
+  bool range_is_empty(const range &rng){
-	  return rng.hi < rng.lo;
+	  return rng.hi < rng.lo;
-  }
+  }
-
+
-  /** return an empty range */
+  /** return an empty range */
-  range range_empty(){
+  range range_empty(){
-     range res;
+     range res;
-	 res.lo = SHRT_MAX;
+	 res.lo = SHRT_MAX;
-	 res.hi = SHRT_MIN;
+	 res.hi = SHRT_MIN;
-	 return res;
+	 return res;
-  }
+  }
-
+
-  /** return an empty range */
+  /** return an empty range */
-  range range_full(){
+  range range_full(){
-     range res;
+     range res;
-	 res.lo = SHRT_MIN;
+	 res.lo = SHRT_MIN;
-	 res.hi = SHRT_MAX;
+	 res.hi = SHRT_MAX;
-	 return res;
+	 return res;
-  }
+  }
-
+
-  /** return the maximal element of a range */
+  /** return the maximal element of a range */
-  int range_max(const range &rng){
+  int range_max(const range &rng){
-	  return rng.hi;
+	  return rng.hi;
-  }
+  }
-
+
-  /** return a minimal (not necessarily unique) element of a range */
+  /** return a minimal (not necessarily unique) element of a range */
-  int range_min(const range &rng){
+  int range_min(const range &rng){
-	  return rng.lo;
+	  return rng.lo;
-  }
+  }
-
+
-  /** return range consisting of downward closure of a point */
+  /** return range consisting of downward closure of a point */
-  range range_downward(int _hi){
+  range range_downward(int _hi){
-    range foo;
+    range foo;
-    foo.lo = SHRT_MIN;
+    foo.lo = SHRT_MIN;
-    foo.hi = _hi;
+    foo.hi = _hi;
-    return foo;
+    return foo;
-  }
+  }
-
+
-  void range_add(int i, range &n){
+  void range_add(int i, range &n){
-#if 0
+#if 0
-	if(i < n.lo) n.lo = i;
+	if(i < n.lo) n.lo = i;
-    if(i > n.hi) n.hi = i;
+    if(i > n.hi) n.hi = i;
-#else
+#else
-    range rng; rng.lo = i; rng.hi = i;
+    range rng; rng.lo = i; rng.hi = i;
-    n = range_lub(rng,n);
+    n = range_lub(rng,n);
-#endif
+#endif
-  }
+  }
-
+
-  /** Choose an element of rng1 that is near to rng2 */
+  /** Choose an element of rng1 that is near to rng2 */
-  int range_near(const range &rng1, const range &rng2){
+  int range_near(const range &rng1, const range &rng2){
-    int frame;
+    int frame;
-    int thing = tree_lca(rng1.lo,rng2.hi);
+    int thing = tree_lca(rng1.lo,rng2.hi);
-    if(thing == rng1.lo) frame = rng1.lo;
+    if(thing == rng1.lo) frame = rng1.lo;
-    else frame = tree_gcd(thing,rng1.hi);
+    else frame = tree_gcd(thing,rng1.hi);
-	return frame;
+	return frame;
-  }
+  }
-#else
+#else
-
+
-  struct range_lo {
+  struct range_lo {
-    int lo;
+    int lo;
-    range_lo *next;
+    range_lo *next;
-    range_lo(int _lo, range_lo *_next){
+    range_lo(int _lo, range_lo *_next){
-      lo = _lo;
+      lo = _lo;
-      next = _next;
+      next = _next;
-    }
+    }
-  };
+  };
-
+
-  struct range {
+  struct range {
-    int hi;
+    int hi;
-    range_lo *lo;
+    range_lo *lo;
-    range(int _hi, range_lo *_lo){
+    range(int _hi, range_lo *_lo){
-      hi = _hi;
+      hi = _hi;
-      lo = _lo;
+      lo = _lo;
-    }
+    }
-    range(){
+    range(){
-      hi = SHRT_MIN;
+      hi = SHRT_MIN;
-      lo = 0;
+      lo = 0;
-    }
+    }
-  };
+  };
-
+
-  range_tables *rt;
+  range_tables *rt;
-
+
-  /** computes the lub (smallest containing subtree) of two ranges */
+  /** computes the lub (smallest containing subtree) of two ranges */
-  range range_lub(const range &rng1, const range &rng2);
+  range range_lub(const range &rng1, const range &rng2);
-  
+  
-  /** computes the glb (intersection) of two ranges */
+  /** computes the glb (intersection) of two ranges */
-  range range_glb(const range &rng1, const range &rng2);
+  range range_glb(const range &rng1, const range &rng2);
-
+
-  /** is this range empty? */
+  /** is this range empty? */
-  bool range_is_empty(const range &rng);
+  bool range_is_empty(const range &rng);
-
+
-  /** return an empty range */
+  /** return an empty range */
-  range range_empty();
+  range range_empty();
-
+
-  /** return a full range */
+  /** return a full range */
-  range range_full();
+  range range_full();
-
+
-  /** return the maximal element of a range */
+  /** return the maximal element of a range */
-  int range_max(const range &rng);
+  int range_max(const range &rng);
-
+
-  /** return a minimal (not necessarily unique) element of a range */
+  /** return a minimal (not necessarily unique) element of a range */
-  int range_min(const range &rng);
+  int range_min(const range &rng);
-
+
-  /** return range consisting of downward closure of a point */
+  /** return range consisting of downward closure of a point */
-  range range_downward(int _hi);
+  range range_downward(int _hi);
-
+
-  /** add an element to a range */
+  /** add an element to a range */
-  void range_add(int i, range &n);
+  void range_add(int i, range &n);
-
+
-  /** Choose an element of rng1 that is near to rng2 */
+  /** Choose an element of rng1 that is near to rng2 */
-  int range_near(const range &rng1, const range &rng2);
+  int range_near(const range &rng1, const range &rng2);
-
+
-  range_lo *find_range_lo(int lo, range_lo *next);
+  range_lo *find_range_lo(int lo, range_lo *next);
-  range_lo *range_lub_lo(range_lo *rng1, range_lo *rng2);
+  range_lo *range_lub_lo(range_lo *rng1, range_lo *rng2);
-  range_lo *range_glb_lo(range_lo *rng1, range_lo *rng2, int lim);
+  range_lo *range_glb_lo(range_lo *rng1, range_lo *rng2, int lim);
-
+
-#endif
+#endif
-  
+  
-  /** test whether a tree node is contained in a range */
+  /** test whether a tree node is contained in a range */
-  bool in_range(int n, const range &rng);
+  bool in_range(int n, const range &rng);
-  
+  
-  /** test whether two ranges of tree nodes intersect */
+  /** test whether two ranges of tree nodes intersect */
-  bool ranges_intersect(const range &rng1, const range &rng2);
+  bool ranges_intersect(const range &rng1, const range &rng2);
-
+
-  /** test whether range rng1 contained in range rng2 */
+  /** test whether range rng1 contained in range rng2 */
-  bool range_contained(const range &rng1, const range &rng2);
+  bool range_contained(const range &rng1, const range &rng2);
-
+
- private:
+ private:
-  int tree_lca(int n1, int n2);
+  int tree_lca(int n1, int n2);
-  int tree_gcd(int n1, int n2);
+  int tree_gcd(int n1, int n2);
-  bool tree_mode(){return parents.size() != 0;}
+  bool tree_mode(){return parents.size() != 0;}
-
+
-
+
-
+
-};
+};
-#endif
+#endif

src/interp/iz3translate.cpp

@@ -464,7 +464,7 @@ public:
 	  for(int i = 0; i < 2; i++){ // try the second equality both ways
 	    if(match_op(eq_ops_r[0],Select,sel_ops,2))
 	      if(match_op(sel_ops[0],Store,sto_ops,3))
-		if(match_op(eq_ops_r[1],Select,sel_ops2,2))
+		if(match_op(eq_ops_r[1],Select,sel_ops2,2))
                   for(int j = 0; j < 2; j++){ // try the first equality both ways
                     if(eq_ops_l[0] == sto_ops[1]
                     && eq_ops_l[1] == sel_ops[1]
@@ -482,8 +482,8 @@ public:
                         // int frame = range_min(ast_scope(res)); TODO
                         // antes.push_back(std::pair<ast,int>(res,frame));
                         return;
-                      }
+                      }
-                      std::swap(eq_ops_l[0],eq_ops_l[1]);
+                      std::swap(eq_ops_l[0],eq_ops_l[1]);
                   }
 	    std::swap(eq_ops_r[0],eq_ops_r[1]);
 	  }

src/interp/iz3translate_direct.cpp

@@ -484,7 +484,7 @@ public:
 	  for(int i = 0; i < 2; i++){ // try the second equality both ways
 	    if(match_op(eq_ops_r[0],Select,sel_ops,2))
 	      if(match_op(sel_ops[0],Store,sto_ops,3))
-		if(match_op(eq_ops_r[1],Select,sel_ops2,2))
+		if(match_op(eq_ops_r[1],Select,sel_ops2,2))
                   for(int j = 0; j < 2; j++){ // try the first equality both ways
                     if(eq_ops_l[0] == sto_ops[1]
                     && eq_ops_l[1] == sel_ops[1]
@@ -502,8 +502,8 @@ public:
                         int frame = range_min(ast_scope(res));
                         antes.push_back(std::pair<ast,int>(res,frame));
                         return;
-                      }
+                      }
-                      std::swap(eq_ops_l[0],eq_ops_l[1]);
+                      std::swap(eq_ops_l[0],eq_ops_l[1]);
                   }
 	    std::swap(eq_ops_r[0],eq_ops_r[1]);
 	  }

src/math/polynomial/upolynomial_factorization.cpp

@@ -530,7 +530,7 @@ bool check_hansel_lift(z_manager & upm, numeral_vector const & C,
     upm.mul(A_lifted.size(), A_lifted.c_ptr(), B_lifted.size(), B_lifted.c_ptr(), test1);
     upm.sub(C.size(), C.c_ptr(), test1.size(), test1.c_ptr(), test1);
     to_zp_manager(br_upm, test1);
-    if (!test1.size() == 0) {
+    if (test1.size() != 0) {
         TRACE("polynomial::factorization::bughunt", 
             tout << "sage: R.<x> = ZZ['x']" << endl;
             tout << "sage: A = "; upm.display(tout, A); tout << endl;

src/smt/theory_fpa.cpp

@@ -0,0 +1,46 @@
+/*++
+Copyright (c) 2014 Microsoft Corporation
+
+Module Name:
+
+    theory_fpa.cpp
+
+Abstract:
+
+    Floating-Point Theory Plugin
+
+Author:
+
+    Christoph (cwinter) 2014-04-23
+
+Revision History:
+
+--*/
+#include"ast_smt2_pp.h"
+#include"theory_fpa.h"
+
+namespace smt {
+
+    bool theory_fpa::internalize_atom(app * atom, bool gate_ctx) {
+        TRACE("bv", tout << "internalizing atom: " << mk_ismt2_pp(atom, get_manager()) << "\n";);
+        SASSERT(atom->get_family_id() == get_family_id());
+        NOT_IMPLEMENTED_YET();
+        return true;
+    }
+
+    void theory_fpa::new_eq_eh(theory_var, theory_var) {
+        NOT_IMPLEMENTED_YET();
+    }
+
+    void theory_fpa::new_diseq_eh(theory_var, theory_var) {
+        NOT_IMPLEMENTED_YET();
+    }
+
+    void theory_fpa::push_scope_eh() {
+        NOT_IMPLEMENTED_YET();
+    }
+
+    void theory_fpa::pop_scope_eh(unsigned num_scopes) {
+        NOT_IMPLEMENTED_YET();
+    }
+};

src/smt/theory_fpa.h

@@ -0,0 +1,45 @@
+/*++
+Copyright (c) 2014 Microsoft Corporation
+
+Module Name:
+
+    theory_fpa.h
+
+Abstract:
+
+    Floating-Point Theory Plugin
+
+Author:
+
+    Christoph (cwinter) 2014-04-23
+
+Revision History:
+
+--*/
+#ifndef _THEORY_FPA_H_
+#define _THEORY_FPA_H_
+
+#include"smt_theory.h"
+#include"fpa2bv_converter.h"
+
+namespace smt {
+    class theory_fpa : public theory {
+        fpa2bv_converter m_converter;
+
+        virtual final_check_status final_check_eh() { return FC_DONE; }
+        virtual bool internalize_atom(app*, bool);
+        virtual bool internalize_term(app*) { return internalize_atom(0, false); }
+        virtual void new_eq_eh(theory_var, theory_var);
+        virtual void new_diseq_eh(theory_var, theory_var);
+        virtual void push_scope_eh();
+        virtual void pop_scope_eh(unsigned num_scopes);
+        virtual theory* mk_fresh(context*) { return alloc(theory_fpa, get_manager()); }
+        virtual char const * get_name() const { return "fpa"; }
+    public:
+        theory_fpa(ast_manager& m) : theory(m.mk_family_id("fpa")), m_converter(m) {}
+    };
+
+};
+
+#endif /* _THEORY_FPA_H_ */
+

src/tactic/fpa/fpa2bv_model_converter.cpp

@@ -0,0 +1,232 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    fpa2bv_model_converter.h
+
+Abstract:
+
+    Model conversion for fpa2bv_converter
+
+Author:
+
+    Christoph (cwinter) 2012-02-09
+
+Notes:
+
+--*/
+#include"ast_smt2_pp.h"
+#include"fpa2bv_model_converter.h"
+
+void fpa2bv_model_converter::display(std::ostream & out) {
+    out << "(fpa2bv-model-converter";
+    for (obj_map<func_decl, expr*>::iterator it = m_const2bv.begin();
+         it != m_const2bv.end();
+         it++) {
+        const symbol & n = it->m_key->get_name();
+        out << "\n  (" << n << " ";
+        unsigned indent = n.size() + 4;
+        out << mk_ismt2_pp(it->m_value, m, indent) << ")";
+    }
+    for (obj_map<func_decl, expr*>::iterator it = m_rm_const2bv.begin();
+         it != m_rm_const2bv.end();
+         it++) {
+        const symbol & n = it->m_key->get_name();
+        out << "\n  (" << n << " ";
+        unsigned indent = n.size() + 4;
+        out << mk_ismt2_pp(it->m_value, m, indent) << ")";
+    }
+    for (obj_map<func_decl, func_decl*>::iterator it = m_uf2bvuf.begin();
+         it != m_uf2bvuf.end();
+         it++) {
+        const symbol & n = it->m_key->get_name();
+        out << "\n  (" << n << " ";
+        unsigned indent = n.size() + 4;
+        out << mk_ismt2_pp(it->m_value, m, indent) << ")";
+    }
+    for (obj_map<func_decl, func_decl_triple>::iterator it = m_uf23bvuf.begin();
+         it != m_uf23bvuf.end();
+         it++) {
+        const symbol & n = it->m_key->get_name();
+        out << "\n  (" << n << " ";
+        unsigned indent = n.size() + 4;
+        out << mk_ismt2_pp(it->m_value.f_sgn, m, indent) << " ; " <<
+            mk_ismt2_pp(it->m_value.f_sig, m, indent) << " ; " <<
+            mk_ismt2_pp(it->m_value.f_exp, m, indent) << " ; " <<
+            ")";
+    }
+    out << ")" << std::endl;
+}
+
+model_converter * fpa2bv_model_converter::translate(ast_translation & translator) {
+    fpa2bv_model_converter * res = alloc(fpa2bv_model_converter, translator.to());
+    for (obj_map<func_decl, expr*>::iterator it = m_const2bv.begin();
+         it != m_const2bv.end();
+         it++)
+    {
+        func_decl * k = translator(it->m_key);
+        expr * v = translator(it->m_value);
+        res->m_const2bv.insert(k, v);
+        translator.to().inc_ref(k);
+        translator.to().inc_ref(v);
+    }
+    for (obj_map<func_decl, expr*>::iterator it = m_rm_const2bv.begin();
+         it != m_rm_const2bv.end();
+         it++)
+    {
+        func_decl * k = translator(it->m_key);
+        expr * v = translator(it->m_value);
+        res->m_rm_const2bv.insert(k, v);
+        translator.to().inc_ref(k);
+        translator.to().inc_ref(v);
+    }
+    return res;
+}
+
+void fpa2bv_model_converter::convert(model * bv_mdl, model * float_mdl) {
+    float_util fu(m);
+    bv_util bu(m);
+    mpf fp_val;
+    unsynch_mpz_manager & mpzm = fu.fm().mpz_manager();
+    unsynch_mpq_manager & mpqm = fu.fm().mpq_manager();
+
+    TRACE("fpa2bv_mc", tout << "BV Model: " << std::endl;
+    for (unsigned i = 0; i < bv_mdl->get_num_constants(); i++)
+        tout << bv_mdl->get_constant(i)->get_name() << " --> " <<
+        mk_ismt2_pp(bv_mdl->get_const_interp(bv_mdl->get_constant(i)), m) << std::endl;
+    );
+
+    obj_hashtable<func_decl> seen;
+
+    for (obj_map<func_decl, expr*>::iterator it = m_const2bv.begin();
+         it != m_const2bv.end();
+         it++)
+    {
+        func_decl * var = it->m_key;
+        app * a = to_app(it->m_value);
+        SASSERT(fu.is_float(var->get_range()));
+        SASSERT(var->get_range()->get_num_parameters() == 2);
+
+        unsigned ebits = fu.get_ebits(var->get_range());
+        unsigned sbits = fu.get_sbits(var->get_range());
+
+        expr_ref sgn(m), sig(m), exp(m);
+        sgn = bv_mdl->get_const_interp(to_app(a->get_arg(0))->get_decl());
+        sig = bv_mdl->get_const_interp(to_app(a->get_arg(1))->get_decl());
+        exp = bv_mdl->get_const_interp(to_app(a->get_arg(2))->get_decl());
+
+        seen.insert(to_app(a->get_arg(0))->get_decl());
+        seen.insert(to_app(a->get_arg(1))->get_decl());
+        seen.insert(to_app(a->get_arg(2))->get_decl());
+
+        if (!sgn && !sig && !exp)
+            continue;
+
+        unsigned sgn_sz = bu.get_bv_size(m.get_sort(a->get_arg(0)));
+        unsigned sig_sz = bu.get_bv_size(m.get_sort(a->get_arg(1))) - 1;
+        unsigned exp_sz = bu.get_bv_size(m.get_sort(a->get_arg(2)));
+
+        rational sgn_q(0), sig_q(0), exp_q(0);
+
+        if (sgn) bu.is_numeral(sgn, sgn_q, sgn_sz);
+        if (sig) bu.is_numeral(sig, sig_q, sig_sz);
+        if (exp) bu.is_numeral(exp, exp_q, exp_sz);
+
+        // un-bias exponent
+        rational exp_unbiased_q;
+        exp_unbiased_q = exp_q - fu.fm().m_powers2.m1(ebits - 1);
+
+        mpz sig_z; mpf_exp_t exp_z;
+        mpzm.set(sig_z, sig_q.to_mpq().numerator());
+        exp_z = mpzm.get_int64(exp_unbiased_q.to_mpq().numerator());
+
+        TRACE("fpa2bv_mc", tout << var->get_name() << " == [" << sgn_q.to_string() << " " <<
+              mpzm.to_string(sig_z) << " " << exp_z << "(" << exp_q.to_string() << ")]" << std::endl;);
+
+        fu.fm().set(fp_val, ebits, sbits, !mpqm.is_zero(sgn_q.to_mpq()), sig_z, exp_z);
+
+        float_mdl->register_decl(var, fu.mk_value(fp_val));
+
+        mpzm.del(sig_z);
+    }
+
+    for (obj_map<func_decl, expr*>::iterator it = m_rm_const2bv.begin();
+         it != m_rm_const2bv.end();
+         it++)
+    {
+        func_decl * var = it->m_key;
+        app * a = to_app(it->m_value);
+        SASSERT(fu.is_rm(var->get_range()));
+        rational val(0);
+        unsigned sz = 0;
+        if (a && bu.is_numeral(a, val, sz)) {
+            TRACE("fpa2bv_mc", tout << var->get_name() << " == " << val.to_string() << std::endl;);
+            SASSERT(val.is_uint64());
+            switch (val.get_uint64())
+            {
+            case BV_RM_TIES_TO_AWAY: float_mdl->register_decl(var, fu.mk_round_nearest_ties_to_away()); break;
+            case BV_RM_TIES_TO_EVEN: float_mdl->register_decl(var, fu.mk_round_nearest_ties_to_even()); break;
+            case BV_RM_TO_NEGATIVE: float_mdl->register_decl(var, fu.mk_round_toward_negative()); break;
+            case BV_RM_TO_POSITIVE: float_mdl->register_decl(var, fu.mk_round_toward_positive()); break;
+            case BV_RM_TO_ZERO:
+            default: float_mdl->register_decl(var, fu.mk_round_toward_zero());
+            }
+            seen.insert(var);
+        }
+    }
+
+    for (obj_map<func_decl, func_decl*>::iterator it = m_uf2bvuf.begin();
+         it != m_uf2bvuf.end();
+         it++)
+         seen.insert(it->m_value);
+
+    for (obj_map<func_decl, func_decl_triple>::iterator it = m_uf23bvuf.begin();
+         it != m_uf23bvuf.end();
+         it++)
+    {
+        seen.insert(it->m_value.f_sgn);
+        seen.insert(it->m_value.f_sig);
+        seen.insert(it->m_value.f_exp);
+    }
+
+    fu.fm().del(fp_val);
+
+    // Keep all the non-float constants.
+    unsigned sz = bv_mdl->get_num_constants();
+    for (unsigned i = 0; i < sz; i++)
+    {
+        func_decl * c = bv_mdl->get_constant(i);
+        if (!seen.contains(c))
+            float_mdl->register_decl(c, bv_mdl->get_const_interp(c));
+    }
+
+    // And keep everything else
+    sz = bv_mdl->get_num_functions();
+    for (unsigned i = 0; i < sz; i++)
+    {
+        func_decl * f = bv_mdl->get_function(i);
+        if (!seen.contains(f))
+        {
+            TRACE("fpa2bv_mc", tout << "Keeping: " << mk_ismt2_pp(f, m) << std::endl;);
+            func_interp * val = bv_mdl->get_func_interp(f);
+            float_mdl->register_decl(f, val);
+        }
+    }
+
+    sz = bv_mdl->get_num_uninterpreted_sorts();
+    for (unsigned i = 0; i < sz; i++)
+    {
+        sort * s = bv_mdl->get_uninterpreted_sort(i);
+        ptr_vector<expr> u = bv_mdl->get_universe(s);
+        float_mdl->register_usort(s, u.size(), u.c_ptr());
+    }
+}
+
+model_converter * mk_fpa2bv_model_converter(ast_manager & m,
+                                            obj_map<func_decl, expr*> const & const2bv,
+                                            obj_map<func_decl, expr*> const & rm_const2bv,
+                                            obj_map<func_decl, func_decl*> const & uf2bvuf,
+                                            obj_map<func_decl, func_decl_triple> const & uf23bvuf) {
+    return alloc(fpa2bv_model_converter, m, const2bv, rm_const2bv, uf2bvuf, uf23bvuf);
+}

src/tactic/fpa/fpa2bv_model_converter.h

@@ -0,0 +1,106 @@
+/*++
+Copyright (c) 2012 Microsoft Corporation
+
+Module Name:
+
+    fpa2bv_model_converter.h
+
+Abstract:
+
+    Model conversion for fpa2bv_converter
+
+Author:
+
+    Christoph (cwinter) 2012-02-09
+
+Notes:
+
+--*/
+#ifndef _FPA2BV_MODEL_CONVERTER_H_
+#define _FPA2BV_MODEL_CONVERTER_H_
+
+#include"fpa2bv_converter.h"
+#include"model_converter.h"
+
+class fpa2bv_model_converter : public model_converter {
+    ast_manager               & m;
+    obj_map<func_decl, expr*>   m_const2bv;
+    obj_map<func_decl, expr*>   m_rm_const2bv;
+    obj_map<func_decl, func_decl*>  m_uf2bvuf;
+    obj_map<func_decl, func_decl_triple>  m_uf23bvuf;
+
+public:
+    fpa2bv_model_converter(ast_manager & m, obj_map<func_decl, expr*> const & const2bv,
+                           obj_map<func_decl, expr*> const & rm_const2bv,
+                           obj_map<func_decl, func_decl*> const & uf2bvuf,
+                           obj_map<func_decl, func_decl_triple> const & uf23bvuf) :
+                           m(m) {
+        // Just create a copy?
+        for (obj_map<func_decl, expr*>::iterator it = const2bv.begin();
+             it != const2bv.end();
+             it++)
+        {
+            m_const2bv.insert(it->m_key, it->m_value);
+            m.inc_ref(it->m_key);
+            m.inc_ref(it->m_value);
+        }
+        for (obj_map<func_decl, expr*>::iterator it = rm_const2bv.begin();
+             it != rm_const2bv.end();
+             it++)
+        {
+            m_rm_const2bv.insert(it->m_key, it->m_value);
+            m.inc_ref(it->m_key);
+            m.inc_ref(it->m_value);
+        }
+        for (obj_map<func_decl, func_decl*>::iterator it = uf2bvuf.begin();
+             it != uf2bvuf.end();
+             it++)
+        {
+            m_uf2bvuf.insert(it->m_key, it->m_value);
+            m.inc_ref(it->m_key);
+            m.inc_ref(it->m_value);
+        }
+        for (obj_map<func_decl, func_decl_triple>::iterator it = uf23bvuf.begin();
+             it != uf23bvuf.end();
+             it++)
+        {
+            m_uf23bvuf.insert(it->m_key, it->m_value);
+            m.inc_ref(it->m_key);
+        }
+    }
+
+    virtual ~fpa2bv_model_converter() {
+        dec_ref_map_key_values(m, m_const2bv);
+        dec_ref_map_key_values(m, m_rm_const2bv);
+    }
+
+    virtual void operator()(model_ref & md, unsigned goal_idx) {
+        SASSERT(goal_idx == 0);
+        model * new_model = alloc(model, m);
+        obj_hashtable<func_decl> bits;
+        convert(md.get(), new_model);
+        md = new_model;
+    }
+
+    virtual void operator()(model_ref & md) {
+        operator()(md, 0);
+    }
+
+    void display(std::ostream & out);
+
+    virtual model_converter * translate(ast_translation & translator);
+
+protected:
+    fpa2bv_model_converter(ast_manager & m) : m(m) { }
+
+    void convert(model * bv_mdl, model * float_mdl);
+};
+
+
+model_converter * mk_fpa2bv_model_converter(ast_manager & m,
+                                            obj_map<func_decl, expr*> const & const2bv,
+                                            obj_map<func_decl, expr*> const & rm_const2bv,
+                                            obj_map<func_decl, func_decl*> const & uf2bvuf,
+                                            obj_map<func_decl, func_decl_triple> const & uf23bvuf);
+
+#endif

src/tactic/fpa/fpa2bv_tactic.cpp

@@ -20,6 +20,7 @@ Notes:
 #include"fpa2bv_rewriter.h"
 #include"simplify_tactic.h"
 #include"fpa2bv_tactic.h"
+#include"fpa2bv_model_converter.h"
 
 class fpa2bv_tactic : public tactic {
     struct imp {