mirrors/z3
3
0
Fork 0
mirror of https://github.com/Z3Prover/z3 synced 2025-04-13 12:28:44 +00:00
Code Activity

Merge branch 'master' of https://github.com/Z3Prover/z3

Browse source
This commit is contained in:
Nikolaj Bjorner 2017-04-07 21:22:48 -07:00
parent ec29a03c8f 27a1758857
commit 80c10d5833
36 changed files with 1430 additions and 845 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
contrib/qprofdiff/Makefile Normal file
View file

@ -0,0 +1,7 @@
qprofdiff: main.cpp
$(CXX) $(CXXFLAGS) main.cpp -o qprofdiff
all: qprofdiff
clean:
rm -f qprofdiff

284
contrib/qprofdiff/main.cpp Normal file
View file

@ -0,0 +1,284 @@
/*++
Copyright (c) 2017 Microsoft Corporation
Module Name:
main.cpp
Abstract:
Main file for qprofdiff.
Author:
Christoph M. Wintersteiger (cwinter)
Revision History:
--*/
#include<errno.h>
#include<limits.h>
#include<string>
#include<iostream>
#include<fstream>
#include<map>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
set<string> options;
// Profile format:
// [quantifier_instances] qname : num_instances : max_generation : max_cost_s
const string prefix = "[quantifier_instances]";
unsigned prefix_len = prefix.length();
typedef struct { unsigned num_instances, max_generation, max_cost; } map_entry;
string trim(string str) {
size_t linx = str.find_first_not_of(' ');
size_t rinx = str.find_last_not_of(' ');
return str.substr(linx, rinx-linx+1);
}
int parse(string const & filename, map<string, map_entry> & data) {
ifstream fs(filename.c_str());
if (!fs.is_open()) {
cout << "Can't open file '" << filename << "'" << endl;
return ENOENT;
}
string qid;
string tokens[4];
unsigned cur_token = 0;
while (!fs.eof()) {
string line;
getline(fs, line);
if (line.substr(0, prefix_len) == prefix) {
line = trim(line.substr(prefix_len));
size_t from = 0, ti = 0;
for (size_t inx = line.find(':', from);
inx != string::npos;
inx = line.find(':', from)) {
tokens[ti] = trim(line.substr(from, inx-from));
from = inx+1;
ti++;
}
if (from != line.length() && ti < 4)
tokens[ti] = trim(line.substr(from));
qid = tokens[0];
if (data.find(qid) == data.end()) {
map_entry & entry = data[qid];
entry.num_instances = entry.max_generation = entry.max_cost = 0;
}
map_entry & entry = data[qid];
entry.num_instances = atoi(tokens[1].c_str());
entry.max_generation = (unsigned)atoi(tokens[2].c_str());
entry.max_cost = (unsigned)atoi(tokens[3].c_str());
}
}
fs.close();
return 0;
}
void display_data(map<string, map_entry> & data) {
for (map<string, map_entry>::iterator it = data.begin();
it != data.end();
it++)
cout << it->first << ": " << it->second.num_instances <<
", " << it->second.max_generation <<
", " << it->second.max_cost << endl;
}
typedef struct {
int d_num_instances, d_max_generation, d_max_cost;
bool left_only, right_only;
} diff_entry;
typedef struct { string qid; diff_entry e; } diff_item;
#define DIFF_LT(X) bool diff_item_lt_ ## X (diff_item const & l, diff_item const & r) { \
int l_lt_r = l.e.d_ ## X < r.e.d_ ## X; \
int l_eq_r = l.e.d_ ## X == r.e.d_ ## X; \
return \
l.e.left_only ? (r.e.left_only ? ((l_eq_r) ? l.qid < r.qid : l_lt_r) : false) : \
l.e.right_only ? (r.e.right_only ? ((l_eq_r) ? l.qid < r.qid : l_lt_r) : true) : \
r.e.right_only ? false : \
r.e.left_only ? true : \
l_lt_r; \
}
DIFF_LT(num_instances)
DIFF_LT(max_generation)
DIFF_LT(max_cost)
int indicate(diff_entry const & e, bool suppress_unchanged) {
if (e.left_only) {
cout << "< ";
return INT_MIN;
}
else if (e.right_only) {
cout << "> ";
return INT_MAX;
}
else {
int const & delta =
(options.find("-si") != options.end()) ? e.d_num_instances :
(options.find("-sg") != options.end()) ? e.d_max_generation :
(options.find("-sc") != options.end()) ? e.d_max_cost :
e.d_num_instances;
if (delta < 0)
cout << "+ ";
else if (delta > 0)
cout << "- ";
else if (delta == 0 && !suppress_unchanged)
cout << "= ";
return delta;
}
}
void diff(map<string, map_entry> & left, map<string, map_entry> & right) {
map<string, diff_entry> diff_data;
for (map<string, map_entry>::const_iterator lit = left.begin();
lit != left.end();
lit++) {
string const & qid = lit->first;
map_entry const & lentry = lit->second;
map<string, map_entry>::const_iterator rit = right.find(qid);
if (rit != right.end()) {
map_entry const & rentry = rit->second;
diff_entry & de = diff_data[qid];
de.left_only = de.right_only = false;
de.d_num_instances = lentry.num_instances - rentry.num_instances;
de.d_max_generation = lentry.max_generation - rentry.max_generation;
de.d_max_cost = lentry.max_cost - rentry.max_cost;
}
else {
diff_entry & de = diff_data[qid];
de.left_only = true;
de.right_only = false;
de.d_num_instances = lentry.num_instances;
de.d_max_generation = lentry.max_generation;
de.d_max_cost = lentry.max_cost;
}
}
for (map<string, map_entry>::const_iterator rit = right.begin();
rit != right.end();
rit++) {
string const & qid = rit->first;
map_entry const & rentry = rit->second;
map<string, map_entry>::const_iterator lit = left.find(qid);
if (lit == left.end()) {
diff_entry & de = diff_data[qid];
de.left_only = false;
de.right_only = true;
de.d_num_instances = -(int)rentry.num_instances;
de.d_max_generation = -(int)rentry.max_generation;
de.d_max_cost = -(int)rentry.max_cost;
}
}
vector<diff_item> flat_data;
for (map<string, diff_entry>::const_iterator it = diff_data.begin();
it != diff_data.end();
it++) {
flat_data.push_back(diff_item());
flat_data.back().qid = it->first;
flat_data.back().e = it->second;
}
stable_sort(flat_data.begin(), flat_data.end(),
options.find("-si") != options.end() ? diff_item_lt_num_instances:
options.find("-sg") != options.end() ? diff_item_lt_max_generation :
options.find("-sc") != options.end() ? diff_item_lt_max_cost :
diff_item_lt_num_instances);
bool suppress_unchanged = options.find("-n") != options.end();
for (vector<diff_item>::const_iterator it = flat_data.begin();
it != flat_data.end();
it++) {
diff_item const & d = *it;
string const & qid = d.qid;
diff_entry const & e = d.e;
int delta = indicate(e, suppress_unchanged);
if (!(delta == 0 && suppress_unchanged))
cout << qid << " (" <<
(e.d_num_instances > 0 ? "" : "+") << -e.d_num_instances << " inst., " <<
(e.d_max_generation > 0 ? "" : "+") << -e.d_max_generation << " max. gen., " <<
(e.d_max_cost > 0 ? "" : "+") << -e.d_max_cost << " max. cost)" <<
endl;
}
}
void display_usage() {
cout << "Usage: qprofdiff [options] <filename> <filename>" << endl;
cout << "Options:" << endl;
cout << " -n Suppress unchanged items" << endl;
cout << " -si Sort by difference in number of instances" << endl;
cout << " -sg Sort by difference in max. generation" << endl;
cout << " -sc Sort by difference in max. cost" << endl;
}
int main(int argc, char ** argv) {
char * filename1 = 0;
char * filename2 = 0;
for (int i = 1; i < argc; i++) {
int len = string(argv[i]).length();
if (len > 1 && argv[i][0] == '-') {
options.insert(string(argv[i]));
}
else if (filename1 == 0)
filename1 = argv[i];
else if (filename2 == 0)
filename2 = argv[i];
else {
cout << "Invalid argument: " << argv[i] << endl << endl;
display_usage();
return EINVAL;
}
}
if (filename1 == 0 || filename2 == 0) {
cout << "Two filenames required." << endl << endl;
display_usage();
return EINVAL;
}
cout << "Comparing " << filename1 << " to " << filename2 << endl;
map<string, map_entry> data1, data2;
int r = parse(filename1, data1);
if (r != 0) return r;
r = parse(filename2, data2);
if (r != 0) return r;
// display_data(data1);
// display_data(data2);
diff(data1, data2);
return 0;
}

137
contrib/qprofdiff/qprofdiff.vcxproj Normal file
View file

@ -0,0 +1,137 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>15.0</VCProjectVersion>
<ProjectGuid>{96E7E3EF-4162-474D-BD32-C702632AAF2B}</ProjectGuid>
<RootNamespace>qprofdiff</RootNamespace>
<WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<CharacterSet>NotSet</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v141</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<IncludePath>$(IncludePath)</IncludePath>
<LibraryPath>$(LibraryPath)</LibraryPath>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<IncludePath>$(IncludePath)</IncludePath>
<LibraryPath>$(LibraryPath)</LibraryPath>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
<AdditionalIncludeDirectories>..\..\src\util;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<MultiProcessorCompilation>
</MultiProcessorCompilation>
<DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
</ClCompile>
<Link>
<AdditionalLibraryDirectories>$(LibraryPath);%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>..\..\src\util;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>..\..\src\util;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<AdditionalIncludeDirectories>..\..\src\util;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="main.cpp" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

22
contrib/qprofdiff/qprofdiff.vcxproj.filters Normal file
View file

@ -0,0 +1,22 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="main.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
</Project>

7
src/api/api_quant.cpp
View file

@ -69,6 +69,9 @@ extern "C" {
} }
expr * const* ps = reinterpret_cast<expr * const*>(patterns); expr * const* ps = reinterpret_cast<expr * const*>(patterns);
expr * const* no_ps = reinterpret_cast<expr * const*>(no_patterns); expr * const* no_ps = reinterpret_cast<expr * const*>(no_patterns);
symbol qid = to_symbol(quantifier_id);
bool is_rec = mk_c(c)->m().rec_fun_qid() == qid;
if (!is_rec) {
pattern_validator v(mk_c(c)->m()); pattern_validator v(mk_c(c)->m());
for (unsigned i = 0; i < num_patterns; i++) { for (unsigned i = 0; i < num_patterns; i++) {
if (!v(num_decls, ps[i], 0, 0)) { if (!v(num_decls, ps[i], 0, 0)) {
@ -76,7 +79,7 @@ extern "C" {
return 0; return 0;
} }
} }
}
sort* const* ts = reinterpret_cast<sort * const*>(sorts); sort* const* ts = reinterpret_cast<sort * const*>(sorts);
svector<symbol> names; svector<symbol> names;
for (unsigned i = 0; i < num_decls; ++i) { for (unsigned i = 0; i < num_decls; ++i) {
@ -88,7 +91,7 @@ extern "C" {
(0 != is_forall), (0 != is_forall),
names.size(), ts, names.c_ptr(), to_expr(body), names.size(), ts, names.c_ptr(), to_expr(body),
weight, weight,
to_symbol(quantifier_id), qid,
to_symbol(skolem_id), to_symbol(skolem_id),
num_patterns, ps, num_patterns, ps,
num_no_patterns, no_ps num_no_patterns, no_ps

6
src/api/python/z3/z3.py
View file

@ -3701,11 +3701,7 @@ def Extract(high, low, a):
high = StringVal(high) high = StringVal(high)
if is_seq(high): if is_seq(high):
s = high s = high
offset = _py2expr(low, high.ctx) offset, length = _coerce_exprs(low, a, s.ctx)
length = _py2expr(a, high.ctx)
if __debug__:
_z3_assert(is_int(offset) and is_int(length), "Second and third arguments must be integers")
return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx) return SeqRef(Z3_mk_seq_extract(s.ctx_ref(), s.as_ast(), offset.as_ast(), length.as_ast()), s.ctx)
if __debug__: if __debug__:
_z3_assert(low <= high, "First argument must be greater than or equal to second argument") _z3_assert(low <= high, "First argument must be greater than or equal to second argument")

15
src/ast/arith_decl_plugin.cpp
View file

@ -285,7 +285,8 @@ arith_decl_plugin::arith_decl_plugin():
m_idiv_0_decl(0), m_idiv_0_decl(0),
m_mod_0_decl(0), m_mod_0_decl(0),
m_u_asin_decl(0), m_u_asin_decl(0),
m_u_acos_decl(0) { m_u_acos_decl(0),
m_convert_int_numerals_to_real(false) {
} }
arith_decl_plugin::~arith_decl_plugin() { arith_decl_plugin::~arith_decl_plugin() {
@ -418,7 +419,7 @@ app * arith_decl_plugin::mk_numeral(rational const & val, bool is_int) {
if (val.is_unsigned()) { if (val.is_unsigned()) {
unsigned u_val = val.get_unsigned(); unsigned u_val = val.get_unsigned();
if (u_val < MAX_SMALL_NUM_TO_CACHE) { if (u_val < MAX_SMALL_NUM_TO_CACHE) {
if (is_int) { if (is_int && !m_convert_int_numerals_to_real) {
app * r = m_small_ints.get(u_val, 0); app * r = m_small_ints.get(u_val, 0);
if (r == 0) { if (r == 0) {
parameter p[2] = { parameter(val), parameter(1) }; parameter p[2] = { parameter(val), parameter(1) };
@ -442,7 +443,7 @@ app * arith_decl_plugin::mk_numeral(rational const & val, bool is_int) {
} }
parameter p[2] = { parameter(val), parameter(static_cast<int>(is_int)) }; parameter p[2] = { parameter(val), parameter(static_cast<int>(is_int)) };
func_decl * decl; func_decl * decl;
if (is_int) if (is_int && !m_convert_int_numerals_to_real)
decl = m_manager->mk_const_decl(m_intv_sym, m_int_decl, func_decl_info(m_family_id, OP_NUM, 2, p)); decl = m_manager->mk_const_decl(m_intv_sym, m_int_decl, func_decl_info(m_family_id, OP_NUM, 2, p));
else else
decl = m_manager->mk_const_decl(m_realv_sym, m_real_decl, func_decl_info(m_family_id, OP_NUM, 2, p)); decl = m_manager->mk_const_decl(m_realv_sym, m_real_decl, func_decl_info(m_family_id, OP_NUM, 2, p));
@ -521,9 +522,17 @@ func_decl * arith_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters
} }
void arith_decl_plugin::get_sort_names(svector<builtin_name>& sort_names, symbol const & logic) { void arith_decl_plugin::get_sort_names(svector<builtin_name>& sort_names, symbol const & logic) {
if (logic == "NRA" ||
logic == "QF_NRA" ||
logic == "QF_UFNRA") {
m_convert_int_numerals_to_real = true;
sort_names.push_back(builtin_name("Real", REAL_SORT));
}
else {
// TODO: only define Int and Real in the right logics // TODO: only define Int and Real in the right logics
sort_names.push_back(builtin_name("Int", INT_SORT)); sort_names.push_back(builtin_name("Int", INT_SORT));
sort_names.push_back(builtin_name("Real", REAL_SORT)); sort_names.push_back(builtin_name("Real", REAL_SORT));
}
} }
void arith_decl_plugin::get_op_names(svector<builtin_name>& op_names, symbol const & logic) { void arith_decl_plugin::get_op_names(svector<builtin_name>& op_names, symbol const & logic) {

2
src/ast/arith_decl_plugin.h
View file

@ -152,6 +152,8 @@ protected:
ptr_vector<app> m_small_ints; ptr_vector<app> m_small_ints;
ptr_vector<app> m_small_reals; ptr_vector<app> m_small_reals;
bool m_convert_int_numerals_to_real;
func_decl * mk_func_decl(decl_kind k, bool is_real); func_decl * mk_func_decl(decl_kind k, bool is_real);
virtual void set_manager(ast_manager * m, family_id id); virtual void set_manager(ast_manager * m, family_id id);
decl_kind fix_kind(decl_kind k, unsigned arity); decl_kind fix_kind(decl_kind k, unsigned arity);

20
src/ast/decl_collector.cpp
View file

@ -23,8 +23,21 @@ void decl_collector::visit_sort(sort * n) {
family_id fid = n->get_family_id(); family_id fid = n->get_family_id();
if (m().is_uninterp(n)) if (m().is_uninterp(n))
m_sorts.push_back(n); m_sorts.push_back(n);
if (fid == m_dt_fid) if (fid == m_dt_fid) {
m_sorts.push_back(n); m_sorts.push_back(n);
unsigned num_cnstr = m_dt_util.get_datatype_num_constructors(n);
for (unsigned i = 0; i < num_cnstr; i++) {
func_decl * cnstr = m_dt_util.get_datatype_constructors(n)->get(i);
m_decls.push_back(cnstr);
ptr_vector<func_decl> const & cnstr_acc = *m_dt_util.get_constructor_accessors(cnstr);
unsigned num_cas = cnstr_acc.size();
for (unsigned j = 0; j < num_cas; j++) {
func_decl * accsr = cnstr_acc.get(j);
m_decls.push_back(accsr);
}
}
}
} }
bool decl_collector::is_bool(sort * s) { bool decl_collector::is_bool(sort * s) {
@ -43,9 +56,10 @@ void decl_collector::visit_func(func_decl * n) {
decl_collector::decl_collector(ast_manager & m, bool preds): decl_collector::decl_collector(ast_manager & m, bool preds):
m_manager(m), m_manager(m),
m_sep_preds(preds) { m_sep_preds(preds),
m_dt_util(m) {
m_basic_fid = m_manager.get_basic_family_id(); m_basic_fid = m_manager.get_basic_family_id();
m_dt_fid = m_manager.mk_family_id("datatype"); m_dt_fid = m_dt_util.get_family_id();
} }
void decl_collector::visit(ast* n) { void decl_collector::visit(ast* n) {

2
src/ast/decl_collector.h
View file

@ -21,6 +21,7 @@ Revision History:
#define SMT_DECL_COLLECTOR_H_ #define SMT_DECL_COLLECTOR_H_
#include"ast.h" #include"ast.h"
#include"datatype_decl_plugin.h"
class decl_collector { class decl_collector {
ast_manager & m_manager; ast_manager & m_manager;
@ -31,6 +32,7 @@ class decl_collector {
ast_mark m_visited; ast_mark m_visited;
family_id m_basic_fid; family_id m_basic_fid;
family_id m_dt_fid; family_id m_dt_fid;
datatype_util m_dt_util;
void visit_sort(sort* n); void visit_sort(sort* n);
bool is_bool(sort* s); bool is_bool(sort* s);

2
src/ast/normal_forms/defined_names.cpp
View file

@ -162,7 +162,7 @@ void defined_names::impl::bound_vars(sort_ref_buffer const & sorts, buffer<symbo
1, symbol::null, symbol::null, 1, symbol::null, symbol::null,
1, patterns); 1, patterns);
TRACE("mk_definition_bug", tout << "before elim_unused_vars:\n" << mk_ismt2_pp(q, m_manager) << "\n";); TRACE("mk_definition_bug", tout << "before elim_unused_vars:\n" << mk_ismt2_pp(q, m_manager) << "\n";);
elim_unused_vars(m_manager, q, result); elim_unused_vars(m_manager, q, params_ref(), result);
TRACE("mk_definition_bug", tout << "after elim_unused_vars:\n" << mk_ismt2_pp(result, m_manager) << "\n";); TRACE("mk_definition_bug", tout << "after elim_unused_vars:\n" << mk_ismt2_pp(result, m_manager) << "\n";);
} }
} }

2
src/ast/rewriter/der.cpp
View file

@ -138,7 +138,7 @@ void der::operator()(quantifier * q, expr_ref & r, proof_ref & pr) {
// Eliminate variables that have become unused // Eliminate variables that have become unused
if (reduced && is_forall(r)) { if (reduced && is_forall(r)) {
quantifier * q = to_quantifier(r); quantifier * q = to_quantifier(r);
elim_unused_vars(m_manager, q, r); elim_unused_vars(m_manager, q, params_ref(), r);
if (m_manager.proofs_enabled()) { if (m_manager.proofs_enabled()) {
proof * p1 = m_manager.mk_elim_unused_vars(q, r); proof * p1 = m_manager.mk_elim_unused_vars(q, r);
pr = m_manager.mk_transitivity(pr, p1); pr = m_manager.mk_transitivity(pr, p1);

3
src/ast/rewriter/rewriter_params.pyg
View file

@ -8,5 +8,6 @@ def_module_params('rewriter',
("push_ite_bv", BOOL, False, "push if-then-else over bit-vector terms."), ("push_ite_bv", BOOL, False, "push if-then-else over bit-vector terms."),
("pull_cheap_ite", BOOL, False, "pull if-then-else terms when cheap."), ("pull_cheap_ite", BOOL, False, "pull if-then-else terms when cheap."),
("bv_ineq_consistency_test_max", UINT, 0, "max size of conjunctions on which to perform consistency test based on inequalities on bitvectors."), ("bv_ineq_consistency_test_max", UINT, 0, "max size of conjunctions on which to perform consistency test based on inequalities on bitvectors."),
("cache_all", BOOL, False, "cache all intermediate results."))) ("cache_all", BOOL, False, "cache all intermediate results."),
("ignore_patterns_on_ground_qbody", BOOL, True, "ignores patterns on quantifiers that don't mention their bound variables.")))

60
src/ast/rewriter/seq_rewriter.cpp
View file

@ -12,6 +12,7 @@ Abstract:
Author: Author:
Nikolaj Bjorner (nbjorner) 2015-12-5 Nikolaj Bjorner (nbjorner) 2015-12-5
Murphy Berzish 2017-02-21
Notes: Notes:
@ -514,30 +515,56 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu
bool constantPos = m_autil.is_numeral(b, pos); bool constantPos = m_autil.is_numeral(b, pos);
bool constantLen = m_autil.is_numeral(c, len); bool constantLen = m_autil.is_numeral(c, len);
// case 1: pos<0 or len<0 // case 1: pos<0 or len<=0
// rewrite to "" // rewrite to ""
if ( (constantPos && pos.is_neg()) || (constantLen && len.is_neg()) ) { if ( (constantPos && pos.is_neg()) || (constantLen && !len.is_pos()) ) {
result = m_util.str.mk_empty(m().get_sort(a)); result = m_util.str.mk_empty(m().get_sort(a));
return BR_DONE; return BR_DONE;
} }
// case 1.1: pos >= length(base) // case 1.1: pos >= length(base)
// rewrite to "" // rewrite to ""
if (constantBase && constantPos && pos.get_unsigned() >= s.length()) { if (constantBase && constantPos && pos >= rational(s.length())) {
result = m_util.str.mk_empty(m().get_sort(a)); result = m_util.str.mk_empty(m().get_sort(a));
return BR_DONE; return BR_DONE;
} }
constantPos &= pos.is_unsigned();
constantLen &= len.is_unsigned();
if (constantBase && constantPos && constantLen) { if (constantBase && constantPos && constantLen) {
if (pos.get_unsigned() + len.get_unsigned() >= s.length()) { if (pos.get_unsigned() + len.get_unsigned() >= s.length()) {
// case 2: pos+len goes past the end of the string // case 2: pos+len goes past the end of the string
unsigned _len = s.length() - pos.get_unsigned() + 1; unsigned _len = s.length() - pos.get_unsigned() + 1;
result = m_util.str.mk_string(s.extract(pos.get_unsigned(), _len)); result = m_util.str.mk_string(s.extract(pos.get_unsigned(), _len));
return BR_DONE;
} else { } else {
// case 3: pos+len still within string // case 3: pos+len still within string
result = m_util.str.mk_string(s.extract(pos.get_unsigned(), len.get_unsigned())); result = m_util.str.mk_string(s.extract(pos.get_unsigned(), len.get_unsigned()));
}
return BR_DONE; return BR_DONE;
} }
if (constantPos && constantLen) {
unsigned _pos = pos.get_unsigned();
unsigned _len = len.get_unsigned();
SASSERT(_len > 0);
expr_ref_vector as(m()), bs(m());
m_util.str.get_concat(a, as);
for (unsigned i = 0; i < as.size() && _len > 0; ++i) {
if (m_util.str.is_unit(as[i].get())) {
if (_pos == 0) {
bs.push_back(as[i].get());
--_len;
}
else {
--_pos;
}
}
else {
return BR_FAILED;
}
}
result = m_util.str.mk_concat(bs);
return BR_DONE;
} }
return BR_FAILED; return BR_FAILED;
@ -640,10 +667,33 @@ br_status seq_rewriter::mk_seq_at(expr* a, expr* b, expr_ref& result) {
result = m_util.str.mk_empty(m().get_sort(a)); result = m_util.str.mk_empty(m().get_sort(a));
return BR_DONE; return BR_DONE;
} }
if (m_util.str.is_string(a, c) && r.is_unsigned() && r < rational(c.length())) { if (m_util.str.is_string(a, c)) {
if (r.is_unsigned() && r < rational(c.length())) {
result = m_util.str.mk_string(c.extract(r.get_unsigned(), 1)); result = m_util.str.mk_string(c.extract(r.get_unsigned(), 1));
}
else {
result = m_util.str.mk_empty(m().get_sort(a));
}
return BR_DONE; return BR_DONE;
} }
if (r.is_unsigned()) {
len = r.get_unsigned();
expr_ref_vector as(m());
m_util.str.get_concat(a, as);
for (unsigned i = 0; i < as.size(); ++i) {
if (m_util.str.is_unit(as[i].get())) {
if (len == 0) {
result = as[i].get();
return BR_DONE;
}
--len;
}
else {
return BR_FAILED;
}
}
}
} }
return BR_FAILED; return BR_FAILED;
} }

4
src/ast/rewriter/th_rewriter.cpp
View file

@ -54,6 +54,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
bool m_cache_all; bool m_cache_all;
bool m_push_ite_arith; bool m_push_ite_arith;
bool m_push_ite_bv; bool m_push_ite_bv;
bool m_ignore_patterns_on_ground_qbody;
// substitution support // substitution support
expr_dependency_ref m_used_dependencies; // set of dependencies of used substitutions expr_dependency_ref m_used_dependencies; // set of dependencies of used substitutions
@ -70,6 +71,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
m_cache_all = p.cache_all(); m_cache_all = p.cache_all();
m_push_ite_arith = p.push_ite_arith(); m_push_ite_arith = p.push_ite_arith();
m_push_ite_bv = p.push_ite_bv(); m_push_ite_bv = p.push_ite_bv();
m_ignore_patterns_on_ground_qbody = p.ignore_patterns_on_ground_qbody();
} }
void updt_params(params_ref const & p) { void updt_params(params_ref const & p) {
@ -649,7 +651,7 @@ struct th_rewriter_cfg : public default_rewriter_cfg {
SASSERT(is_well_sorted(m(), q1)); SASSERT(is_well_sorted(m(), q1));
} }
elim_unused_vars(m(), q1, result); elim_unused_vars(m(), q1, params_ref(), result);
TRACE("reduce_quantifier", tout << "after elim_unused_vars:\n" << mk_ismt2_pp(result, m()) << "\n";); TRACE("reduce_quantifier", tout << "after elim_unused_vars:\n" << mk_ismt2_pp(result, m()) << "\n";);

14
src/ast/rewriter/var_subst.cpp
View file

@ -39,10 +39,16 @@ void var_subst::operator()(expr * n, unsigned num_args, expr * const * args, exp
tout << mk_ismt2_pp(result, m_reducer.m()) << "\n";); tout << mk_ismt2_pp(result, m_reducer.m()) << "\n";);
} }
unused_vars_eliminator::unused_vars_eliminator(ast_manager & m, params_ref const & params) :
m(m), m_subst(m), m_params(params)
{
m_ignore_patterns_on_ground_qbody = m_params.get_bool("ignore_patterns_on_ground_qbody", true);
}
void unused_vars_eliminator::operator()(quantifier* q, expr_ref & result) { void unused_vars_eliminator::operator()(quantifier* q, expr_ref & result) {
SASSERT(is_well_sorted(m, q)); SASSERT(is_well_sorted(m, q));
if (is_ground(q->get_expr())) { if (m_ignore_patterns_on_ground_qbody && is_ground(q->get_expr())) {
// ignore patterns if the body is a ground formula. // Ignore patterns if the body is a ground formula.
result = q->get_expr(); result = q->get_expr();
return; return;
} }
@ -146,8 +152,8 @@ void unused_vars_eliminator::operator()(quantifier* q, expr_ref & result) {
SASSERT(is_well_sorted(m, result)); SASSERT(is_well_sorted(m, result));
} }
void elim_unused_vars(ast_manager & m, quantifier * q, expr_ref & result) { void elim_unused_vars(ast_manager & m, quantifier * q, params_ref const & params, expr_ref & result) {
unused_vars_eliminator el(m); unused_vars_eliminator el(m, params);
el(q, result); el(q, result);
} }

9
src/ast/rewriter/var_subst.h
View file

@ -21,6 +21,7 @@ Notes:
#include"rewriter.h" #include"rewriter.h"
#include"used_vars.h" #include"used_vars.h"
#include"params.h"
/** /**
\brief Alias for var_shifter class. \brief Alias for var_shifter class.
@ -55,15 +56,17 @@ public:
\brief Eliminate the unused variables from \c q. Store the result in \c r. \brief Eliminate the unused variables from \c q. Store the result in \c r.
*/ */
class unused_vars_eliminator { class unused_vars_eliminator {
ast_manager& m; ast_manager & m;
var_subst m_subst; var_subst m_subst;
used_vars m_used; used_vars m_used;
params_ref m_params;
bool m_ignore_patterns_on_ground_qbody;
public: public:
unused_vars_eliminator(ast_manager& m): m(m), m_subst(m) {} unused_vars_eliminator(ast_manager & m, params_ref const & params);
void operator()(quantifier* q, expr_ref& r); void operator()(quantifier* q, expr_ref& r);
}; };
void elim_unused_vars(ast_manager & m, quantifier * q, expr_ref & r); void elim_unused_vars(ast_manager & m, quantifier * q, params_ref const & params, expr_ref & r);
/** /**
\brief Instantiate quantifier q using the given exprs. \brief Instantiate quantifier q using the given exprs.

2
src/ast/simplifier/distribute_forall.cpp
View file

@ -126,7 +126,7 @@ void distribute_forall::reduce1_quantifier(quantifier * q) {
quantifier_ref tmp_q(m_manager); quantifier_ref tmp_q(m_manager);
tmp_q = m_manager.update_quantifier(q, not_arg); tmp_q = m_manager.update_quantifier(q, not_arg);
expr_ref new_q(m_manager); expr_ref new_q(m_manager);
elim_unused_vars(m_manager, tmp_q, new_q); elim_unused_vars(m_manager, tmp_q, params_ref(), new_q);
new_args.push_back(new_q); new_args.push_back(new_q);
} }
expr_ref result(m_manager); expr_ref result(m_manager);

2
src/ast/simplifier/elim_bounds.cpp
View file

@ -188,7 +188,7 @@ void elim_bounds::operator()(quantifier * q, expr_ref & r) {
} }
quantifier_ref new_q(m_manager); quantifier_ref new_q(m_manager);
new_q = m_manager.update_quantifier(q, new_body); new_q = m_manager.update_quantifier(q, new_body);
elim_unused_vars(m_manager, new_q, r); elim_unused_vars(m_manager, new_q, params_ref(), r);
TRACE("elim_bounds", tout << mk_pp(q, m_manager) << "\n" << mk_pp(r, m_manager) << "\n";); TRACE("elim_bounds", tout << mk_pp(q, m_manager) << "\n" << mk_pp(r, m_manager) << "\n";);
} }

2
src/ast/simplifier/simplifier.cpp
View file

@ -852,7 +852,7 @@ void simplifier::reduce1_quantifier(quantifier * q) {
} }
expr_ref r(m); expr_ref r(m);
elim_unused_vars(m, q1, r); elim_unused_vars(m, q1, params_ref(), r);
proof * pr = 0; proof * pr = 0;
if (m.fine_grain_proofs()) { if (m.fine_grain_proofs()) {

25
src/cmd_context/basic_cmds.cpp
View file

@ -100,13 +100,34 @@ public:
ATOMIC_CMD(exit_cmd, "exit", "exit.", ctx.print_success(); throw stop_parser_exception();); ATOMIC_CMD(exit_cmd, "exit", "exit.", ctx.print_success(); throw stop_parser_exception(););
ATOMIC_CMD(get_model_cmd, "get-model", "retrieve model for the last check-sat command", { class get_model_cmd : public cmd {
unsigned m_index;
public:
get_model_cmd(): cmd("get-model"), m_index(0) {}
virtual char const * get_usage() const { return "[<index of box objective>]"; }
virtual char const * get_descr(cmd_context & ctx) const {
return "retrieve model for the last check-sat command.\nSupply optional index if retrieving a model corresponding to a box optimization objective";
}
virtual unsigned get_arity() const { return VAR_ARITY; }
virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_UINT; }
virtual void set_next_arg(cmd_context & ctx, unsigned index) { m_index = index; }
virtual void execute(cmd_context & ctx) {
if (!ctx.is_model_available() || ctx.get_check_sat_result() == 0) if (!ctx.is_model_available() || ctx.get_check_sat_result() == 0)
throw cmd_exception("model is not available"); throw cmd_exception("model is not available");
model_ref m; model_ref m;
if (m_index > 0 && ctx.get_opt()) {
ctx.get_opt()->get_box_model(m, m_index);
}
else {
ctx.get_check_sat_result()->get_model(m); ctx.get_check_sat_result()->get_model(m);
}
ctx.display_model(m); ctx.display_model(m);
}); }
virtual void reset(cmd_context& ctx) {
m_index = 0;
}
};
ATOMIC_CMD(get_assignment_cmd, "get-assignment", "retrieve assignment", { ATOMIC_CMD(get_assignment_cmd, "get-assignment", "retrieve assignment", {
if (!ctx.is_model_available() || ctx.get_check_sat_result() == 0) if (!ctx.is_model_available() || ctx.get_check_sat_result() == 0)

1
src/cmd_context/cmd_context.h
View file

@ -124,6 +124,7 @@ public:
virtual bool is_pareto() = 0; virtual bool is_pareto() = 0;
virtual void set_logic(symbol const& s) = 0; virtual void set_logic(symbol const& s) = 0;
virtual bool print_model() const = 0; virtual bool print_model() const = 0;
virtual void get_box_model(model_ref& mdl, unsigned index) = 0;
virtual void updt_params(params_ref const& p) = 0; virtual void updt_params(params_ref const& p) = 0;
}; };

7
src/cmd_context/eval_cmd.cpp
View file

@ -38,6 +38,7 @@ public:
virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) { virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) {
model_evaluator::get_param_descrs(p); model_evaluator::get_param_descrs(p);
insert_timeout(p); insert_timeout(p);
p.insert("model_index", CPK_UINT, "(default: 0) index of model from box optimization objective");
} }
virtual void prepare(cmd_context & ctx) { virtual void prepare(cmd_context & ctx) {
@ -58,9 +59,15 @@ public:
if (!ctx.is_model_available()) if (!ctx.is_model_available())
throw cmd_exception("model is not available"); throw cmd_exception("model is not available");
model_ref md; model_ref md;
unsigned index = m_params.get_uint("model_index", 0);
check_sat_result * last_result = ctx.get_check_sat_result(); check_sat_result * last_result = ctx.get_check_sat_result();
SASSERT(last_result); SASSERT(last_result);
if (index == 0 || !ctx.get_opt()) {
last_result->get_model(md); last_result->get_model(md);
}
else {
ctx.get_opt()->get_box_model(md, index);
}
expr_ref r(ctx.m()); expr_ref r(ctx.m());
unsigned timeout = m_params.get_uint("timeout", UINT_MAX); unsigned timeout = m_params.get_uint("timeout", UINT_MAX);
unsigned rlimit = m_params.get_uint("rlimit", 0); unsigned rlimit = m_params.get_uint("rlimit", 0);

3
src/cmd_context/extra_cmds/dbg_cmds.cpp
View file

@ -29,6 +29,7 @@ Notes:
#include"bound_manager.h" #include"bound_manager.h"
#include"used_vars.h" #include"used_vars.h"
#include"var_subst.h" #include"var_subst.h"
#include"gparams.h"
#ifndef _EXTERNAL_RELEASE #ifndef _EXTERNAL_RELEASE
@ -271,7 +272,7 @@ UNARY_CMD(elim_unused_vars_cmd, "dbg-elim-unused-vars", "<expr>", "eliminate unu
return; return;
} }
expr_ref r(ctx.m()); expr_ref r(ctx.m());
elim_unused_vars(ctx.m(), to_quantifier(arg), r); elim_unused_vars(ctx.m(), to_quantifier(arg), gparams::get(), r);
SASSERT(!is_quantifier(r) || !to_quantifier(r)->may_have_unused_vars()); SASSERT(!is_quantifier(r) || !to_quantifier(r)->may_have_unused_vars());
ctx.display(ctx.regular_stream(), r); ctx.display(ctx.regular_stream(), r);
ctx.regular_stream() << std::endl; ctx.regular_stream() << std::endl;

4
src/duality/duality_wrapper.cpp
View file

@ -348,7 +348,7 @@ namespace Duality {
expr expr::qe_lite() const { expr expr::qe_lite() const {
::qe_lite qe(m()); ::qe_lite qe(m(), params_ref());
expr_ref result(to_expr(raw()),m()); expr_ref result(to_expr(raw()),m());
proof_ref pf(m()); proof_ref pf(m());
qe(result,pf); qe(result,pf);
@ -356,7 +356,7 @@ namespace Duality {
} }
expr expr::qe_lite(const std::set<int> &idxs, bool index_of_bound) const { expr expr::qe_lite(const std::set<int> &idxs, bool index_of_bound) const {
::qe_lite qe(m()); ::qe_lite qe(m(), params_ref());
expr_ref result(to_expr(raw()),m()); expr_ref result(to_expr(raw()),m());
proof_ref pf(m()); proof_ref pf(m());
uint_set uis; uint_set uis;

2
src/muz/base/dl_rule.cpp
View file

@ -54,7 +54,7 @@ namespace datalog {
m_head(m), m_head(m),
m_args(m), m_args(m),
m_hnf(m), m_hnf(m),
m_qe(m), m_qe(m, params_ref()),
m_rwr(m), m_rwr(m),
m_ufproc(m) {} m_ufproc(m) {}

2
src/muz/pdr/pdr_context.cpp
View file

@ -2241,7 +2241,7 @@ namespace pdr {
vars.append(aux_vars.size(), aux_vars.c_ptr()); vars.append(aux_vars.size(), aux_vars.c_ptr());
scoped_ptr<expr_replacer> rep; scoped_ptr<expr_replacer> rep;
qe_lite qe(m); qe_lite qe(m, m_params.p);
expr_ref phi1 = m_pm.mk_and(Phi); expr_ref phi1 = m_pm.mk_and(Phi);
qe(vars, phi1); qe(vars, phi1);
TRACE("pdr", tout << "Eliminated\n" << mk_pp(phi1, m) << "\n";); TRACE("pdr", tout << "Eliminated\n" << mk_pp(phi1, m) << "\n";);

4
src/muz/tab/tab_context.cpp
View file

@ -520,7 +520,7 @@ namespace tb {
m_matcher(m), m_matcher(m),
m_refs(m), m_refs(m),
m_subst(m), m_subst(m),
m_qe(m), m_qe(m, params_ref()),
m_rw(m), m_rw(m),
m_solver(m, m_fparams) {} m_solver(m, m_fparams) {}
@ -1067,7 +1067,7 @@ namespace tb {
} }
bool unify(clause const& tgt, unsigned idx, clause const& src, bool compute_subst, ref<clause>& result) { bool unify(clause const& tgt, unsigned idx, clause const& src, bool compute_subst, ref<clause>& result) {
qe_lite qe(m); qe_lite qe(m, params_ref());
reset(); reset();
SASSERT(tgt.get_predicate(idx)->get_decl() == src.get_decl()); SASSERT(tgt.get_predicate(idx)->get_decl() == src.get_decl());
unsigned var_cnt = std::max(tgt.get_num_vars(), src.get_num_vars()); unsigned var_cnt = std::max(tgt.get_num_vars(), src.get_num_vars());

8
src/opt/opt_context.cpp
View file

@ -342,6 +342,14 @@ namespace opt {
fix_model(mdl); fix_model(mdl);
} }
void context::get_box_model(model_ref& mdl, unsigned index) {
if (index >= m_box_models.size()) {
throw default_exception("index into models is out of bounds");
}
mdl = m_box_models[index];
fix_model(mdl);
}
lbool context::execute_min_max(unsigned index, bool committed, bool scoped, bool is_max) { lbool context::execute_min_max(unsigned index, bool committed, bool scoped, bool is_max) {
if (scoped) get_solver().push(); if (scoped) get_solver().push();
lbool result = m_optsmt.lex(index, is_max); lbool result = m_optsmt.lex(index, is_max);

1
src/opt/opt_context.h
View file

@ -186,6 +186,7 @@ namespace opt {
virtual bool print_model() const; virtual bool print_model() const;
virtual void set_model(model_ref& _m) { m_model = _m; } virtual void set_model(model_ref& _m) { m_model = _m; }
virtual void get_model(model_ref& _m); virtual void get_model(model_ref& _m);
virtual void get_box_model(model_ref& _m, unsigned index);
virtual void fix_model(model_ref& _m); virtual void fix_model(model_ref& _m);
virtual void collect_statistics(statistics& stats) const; virtual void collect_statistics(statistics& stats) const;
virtual proof* get_proof() { return 0; } virtual proof* get_proof() { return 0; }

21
src/qe/qe_lite.cpp
View file

@ -91,6 +91,7 @@ namespace eq {
expr_ref_vector m_subst_map; expr_ref_vector m_subst_map;
expr_ref_buffer m_new_args; expr_ref_buffer m_new_args;
th_rewriter m_rewriter; th_rewriter m_rewriter;
params_ref m_params;
void der_sort_vars(ptr_vector<var> & vars, ptr_vector<expr> & definitions, unsigned_vector & order) { void der_sort_vars(ptr_vector<var> & vars, ptr_vector<expr> & definitions, unsigned_vector & order) {
order.reset(); order.reset();
@ -563,7 +564,8 @@ namespace eq {
void elim_unused_vars(expr_ref& r, proof_ref &pr) { void elim_unused_vars(expr_ref& r, proof_ref &pr) {
if (is_quantifier(r)) { if (is_quantifier(r)) {
quantifier * q = to_quantifier(r); quantifier * q = to_quantifier(r);
::elim_unused_vars(m, q, r);
::elim_unused_vars(m, q, m_params, r);
if (m.proofs_enabled()) { if (m.proofs_enabled()) {
proof * p1 = m.mk_elim_unused_vars(q, r); proof * p1 = m.mk_elim_unused_vars(q, r);
pr = m.mk_transitivity(pr, p1); pr = m.mk_transitivity(pr, p1);
@ -744,7 +746,7 @@ namespace eq {
} }
public: public:
der(ast_manager & m): der(ast_manager & m, params_ref const & p):
m(m), m(m),
a(m), a(m),
dt(m), dt(m),
@ -753,7 +755,8 @@ namespace eq {
m_new_exprs(m), m_new_exprs(m),
m_subst_map(m), m_subst_map(m),
m_new_args(m), m_new_args(m),
m_rewriter(m) {} m_rewriter(m),
m_params(p) {}
void set_is_variable_proc(is_variable_proc& proc) { m_is_variable = &proc;} void set_is_variable_proc(is_variable_proc& proc) { m_is_variable = &proc;}
@ -2346,9 +2349,9 @@ private:
} }
public: public:
impl(ast_manager& m): impl(ast_manager & m, params_ref const & p):
m(m), m(m),
m_der(m), m_der(m, p),
m_fm(m), m_fm(m),
m_array_der(m), m_array_der(m),
m_elim_star(*this), m_elim_star(*this),
@ -2438,8 +2441,8 @@ public:
}; };
qe_lite::qe_lite(ast_manager& m) { qe_lite::qe_lite(ast_manager & m, params_ref const & p) {
m_impl = alloc(impl, m); m_impl = alloc(impl, m, p);
} }
qe_lite::~qe_lite() { qe_lite::~qe_lite() {
@ -2469,9 +2472,9 @@ class qe_lite_tactic : public tactic {
ast_manager& m; ast_manager& m;
qe_lite m_qe; qe_lite m_qe;
imp(ast_manager& m, params_ref const& p): imp(ast_manager& m, params_ref const & p):
m(m), m(m),
m_qe(m) m_qe(m, p)
{} {}
void checkpoint() { void checkpoint() {

2
src/qe/qe_lite.h
View file

@ -31,7 +31,7 @@ class qe_lite {
class impl; class impl;
impl * m_impl; impl * m_impl;
public: public:
qe_lite(ast_manager& m); qe_lite(ast_manager & m, params_ref const & p);
~qe_lite(); ~qe_lite();

2
src/smt/smt_justification.cpp
View file

@ -246,6 +246,7 @@ namespace smt {
simple_justification::simple_justification(region & r, unsigned num_lits, literal const * lits): simple_justification::simple_justification(region & r, unsigned num_lits, literal const * lits):
m_num_literals(num_lits) { m_num_literals(num_lits) {
if (num_lits != 0) {
m_literals = new (r) literal[num_lits]; m_literals = new (r) literal[num_lits];
memcpy(m_literals, lits, sizeof(literal) * num_lits); memcpy(m_literals, lits, sizeof(literal) * num_lits);
#ifdef Z3DEBUG #ifdef Z3DEBUG
@ -254,6 +255,7 @@ namespace smt {
} }
#endif #endif
} }
}
void simple_justification::get_antecedents(conflict_resolution & cr) { void simple_justification::get_antecedents(conflict_resolution & cr) {
for (unsigned i = 0; i < m_num_literals; i++) for (unsigned i = 0; i < m_num_literals; i++)

5
src/tactic/bv/elim_small_bv_tactic.cpp
View file

@ -34,6 +34,7 @@ class elim_small_bv_tactic : public tactic {
struct rw_cfg : public default_rewriter_cfg { struct rw_cfg : public default_rewriter_cfg {
ast_manager & m; ast_manager & m;
params_ref m_params;
bv_util m_util; bv_util m_util;
simplifier m_simp; simplifier m_simp;
ref<filter_model_converter> m_mc; ref<filter_model_converter> m_mc;
@ -47,6 +48,7 @@ class elim_small_bv_tactic : public tactic {
rw_cfg(ast_manager & _m, params_ref const & p) : rw_cfg(ast_manager & _m, params_ref const & p) :
m(_m), m(_m),
m_params(p),
m_util(_m), m_util(_m),
m_simp(_m), m_simp(_m),
m_bindings(_m), m_bindings(_m),
@ -178,7 +180,7 @@ class elim_small_bv_tactic : public tactic {
quantifier_ref new_q(m); quantifier_ref new_q(m);
new_q = m.update_quantifier(q, body); new_q = m.update_quantifier(q, body);
unused_vars_eliminator el(m); unused_vars_eliminator el(m, m_params);
el(new_q, result); el(new_q, result);
TRACE("elim_small_bv", tout << "elimination result: " << mk_ismt2_pp(result, m) << std::endl; ); TRACE("elim_small_bv", tout << "elimination result: " << mk_ismt2_pp(result, m) << std::endl; );
@ -203,6 +205,7 @@ class elim_small_bv_tactic : public tactic {
} }
void updt_params(params_ref const & p) { void updt_params(params_ref const & p) {
m_params = p;
m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX)); m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX));
m_max_steps = p.get_uint("max_steps", UINT_MAX); m_max_steps = p.get_uint("max_steps", UINT_MAX);
m_max_bits = p.get_uint("max_bits", 4); m_max_bits = p.get_uint("max_bits", 4);

4
src/tactic/core/distribute_forall_tactic.cpp
View file

@ -50,7 +50,7 @@ class distribute_forall_tactic : public tactic {
quantifier_ref tmp_q(m); quantifier_ref tmp_q(m);
tmp_q = m.update_quantifier(old_q, not_arg); tmp_q = m.update_quantifier(old_q, not_arg);
expr_ref new_q(m); expr_ref new_q(m);
elim_unused_vars(m, tmp_q, new_q); elim_unused_vars(m, tmp_q, params_ref(), new_q);
new_args.push_back(new_q); new_args.push_back(new_q);
} }
result = m.mk_and(new_args.size(), new_args.c_ptr()); result = m.mk_and(new_args.size(), new_args.c_ptr());
@ -70,7 +70,7 @@ class distribute_forall_tactic : public tactic {
quantifier_ref tmp_q(m); quantifier_ref tmp_q(m);
tmp_q = m.update_quantifier(old_q, arg); tmp_q = m.update_quantifier(old_q, arg);
expr_ref new_q(m); expr_ref new_q(m);
elim_unused_vars(m, tmp_q, new_q); elim_unused_vars(m, tmp_q, params_ref(), new_q);
new_args.push_back(new_q); new_args.push_back(new_q);
} }
result = m.mk_and(new_args.size(), new_args.c_ptr()); result = m.mk_and(new_args.size(), new_args.c_ptr());

2
src/tactic/ufbv/ufbv_rewriter.cpp
View file

@ -417,7 +417,7 @@ expr * ufbv_rewriter::rewrite(expr * n) {
q = m_manager.update_quantifier(to_quantifier(actual), new_body); q = m_manager.update_quantifier(to_quantifier(actual), new_body);
m_new_exprs.push_back(q); m_new_exprs.push_back(q);
expr_ref new_q(m_manager); expr_ref new_q(m_manager);
elim_unused_vars(m_manager, q, new_q); elim_unused_vars(m_manager, q, params_ref(), new_q);
m_new_exprs.push_back(new_q); m_new_exprs.push_back(new_q);
rewrite_cache(e, new_q, true); rewrite_cache(e, new_q, true);
m_rewrite_todo.pop_back(); m_rewrite_todo.pop_back();