diff --git a/.gitignore b/.gitignore index b7e4a0186..e189a9569 100644 --- a/.gitignore +++ b/.gitignore @@ -43,6 +43,7 @@ bld_dbg/* bld_rel/* bld_dbg_x64/* bld_rel_x64/* +.vscode # Auto generated files. config.log config.status diff --git a/CMakeLists.txt b/CMakeLists.txt index a086afd71..5934b7c17 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -34,7 +34,7 @@ endif() ################################################################################ set(Z3_VERSION_MAJOR 4) set(Z3_VERSION_MINOR 8) -set(Z3_VERSION_PATCH 0) +set(Z3_VERSION_PATCH 5) set(Z3_VERSION_TWEAK 0) set(Z3_VERSION "${Z3_VERSION_MAJOR}.${Z3_VERSION_MINOR}.${Z3_VERSION_PATCH}.${Z3_VERSION_TWEAK}") set(Z3_FULL_VERSION_STR "${Z3_VERSION}") # Note this might be modified @@ -99,7 +99,7 @@ set(GIT_DIR "${CMAKE_SOURCE_DIR}/.git") if (EXISTS "${GIT_DIR}") # Try to make CMake configure depend on the current git HEAD so that # a re-configure is triggered when the HEAD changes. - add_git_dir_dependency("${GIT_DIR}" ADD_GIT_DEP_SUCCESS) + add_git_dir_dependency("${CMAKE_SOURCE_DIR}" ADD_GIT_DEP_SUCCESS) if (ADD_GIT_DEP_SUCCESS) if (INCLUDE_GIT_HASH) get_git_head_hash("${GIT_DIR}" Z3GITHASH) @@ -205,9 +205,6 @@ message(STATUS "PYTHON_EXECUTABLE: ${PYTHON_EXECUTABLE}") include(${CMAKE_SOURCE_DIR}/cmake/target_arch_detect.cmake) detect_target_architecture(TARGET_ARCHITECTURE) message(STATUS "Detected target architecture: ${TARGET_ARCHITECTURE}") -if ("${TARGET_ARCHITECTURE}" STREQUAL "x86_64") - list(APPEND Z3_COMPONENT_CXX_DEFINES "-D_AMD64_") -endif() ################################################################################ @@ -240,7 +237,7 @@ if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux") list(APPEND Z3_COMPONENT_CXX_DEFINES "-D_USE_THREAD_LOCAL") endif() elseif ("${CMAKE_SYSTEM_NAME}" STREQUAL "Darwin") - # Does OSX really not need any special flags? + # Does macOS really not need any special flags? message(STATUS "Platform: Darwin") elseif ("${CMAKE_SYSTEM_NAME}" MATCHES "FreeBSD") message(STATUS "Platform: FreeBSD") @@ -380,9 +377,17 @@ endif() ################################################################################ # FIXME: Support ARM "-mfpu=vfp -mfloat-abi=hard" if (("${TARGET_ARCHITECTURE}" STREQUAL "x86_64") OR ("${TARGET_ARCHITECTURE}" STREQUAL "i686")) - if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")) + if (("${CMAKE_CXX_COMPILER_ID}" MATCHES "GNU") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang") OR ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel")) + if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel") + # Intel's compiler requires linking with libiomp5 + list(APPEND Z3_DEPENDENT_LIBS "iomp5") + endif() set(SSE_FLAGS "-mfpmath=sse" "-msse" "-msse2") # FIXME: Remove "x.." when CMP0054 is set to NEW + elseif ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Intel") + set(SSE_FLAGS "-mfpmath=sse" "-msse" "-msse2") + # Intel's compiler requires linking with libiomp5 + list(APPEND Z3_DEPENDENT_LIBS "iomp5") elseif ("x${CMAKE_CXX_COMPILER_ID}" STREQUAL "xMSVC") set(SSE_FLAGS "/arch:SSE2") else() @@ -417,6 +422,15 @@ list(APPEND Z3_DEPENDENT_LIBS ${CMAKE_THREAD_LIBS_INIT}) ################################################################################ include(${CMAKE_SOURCE_DIR}/cmake/compiler_warnings.cmake) +################################################################################ +# Save Clang optimization records +################################################################################ +option(SAVE_CLANG_OPTIMIZATION_RECORDS "Enable saving Clang optimization records." OFF) + +if (SAVE_CLANG_OPTIMIZATION_RECORDS) + z3_add_cxx_flag("-fsave-optimization-record" REQUIRED) +endif() + ################################################################################ # If using Ninja, force color output for Clang (and gcc, disabled to check build). ################################################################################ diff --git a/README.md b/README.md index 447034a84..808b24034 100644 --- a/README.md +++ b/README.md @@ -5,16 +5,19 @@ under the [MIT license](LICENSE.txt). If you are not familiar with Z3, you can start [here](https://github.com/Z3Prover/z3/wiki#background). +Pre-built binaries for releases are available from [here](https://github.com/Z3Prover/z3/releases), +and nightly builds from [here](https://github.com/Z3Prover/bin/tree/master/nightly). + Z3 can be built using [Visual Studio][1], a [Makefile][2] or using [CMake][3]. It provides -[bindings for several programming languages][4]. +[bindings for several programming languages][4]. See the [release notes](RELEASE_NOTES) for notes on various stable releases of Z3. ## Build status -| Windows x64 | Windows x86 | Windows x64 | Ubuntu x64 | Debian x64 | OSX | TravisCI | -| ----------- | ----------- | ----------- | ---------- | ---------- | --- | -------- | -[![win64-badge](https://z3build.visualstudio.com/_apis/public/build/definitions/2e0aa542-a22c-4b1a-8dcd-3ebae8e12db4/4/badge)](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=4) | [![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![osx-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/2/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) +| Windows x64 | Windows x86 | Windows x64 | Ubuntu x64 | Debian x64 | macOS | TravisCI | +| ----------- | ----------- | ----------- | ---------- | ---------- | ----- | -------- | +[![win64-badge](https://z3build.visualstudio.com/_apis/public/build/definitions/2e0aa542-a22c-4b1a-8dcd-3ebae8e12db4/4/badge)](https://z3build.visualstudio.com/Z3Build/_build/index?definitionId=4) | [![win32-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/4/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=4) | [![win64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/7/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=7) | [![ubuntu-x64-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/3/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=3) | [![debian-badge](https://cz3.visualstudio.com/_apis/public/build/definitions/bf14bcc7-ebd4-4240-812c-5972fa59e0ad/5/badge)](https://cz3.visualstudio.com/Z3/_build/index?definitionId=5) | [![Build status](https://cz3.visualstudio.com/Z3/_apis/build/status/OSX)](https://cz3.visualstudio.com/Z3/_build/latest?definitionId=2) | [![Build Status](https://travis-ci.org/Z3Prover/z3.svg?branch=master)](https://travis-ci.org/Z3Prover/z3) [1]: #building-z3-on-windows-using-visual-studio-command-prompt [2]: #building-z3-using-make-and-gccclang @@ -75,7 +78,7 @@ A 32 bit build should work similarly (but is untested); the same is true for 32/ By default, it will install z3 executable at ``PREFIX/bin``, libraries at ``PREFIX/lib``, and include files at ``PREFIX/include``, where ``PREFIX`` installation prefix if inferred by the ``mk_make.py`` script. It is usually -``/usr`` for most Linux distros, and ``/usr/local`` for FreeBSD and OSX. Use +``/usr`` for most Linux distros, and ``/usr/local`` for FreeBSD and macOS. Use the ``--prefix=`` command line option to change the install prefix. For example: ```bash diff --git a/RELEASE_NOTES b/RELEASE_NOTES index 3337f098b..ba254db4e 100644 --- a/RELEASE_NOTES +++ b/RELEASE_NOTES @@ -1,5 +1,33 @@ RELEASE NOTES +Version 4.8.4 +============= + +- Notes + - fixes bugs + - a substantial update to how the seq theory solver handles regular + expressions. Other performance improvements to the seq solver. + - Managed .NET DLLs include dotnet standard 1.4 on supported platforms. + - Windows Managed DLLs are strong signed in the released binaries. + +Version 4.8.3 +============= +- New features + - Native handling of recursive function definitions, thanks to Simon Cruanes + - PB rounding based option for conflict resolution when reasoning about PB constraints. + - Access to numeral constants as a double from the native API. + +- Notes + - fixes several bugs discovered since the 4.8.1 release. + +Version 4.8.2 +============= +- Post-Release. + +Version 4.8.1 +============= +- Release. Bug-fix for 4.8.0 + Version 4.8.0 ============= @@ -21,7 +49,7 @@ Version 4.8.0 extracting models from apply_result have been replaced. - An optional mode handles xor constraints using a custom xor propagator. It is off by default and its value not demonstrated. - - The SAT solver includes new inprocessing technques that are available during simplification. + - The SAT solver includes new inprocessing techniques that are available during simplification. It performs asymmetric tautology elimination by default, and one can turn on more powerful inprocessing techniques (known as ACCE, ABCE, CCE). Asymmetric branching also uses features introduced in Lingeling by exploiting binary implication graphs. Use sat.acce=true to enable the full repertoire of inprocessing methods. By default, clauses that are "eliminated" by acce are tagged @@ -318,7 +346,7 @@ First source code release (October 2, 2012) - Added support for numbers in scientific notation at Z3_ast Z3_mk_numeral(__in Z3_context c, __in Z3_string numeral, __in Z3_sort ty). -- New builtin symbols in the arithmetic theory: pi, euler, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh. The first two are constants, and the others are unary functions. These symbols are not available if the a SMT 2.0 logic is specified (e.g., QF_LRA, QF_NRA, QF_LIA, etc) because these symbols are not defined in these logics. That is, the new symbols are only available if the logic is not specified. +- New builtin symbols in the arithmetic theory: pi, euler, sin, cos, tan, asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh. The first two are constants, and the others are unary functions. These symbols are not available if a SMT 2.0 logic is specified (e.g., QF_LRA, QF_NRA, QF_LIA, etc) because these symbols are not defined in these logics. That is, the new symbols are only available if the logic is not specified. Version 4.1 =========== diff --git a/cmake/msvc_legacy_quirks.cmake b/cmake/msvc_legacy_quirks.cmake index 36fe82bb3..a8006e2d3 100644 --- a/cmake/msvc_legacy_quirks.cmake +++ b/cmake/msvc_legacy_quirks.cmake @@ -8,13 +8,13 @@ # FIXME: All the commented out defines should be removed once # we are confident it is correct to not set them. set(Z3_MSVC_LEGACY_DEFINES - # Don't set `_DEBUG`. The old build sytem sets this but this + # Don't set `_DEBUG`. The old build system sets this but this # is wrong. MSVC will set this depending on which runtime is being used. # See https://msdn.microsoft.com/en-us/library/b0084kay.aspx # _DEBUG # The old build system only set `UNICODE` and `_UNICODE` for x86_64 release. - # That seems completly wrong so set it for all configurations. + # That seems completely wrong so set it for all configurations. # According to https://blogs.msdn.microsoft.com/oldnewthing/20040212-00/?p=40643/ # `UNICODE` affects Windows headers and `_UNICODE` affects C runtime header files. # There is some discussion of this define at https://msdn.microsoft.com/en-us/library/dybsewaf.aspx @@ -116,7 +116,7 @@ z3_add_cxx_flag("/analyze-" REQUIRED) ################################################################################ # By default CMake enables incremental linking for Debug and RelWithDebInfo -# builds. The old build sytem disables it for all builds so try to do the same +# builds. The old build system disables it for all builds so try to do the same # by changing all configurations if necessary string(TOUPPER "${available_build_types}" _build_types_as_upper) foreach (_build_type ${_build_types_as_upper}) diff --git a/cmake/z3_add_component.cmake b/cmake/z3_add_component.cmake index d87ffbe61..8ab6e045d 100644 --- a/cmake/z3_add_component.cmake +++ b/cmake/z3_add_component.cmake @@ -7,7 +7,7 @@ function(z3_expand_dependencies output_var) if (ARGC LESS 2) message(FATAL_ERROR "Invalid number of arguments") endif() - # Remaing args should be component names + # Remaining args should be component names set(_expanded_deps ${ARGN}) set(_old_number_of_deps 0) list(LENGTH _expanded_deps _number_of_deps) @@ -33,7 +33,7 @@ function(z3_add_component_dependencies_to_target target_name) if (NOT (TARGET ${target_name})) message(FATAL_ERROR "Target \"${target_name}\" does not exist") endif() - # Remaing args should be component names + # Remaining args should be component names set(_expanded_deps ${ARGN}) foreach (dependency ${_expanded_deps}) # Ensure this component's dependencies are built before this component. @@ -219,7 +219,7 @@ macro(z3_add_component component_name) # Record this component's dependencies foreach (dependency ${Z3_MOD_COMPONENT_DEPENDENCIES}) if (NOT (TARGET ${dependency})) - message(FATAL_ERROR "Component \"${component_name}\" depends on a non existant component \"${dependency}\"") + message(FATAL_ERROR "Component \"${component_name}\" depends on a non existent component \"${dependency}\"") endif() set_property(GLOBAL APPEND PROPERTY Z3_${component_name}_DEPS "${dependency}") endforeach() diff --git a/contrib/ci/README.md b/contrib/ci/README.md index bd1c52792..d0f336f92 100644 --- a/contrib/ci/README.md +++ b/contrib/ci/README.md @@ -1,4 +1,4 @@ -# Continous integration scripts +# Continuous integration scripts ## TravisCI @@ -45,7 +45,7 @@ the future. * `Z3_VERBOSE_BUILD_OUTPUT` - Show compile commands in CMake builds (`0` or `1`) * `Z3_STATIC_BUILD` - Build Z3 binaries and libraries statically (`0` or `1`) * `Z3_SYSTEM_TEST_GIT_REVISION` - Git revision of [z3test](https://github.com/Z3Prover/z3test). If empty lastest revision will be used. -* `Z3_WARNINGS_AS_ERRORS` - Set the `WARNINGS_AS_ERRORS` CMake option pased to Z3 (`OFF`, `ON`, or `SERIOUS_ONLY`) +* `Z3_WARNINGS_AS_ERRORS` - Set the `WARNINGS_AS_ERRORS` CMake option passed to Z3 (`OFF`, `ON`, or `SERIOUS_ONLY`) ### Linux diff --git a/doc/design_recfuns.md b/doc/design_recfuns.md new file mode 100644 index 000000000..89980931e --- /dev/null +++ b/doc/design_recfuns.md @@ -0,0 +1,93 @@ +# Design for handling recursive functions + +Main source of inspiration is [Sutter, Köksal & Kuncak 2011], +as implemented in Leon, but the main +differences is that we should unroll function definitions directly from the +inside of Z3, in a backtracking way. Termination and fairness are ensured by +iterative-deepening on the maximum number of unrollings in a given branch. + +## Unfolding + +The idea is that every function definition `f(x1…xn) := rhs[x1…xn]` is +compiled into: + +- a list of cases `A_f_i[x1…xn] => f(x1…xn) = rhs_i[x1…xn]`. + When `A_f_i[t1…tn]` becomes true in the model, `f(t1…tn)` is said to be + *unfolded* and the clause `A_f_i[t1…tn] => f(t1…tn) = rhs_i[t1…tn]` + is added as an auxiliary clause. +- a list of constraints `Γ_f_i[x1…xn] <=> A_f_i[x1…xn]` + that states when `A_f_i[x1…xn]` should be true, depending on inputs `x1…xn`. + For every term `f(t1…tn)` present in congruence closure, we + immediately add all the `Γ_f_i[t1…tn] <=> A_f_i[t1…tn]` as auxiliary clauses + (maybe during internalization of `f(t1…tn)`?). + +where each `A_f_i[x1…xn]` is a special new predicate representing the +given case of `f`, and `rhs_i` does not contain any `ite`. +We assume pattern matching has been compiled to `ite` beforehand. + +For example, `fact(n) := if n<2 then 1 else n * fact(n-1)` is compiled into: + +- `A_fact_0[n] => fact(n) = 1` +- `A_fact_1[n] => fact(n) = n * fact(n-1)` +- `A_fact_0[n] <=> n < 2` +- `A_fact_1[n] <=> ¬(n < 2)` + +The 2 first clauses are only added when `A_fact_0[t]` is true +(respectively `A_fact_1[t]` is true). +The 2 other clauses are added as soon as `fact(t)` is internalized. + +## Termination + +To ensure termination, we define variables: + +- `unfold_depth: int` +- `current_max_unfold_depth: int` +- `global_max_unfold_depth: int` + +and a special literal `[max_depth=$n]` for each `n:int`. +Solving is done under the local assumption +`[max_depth=$current_max_unfold_depth]` (this should be handled in some outer +loop, e.g. in a custom tactic). + +Whenever `A_f_i[t1…tn]` becomes true (for any `f`), we increment +`unfold_depth`. If `unfold_depth > current_max_unfold_depth`, then +the conflict clause `[max_depth=$current_max_unfold_depth] => Γ => false` +where `Γ` is the conjunction of all `A_f_i[t1…tn]` true in the trail. + +For non-recursive functions, we don't have to increment `unfold_depth`. Some other functions that are known + +If the solver answers "SAT", we have a model. +Otherwise, if `[max_depth=$current_max_unfold_depth]` is part of the +unsat-core, then we increase `current_max_unfold_depth`. +If `current_max_unfold_depth == global_max_unfold_depth` then +we report "UNKNOWN" (reached global depth limit), otherwise we can +try to `solve()` again with the new assumption (higher depth limit). + +## Tactic + +there should be a parametrized tactic `funrec(t, n)` where `t` is the tactic +used to solve (under assumption that depth is limited to `current_max_unfold_depth`) +and `n` is an integer that is assigned to `global_max_unfold_depth`. + +This way, to try and find models for a problem with recursive functions + LIA, +one could use something like `(funrec (then simplify dl smt) 100)`. + +## Expected benefits + +This addition to Z3 would bring many benefits compared to current alternatives (Leon, quantifiers, …) + +- should be very fast and lightweight + (compared to Leon or quantifiers). + In particular, every function call is very lightweight even compared to Leon (no need for full model building, followed by unsat core extraction) +- possibility of answering "SAT" for any `QF_*` fragment + + recursive functions +- makes `define-funs-rec` a first-class citizen of the language, usable to model user-defined theories or to analyze functional + programs directly + +## Optimizations + +- maybe `C_f_i` literals should never be decided on + (they can always be propagated). + Even stronger: they should not be part of conflicts? + (i.e. tune conflict resolution to always resolve + these literals away, disregarding their level) diff --git a/doc/z3api.cfg.in b/doc/z3api.cfg.in index 9c4b464c2..e58b561c9 100644 --- a/doc/z3api.cfg.in +++ b/doc/z3api.cfg.in @@ -944,7 +944,7 @@ HTML_STYLESHEET = # user-defined cascading style sheet that is included after the standard # style sheets created by doxygen. Using this option one can overrule # certain style aspects. This is preferred over using HTML_STYLESHEET -# since it does not replace the standard style sheet and is therefor more +# since it does not replace the standard style sheet and is therefore more # robust against future updates. Doxygen will copy the style sheet file to # the output directory. @@ -1711,7 +1711,7 @@ UML_LOOK = NO # the class node. If there are many fields or methods and many nodes the # graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS # threshold limits the number of items for each type to make the size more -# managable. Set this to 0 for no limit. Note that the threshold may be +# manageable. Set this to 0 for no limit. Note that the threshold may be # exceeded by 50% before the limit is enforced. UML_LIMIT_NUM_FIELDS = 10 diff --git a/examples/c++/CMakeLists.txt b/examples/c++/CMakeLists.txt index 0a41d6a93..52758889d 100644 --- a/examples/c++/CMakeLists.txt +++ b/examples/c++/CMakeLists.txt @@ -7,8 +7,8 @@ find_package(Z3 REQUIRED CONFIG # `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3. - # This should prevent us from accidently picking up an installed - # copy of Z3. This is here to benefit Z3's build sytem when building + # This should prevent us from accidentally picking up an installed + # copy of Z3. This is here to benefit Z3's build system when building # this project. When making your own project you probably shouldn't # use this option. NO_DEFAULT_PATH diff --git a/examples/c++/README b/examples/c++/README index 56775e537..2b3c5affc 100644 --- a/examples/c++/README +++ b/examples/c++/README @@ -5,6 +5,6 @@ in the build directory. This command will create the executable cpp_example. On Windows, you can just execute it. -On OSX and Linux, you must install z3 first using +On macOS and Linux, you must install z3 first using sudo make install -OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (OSX) with the build directory. You need that to be able to find the Z3 shared library. \ No newline at end of file +OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (macOS) with the build directory. You need that to be able to find the Z3 shared library. diff --git a/examples/c++/example.cpp b/examples/c++/example.cpp index 6faeb3edc..ab9c73209 100644 --- a/examples/c++/example.cpp +++ b/examples/c++/example.cpp @@ -835,6 +835,17 @@ void tst_visit() { visit(f); } +void tst_numeral() { + context c; + expr x = c.real_val("1/3"); + double d = 0; + if (!x.is_numeral(d)) { + std::cout << x << " is not recognized as a numeral\n"; + return; + } + std::cout << x << " is " << d << "\n"; +} + void incremental_example1() { std::cout << "incremental example1\n"; context c; @@ -1179,6 +1190,20 @@ void mk_model_example() { std::cout << m.eval(a + b < 2)<< std::endl; } +void recfun_example() { + std::cout << "recfun example\n"; + context c; + expr x = c.int_const("x"); + expr y = c.int_const("y"); + expr b = c.bool_const("b"); + sort I = c.int_sort(); + sort B = c.bool_sort(); + func_decl f = recfun("f", I, B, I); + expr_vector args(c); + args.push_back(x); args.push_back(b); + c.recdef(f, args, ite(b, x, f(x + 1, !b))); + prove(f(x,c.bool_val(false)) > x); +} int main() { @@ -1212,6 +1237,7 @@ int main() { tactic_example9(); std::cout << "\n"; tactic_qe(); std::cout << "\n"; tst_visit(); std::cout << "\n"; + tst_numeral(); std::cout << "\n"; incremental_example1(); std::cout << "\n"; incremental_example2(); std::cout << "\n"; incremental_example3(); std::cout << "\n"; @@ -1227,6 +1253,7 @@ int main() { consequence_example(); std::cout << "\n"; parse_example(); std::cout << "\n"; mk_model_example(); std::cout << "\n"; + recfun_example(); std::cout << "\n"; std::cout << "done\n"; } catch (exception & ex) { diff --git a/examples/c/CMakeLists.txt b/examples/c/CMakeLists.txt index c47a4947a..e45c82d37 100644 --- a/examples/c/CMakeLists.txt +++ b/examples/c/CMakeLists.txt @@ -24,8 +24,8 @@ find_package(Z3 REQUIRED CONFIG # `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3. - # This should prevent us from accidently picking up an installed - # copy of Z3. This is here to benefit Z3's build sytem when building + # This should prevent us from accidentally picking up an installed + # copy of Z3. This is here to benefit Z3's build system when building # this project. When making your own project you probably shouldn't # use this option. NO_DEFAULT_PATH diff --git a/examples/c/README b/examples/c/README index 4ca71e0f8..af9dd39f6 100644 --- a/examples/c/README +++ b/examples/c/README @@ -5,7 +5,7 @@ in the build directory. This command will create the executable c_example. On Windows, you can just execute it. -On OSX and Linux, you must install z3 first using +On macOS and Linux, you must install z3 first using sudo make install -OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (OSX) with the build directory. You need that to be able to find the Z3 shared library. +OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (macOS) with the build directory. You need that to be able to find the Z3 shared library. diff --git a/examples/c/test_capi.c b/examples/c/test_capi.c index 14e403826..f9c108b92 100644 --- a/examples/c/test_capi.c +++ b/examples/c/test_capi.c @@ -241,7 +241,7 @@ void check(Z3_context ctx, Z3_solver s, Z3_lbool expected_result) The context \c ctx is not modified by this function. */ -void prove(Z3_context ctx, Z3_solver s, Z3_ast f, Z3_bool is_valid) +void prove(Z3_context ctx, Z3_solver s, Z3_ast f, bool is_valid) { Z3_model m = 0; Z3_ast not_f; @@ -379,6 +379,7 @@ void assert_comm_axiom(Z3_context ctx, Z3_solver s, Z3_func_decl f) Z3_sort t; Z3_symbol f_name, t_name; Z3_ast_vector q; + unsigned i; t = Z3_get_range(ctx, f); @@ -399,7 +400,7 @@ void assert_comm_axiom(Z3_context ctx, Z3_solver s, Z3_func_decl f) 1, &t_name, &t, 1, &f_name, &f); printf("assert axiom:\n%s\n", Z3_ast_vector_to_string(ctx, q)); - for (unsigned i = 0; i < Z3_ast_vector_size(ctx, q); ++i) { + for (i = 0; i < Z3_ast_vector_size(ctx, q); ++i) { Z3_solver_assert(ctx, s, Z3_ast_vector_get(ctx, q, i)); } } @@ -638,7 +639,7 @@ void display_model(Z3_context c, FILE * out, Z3_model m) Z3_symbol name; Z3_func_decl cnst = Z3_model_get_const_decl(c, m, i); Z3_ast a, v; - Z3_bool ok; + bool ok; name = Z3_get_decl_name(c, cnst); display_symbol(c, out, name); fprintf(out, " = "); @@ -898,7 +899,7 @@ void prove_example1() /* prove g(x) = g(y) */ f = Z3_mk_eq(ctx, gx, gy); printf("prove: x = y implies g(x) = g(y)\n"); - prove(ctx, s, f, Z3_TRUE); + prove(ctx, s, f, true); /* create g(g(x)) */ ggx = mk_unary_app(ctx, g, gx); @@ -906,7 +907,7 @@ void prove_example1() /* disprove g(g(x)) = g(y) */ f = Z3_mk_eq(ctx, ggx, gy); printf("disprove: x = y implies g(g(x)) = g(y)\n"); - prove(ctx, s, f, Z3_FALSE); + prove(ctx, s, f, false); del_solver(ctx, s); Z3_del_context(ctx); @@ -978,13 +979,13 @@ void prove_example2() /* prove z < 0 */ f = Z3_mk_lt(ctx, z, zero); printf("prove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < 0\n"); - prove(ctx, s, f, Z3_TRUE); + prove(ctx, s, f, true); /* disprove z < -1 */ minus_one = mk_int(ctx, -1); f = Z3_mk_lt(ctx, z, minus_one); printf("disprove: not(g(g(x) - g(y)) = g(z)), x + z <= y <= x implies z < -1\n"); - prove(ctx, s, f, Z3_FALSE); + prove(ctx, s, f, false); del_solver(ctx, s); Z3_del_context(ctx); @@ -1130,7 +1131,7 @@ void quantifier_example1() /* prove f(x, y) = f(w, v) implies y = v */ p2 = Z3_mk_eq(ctx, y, v); printf("prove: f(x, y) = f(w, v) implies y = v\n"); - prove(ctx, s, p2, Z3_TRUE); + prove(ctx, s, p2, true); /* disprove f(x, y) = f(w, v) implies x = w */ /* using check2 instead of prove */ @@ -1197,7 +1198,7 @@ void array_example1() thm = Z3_mk_implies(ctx, antecedent, consequent); printf("prove: store(a1, i1, v1) = store(a2, i2, v2) implies (i1 = i3 or i2 = i3 or select(a1, i3) = select(a2, i3))\n"); printf("%s\n", Z3_ast_to_string(ctx, thm)); - prove(ctx, s, thm, Z3_TRUE); + prove(ctx, s, thm, true); del_solver(ctx, s); Z3_del_context(ctx); @@ -1338,13 +1339,13 @@ void tuple_example1() eq2 = Z3_mk_eq(ctx, x, one); thm = Z3_mk_implies(ctx, eq1, eq2); printf("prove: get_x(mk_pair(x, y)) = 1 implies x = 1\n"); - prove(ctx, s, thm, Z3_TRUE); + prove(ctx, s, thm, true); /* disprove that get_x(mk_pair(x,y)) == 1 implies y = 1*/ eq3 = Z3_mk_eq(ctx, y, one); thm = Z3_mk_implies(ctx, eq1, eq3); printf("disprove: get_x(mk_pair(x, y)) = 1 implies y = 1\n"); - prove(ctx, s, thm, Z3_FALSE); + prove(ctx, s, thm, false); } { @@ -1365,12 +1366,12 @@ void tuple_example1() consequent = Z3_mk_eq(ctx, p1, p2); thm = Z3_mk_implies(ctx, antecedent, consequent); printf("prove: get_x(p1) = get_x(p2) and get_y(p1) = get_y(p2) implies p1 = p2\n"); - prove(ctx, s, thm, Z3_TRUE); + prove(ctx, s, thm, true); /* disprove that get_x(p1) = get_x(p2) implies p1 = p2 */ thm = Z3_mk_implies(ctx, antecedents[0], consequent); printf("disprove: get_x(p1) = get_x(p2) implies p1 = p2\n"); - prove(ctx, s, thm, Z3_FALSE); + prove(ctx, s, thm, false); } { @@ -1389,14 +1390,14 @@ void tuple_example1() consequent = Z3_mk_eq(ctx, x, ten); thm = Z3_mk_implies(ctx, antecedent, consequent); printf("prove: p2 = update(p1, 0, 10) implies get_x(p2) = 10\n"); - prove(ctx, s, thm, Z3_TRUE); + prove(ctx, s, thm, true); /* disprove that p2 = update(p1, 0, 10) implies get_y(p2) = 10 */ y = mk_unary_app(ctx, get_y_decl, p2); consequent = Z3_mk_eq(ctx, y, ten); thm = Z3_mk_implies(ctx, antecedent, consequent); printf("disprove: p2 = update(p1, 0, 10) implies get_y(p2) = 10\n"); - prove(ctx, s, thm, Z3_FALSE); + prove(ctx, s, thm, false); } del_solver(ctx, s); @@ -1428,7 +1429,7 @@ void bitvector_example1() c2 = Z3_mk_bvsle(ctx, x_minus_ten, zero); thm = Z3_mk_iff(ctx, c1, c2); printf("disprove: x - 10 <= 0 IFF x <= 10 for (32-bit) machine integers\n"); - prove(ctx, s, thm, Z3_FALSE); + prove(ctx, s, thm, false); del_solver(ctx, s); Z3_del_context(ctx); @@ -1644,6 +1645,7 @@ void parser_example2() Z3_symbol names[2]; Z3_func_decl decls[2]; Z3_ast_vector f; + unsigned i; printf("\nparser_example2\n"); LOG_MSG("parser_example2"); @@ -1668,7 +1670,7 @@ void parser_example2() 2, names, decls); printf("formula: %s\n", Z3_ast_vector_to_string(ctx, f)); printf("assert axiom:\n%s\n", Z3_ast_vector_to_string(ctx, f)); - for (unsigned i = 0; i < Z3_ast_vector_size(ctx, f); ++i) { + for (i = 0; i < Z3_ast_vector_size(ctx, f); ++i) { Z3_solver_assert(ctx, s, Z3_ast_vector_get(ctx, f, i)); } check(ctx, s, Z3_L_TRUE); @@ -1695,7 +1697,7 @@ void parser_example3() LOG_MSG("parser_example3"); cfg = Z3_mk_config(); - /* See quantifer_example1 */ + /* See quantifier_example1 */ Z3_set_param_value(cfg, "model", "true"); ctx = mk_context_custom(cfg, error_handler); Z3_del_config(cfg); @@ -1715,7 +1717,7 @@ void parser_example3() 0, 0, 0, 1, &g_name, &g); printf("formula: %s\n", Z3_ast_vector_to_string(ctx, thm)); - prove(ctx, s, Z3_ast_vector_get(ctx, thm, 0), Z3_TRUE); + prove(ctx, s, Z3_ast_vector_get(ctx, thm, 0), true); del_solver(ctx, s); Z3_del_context(ctx); @@ -1779,13 +1781,13 @@ void numeral_example() { n2 = Z3_mk_numeral(ctx, "0.5", real_ty); printf("Numerals n1:%s", Z3_ast_to_string(ctx, n1)); printf(" n2:%s\n", Z3_ast_to_string(ctx, n2)); - prove(ctx, s, Z3_mk_eq(ctx, n1, n2), Z3_TRUE); + prove(ctx, s, Z3_mk_eq(ctx, n1, n2), true); n1 = Z3_mk_numeral(ctx, "-1/3", real_ty); n2 = Z3_mk_numeral(ctx, "-0.33333333333333333333333333333333333333333333333333", real_ty); printf("Numerals n1:%s", Z3_ast_to_string(ctx, n1)); printf(" n2:%s\n", Z3_ast_to_string(ctx, n2)); - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, n1, n2)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, n1, n2)), true); del_solver(ctx, s); Z3_del_context(ctx); } @@ -1850,14 +1852,14 @@ void enum_example() { orange = Z3_mk_app(ctx, enum_consts[2], 0, 0); /* Apples are different from oranges */ - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, apple, orange)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, apple, orange)), true); /* Apples pass the apple test */ - prove(ctx, s, Z3_mk_app(ctx, enum_testers[0], 1, &apple), Z3_TRUE); + prove(ctx, s, Z3_mk_app(ctx, enum_testers[0], 1, &apple), true); /* Oranges fail the apple test */ - prove(ctx, s, Z3_mk_app(ctx, enum_testers[0], 1, &orange), Z3_FALSE); - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_app(ctx, enum_testers[0], 1, &orange)), Z3_TRUE); + prove(ctx, s, Z3_mk_app(ctx, enum_testers[0], 1, &orange), false); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_app(ctx, enum_testers[0], 1, &orange)), true); fruity = mk_var(ctx, "fruity", fruit); @@ -1866,7 +1868,7 @@ void enum_example() { ors[1] = Z3_mk_eq(ctx, fruity, banana); ors[2] = Z3_mk_eq(ctx, fruity, orange); - prove(ctx, s, Z3_mk_or(ctx, 3, ors), Z3_TRUE); + prove(ctx, s, Z3_mk_or(ctx, 3, ors), true); /* delete logical context */ del_solver(ctx, s); @@ -1898,41 +1900,41 @@ void list_example() { l2 = mk_binary_app(ctx, cons_decl, mk_int(ctx, 2), nil); /* nil != cons(1, nil) */ - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, l1)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, l1)), true); /* cons(2,nil) != cons(1, nil) */ - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, l1, l2)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, l1, l2)), true); /* cons(x,nil) = cons(y, nil) => x = y */ x = mk_var(ctx, "x", int_ty); y = mk_var(ctx, "y", int_ty); l1 = mk_binary_app(ctx, cons_decl, x, nil); l2 = mk_binary_app(ctx, cons_decl, y, nil); - prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), Z3_TRUE); + prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), true); /* cons(x,u) = cons(x, v) => u = v */ u = mk_var(ctx, "u", int_list); v = mk_var(ctx, "v", int_list); l1 = mk_binary_app(ctx, cons_decl, x, u); l2 = mk_binary_app(ctx, cons_decl, y, v); - prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), Z3_TRUE); - prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), Z3_TRUE); + prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), true); + prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), true); /* is_nil(u) or is_cons(u) */ ors[0] = Z3_mk_app(ctx, is_nil_decl, 1, &u); ors[1] = Z3_mk_app(ctx, is_cons_decl, 1, &u); - prove(ctx, s, Z3_mk_or(ctx, 2, ors), Z3_TRUE); + prove(ctx, s, Z3_mk_or(ctx, 2, ors), true); /* occurs check u != cons(x,u) */ - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), true); /* destructors: is_cons(u) => u = cons(head(u),tail(u)) */ fml1 = Z3_mk_eq(ctx, u, mk_binary_app(ctx, cons_decl, mk_unary_app(ctx, head_decl, u), mk_unary_app(ctx, tail_decl, u))); fml = Z3_mk_implies(ctx, Z3_mk_app(ctx, is_cons_decl, 1, &u), fml1); printf("Formula %s\n", Z3_ast_to_string(ctx, fml)); - prove(ctx, s, fml, Z3_TRUE); + prove(ctx, s, fml, true); - prove(ctx, s, fml1, Z3_FALSE); + prove(ctx, s, fml1, false); /* delete logical context */ del_solver(ctx, s); @@ -1980,7 +1982,7 @@ void tree_example() { l2 = mk_binary_app(ctx, cons_decl, l1, nil); /* nil != cons(nil, nil) */ - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, l1)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, l1)), true); /* cons(x,u) = cons(x, v) => u = v */ u = mk_var(ctx, "u", cell); @@ -1989,24 +1991,24 @@ void tree_example() { y = mk_var(ctx, "y", cell); l1 = mk_binary_app(ctx, cons_decl, x, u); l2 = mk_binary_app(ctx, cons_decl, y, v); - prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), Z3_TRUE); - prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), Z3_TRUE); + prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), true); + prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), true); /* is_nil(u) or is_cons(u) */ ors[0] = Z3_mk_app(ctx, is_nil_decl, 1, &u); ors[1] = Z3_mk_app(ctx, is_cons_decl, 1, &u); - prove(ctx, s, Z3_mk_or(ctx, 2, ors), Z3_TRUE); + prove(ctx, s, Z3_mk_or(ctx, 2, ors), true); /* occurs check u != cons(x,u) */ - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), true); /* destructors: is_cons(u) => u = cons(car(u),cdr(u)) */ fml1 = Z3_mk_eq(ctx, u, mk_binary_app(ctx, cons_decl, mk_unary_app(ctx, car_decl, u), mk_unary_app(ctx, cdr_decl, u))); fml = Z3_mk_implies(ctx, Z3_mk_app(ctx, is_cons_decl, 1, &u), fml1); printf("Formula %s\n", Z3_ast_to_string(ctx, fml)); - prove(ctx, s, fml, Z3_TRUE); + prove(ctx, s, fml, true); - prove(ctx, s, fml1, Z3_FALSE); + prove(ctx, s, fml1, false); /* delete logical context */ del_solver(ctx, s); @@ -2098,8 +2100,8 @@ void forest_example() { /* nil != cons(nil,nil) */ - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil1, f1)), Z3_TRUE); - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil2, t1)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil1, f1)), true); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil2, t1)), true); /* cons(x,u) = cons(x, v) => u = v */ @@ -2109,16 +2111,16 @@ void forest_example() { y = mk_var(ctx, "y", tree); l1 = mk_binary_app(ctx, cons1_decl, x, u); l2 = mk_binary_app(ctx, cons1_decl, y, v); - prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), Z3_TRUE); - prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), Z3_TRUE); + prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, u, v)), true); + prove(ctx, s, Z3_mk_implies(ctx, Z3_mk_eq(ctx,l1,l2), Z3_mk_eq(ctx, x, y)), true); /* is_nil(u) or is_cons(u) */ ors[0] = Z3_mk_app(ctx, is_nil1_decl, 1, &u); ors[1] = Z3_mk_app(ctx, is_cons1_decl, 1, &u); - prove(ctx, s, Z3_mk_or(ctx, 2, ors), Z3_TRUE); + prove(ctx, s, Z3_mk_or(ctx, 2, ors), true); /* occurs check u != cons(x,u) */ - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, u, l1)), true); /* delete logical context */ del_solver(ctx, s); @@ -2191,19 +2193,19 @@ void binary_tree_example() { Z3_ast node3 = Z3_mk_app(ctx, node_decl, 3, args3); /* prove that nil != node1 */ - prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, node1)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, Z3_mk_eq(ctx, nil, node1)), true); /* prove that nil = left(node1) */ - prove(ctx, s, Z3_mk_eq(ctx, nil, mk_unary_app(ctx, left_decl, node1)), Z3_TRUE); + prove(ctx, s, Z3_mk_eq(ctx, nil, mk_unary_app(ctx, left_decl, node1)), true); /* prove that node1 = right(node3) */ - prove(ctx, s, Z3_mk_eq(ctx, node1, mk_unary_app(ctx, right_decl, node3)), Z3_TRUE); + prove(ctx, s, Z3_mk_eq(ctx, node1, mk_unary_app(ctx, right_decl, node3)), true); /* prove that !is-nil(node2) */ - prove(ctx, s, Z3_mk_not(ctx, mk_unary_app(ctx, is_nil_decl, node2)), Z3_TRUE); + prove(ctx, s, Z3_mk_not(ctx, mk_unary_app(ctx, is_nil_decl, node2)), true); /* prove that value(node2) >= 0 */ - prove(ctx, s, Z3_mk_ge(ctx, mk_unary_app(ctx, value_decl, node2), mk_int(ctx, 0)), Z3_TRUE); + prove(ctx, s, Z3_mk_ge(ctx, mk_unary_app(ctx, value_decl, node2), mk_int(ctx, 0)), true); } /* delete logical context */ @@ -2302,7 +2304,7 @@ typedef struct { // IMPORTANT: the fields m_answer_literals, m_retracted and m_num_answer_literals must be saved/restored // if push/pop operations are performed on m_context. Z3_ast m_answer_literals[MAX_RETRACTABLE_ASSERTIONS]; - Z3_bool m_retracted[MAX_RETRACTABLE_ASSERTIONS]; // true if the assertion was retracted. + bool m_retracted[MAX_RETRACTABLE_ASSERTIONS]; // true if the assertion was retracted. unsigned m_num_answer_literals; } Z3_ext_context_struct; @@ -2345,7 +2347,7 @@ unsigned assert_retractable_cnstr(Z3_ext_context ctx, Z3_ast c) { ans_lit = Z3_mk_fresh_const(ctx->m_context, "k", ty); result = ctx->m_num_answer_literals; ctx->m_answer_literals[result] = ans_lit; - ctx->m_retracted[result] = Z3_FALSE; + ctx->m_retracted[result] = false; ctx->m_num_answer_literals++; // assert: c OR (not ans_lit) args[0] = c; @@ -2361,7 +2363,7 @@ void retract_cnstr(Z3_ext_context ctx, unsigned id) { if (id >= ctx->m_num_answer_literals) { exitf("invalid constraint id."); } - ctx->m_retracted[id] = Z3_TRUE; + ctx->m_retracted[id] = true; } /** @@ -2371,7 +2373,7 @@ void reassert_cnstr(Z3_ext_context ctx, unsigned id) { if (id >= ctx->m_num_answer_literals) { exitf("invalid constraint id."); } - ctx->m_retracted[id] = Z3_FALSE; + ctx->m_retracted[id] = false; } /** @@ -2385,7 +2387,7 @@ Z3_lbool ext_check(Z3_ext_context ctx) { unsigned core_size; unsigned i; for (i = 0; i < ctx->m_num_answer_literals; i++) { - if (ctx->m_retracted[i] == Z3_FALSE) { + if (ctx->m_retracted[i] == false) { // Since the answer literal was not retracted, we added it as an assumption. // Recall that we assert (C \/ (not ans_lit)). Therefore, adding ans_lit as an assumption has the effect of "asserting" C. // If the constraint was "retracted" (ctx->m_retracted[i] == Z3_true), then we don't really need to add (not ans_lit) as an assumption. @@ -2870,19 +2872,19 @@ void mk_model_example() { /*num_args=*/2, /*args=*/addArgs); Z3_ast aPlusBEval = NULL; - Z3_bool aPlusBEvalSuccess = + bool aPlusBEvalSuccess = Z3_model_eval(ctx, m, aPlusB, - /*model_completion=*/Z3_FALSE, &aPlusBEval); - if (aPlusBEvalSuccess != Z3_TRUE) { + /*model_completion=*/false, &aPlusBEval); + if (aPlusBEvalSuccess != true) { printf("Failed to evaluate model\n"); exit(1); } { int aPlusBValue = 0; - Z3_bool getAPlusBValueSuccess = + bool getAPlusBValueSuccess = Z3_get_numeral_int(ctx, aPlusBEval, &aPlusBValue); - if (getAPlusBValueSuccess != Z3_TRUE) { + if (getAPlusBValueSuccess != true) { printf("Failed to get integer value for a+b\n"); exit(1); } @@ -2904,18 +2906,18 @@ void mk_model_example() { /*num_args=*/3, /*args=*/arrayAddArgs); Z3_ast arrayAddEval = NULL; - Z3_bool arrayAddEvalSuccess = + bool arrayAddEvalSuccess = Z3_model_eval(ctx, m, arrayAdd, - /*model_completion=*/Z3_FALSE, &arrayAddEval); - if (arrayAddEvalSuccess != Z3_TRUE) { + /*model_completion=*/false, &arrayAddEval); + if (arrayAddEvalSuccess != true) { printf("Failed to evaluate model\n"); exit(1); } { int arrayAddValue = 0; - Z3_bool getArrayAddValueSuccess = + bool getArrayAddValueSuccess = Z3_get_numeral_int(ctx, arrayAddEval, &arrayAddValue); - if (getArrayAddValueSuccess != Z3_TRUE) { + if (getArrayAddValueSuccess != true) { printf("Failed to get integer value for c[0] + c[1] + c[2]\n"); exit(1); } diff --git a/examples/dotnet/Program.cs b/examples/dotnet/Program.cs index 230aacf6f..47906add4 100644 --- a/examples/dotnet/Program.cs +++ b/examples/dotnet/Program.cs @@ -363,10 +363,10 @@ namespace test_mapi Console.WriteLine("Model = " + s.Model); - Console.WriteLine("Interpretation of MyArray:\n" + s.Model.FuncInterp(aex.FuncDecl)); + //Console.WriteLine("Interpretation of MyArray:\n" + s.Model.ConstInterp(aex.FuncDecl)); Console.WriteLine("Interpretation of x:\n" + s.Model.ConstInterp(xc)); Console.WriteLine("Interpretation of f:\n" + s.Model.FuncInterp(fd)); - Console.WriteLine("Interpretation of MyArray as Term:\n" + s.Model.FuncInterp(aex.FuncDecl)); + //Console.WriteLine("Interpretation of MyArray as Term:\n" + s.Model.ConstInterp(aex.FuncDecl)); } /// diff --git a/examples/java/README b/examples/java/README index 1939afc49..d3ff93fe0 100644 --- a/examples/java/README +++ b/examples/java/README @@ -10,5 +10,5 @@ which can be run on Windows via On Linux and FreeBSD, we must use LD_LIBRARY_PATH=. java -cp com.microsoft.z3.jar:. JavaExample -On OSX, the corresponding option is DYLD_LIBRARY_PATH: +On macOS, the corresponding option is DYLD_LIBRARY_PATH: DYLD_LIBRARY_PATH=. java -cp com.microsoft.z3.jar:. JavaExample diff --git a/examples/maxsat/CMakeLists.txt b/examples/maxsat/CMakeLists.txt index 019243ecf..e59486297 100644 --- a/examples/maxsat/CMakeLists.txt +++ b/examples/maxsat/CMakeLists.txt @@ -11,8 +11,8 @@ find_package(Z3 REQUIRED CONFIG # `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3. - # This should prevent us from accidently picking up an installed - # copy of Z3. This is here to benefit Z3's build sytem when building + # This should prevent us from accidentally picking up an installed + # copy of Z3. This is here to benefit Z3's build system when building # this project. When making your own project you probably shouldn't # use this option. NO_DEFAULT_PATH diff --git a/examples/maxsat/README b/examples/maxsat/README index 6c24da66b..8c7d3b0f7 100644 --- a/examples/maxsat/README +++ b/examples/maxsat/README @@ -5,8 +5,8 @@ in the build directory. This command will create the executable maxsat. On Windows, you can just execute it. -On OSX and Linux, you must install z3 first using +On macOS and Linux, you must install z3 first using sudo make install -OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (OSX) with the build directory. You need that to be able to find the Z3 shared library. +OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (macOS) with the build directory. You need that to be able to find the Z3 shared library. This directory contains a test file (ex.smt) that can be used as input for the maxsat test application. diff --git a/examples/maxsat/maxsat.c b/examples/maxsat/maxsat.c index 5696f5b89..1f9ae165f 100644 --- a/examples/maxsat/maxsat.c +++ b/examples/maxsat/maxsat.c @@ -138,7 +138,7 @@ void assert_hard_constraints(Z3_context ctx, Z3_solver s, unsigned num_cnstrs, Z /** \brief Assert soft constraints stored in the given array. - This funtion will assert each soft-constraint C_i as (C_i or k_i) where k_i is a fresh boolean variable. + This function will assert each soft-constraint C_i as (C_i or k_i) where k_i is a fresh boolean variable. It will also return an array containing these fresh variables. */ Z3_ast * assert_soft_constraints(Z3_context ctx, Z3_solver s, unsigned num_cnstrs, Z3_ast * cnstrs) @@ -382,7 +382,7 @@ unsigned get_num_disabled_soft_constraints(Z3_context ctx, Z3_model m, unsigned Z3_ast t = Z3_mk_true(ctx); for (i = 0; i < num_soft_cnstrs; i++) { Z3_ast val; - if (Z3_model_eval(ctx, m, aux_vars[i], 1, &val) == Z3_TRUE) { + if (Z3_model_eval(ctx, m, aux_vars[i], 1, &val) == true) { // printf("%s", Z3_ast_to_string(ctx, aux_vars[i])); // printf(" -> %s\n", Z3_ast_to_string(ctx, val)); if (Z3_is_eq_ast(ctx, val, t)) { @@ -565,7 +565,7 @@ int fu_malik_maxsat(Z3_context ctx, Z3_solver s, unsigned num_hard_cnstrs, Z3_as /** \brief Finds the maximal number of assumptions that can be satisfied. - An assumption is any formula preceeded with the :assumption keyword. + An assumption is any formula preceded with the :assumption keyword. "Hard" constraints can be supported by using the :formula keyword. Input: file in SMT-LIB format, and MaxSAT algorithm to be used: 0 - Naive, 1 - Fu&Malik's algo. diff --git a/examples/ml/README b/examples/ml/README index 1c474fe33..9797b85e3 100644 --- a/examples/ml/README +++ b/examples/ml/README @@ -20,4 +20,4 @@ ocamlfind ocamlopt -o ml_example -package Z3 -linkpkg ml_example.ml Note that the resulting binaries depend on the shared z3 library (libz3.dll/.so/.dylb), which needs to be in the PATH (Windows), LD_LIBRARY_PATH -(Linux), or DYLD_LIBRARY_PATH (OSX). +(Linux), or DYLD_LIBRARY_PATH (macOS). diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseSolver.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseSolver.cs index 1c82406be..5297d3e67 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseSolver.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3BaseSolver.cs @@ -226,7 +226,7 @@ namespace Microsoft.SolverFoundation.Plugin.Z3 } /// - /// Adds a MSF variable with the coresponding assertion to the Z3 variables. + /// Adds a MSF variable with the corresponding assertion to the Z3 variables. /// /// The MSF id of the variable internal void AddVariable(int vid) diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPSolver.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPSolver.cs index f3a8f9f2c..4f8cdc759 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPSolver.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3MILPSolver.cs @@ -33,14 +33,14 @@ namespace Microsoft.SolverFoundation.Plugin.Z3 #region Solver construction and destruction - /// Constructor that initializes the base clases + /// Constructor that initializes the base classes public Z3MILPSolver() : base(null) { _result = LinearResult.Feasible; _solver = new Z3BaseSolver(this); } - /// Constructor that initializes the base clases + /// Constructor that initializes the base classes public Z3MILPSolver(ISolverEnvironment context) : this() { } /// diff --git a/examples/msf/SolverFoundation.Plugin.Z3/Z3TermSolver.cs b/examples/msf/SolverFoundation.Plugin.Z3/Z3TermSolver.cs index 530df3394..de91c7b6e 100644 --- a/examples/msf/SolverFoundation.Plugin.Z3/Z3TermSolver.cs +++ b/examples/msf/SolverFoundation.Plugin.Z3/Z3TermSolver.cs @@ -29,13 +29,13 @@ namespace Microsoft.SolverFoundation.Plugin.Z3 private NonlinearResult _result; private Z3BaseSolver _solver; - /// Constructor that initializes the base clases + /// Constructor that initializes the base classes public Z3TermSolver() : base(null) { _solver = new Z3BaseSolver(this); } - /// Constructor that initializes the base clases + /// Constructor that initializes the base classes public Z3TermSolver(ISolverEnvironment context) : this() { } /// diff --git a/examples/python/data/horn1.smt2 b/examples/python/data/horn1.smt2 new file mode 100644 index 000000000..20d043534 --- /dev/null +++ b/examples/python/data/horn1.smt2 @@ -0,0 +1,50 @@ +(declare-rel Goal (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool)) +(declare-rel Invariant (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool)) +(declare-var A Bool) +(declare-var B Bool) +(declare-var C Bool) +(declare-var D Bool) +(declare-var E Bool) +(declare-var F Bool) +(declare-var G Bool) +(declare-var H Bool) +(declare-var I Bool) +(declare-var J Bool) +(declare-var K Bool) +(declare-var L Bool) +(declare-var M Bool) +(declare-var N Bool) +(declare-var O Bool) +(declare-var P Bool) +(declare-var Q Bool) +(declare-var R Bool) +(declare-var S Bool) +(declare-var T Bool) +(declare-var U Bool) +(declare-var V Bool) +(declare-var W Bool) +(declare-var X Bool) +(rule (=> (not (or L K J I H G F E D C B A)) (Invariant L K J I H G F E D C B A))) +(rule (let ((a!1 (and (Invariant X W V U T S R Q P O N M) + (=> (not (and true)) (not F)) + (=> (not (and true)) (not E)) + (=> (not (and W)) (not D)) + (=> (not (and W)) (not C)) + (=> (not (and U)) (not B)) + (=> (not (and U)) (not A)) + (= L (xor F X)) + (= K (xor E W)) + (= J (xor D V)) + (= I (xor C U)) + (= H (xor B T)) + (= G (xor A S)) + (=> D (not E)) + (=> C (not E)) + (=> B (not C)) + (=> A (not C)) + ((_ at-most 5) L K J I H G)))) + (=> a!1 (Invariant L K J I H G F E D C B A)))) +(rule (=> (and (Invariant L K J I H G F E D C B A) L (not K) J (not I) H G) + (Goal L K J I H G F E D C B A))) + +(query Goal) \ No newline at end of file diff --git a/examples/python/data/horn2.smt2 b/examples/python/data/horn2.smt2 new file mode 100644 index 000000000..478c39d5f --- /dev/null +++ b/examples/python/data/horn2.smt2 @@ -0,0 +1,44 @@ +(declare-rel Invariant (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool)) +(declare-rel Goal (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool)) +(declare-var A Bool) +(declare-var B Bool) +(declare-var C Bool) +(declare-var D Bool) +(declare-var E Bool) +(declare-var F Bool) +(declare-var G Bool) +(declare-var H Bool) +(declare-var I Bool) +(declare-var J Bool) +(declare-var K Bool) +(declare-var L Bool) +(declare-var M Bool) +(declare-var N Bool) +(declare-var O Bool) +(declare-var P Bool) +(declare-var Q Bool) +(declare-var R Bool) +(declare-var S Bool) +(declare-var T Bool) +(rule (=> (not (or J I H G F E D C B A)) (Invariant J I H G F E D C B A))) +(rule (let ((a!1 (and (Invariant T S R Q P O N M L K) + (=> (not (and true)) (not E)) + (=> (not (and T)) (not D)) + (=> (not (and S)) (not C)) + (=> (not (and R)) (not B)) + (=> (not (and Q)) (not A)) + (= J (xor E T)) + (= I (xor D S)) + (= H (xor C R)) + (= G (xor B Q)) + (= F (xor A P)) + (=> D (not E)) + (=> C (not D)) + (=> B (not C)) + (=> A (not B)) + ((_ at-most 3) J I H G F)))) + (=> a!1 (Invariant J I H G F E D C B A)))) +(rule (=> (and (Invariant J I H G F E D C B A) (not J) (not I) (not H) (not G) F) + (Goal J I H G F E D C B A))) + +(query Goal) diff --git a/examples/python/data/horn3.smt2 b/examples/python/data/horn3.smt2 new file mode 100644 index 000000000..873784e43 --- /dev/null +++ b/examples/python/data/horn3.smt2 @@ -0,0 +1,17 @@ +(declare-rel Invariant (Bool)) +(declare-rel Goal ()) +(declare-var l0 Bool) +(declare-var l2 Bool) +(declare-var l4 Bool) +(declare-var l6 Bool) +(declare-var l8 Bool) +(declare-var l10 Bool) +(rule (=> (not (or l4)) (Invariant l4))) +(rule (=> (and (Invariant l4) + (= (and (not l4) (not l2)) l6) + (= (and l4 l2) l8) + (= (and (not l8) (not l6)) l10) + ) (Invariant l10))) +(rule (=> (and (Invariant l4) + l4) Goal)) +(query Goal) diff --git a/examples/python/data/horn4.smt2 b/examples/python/data/horn4.smt2 new file mode 100644 index 000000000..0a64b41db --- /dev/null +++ b/examples/python/data/horn4.smt2 @@ -0,0 +1,99 @@ +(declare-rel Invariant (Bool Bool Bool Bool Bool Bool)) +(declare-rel Goal ()) +(declare-var l0 Bool) +(declare-var l2 Bool) +(declare-var l4 Bool) +(declare-var l6 Bool) +(declare-var l8 Bool) +(declare-var l10 Bool) +(declare-var l12 Bool) +(declare-var l14 Bool) +(declare-var l16 Bool) +(declare-var l18 Bool) +(declare-var l20 Bool) +(declare-var l22 Bool) +(declare-var l24 Bool) +(declare-var l26 Bool) +(declare-var l28 Bool) +(declare-var l30 Bool) +(declare-var l32 Bool) +(declare-var l34 Bool) +(declare-var l36 Bool) +(declare-var l38 Bool) +(declare-var l40 Bool) +(declare-var l42 Bool) +(declare-var l44 Bool) +(declare-var l46 Bool) +(declare-var l48 Bool) +(declare-var l50 Bool) +(declare-var l52 Bool) +(declare-var l54 Bool) +(declare-var l56 Bool) +(declare-var l58 Bool) +(declare-var l60 Bool) +(declare-var l62 Bool) +(declare-var l64 Bool) +(declare-var l66 Bool) +(declare-var l68 Bool) +(declare-var l70 Bool) +(declare-var l72 Bool) +(declare-var l74 Bool) +(declare-var l76 Bool) +(declare-var l78 Bool) +(declare-var l80 Bool) +(declare-var l82 Bool) +(declare-var l84 Bool) +(declare-var l86 Bool) +(rule (=> (not (or l4 l6 l8 l10 l12 l14)) (Invariant l4 l6 l8 l10 l12 l14))) +(rule (=> (and (Invariant l4 l6 l8 l10 l12 l14) + (= (and l6 (not l4)) l16) + (= (and l10 (not l8)) l18) + (= (and l18 l16) l20) + (= (and (not l14) (not l12)) l22) + (= (and l22 l20) l24) + (= (and (not l24) (not l4)) l26) + (= (and (not l6) l4) l28) + (= (and (not l28) (not l16)) l30) + (= (and (not l30) (not l24)) l32) + (= (and l6 l4) l34) + (= (and (not l34) l8) l36) + (= (and l34 (not l8)) l38) + (= (and (not l38) (not l36)) l40) + (= (and (not l40) (not l24)) l42) + (= (and l34 l8) l44) + (= (and (not l44) l10) l46) + (= (and l44 (not l10)) l48) + (= (and (not l48) (not l46)) l50) + (= (and (not l50) (not l24)) l52) + (= (and l10 l8) l54) + (= (and l54 l34) l56) + (= (and (not l56) l12) l58) + (= (and l56 (not l12)) l60) + (= (and (not l60) (not l58)) l62) + (= (and (not l62) (not l24)) l64) + (= (and l56 l12) l66) + (= (and (not l66) l14) l68) + (= (and l66 (not l14)) l70) + (= (and (not l70) (not l68)) l72) + (= (and (not l72) (not l24)) l74) + (= (and l6 l4) l76) + (= (and (not l76) l18) l78) + (= (and (not l78) l10) l80) + (= (and (not l80) l22) l82) + (= (and (not l82) (not l24)) l84) + (= (and l84 (not l0)) l86) + ) (Invariant l26 l32 l42 l52 l64 l74))) +(rule (=> (and (Invariant l4 l6 l8 l10 l12 l14) + (= (and l84 (not l0)) l86) + (= (and (not l82) (not l24)) l84) + (= (and (not l80) l22) l82) + (= (and (not l78) l10) l80) + (= (and (not l76) l18) l78) + (= (and l6 l4) l76) + (= (and l10 (not l8)) l18) + (= (and (not l14) (not l12)) l22) + (= (and l22 l20) l24) + (= (and l18 l16) l20) + (= (and l6 (not l4)) l16) + l86) Goal)) +(query Goal) diff --git a/examples/python/data/horn5.smt2 b/examples/python/data/horn5.smt2 new file mode 100644 index 000000000..37642d517 --- /dev/null +++ b/examples/python/data/horn5.smt2 @@ -0,0 +1,21 @@ +(declare-rel Invariant (Bool Bool Bool Bool)) +(declare-rel Goal ()) +(declare-var l0 Bool) +(declare-var l2 Bool) +(declare-var l4 Bool) +(declare-var l6 Bool) +(declare-var l8 Bool) +(declare-var l10 Bool) +(declare-var l12 Bool) +(declare-var l14 Bool) +(declare-var l16 Bool) +(rule (=> (not (or l4 l6 l8 l10)) (Invariant l4 l6 l8 l10))) +(rule (=> (and (Invariant l4 l6 l8 l10) + (= (and l6 l4) l12) + (= (and l12 l8) l14) + (= (and l10 (not l0)) l16) + ) (Invariant l12 l8 l0 l14))) +(rule (=> (and (Invariant l4 l6 l8 l10) + (= (and l10 (not l0)) l16) + l16) Goal)) +(query Goal) diff --git a/examples/python/data/horn6.smt2 b/examples/python/data/horn6.smt2 new file mode 100644 index 000000000..d90187e4d --- /dev/null +++ b/examples/python/data/horn6.smt2 @@ -0,0 +1,292 @@ +(declare-rel Invariant (Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool Bool)) +(declare-rel Goal ()) +(declare-var l0 Bool) +(declare-var l2 Bool) +(declare-var l4 Bool) +(declare-var l6 Bool) +(declare-var l8 Bool) +(declare-var l10 Bool) +(declare-var l12 Bool) +(declare-var l14 Bool) +(declare-var l16 Bool) +(declare-var l18 Bool) +(declare-var l20 Bool) +(declare-var l22 Bool) +(declare-var l24 Bool) +(declare-var l26 Bool) +(declare-var l28 Bool) +(declare-var l30 Bool) +(declare-var l32 Bool) +(declare-var l34 Bool) +(declare-var l36 Bool) +(declare-var l38 Bool) +(declare-var l40 Bool) +(declare-var l42 Bool) +(declare-var l44 Bool) +(declare-var l46 Bool) +(declare-var l48 Bool) +(declare-var l50 Bool) +(declare-var l52 Bool) +(declare-var l54 Bool) +(declare-var l56 Bool) +(declare-var l58 Bool) +(declare-var l60 Bool) +(declare-var l62 Bool) +(declare-var l64 Bool) +(declare-var l66 Bool) +(declare-var l68 Bool) +(declare-var l70 Bool) +(declare-var l72 Bool) +(declare-var l74 Bool) +(declare-var l76 Bool) +(declare-var l78 Bool) +(declare-var l80 Bool) +(declare-var l82 Bool) +(declare-var l84 Bool) +(declare-var l86 Bool) +(declare-var l88 Bool) +(declare-var l90 Bool) +(declare-var l92 Bool) +(declare-var l94 Bool) +(declare-var l96 Bool) +(declare-var l98 Bool) +(declare-var l100 Bool) +(declare-var l102 Bool) +(declare-var l104 Bool) +(declare-var l106 Bool) +(declare-var l108 Bool) +(declare-var l110 Bool) +(declare-var l112 Bool) +(declare-var l114 Bool) +(declare-var l116 Bool) +(declare-var l118 Bool) +(declare-var l120 Bool) +(declare-var l122 Bool) +(declare-var l124 Bool) +(declare-var l126 Bool) +(declare-var l128 Bool) +(declare-var l130 Bool) +(declare-var l132 Bool) +(declare-var l134 Bool) +(declare-var l136 Bool) +(declare-var l138 Bool) +(declare-var l140 Bool) +(declare-var l142 Bool) +(declare-var l144 Bool) +(declare-var l146 Bool) +(declare-var l148 Bool) +(declare-var l150 Bool) +(declare-var l152 Bool) +(declare-var l154 Bool) +(declare-var l156 Bool) +(declare-var l158 Bool) +(declare-var l160 Bool) +(declare-var l162 Bool) +(declare-var l164 Bool) +(declare-var l166 Bool) +(declare-var l168 Bool) +(declare-var l170 Bool) +(declare-var l172 Bool) +(declare-var l174 Bool) +(declare-var l176 Bool) +(declare-var l178 Bool) +(declare-var l180 Bool) +(declare-var l182 Bool) +(declare-var l184 Bool) +(declare-var l186 Bool) +(declare-var l188 Bool) +(declare-var l190 Bool) +(declare-var l192 Bool) +(declare-var l194 Bool) +(declare-var l196 Bool) +(declare-var l198 Bool) +(declare-var l200 Bool) +(declare-var l202 Bool) +(declare-var l204 Bool) +(declare-var l206 Bool) +(declare-var l208 Bool) +(declare-var l210 Bool) +(declare-var l212 Bool) +(declare-var l214 Bool) +(declare-var l216 Bool) +(declare-var l218 Bool) +(declare-var l220 Bool) +(declare-var l222 Bool) +(declare-var l224 Bool) +(declare-var l226 Bool) +(declare-var l228 Bool) +(declare-var l230 Bool) +(declare-var l232 Bool) +(declare-var l234 Bool) +(declare-var l236 Bool) +(declare-var l238 Bool) +(declare-var l240 Bool) +(declare-var l242 Bool) +(declare-var l244 Bool) +(declare-var l246 Bool) +(declare-var l248 Bool) +(declare-var l250 Bool) +(declare-var l252 Bool) +(declare-var l254 Bool) +(declare-var l256 Bool) +(declare-var l258 Bool) +(declare-var l260 Bool) +(declare-var l262 Bool) +(declare-var l264 Bool) +(declare-var l266 Bool) +(declare-var l268 Bool) +(declare-var l270 Bool) +(declare-var l272 Bool) +(declare-var l274 Bool) +(declare-var l276 Bool) +(declare-var l278 Bool) +(declare-var l280 Bool) +(declare-var l282 Bool) +(declare-var l284 Bool) +(declare-var l286 Bool) +(declare-var l288 Bool) +(declare-var l290 Bool) +(declare-var l292 Bool) +(declare-var l294 Bool) +(declare-var l296 Bool) +(declare-var l298 Bool) +(declare-var l300 Bool) +(declare-var l302 Bool) +(declare-var l304 Bool) +(declare-var l306 Bool) +(declare-var l308 Bool) +(declare-var l310 Bool) +(declare-var l312 Bool) +(declare-var l314 Bool) +(declare-var l316 Bool) +(rule (=> (not (or l8 l10 l12 l14 l16 l18 l20 l22 l24 l26 l28 l30 l32 l34 l36 l38 l40 l42 l44 l46 l48 l50 l52 l54 l56 l58 l60 l62 l64 l66 l68 l70 l72 l74)) (Invariant l8 l10 l12 l14 l16 l18 l20 l22 l24 l26 l28 l30 l32 l34 l36 l38 l40 l42 l44 l46 l48 l50 l52 l54 l56 l58 l60 l62 l64 l66 l68 l70 l72 l74))) +(rule (=> (and (Invariant l8 l10 l12 l14 l16 l18 l20 l22 l24 l26 l28 l30 l32 l34 l36 l38 l40 l42 l44 l46 l48 l50 l52 l54 l56 l58 l60 l62 l64 l66 l68 l70 l72 l74) + (= (and (not l20) (not l14)) l76) + (= (and (not l76) l8) l78) + (= (and l20 l14) l80) + (= (and (not l80) (not l78)) l82) + (= (and (not l28) l8) l84) + (= (and (not l84) l10) l86) + (= (and l18 l12) l88) + (= (and l88 l38) l90) + (= (and (not l24) (not l8)) l92) + (= (and l92 (not l26)) l94) + (= (and l94 l28) l96) + (= (and l96 (not l90)) l98) + (= (and (not l98) (not l86)) l100) + (= (and l38 l18) l102) + (= (and l102 l12) l104) + (= (and (not l104) (not l26)) l106) + (= (and l24 (not l16)) l108) + (= (and l108 (not l32)) l110) + (= (and l110 l106) l112) + (= (and (not l32) l14) l114) + (= (and (not l114) (not l112)) l116) + (= (and (not l114) l16) l118) + (= (and l32 (not l14)) l120) + (= (and l120 l106) l122) + (= (and l122 l24) l124) + (= (and (not l124) (not l118)) l126) + (= (and l26 (not l22)) l128) + (= (and l128 (not l36)) l130) + (= (and (not l36) l20) l132) + (= (and l130 (not l90)) l134) + (= (and (not l134) (not l132)) l136) + (= (and (not l132) l22) l138) + (= (and l26 (not l20)) l140) + (= (and l140 l36) l142) + (= (and l142 (not l90)) l144) + (= (and (not l144) (not l138)) l146) + (= (and (not l106) l24) l148) + (= (and l106 (not l24)) l150) + (= (and (not l150) (not l148)) l152) + (= (and (not l90) l24) l154) + (= (and l90 l26) l156) + (= (and (not l156) (not l154)) l158) + (= (and (not l30) l2) l160) + (= (and l28 (not l2)) l162) + (= (and (not l162) (not l160)) l164) + (= (and l28 l2) l166) + (= (and (not l166) l30) l168) + (= (and (not l30) l28) l170) + (= (and l170 l8) l172) + (= (and (not l172) (not l168)) l174) + (= (and (not l34) l4) l176) + (= (and l32 (not l4)) l178) + (= (and (not l178) (not l176)) l180) + (= (and l32 l4) l182) + (= (and (not l182) l34) l184) + (= (and (not l34) l32) l186) + (= (and l186 l14) l188) + (= (and (not l188) (not l184)) l190) + (= (and (not l40) l6) l192) + (= (and l36 (not l6)) l194) + (= (and (not l194) (not l192)) l196) + (= (and (not l24) (not l10)) l198) + (= (and l198 (not l26)) l200) + (= (and l200 (not l28)) l202) + (= (and l202 (not l90)) l204) + (= (and (not l204) (not l84)) l206) + (= (and l36 l6) l208) + (= (and (not l208) l40) l210) + (= (and (not l40) l36) l212) + (= (and l212 l20) l214) + (= (and (not l214) (not l210)) l216) + (= (and l62 l44) l218) + (= (and l52 l46) l220) + (= (and l220 l72) l222) + (= (and (not l60) (not l58)) l224) + (= (and l224 l62) l226) + (= (and l226 (not l222)) l228) + (= (and (not l228) (not l218)) l230) + (= (and (not l222) (not l60)) l232) + (= (and (not l66) l58) l234) + (= (and (not l66) l48) l236) + (= (and l234 l232) l238) + (= (and (not l238) (not l236)) l240) + (= (and l66 l50) l242) + (= (and l66 (not l48)) l244) + (= (and l244 l232) l246) + (= (and l246 l58) l248) + (= (and (not l248) (not l242)) l250) + (= (and (not l70) l60) l252) + (= (and (not l70) l54) l254) + (= (and l252 (not l222)) l256) + (= (and (not l256) (not l254)) l258) + (= (and l70 l56) l260) + (= (and l70 l60) l262) + (= (and l262 (not l222)) l264) + (= (and (not l264) (not l260)) l266) + (= (and (not l232) l58) l268) + (= (and l232 (not l58)) l270) + (= (and (not l270) (not l268)) l272) + (= (and l222 l60) l274) + (= (and (not l222) l58) l276) + (= (and (not l276) (not l274)) l278) + (= (and l62 (not l2)) l280) + (= (and (not l64) l2) l282) + (= (and (not l282) (not l280)) l284) + (= (and l62 l42) l286) + (= (and l286 (not l284)) l288) + (= (and l66 (not l4)) l290) + (= (and (not l68) l4) l292) + (= (and (not l292) (not l290)) l294) + (= (and (not l244) l66) l296) + (= (and l296 (not l294)) l298) + (= (and l70 (not l6)) l300) + (= (and (not l74) l6) l302) + (= (and (not l302) (not l300)) l304) + (= (and l224 (not l62)) l306) + (= (and (not l62) l42) l308) + (= (and l306 (not l222)) l310) + (= (and (not l310) (not l308)) l312) + (= (and l70 l54) l314) + (= (and l314 (not l304)) l316) + ) (Invariant l86 l100 l116 l118 l126 l136 l138 l146 l152 l158 l164 l174 l180 l190 l196 l206 l216 l218 l230 l240 l242 l250 l258 l260 l266 l272 l278 l284 l288 l294 l298 l304 l312 l316))) +(rule (=> (and (Invariant l8 l10 l12 l14 l16 l18 l20 l22 l24 l26 l28 l30 l32 l34 l36 l38 l40 l42 l44 l46 l48 l50 l52 l54 l56 l58 l60 l62 l64 l66 l68 l70 l72 l74) + (= (and (not l80) (not l78)) l82) + (= (and l20 l14) l80) + (= (and (not l76) l8) l78) + (= (and (not l20) (not l14)) l76) + (not l82)) Goal)) +(query Goal) diff --git a/examples/python/example.py b/examples/python/example.py index a17668506..761ae10be 100644 --- a/examples/python/example.py +++ b/examples/python/example.py @@ -20,7 +20,7 @@ # export PYTHONPATH=MYZ3/bin/python # python example.py -# Running this example on OSX: +# Running this example on macOS: # export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:MYZ3/bin # export PYTHONPATH=MYZ3/bin/python # python example.py diff --git a/examples/python/mini_ic3.py b/examples/python/mini_ic3.py new file mode 100644 index 000000000..048e8e518 --- /dev/null +++ b/examples/python/mini_ic3.py @@ -0,0 +1,469 @@ +from z3 import * +import heapq + + +# Simplistic (and fragile) converter from +# a class of Horn clauses corresponding to +# a transition system into a transition system +# representation as +# It assumes it is given three Horn clauses +# of the form: +# init(x) => Invariant(x) +# Invariant(x) and trans(x,x') => Invariant(x') +# Invariant(x) and goal(x) => Goal(x) +# where Invariant and Goal are uninterpreted predicates + +class Horn2Transitions: + def __init__(self): + self.trans = True + self.init = True + self.inputs = [] + self.goal = True + self.index = 0 + + def parse(self, file): + fp = Fixedpoint() + goals = fp.parse_file(file) + for r in fp.get_rules(): + if not is_quantifier(r): + continue + b = r.body() + if not is_implies(b): + continue + f = b.arg(0) + g = b.arg(1) + if self.is_goal(f, g): + continue + if self.is_transition(f, g): + continue + if self.is_init(f, g): + continue + + def is_pred(self, p, name): + return is_app(p) and p.decl().name() == name + + def is_goal(self, body, head): + if not self.is_pred(head, "Goal"): + return False + pred, inv = self.is_body(body) + if pred is None: + return False + self.goal = self.subst_vars("x", inv, pred) + self.goal = self.subst_vars("i", self.goal, self.goal) + self.inputs += self.vars + self.inputs = list(set(self.inputs)) + return True + + def is_body(self, body): + if not is_and(body): + return None, None + fmls = [f for f in body.children() if self.is_inv(f) is None] + inv = None + for f in body.children(): + if self.is_inv(f) is not None: + inv = f; + break + return And(fmls), inv + + def is_inv(self, f): + if self.is_pred(f, "Invariant"): + return f + return None + + def is_transition(self, body, head): + pred, inv0 = self.is_body(body) + if pred is None: + return False + inv1 = self.is_inv(head) + if inv1 is None: + return False + pred = self.subst_vars("x", inv0, pred) + self.xs = self.vars + pred = self.subst_vars("xn", inv1, pred) + self.xns = self.vars + pred = self.subst_vars("i", pred, pred) + self.inputs += self.vars + self.inputs = list(set(self.inputs)) + self.trans = pred + return True + + def is_init(self, body, head): + for f in body.children(): + if self.is_inv(f) is not None: + return False + inv = self.is_inv(head) + if inv is None: + return False + self.init = self.subst_vars("x", inv, body) + return True + + def subst_vars(self, prefix, inv, fml): + subst = self.mk_subst(prefix, inv) + self.vars = [ v for (k,v) in subst ] + return substitute(fml, subst) + + def mk_subst(self, prefix, inv): + self.index = 0 + if self.is_inv(inv) is not None: + return [(f, self.mk_bool(prefix)) for f in inv.children()] + else: + vars = self.get_vars(inv) + return [(f, self.mk_bool(prefix)) for f in vars] + + def mk_bool(self, prefix): + self.index += 1 + return Bool("%s%d" % (prefix, self.index)) + + def get_vars(self, f, rs=[]): + if is_var(f): + return z3util.vset(rs + [f], str) + else: + for f_ in f.children(): + rs = self.get_vars(f_, rs) + return z3util.vset(rs, str) + +# Produce a finite domain solver. +# The theory QF_FD covers bit-vector formulas +# and pseudo-Boolean constraints. +# By default cardinality and pseudo-Boolean +# constraints are converted to clauses. To override +# this default for cardinality constraints +# we set sat.cardinality.solver to True + +def fd_solver(): + s = SolverFor("QF_FD") + s.set("sat.cardinality.solver", True) + return s + + +# negate, avoid double negation +def negate(f): + if is_not(f): + return f.arg(0) + else: + return Not(f) + +def cube2clause(cube): + return Or([negate(f) for f in cube]) + +class State: + def __init__(self, s): + self.R = set([]) + self.solver = s + + def add(self, clause): + if clause not in self.R: + self.R |= { clause } + self.solver.add(clause) + +class Goal: + def __init__(self, cube, parent, level): + self.level = level + self.cube = cube + self.parent = parent + +def is_seq(f): + return isinstance(f, list) or isinstance(f, tuple) or isinstance(f, AstVector) + +# Check if the initial state is bad +def check_disjoint(a, b): + s = fd_solver() + s.add(a) + s.add(b) + return unsat == s.check() + + +# Remove clauses that are subsumed +def prune(R): + removed = set([]) + s = fd_solver() + for f1 in R: + s.push() + for f2 in R: + if f2 not in removed: + s.add(Not(f2) if f1.eq(f2) else f2) + if s.check() == unsat: + removed |= { f1 } + s.pop() + return R - removed + +class MiniIC3: + def __init__(self, init, trans, goal, x0, inputs, xn): + self.x0 = x0 + self.inputs = inputs + self.xn = xn + self.init = init + self.bad = goal + self.trans = trans + self.min_cube_solver = fd_solver() + self.min_cube_solver.add(Not(trans)) + self.goals = [] + s = State(fd_solver()) + s.add(init) + s.solver.add(trans) + self.states = [s] + self.s_bad = fd_solver() + self.s_good = fd_solver() + self.s_bad.add(self.bad) + self.s_good.add(Not(self.bad)) + + def next(self, f): + if is_seq(f): + return [self.next(f1) for f1 in f] + return substitute(f, zip(self.x0, self.xn)) + + def prev(self, f): + if is_seq(f): + return [self.prev(f1) for f1 in f] + return substitute(f, zip(self.xn, self.x0)) + + def add_solver(self): + s = fd_solver() + s.add(self.trans) + self.states += [State(s)] + + def R(self, i): + return And(self.states[i].R) + + # Check if there are two states next to each other that have the same clauses. + def is_valid(self): + i = 1 + while i + 1 < len(self.states): + if not (self.states[i].R - self.states[i+1].R): + return And(prune(self.states[i].R)) + i += 1 + return None + + def value2literal(self, m, x): + value = m.eval(x) + if is_true(value): + return x + if is_false(value): + return Not(x) + return None + + def values2literals(self, m, xs): + p = [self.value2literal(m, x) for x in xs] + return [x for x in p if x is not None] + + def project0(self, m): + return self.values2literals(m, self.x0) + + def projectI(self, m): + return self.values2literals(m, self.inputs) + + def projectN(self, m): + return self.values2literals(m, self.xn) + + # Determine if there is a cube for the current state + # that is potentially reachable. + def unfold(self): + core = [] + self.s_bad.push() + R = self.R(len(self.states)-1) + self.s_bad.add(R) + is_sat = self.s_bad.check() + if is_sat == sat: + m = self.s_bad.model() + cube = self.project0(m) + props = cube + self.projectI(m) + self.s_good.push() + self.s_good.add(R) + is_sat2 = self.s_good.check(props) + assert is_sat2 == unsat + core = self.s_good.unsat_core() + core = [c for c in core if c in set(cube)] + self.s_good.pop() + self.s_bad.pop() + return is_sat, core + + # Block a cube by asserting the clause corresponding to its negation + def block_cube(self, i, cube): + self.assert_clause(i, cube2clause(cube)) + + # Add a clause to levels 0 until i + def assert_clause(self, i, clause): + for j in range(i + 1): + self.states[j].add(clause) + + # minimize cube that is core of Dual solver. + # this assumes that props & cube => Trans + def minimize_cube(self, cube, inputs, lits): + is_sat = self.min_cube_solver.check(lits + [c for c in cube] + [i for i in inputs]) + assert is_sat == unsat + core = self.min_cube_solver.unsat_core() + assert core + return [c for c in core if c in set(cube)] + + # push a goal on a heap + def push_heap(self, goal): + heapq.heappush(self.goals, (goal.level, goal)) + + # A state s0 and level f0 such that + # not(s0) is f0-1 inductive + def ic3_blocked(self, s0, f0): + self.push_heap(Goal(self.next(s0), None, f0)) + while self.goals: + f, g = heapq.heappop(self.goals) + sys.stdout.write("%d." % f) + sys.stdout.flush() + # Not(g.cube) is f-1 invariant + if f == 0: + print("") + return g + cube, f, is_sat = self.is_inductive(f, g.cube) + if is_sat == unsat: + self.block_cube(f, self.prev(cube)) + if f < f0: + self.push_heap(Goal(g.cube, g.parent, f + 1)) + elif is_sat == sat: + self.push_heap(Goal(cube, g, f - 1)) + self.push_heap(g) + else: + return is_sat + print("") + return None + + # Rudimentary generalization: + # If the cube is already unsat with respect to transition relation + # extract a core (not necessarily minimal) + # otherwise, just return the cube. + def generalize(self, cube, f): + s = self.states[f - 1].solver + if unsat == s.check(cube): + core = s.unsat_core() + if not check_disjoint(self.init, self.prev(And(core))): + return core, f + return cube, f + + # Check if the negation of cube is inductive at level f + def is_inductive(self, f, cube): + s = self.states[f - 1].solver + s.push() + s.add(self.prev(Not(And(cube)))) + is_sat = s.check(cube) + if is_sat == sat: + m = s.model() + s.pop() + if is_sat == sat: + cube = self.next(self.minimize_cube(self.project0(m), self.projectI(m), self.projectN(m))) + elif is_sat == unsat: + cube, f = self.generalize(cube, f) + return cube, f, is_sat + + def run(self): + if not check_disjoint(self.init, self.bad): + return "goal is reached in initial state" + level = 0 + while True: + inv = self.is_valid() + if inv is not None: + return inv + is_sat, cube = self.unfold() + if is_sat == unsat: + level += 1 + print("Unfold %d" % level) + sys.stdout.flush() + self.add_solver() + elif is_sat == sat: + cex = self.ic3_blocked(cube, level) + if cex is not None: + return cex + else: + return is_sat + +def test(file): + h2t = Horn2Transitions() + h2t.parse(file) + mp = MiniIC3(h2t.init, h2t.trans, h2t.goal, h2t.xs, h2t.inputs, h2t.xns) + result = mp.run() + if isinstance(result, Goal): + g = result + print("Trace") + while g: + print(g.level, g.cube) + g = g.parent + return + if isinstance(result, ExprRef): + print("Invariant:\n%s " % result) + return + print(result) + +test("data/horn1.smt2") +test("data/horn2.smt2") +test("data/horn3.smt2") +test("data/horn4.smt2") +test("data/horn5.smt2") +test("data/horn6.smt2") + + + +""" +# TBD: Quip variant of IC3 + +must = True +may = False + +class QGoal: + def __init__(self, cube, parent, level, must): + self.level = level + self.cube = cube + self.parent = parent + self.must = must + +class Quip(MiniIC3): + + # prev & tras -> r', such that r' intersects with cube + def add_reachable(self, prev, cube): + s = fd_solver() + s.add(self.trans) + s.add(prev) + s.add(Or(cube)) + is_sat = s.check() + assert is_sat == sat + m = s.model(); + result = self.values2literals(m, cube) + assert result + self.reachable.add(result) + + # A state s0 and level f0 such that + # not(s0) is f0-1 inductive + def quip_blocked(self, s0, f0): + self.push_heap(QGoal(self.next(s0), None, f0, must)) + while self.goals: + f, g = heapq.heappop(self.goals) + sys.stdout.write("%d." % f) + sys.stdout.flush() + if f == 0: + if g.must: + print("") + return g + self.add_reachable(self.init, p.parent.cube) + continue + + # TBD + return None + + + def run(self): + if not check_disjoint(self.init, self.bad): + return "goal is reached in initial state" + level = 0 + while True: + inv = self.is_valid() + if inv is not None: + return inv + is_sat, cube = self.unfold() + if is_sat == unsat: + level += 1 + print("Unfold %d" % level) + sys.stdout.flush() + self.add_solver() + elif is_sat == sat: + cex = self.quipie_blocked(cube, level) + if cex is not None: + return cex + else: + return is_sat + +""" diff --git a/examples/python/rc2.py b/examples/python/rc2.py new file mode 100644 index 000000000..10bd83469 --- /dev/null +++ b/examples/python/rc2.py @@ -0,0 +1,149 @@ +# RC2 algorithm +# basic version with some optimizations +# - process soft constraints in order of highest values first. +# - extract multiple cores, not just one +# - use built-in cardinality constraints, cheap core minimization. +# +# See also https://github.com/pysathq/pysat and papers in CP 2014, JSAT 2015. + +from z3 import * + +def tt(s, f): + return is_true(s.model().eval(f)) + +def add(Ws, f, w): + Ws[f] = w + (Ws[f] if f in Ws else 0) + +def sub(Ws, f, w): + w1 = Ws[f] + if w1 > w: + Ws[f] = w1 - w + else: + del(Ws[f]) + +class RC2: + + def __init__(self, s): + self.bounds = {} + self.names = {} + self.solver = s + self.solver.set("sat.cardinality.solver", True) + self.solver.set("sat.core.minimize", True) + self.solver.set("sat.core.minimize_partial", True) + + def at_most(self, S, k): + fml = simplify(AtMost(S + [k])) + if fml in self.names: + return self.names[fml] + name = Bool("%s" % fml) + self.solver.add(Implies(name, fml)) + self.bounds[name] = (S, k) + sel.names[fml] = name + return name + + def print_cost(self): + print("cost [", self.min_cost, ":", self.max_cost, "]") + + def update_max_cost(self): + self.max_cost = min(self.max_cost, self.get_cost()) + self.print_cost() + + # sort W, and incrementally add elements of W + # in sorted order to prefer cores with high weight. + def check(self, Ws): + ws = sorted(list(Ws), lambda f,w : -w) + # print(ws) + i = 0 + while i < len(ws): + j = i + # increment j until making 5% progress or exhausting equal weight entries + while (j < len(ws) and ws[j][1] == ws[i][1]) or (i > 0 and (i - j)*20 < len(ws)): + j += 1 + i = j + r = self.solver.check(ws[j][0] for j in range(i)) + if r == sat: + self.update_max_cost() + else: + return r + return sat + + def get_cost(self): + return sum(self.Ws0[c] for c in self.Ws0 if not tt(self.solver, c)) + + # Retrieve independendent cores from Ws + def get_cores(self, Ws): + cores = [] + while unsat == self.check(Ws): + core = list(self.solver.unsat_core()) + print (self.solver.statistics()) + if not core: + return unsat + w = min([Ws[c] for c in core]) + for f in core: + sub(Ws, f, w) + cores += [(core, w)] + self.update_max_cost() + return cores + + # Add new soft constraints to replace core + # with weight w. Allow to weaken at most + # one element of core. Elements that are + # cardinality constraints are weakened by + # increasing their bounds. Non-cardinality + # constraints are weakened to "true". They + # correspond to the constraint Not(s) <= 0, + # so weakening produces Not(s) <= 1, which + # is a tautology. + def update_bounds(self, Ws, core, w): + for f in core: + if f in self.bounds: + S, k = self.bounds[f] + if k + 1 < len(S): + add(Ws, self.at_most(S, k + 1), w) + add(Ws, self.at_most([mk_not(f) for f in core], 1), w) + + # Ws are weighted soft constraints + # Whenever there is an unsatisfiable core over ws + # increase the limit of each soft constraint from a bound + # and create a soft constraint that limits the number of + # increased bounds to be at most one. + def maxsat(self, Ws): + self.min_cost = 0 + self.max_cost = sum(Ws[c] for c in Ws) + self.Ws0 = Ws.copy() + while True: + cores = self.get_cores(Ws) + if not cores: + break + if cores == unsat: + return unsat + for (core, w) in cores: + self.min_cost += w + self.print_cost() + self.update_bounds(Ws, core, w) + return sel.min_cost, { f for f in self.Ws0 if not tt(self.solver, f) } + + def from_file(self, file): + opt = Optimize() + opt.from_file(file) + self.solver.add(opt.assertions()) + obj = opt.objectives()[0] + Ws = {} + for f in obj.children(): + assert(f.arg(1).as_long() == 0) + add(Ws, f.arg(0), f.arg(2).as_long()) + return self.maxsat(Ws) + +def main(file): + s = SolverFor("QF_FD") + rc2 = RC2(s) + set_param(verbose=0) + cost, falses = rc2.from_file(file) + print(cost) + print(s.statistics()) + +if len(sys.argv) > 1: + main(sys.argv[1]) + +# main() + diff --git a/examples/tptp/CMakeLists.txt b/examples/tptp/CMakeLists.txt index 8e8dfb8ea..7870e5408 100644 --- a/examples/tptp/CMakeLists.txt +++ b/examples/tptp/CMakeLists.txt @@ -7,8 +7,8 @@ find_package(Z3 REQUIRED CONFIG # `NO_DEFAULT_PATH` is set so that -DZ3_DIR has to be passed to find Z3. - # This should prevent us from accidently picking up an installed - # copy of Z3. This is here to benefit Z3's build sytem when building + # This should prevent us from accidentally picking up an installed + # copy of Z3. This is here to benefit Z3's build system when building # this project. When making your own project you probably shouldn't # use this option. NO_DEFAULT_PATH diff --git a/examples/tptp/README b/examples/tptp/README index c28a53da4..b3edfe6a8 100644 --- a/examples/tptp/README +++ b/examples/tptp/README @@ -5,9 +5,9 @@ in the build directory. This command will create the executable tptp. On Windows, you can just execute it. -On OSX and Linux, you must install z3 first using +On macOS and Linux, you must install z3 first using sudo make install -OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (OSX) +OR update LD_LIBRARY_PATH (Linux) or DYLD_LIBRARY_PATH (macOS) with the build directory. You need that to be able to find the Z3 shared library. diff --git a/examples/tptp/tptp5.cpp b/examples/tptp/tptp5.cpp index facbf6c0a..1a1e31f0a 100644 --- a/examples/tptp/tptp5.cpp +++ b/examples/tptp/tptp5.cpp @@ -233,7 +233,7 @@ class env { void check_arity(unsigned num_args, unsigned arity) { if (num_args != arity) { - throw failure_ex("arity missmatch"); + throw failure_ex("arity mismatch"); } } @@ -1337,7 +1337,7 @@ public: } } else if (e.is_quantifier()) { - Z3_bool is_forall = Z3_is_quantifier_forall(ctx, e); + bool is_forall = Z3_is_quantifier_forall(ctx, e); unsigned nb = Z3_get_quantifier_num_bound(ctx, e); out << (is_forall?"!":"?") << "["; diff --git a/noarch/repodata.json b/noarch/repodata.json new file mode 100644 index 000000000..e69de29bb diff --git a/noarch/repodata.json.bz2 b/noarch/repodata.json.bz2 new file mode 100644 index 000000000..b56f3b974 Binary files /dev/null and b/noarch/repodata.json.bz2 differ diff --git a/package/Microsoft.Z3.x64.nuspec b/package/Microsoft.Z3.x64.nuspec new file mode 100644 index 000000000..506e5f9c7 --- /dev/null +++ b/package/Microsoft.Z3.x64.nuspec @@ -0,0 +1,22 @@ + + + + Microsoft.Z3.x64 + $(releaseVersion) + © Microsoft Corporation. All rights reserved. + Microsoft + https://raw.githubusercontent.com/Z3Prover/z3/$(releaseCommitHash)/package/icon.jpg + https://github.com/Z3Prover/z3 + https://raw.githubusercontent.com/Z3Prover/z3/$(releaseCommitHash)/LICENSE.txt + + true + Z3 is a satisfiability modulo theories solver from Microsoft Research. + smt constraint solver theorem prover + en + + diff --git a/package/Microsoft.Z3.x64.targets b/package/Microsoft.Z3.x64.targets new file mode 100644 index 000000000..a5b636f69 --- /dev/null +++ b/package/Microsoft.Z3.x64.targets @@ -0,0 +1,10 @@ + + + + + false + libz3.dll + PreserveNewest + + + diff --git a/package/PackageCreationDirections.md b/package/PackageCreationDirections.md new file mode 100644 index 000000000..6aaee5a1d --- /dev/null +++ b/package/PackageCreationDirections.md @@ -0,0 +1,34 @@ +# Z3 NuGet packaging + +## Creation + + 1. After tagging a commit for release, sign Microsoft.Z3.dll and libz3.dll (both x86 and x64 versions) with Microsoft's Authenticode certificate + 2. Test the signed DLLs with the `Get-AuthenticodeSignature` PowerShell commandlet + 3. Create the following directory structure for the x64 package (for x86, substitute the "x64" strings for "x86" and use x86 DLLs): + ``` + +-- Microsoft.Z3.x64 + | +-- Microsoft.Z3.x64.nuspec + | +-- lib + | +-- net40 + | +-- Microsoft.Z3.dll + | +-- build + | +-- Microsoft.Z3.x64.targets + | +-- libz3.dll + ``` + 4. Open the nuspec file and fill in the appropriate macro values: + * $(releaseVersion) - the Z3 version being released in this package + * $(releaseCommitHash) - hash of the release commit (there are several of these) + 5. Run `nuget pack Microsoft.Z3.x64\Microsoft.Z3.x64.nuspec` + 6. Test the resulting nupkg file (described below) then submit the package for signing before uploading to NuGet.org + +## Testing + + 1. Create a directory on your machine at C:\nuget-test-source + 2. Put the Microsoft.Z3.x64.nupkg file in the directory + 3. Open Visual Studio 2017, create a new C# project, then right click the project and click "Manage NuGet packages" + 4. Add a new package source - your C:\nuget-test-source directory + 5. Find the Microsoft.Z3.x64 package, ensuring in preview window that icon is present and all fields correct + 6. Install the Microsoft.Z3.x64 package, ensuring you are asked to accept the license + 7. Build your project. Check the output directory to ensure both Microsoft.Z3.dll and libz3.dll are present + 8. Import Microsoft.Z3 to your project then add a simple line of code like `using (var ctx = new Context()) { }`; build then run your project to ensure the assemblies load properly + \ No newline at end of file diff --git a/package/icon.jpg b/package/icon.jpg new file mode 100644 index 000000000..a862aa824 Binary files /dev/null and b/package/icon.jpg differ diff --git a/scripts/mk_genfile_common.py b/scripts/mk_genfile_common.py index 7fa6d4041..a65b41026 100644 --- a/scripts/mk_genfile_common.py +++ b/scripts/mk_genfile_common.py @@ -692,31 +692,35 @@ def mk_install_tactic_cpp_internal(h_files_full_path, path): fout.write('#include "cmd_context/tactic_cmds.h"\n') fout.write('#include "cmd_context/cmd_context.h"\n') tactic_pat = re.compile('[ \t]*ADD_TACTIC\(.*\)') - probe_pat = re.compile('[ \t]*ADD_PROBE\(.*\)') + probe_pat = re.compile('[ \t]*ADD_PROBE\(.*\)') for h_file in sorted_headers_by_component(h_files_full_path): added_include = False - with open(h_file, 'r') as fin: - for line in fin: - if tactic_pat.match(line): - if not added_include: - added_include = True - fout.write('#include "%s"\n' % path_after_src(h_file)) - try: - eval(line.strip('\n '), eval_globals, None) - except Exception as e: - _logger.error("Failed processing ADD_TACTIC command at '{}'\n{}".format( - fullname, line)) - raise e - if probe_pat.match(line): - if not added_include: - added_include = True - fout.write('#include "%s"\n' % path_after_src(h_file)) - try: - eval(line.strip('\n '), eval_globals, None) - except Exception as e: - _logger.error("Failed processing ADD_PROBE command at '{}'\n{}".format( - fullname, line)) - raise e + try: + with open(h_file, 'r') as fin: + for line in fin: + if tactic_pat.match(line): + if not added_include: + added_include = True + fout.write('#include "%s"\n' % path_after_src(h_file)) + try: + eval(line.strip('\n '), eval_globals, None) + except Exception as e: + _logger.error("Failed processing ADD_TACTIC command at '{}'\n{}".format( + fullname, line)) + raise e + if probe_pat.match(line): + if not added_include: + added_include = True + fout.write('#include "%s"\n' % path_after_src(h_file)) + try: + eval(line.strip('\n '), eval_globals, None) + except Exception as e: + _logger.error("Failed processing ADD_PROBE command at '{}'\n{}".format( + fullname, line)) + raise e + except Exception as e: + _logger.error("Failed to read file {}\n".format(h_file)) + raise e # First pass will just generate the tactic factories fout.write('#define ADD_TACTIC_CMD(NAME, DESCR, CODE) ctx.insert(alloc(tactic_cmd, symbol(NAME), DESCR, [](ast_manager &m, const params_ref &p) { return CODE; }))\n') fout.write('#define ADD_PROBE(NAME, DESCR, PROBE) ctx.insert(alloc(probe_info, symbol(NAME), DESCR, PROBE))\n') diff --git a/scripts/mk_nuget_release.py b/scripts/mk_nuget_release.py new file mode 100644 index 000000000..c5079ed2c --- /dev/null +++ b/scripts/mk_nuget_release.py @@ -0,0 +1,118 @@ +# +# Copyright (c) 2018 Microsoft Corporation +# + +# 1. download releases from github +# 2. copy over libz3.dll for the different architectures +# 3. copy over Microsoft.Z3.dll from suitable distribution +# 4. copy nuspec file from packages +# 5. call nuget pack + +import json +import os +import urllib.request +import zipfile +import sys +import os.path +import shutil +import subprocess +import mk_util +import mk_project + +data = json.loads(urllib.request.urlopen("https://api.github.com/repos/Z3Prover/z3/releases/latest").read().decode()) + +version_str = data['tag_name'] + +print(version_str) + +def mk_dir(d): + if not os.path.exists(d): + os.makedirs(d) + +def download_installs(): + for asset in data['assets']: + url = asset['browser_download_url'] + name = asset['name'] + print("Downloading ", url) + sys.stdout.flush() + urllib.request.urlretrieve(url, "packages/%s" % name) + +os_info = {"z64-ubuntu-14" : ('so', 'ubuntu.14.04-x64'), + 'ubuntu-16' : ('so', 'ubuntu.16.04-x64'), + 'x64-win' : ('dll', 'win-x64'), + 'x86-win' : ('dll', 'win-x86'), + 'osx' : ('dylib', 'macos'), + 'debian' : ('so', 'debian.8-x64') } + +def classify_package(f): + for os_name in os_info: + if os_name in f: + ext, dst = os_info[os_name] + return os_name, f[:-4], ext, dst + return None + +def unpack(): + shutil.rmtree("out", ignore_errors=True) + # unzip files in packages + # out + # +- runtimes + # +- win-x64 + # +- win-x86 + # +- ubuntu.16.04-x64 + # +- ubuntu.14.04-x64 + # +- debian.8-x64 + # +- macos + # + + for f in os.listdir("packages"): + print(f) + if f.endswith(".zip") and classify_package(f): + os_name, package_dir, ext, dst = classify_package(f) + path = os.path.abspath(os.path.join("packages", f)) + zip_ref = zipfile.ZipFile(path, 'r') + zip_ref.extract("%s/bin/libz3.%s" % (package_dir, ext), "tmp") + mk_dir("out/runtimes/%s/native" % dst) + shutil.move("tmp/%s/bin/libz3.%s" % (package_dir, ext), "out/runtimes/%s/native/." % dst, "/y") + if "x64-win" in f: + mk_dir("out/lib/netstandard1.4/") + for b in ["Microsoft.Z3.dll"]: + zip_ref.extract("%s/bin/%s" % (package_dir, b), "tmp") + shutil.move("tmp/%s/bin/%s" % (package_dir, b), "out/lib/netstandard1.4/%s" % b) + +def create_nuget_spec(): + contents = """ + + + Microsoft.Z3 + %s + Microsoft + Z3 is a satisfiability modulo theories solver from Microsoft Research. + Copyright Microsoft Corporation. All rights reserved. + smt constraint solver theorem prover + https://raw.githubusercontent.com/Z3Prover/z3/master/package/icon.jpg + https://github.com/Z3Prover/z3 + https://raw.githubusercontent.com/Z3Prover/z3/master/LICENSE.txt + + true + en + +""" + + with open("out/Microsoft.Z3.nuspec", 'w') as f: + f.write(contents % version_str[3:]) + +def create_nuget_package(): + subprocess.call(["nuget", "pack"], cwd="out") + +def main(): + mk_dir("packages") + download_installs() + unpack() + create_nuget_spec() + create_nuget_package() + + +main() diff --git a/scripts/mk_project.py b/scripts/mk_project.py index ca62f5c5f..58d087f32 100644 --- a/scripts/mk_project.py +++ b/scripts/mk_project.py @@ -7,10 +7,13 @@ ############################################ from mk_util import * +def init_version(): + set_version(4, 8, 5, 0) + # Z3 Project definition def init_project_def(): - set_version(4, 8, 0, 0) - add_lib('util', []) + init_version() + add_lib('util', [], includes2install = ['z3_version.h']) add_lib('polynomial', ['util'], 'math/polynomial') add_lib('sat', ['util']) add_lib('nlsat', ['polynomial', 'sat']) @@ -84,6 +87,7 @@ def init_project_def(): export_files=API_files, staging_link='python') add_dot_net_dll('dotnet', ['api_dll'], 'api/dotnet', dll_name='Microsoft.Z3', assembly_info_dir='Properties', default_key_file='src/api/dotnet/Microsoft.Z3.snk') + add_dot_net_core_dll('dotnetcore', ['api_dll'], 'api/dotnet', dll_name='Microsoft.Z3', assembly_info_dir='Properties', default_key_file='src/api/dotnet/Microsoft.Z3.snk') add_java_dll('java', ['api_dll'], 'api/java', dll_name='libz3java', package_name="com.microsoft.z3", manifest_file='manifest') add_ml_lib('ml', ['api_dll'], 'api/ml', lib_name='libz3ml') add_hlib('cpp', 'api/c++', includes2install=['z3++.h']) diff --git a/scripts/mk_unix_dist.py b/scripts/mk_unix_dist.py index 00cf3c706..bad51528f 100644 --- a/scripts/mk_unix_dist.py +++ b/scripts/mk_unix_dist.py @@ -23,6 +23,7 @@ VERBOSE=True DIST_DIR='dist' FORCE_MK=False DOTNET_ENABLED=True +DOTNET_CORE_ENABLED=False DOTNET_KEY_FILE=None JAVA_ENABLED=True GIT_HASH=False @@ -55,6 +56,7 @@ def display_help(): print(" -b , --build= subdirectory where x86 and x64 Z3 versions will be built (default: build-dist).") print(" -f, --force force script to regenerate Makefiles.") print(" --nodotnet do not include .NET bindings in the binary distribution files.") + print(" --dotnetcore build for dotnet core.") print(" --dotnet-key= sign the .NET assembly with the private key in .") print(" --nojava do not include Java bindings in the binary distribution files.") print(" --nopython do not include Python bindings in the binary distribution files.") @@ -63,7 +65,7 @@ def display_help(): # Parse configuration option for mk_make script def parse_options(): - global FORCE_MK, JAVA_ENABLED, GIT_HASH, DOTNET_ENABLED, DOTNET_KEY_FILE + global FORCE_MK, JAVA_ENABLED, GIT_HASH, DOTNET_ENABLED, DOTNET_CORE_ENABLED, DOTNET_KEY_FILE path = BUILD_DIR options, remainder = getopt.gnu_getopt(sys.argv[1:], 'b:hsf', ['build=', 'help', @@ -71,6 +73,7 @@ def parse_options(): 'force', 'nojava', 'nodotnet', + 'dotnetcore', 'dotnet-key=', 'githash', 'nopython' @@ -88,6 +91,9 @@ def parse_options(): FORCE_MK = True elif opt == '--nodotnet': DOTNET_ENABLED = False + elif opt == '--dotnetcore': + DOTNET_CORE_ENABLED = True + DOTNET_ENABLED = False elif opt == '--nopython': PYTHON_ENABLED = False elif opt == '--dotnet-key': @@ -108,7 +114,11 @@ def check_build_dir(path): def mk_build_dir(path): if not check_build_dir(path) or FORCE_MK: opts = ["python", os.path.join('scripts', 'mk_make.py'), "-b", path, "--staticlib"] - if DOTNET_ENABLED: + if DOTNET_CORE_ENABLED: + opts.append('--dotnetcore') + if not DOTNET_KEY_FILE is None: + opts.append('--dotnet-key=' + DOTNET_KEY_FILE) + elif DOTNET_ENABLED: opts.append('--dotnet') if not DOTNET_KEY_FILE is None: opts.append('--dotnet-key=' + DOTNET_KEY_FILE) @@ -186,7 +196,8 @@ def mk_dist_dir(): build_path = BUILD_DIR dist_path = os.path.join(DIST_DIR, get_z3_name()) mk_dir(dist_path) - mk_util.DOTNET_ENABLED = DOTNET_ENABLED + mk_util.DOTNET_CORE_ENABLED = DOTNET_CORE_ENABLED + mk_util.DOTNET_ENABLED = DOTNET_ENABLED mk_util.DOTNET_KEY_FILE = DOTNET_KEY_FILE mk_util.JAVA_ENABLED = JAVA_ENABLED mk_util.PYTHON_ENABLED = PYTHON_ENABLED diff --git a/scripts/mk_util.py b/scripts/mk_util.py index 770e118ee..9076b582f 100644 --- a/scripts/mk_util.py +++ b/scripts/mk_util.py @@ -37,6 +37,7 @@ OCAMLOPT=getenv("OCAMLOPT", "ocamlopt") OCAML_LIB=getenv("OCAML_LIB", None) OCAMLFIND=getenv("OCAMLFIND", "ocamlfind") CSC=getenv("CSC", None) +DOTNET="dotnet" GACUTIL=getenv("GACUTIL", 'gacutil') # Standard install directories relative to PREFIX INSTALL_BIN_DIR=getenv("Z3_INSTALL_BIN_DIR", "bin") @@ -60,6 +61,7 @@ PATTERN_COMPONENT='pattern' UTIL_COMPONENT='util' API_COMPONENT='api' DOTNET_COMPONENT='dotnet' +DOTNET_CORE_COMPONENT='dotnetcore' JAVA_COMPONENT='java' ML_COMPONENT='ml' CPP_COMPONENT='cpp' @@ -87,6 +89,8 @@ VS_PROJ = False TRACE = False PYTHON_ENABLED=False DOTNET_ENABLED=False +DOTNET_CORE_ENABLED=False +ESRP_SIGN=False DOTNET_KEY_FILE=getenv("Z3_DOTNET_KEY_FILE", None) JAVA_ENABLED=False ML_ENABLED=False @@ -396,7 +400,7 @@ def check_java(): libdirs = m.group(1).split(',') for libdir in libdirs: q = os.path.dirname(libdir) - if cdirs.count(q) == 0: + if cdirs.count(q) == 0 and len(q) > 0: cdirs.append(q) t.close() @@ -452,6 +456,13 @@ def check_dotnet(): if r != 0: raise MKException('Failed testing gacutil. Set environment variable GACUTIL with the path to gacutil.') +def check_dotnet_core(): + if not IS_WINDOWS: + return + r = exec_cmd([DOTNET, '--help']) + if r != 0: + raise MKException('Failed testing dotnet. Make sure to install and configure dotnet core utilities') + def check_ml(): t = TempFile('hello.ml') t.add('print_string "Hello world!\n";;') @@ -553,6 +564,11 @@ def set_version(major, minor, build, revision): def get_version(): return (VER_MAJOR, VER_MINOR, VER_BUILD, VER_REVISION) +def get_version_string(n): + if n == 3: + return "{}.{}.{}".format(VER_MAJOR,VER_MINOR,VER_BUILD) + return "{}.{}.{}.{}".format(VER_MAJOR,VER_MINOR,VER_BUILD,VER_REVISION) + def build_static_lib(): return STATIC_LIB @@ -652,6 +668,7 @@ def display_help(exit_code): if IS_WINDOWS: print(" -v, --vsproj generate Visual Studio Project Files.") print(" --optimize generate optimized code during linking.") + print(" --dotnetcore generate .NET platform bindings.") print(" --dotnet generate .NET bindings.") print(" --dotnet-key= sign the .NET assembly using the private key in .") print(" --java generate Java bindings.") @@ -690,14 +707,14 @@ def display_help(exit_code): # Parse configuration option for mk_make script def parse_options(): global VERBOSE, DEBUG_MODE, IS_WINDOWS, VS_X64, ONLY_MAKEFILES, SHOW_CPPS, VS_PROJ, TRACE, VS_PAR, VS_PAR_NUM - global DOTNET_ENABLED, DOTNET_KEY_FILE, JAVA_ENABLED, ML_ENABLED, JS_ENABLED, STATIC_LIB, STATIC_BIN, PREFIX, GMP, PYTHON_PACKAGE_DIR, GPROF, GIT_HASH, GIT_DESCRIBE, PYTHON_INSTALL_ENABLED, PYTHON_ENABLED + global DOTNET_ENABLED, DOTNET_CORE_ENABLED, DOTNET_KEY_FILE, JAVA_ENABLED, ML_ENABLED, JS_ENABLED, STATIC_LIB, STATIC_BIN, PREFIX, GMP, PYTHON_PACKAGE_DIR, GPROF, GIT_HASH, GIT_DESCRIBE, PYTHON_INSTALL_ENABLED, PYTHON_ENABLED, ESRP_SIGN global LINUX_X64, SLOW_OPTIMIZE, USE_OMP, LOG_SYNC global GUARD_CF, ALWAYS_DYNAMIC_BASE try: options, remainder = getopt.gnu_getopt(sys.argv[1:], 'b:df:sxhmcvtnp:gj', ['build=', 'debug', 'silent', 'x64', 'help', 'makefiles', 'showcpp', 'vsproj', 'guardcf', - 'trace', 'dotnet', 'dotnet-key=', 'staticlib', 'prefix=', 'gmp', 'java', 'parallel=', 'gprof', 'js', + 'trace', 'dotnet', 'dotnetcore', 'dotnet-key=', 'esrp', 'staticlib', 'prefix=', 'gmp', 'java', 'parallel=', 'gprof', 'js', 'githash=', 'git-describe', 'x86', 'ml', 'optimize', 'noomp', 'pypkgdir=', 'python', 'staticbin', 'log-sync']) except: print("ERROR: Invalid command line option") @@ -731,8 +748,12 @@ def parse_options(): TRACE = True elif opt in ('-.net', '--dotnet'): DOTNET_ENABLED = True + elif opt in ('--dotnetcore',): + DOTNET_CORE_ENABLED = True elif opt in ('--dotnet-key'): DOTNET_KEY_FILE = arg + elif opt in ('--esrp'): + ESRP_SIGN = True elif opt in ('--staticlib'): STATIC_LIB = True elif opt in ('--staticbin'): @@ -887,6 +908,9 @@ def is_js_enabled(): def is_dotnet_enabled(): return DOTNET_ENABLED +def is_dotnet_core_enabled(): + return DOTNET_CORE_ENABLED + def is_python_enabled(): return PYTHON_ENABLED @@ -1606,6 +1630,23 @@ class PythonInstallComponent(Component): def mk_makefile(self, out): return +def set_key_file(self): + global DOTNET_KEY_FILE + # We need to give the assembly a strong name so that it + # can be installed into the GAC with ``make install`` + if not DOTNET_KEY_FILE is None: + self.key_file = DOTNET_KEY_FILE + + if not self.key_file is None: + if os.path.isfile(self.key_file): + self.key_file = os.path.abspath(self.key_file) + elif os.path.isfile(os.path.join(self.src_dir, self.key_file)): + self.key_file = os.path.abspath(os.path.join(self.src_dir, self.key_file)) + else: + print("Keyfile '%s' could not be found; %s.dll will be unsigned." % (self.key_file, self.dll_name)) + self.key_file = None + + class DotNetDLLComponent(Component): def __init__(self, name, dll_name, path, deps, assembly_info_dir, default_key_file): Component.__init__(self, name, path, deps) @@ -1625,11 +1666,7 @@ class DotNetDLLComponent(Component): pkg_config_template = os.path.join(self.src_dir, '{}.pc.in'.format(self.gac_pkg_name())) substitutions = { 'PREFIX': PREFIX, 'GAC_PKG_NAME': self.gac_pkg_name(), - 'VERSION': "{}.{}.{}.{}".format( - VER_MAJOR, - VER_MINOR, - VER_BUILD, - VER_REVISION) + 'VERSION': get_version_string(4) } pkg_config_output = os.path.join(BUILD_DIR, self.build_dir, @@ -1668,25 +1705,10 @@ class DotNetDLLComponent(Component): '/noconfig', '/nostdlib+', '/reference:mscorlib.dll', - # Under mono this isn't neccessary as mono will search the system - # library paths for libz3.so - '/linkresource:{}.dll'.format(get_component(Z3_DLL_COMPONENT).dll_name), ] ) - # We need to give the assembly a strong name so that it - # can be installed into the GAC with ``make install`` - if not DOTNET_KEY_FILE is None: - self.key_file = DOTNET_KEY_FILE - - if not self.key_file is None: - if os.path.isfile(self.key_file): - self.key_file = os.path.abspath(self.key_file) - elif os.path.isfile(os.path.join(self.src_dir, self.key_file)): - self.key_file = os.path.abspath(os.path.join(self.src_dir, self.key_file)) - else: - print("Keyfile '%s' could not be found; %s.dll will be unsigned." % (self.key_file, self.dll_name)) - self.key_file = None + set_key_file(self) if not self.key_file is None: print("%s.dll will be signed using key '%s'." % (self.dll_name, self.key_file)) @@ -1814,6 +1836,204 @@ class DotNetDLLComponent(Component): pkg_config_file = os.path.join('lib','pkgconfig','{}.pc'.format(self.gac_pkg_name())) MakeRuleCmd.remove_installed_files(out, pkg_config_file) + +# build for dotnet core +class DotNetCoreDLLComponent(Component): + def __init__(self, name, dll_name, path, deps, assembly_info_dir, default_key_file): + Component.__init__(self, name, path, deps) + if dll_name is None: + dll_name = name + if assembly_info_dir is None: + assembly_info_dir = "." + self.dll_name = dll_name + self.assembly_info_dir = assembly_info_dir + self.key_file = default_key_file + + + def mk_makefile(self, out): + if not is_dotnet_core_enabled(): + return + cs_fp_files = [] + for cs_file in get_cs_files(self.src_dir): + cs_fp_files.append(os.path.join(self.to_src_dir, cs_file)) + if self.assembly_info_dir != '.': + for cs_file in get_cs_files(os.path.join(self.src_dir, self.assembly_info_dir)): + cs_fp_files.append(os.path.join(self.to_src_dir, self.assembly_info_dir, cs_file)) + dllfile = '%s.dll' % self.dll_name + out.write('%s: %s$(SO_EXT)' % (dllfile, get_component(Z3_DLL_COMPONENT).dll_name)) + for cs_file in cs_fp_files: + out.write(' ') + out.write(cs_file) + out.write('\n') + + set_key_file(self) + key = "" + if not self.key_file is None: + key = "%s" % self.key_file + key += "\ntrue" + + if VS_X64: + platform = 'x64' + elif VS_ARM: + platform = 'ARM' + else: + platform = 'x86' + + version = get_version_string(3) + + core_csproj_str = """ + + + netstandard1.4 + %s + $(DefineConstants);DOTNET_CORE + portable + Microsoft.Z3 + Library + Microsoft.Z3 + 1.0.4 + %s + true + Microsoft + Microsoft + Z3 is a satisfiability modulo theories solver from Microsoft Research. + Copyright Microsoft Corporation. All rights reserved. + smt constraint solver theorem prover + %s + + + + + + +""" % (platform, version, key, self.to_src_dir) + + mk_dir(os.path.join(BUILD_DIR, 'dotnet')) + csproj = os.path.join('dotnet', 'z3.csproj') + with open(os.path.join(BUILD_DIR, csproj), 'w') as ous: + ous.write(core_csproj_str) + + dotnetCmdLine = [DOTNET, "build", csproj] + + dotnetCmdLine.extend(['-c']) + if DEBUG_MODE: + dotnetCmdLine.extend(['Debug']) + else: + dotnetCmdLine.extend(['Release']) + + path = os.path.join(os.path.abspath(BUILD_DIR), ".") + dotnetCmdLine.extend(['-o', path]) + + MakeRuleCmd.write_cmd(out, ' '.join(dotnetCmdLine)) + self.sign_esrp(out) + out.write('\n') + out.write('%s: %s\n\n' % (self.name, dllfile)) + + def sign_esrp(self, out): + global ESRP_SIGNx + print("esrp-sign", ESRP_SIGN) + if not ESRP_SIGN: + return + + import uuid + guid = str(uuid.uuid4()) + path = os.path.abspath(BUILD_DIR).replace("\\","\\\\") + assemblySignStr = """ +{ + "Version": "1.0.0", + "SignBatches" + : + [ + { + "SourceLocationType": "UNC", + "SourceRootDirectory": "%s", + "DestinationLocationType": "UNC", + "DestinationRootDirectory": "c:\\\\ESRP\\\\output", + "SignRequestFiles": [ + { + "CustomerCorrelationId": "%s", + "SourceLocation": "libz3.dll", + "DestinationLocation": "libz3.dll" + }, + { + "CustomerCorrelationId": "%s", + "SourceLocation": "Microsoft.Z3.dll", + "DestinationLocation": "Microsoft.Z3.dll" + } + ], + "SigningInfo": { + "Operations": [ + { + "KeyCode" : "CP-230012", + "OperationCode" : "SigntoolSign", + "Parameters" : { + "OpusName": "Microsoft", + "OpusInfo": "http://www.microsoft.com", + "FileDigest": "/fd \\"SHA256\\"", + "PageHash": "/NPH", + "TimeStamp": "/tr \\"http://rfc3161.gtm.corp.microsoft.com/TSS/HttpTspServer\\" /td sha256" + }, + "ToolName" : "sign", + "ToolVersion" : "1.0" + }, + { + "KeyCode" : "CP-230012", + "OperationCode" : "SigntoolVerify", + "Parameters" : {}, + "ToolName" : "sign", + "ToolVersion" : "1.0" + } + ] + } + } + ] +} """ % (path, guid, guid) + assemblySign = os.path.join(os.path.abspath(BUILD_DIR), 'dotnet', 'assembly-sign-input.json') + with open(assemblySign, 'w') as ous: + ous.write(assemblySignStr) + outputFile = os.path.join(os.path.abspath(BUILD_DIR), 'dotnet', "esrp-out.json") + esrpCmdLine = ["esrpclient.exe", "sign", "-a", "C:\\esrp\\config\\authorization.json", "-p", "C:\\esrp\\config\\policy.json", "-i", assemblySign, "-o", outputFile] + MakeRuleCmd.write_cmd(out, ' '.join(esrpCmdLine)) + MakeRuleCmd.write_cmd(out, "move /Y C:\\esrp\\output\\libz3.dll .") + MakeRuleCmd.write_cmd(out, "move /Y C:\\esrp\\output\\Microsoft.Z3.dll .") + + + def main_component(self): + return is_dotnet_core_enabled() + + def has_assembly_info(self): + # TBD: is this required for dotnet core given that version numbers are in z3.csproj file? + return True + + + def mk_win_dist(self, build_path, dist_path): + if is_dotnet_core_enabled(): + mk_dir(os.path.join(dist_path, INSTALL_BIN_DIR)) + shutil.copy('%s.dll' % os.path.join(build_path, self.dll_name), + '%s.dll' % os.path.join(dist_path, INSTALL_BIN_DIR, self.dll_name)) + shutil.copy('%s.deps.json' % os.path.join(build_path, self.dll_name), + '%s.deps.json' % os.path.join(dist_path, INSTALL_BIN_DIR, self.dll_name)) + if DEBUG_MODE: + shutil.copy('%s.pdb' % os.path.join(build_path, self.dll_name), + '%s.pdb' % os.path.join(dist_path, INSTALL_BIN_DIR, self.dll_name)) + + def mk_unix_dist(self, build_path, dist_path): + if is_dotnet_core_enabled(): + mk_dir(os.path.join(dist_path, INSTALL_BIN_DIR)) + shutil.copy('%s.dll' % os.path.join(build_path, self.dll_name), + '%s.dll' % os.path.join(dist_path, INSTALL_BIN_DIR, self.dll_name)) + shutil.copy('%s.deps.json' % os.path.join(build_path, self.dll_name), + '%s.deps.json' % os.path.join(dist_path, INSTALL_BIN_DIR, self.dll_name)) + + def mk_install_deps(self, out): + pass + + def mk_install(self, out): + pass + + def mk_uninstall(self, out): + pass + class JavaDLLComponent(Component): def __init__(self, name, dll_name, package_name, manifest_file, path, deps): Component.__init__(self, name, path, deps) @@ -2204,7 +2424,7 @@ class DotNetExampleComponent(ExampleComponent): ExampleComponent.__init__(self, name, path) def is_example(self): - return is_dotnet_enabled() + return is_dotnet_enabled() or is_dotnet_core_enabled() def mk_makefile(self, out): if is_dotnet_enabled(): @@ -2232,6 +2452,48 @@ class DotNetExampleComponent(ExampleComponent): out.write(os.path.join(relative_path, csfile)) out.write('\n') out.write('_ex_%s: %s\n\n' % (self.name, exefile)) + if is_dotnet_core_enabled(): + proj_name = 'dotnet_example.csproj' + out.write('_ex_%s:' % self.name) + for csfile in get_cs_files(self.ex_dir): + out.write(' ') + out.write(os.path.join(self.to_ex_dir, csfile)) + + mk_dir(os.path.join(BUILD_DIR, 'dotnet_example')) + csproj = os.path.join('dotnet_example', proj_name) + if VS_X64: + platform = 'x64' + elif VS_ARM: + platform = 'ARM' + else: + platform = 'x86' + + dotnet_proj_str = """ + + Exe + netcoreapp2.0 + %s + + + + + ..\Microsoft.Z3.dll + + +""" % (platform, self.to_ex_dir) + + with open(os.path.join(BUILD_DIR, csproj), 'w') as ous: + ous.write(dotnet_proj_str) + + out.write('\n') + dotnetCmdLine = [DOTNET, "build", csproj] + dotnetCmdLine.extend(['-c']) + if DEBUG_MODE: + dotnetCmdLine.extend(['Debug']) + else: + dotnetCmdLine.extend(['Release']) + MakeRuleCmd.write_cmd(out, ' '.join(dotnetCmdLine)) + out.write('\n') class JavaExampleComponent(ExampleComponent): def __init__(self, name, path): @@ -2350,6 +2612,10 @@ def add_dot_net_dll(name, deps=[], path=None, dll_name=None, assembly_info_dir=N c = DotNetDLLComponent(name, dll_name, path, deps, assembly_info_dir, default_key_file) reg_component(name, c) +def add_dot_net_core_dll(name, deps=[], path=None, dll_name=None, assembly_info_dir=None, default_key_file=None): + c = DotNetCoreDLLComponent(name, dll_name, path, deps, assembly_info_dir, default_key_file) + reg_component(name, c) + def add_java_dll(name, deps=[], path=None, dll_name=None, package_name=None, manifest_file=None): c = JavaDLLComponent(name, dll_name, package_name, manifest_file, path, deps) reg_component(name, c) @@ -2442,7 +2708,7 @@ def mk_config(): 'SLINK_FLAGS=/nologo /LDd\n' % static_opt) if VS_X64: config.write( - 'CXXFLAGS=/c /Zi /nologo /W3 /WX- /Od /Oy- /D WIN32 /D _AMD64_ /D _DEBUG /D Z3DEBUG /D _CONSOLE /D _TRACE /D _WINDOWS /Gm- /EHsc /RTC1 /GS /fp:precise /Zc:wchar_t /Zc:forScope /Gd /analyze- %s %s\n' % (extra_opt, static_opt)) + 'CXXFLAGS=/c /Zi /nologo /W3 /WX- /Od /Oy- /D WIN32 /D _DEBUG /D Z3DEBUG /D _CONSOLE /D _TRACE /D _WINDOWS /Gm- /EHsc /RTC1 /GS /fp:precise /Zc:wchar_t /Zc:forScope /Gd /analyze- %s %s\n' % (extra_opt, static_opt)) config.write( 'LINK_EXTRA_FLAGS=/link /DEBUG /MACHINE:X64 /SUBSYSTEM:CONSOLE /INCREMENTAL:NO /STACK:8388608 /OPT:REF /OPT:ICF /TLBID:1 /DYNAMICBASE /NXCOMPAT %s\n' 'SLINK_EXTRA_FLAGS=/link /DEBUG /MACHINE:X64 /SUBSYSTEM:WINDOWS /INCREMENTAL:NO /STACK:8388608 /OPT:REF /OPT:ICF /TLBID:1 %s %s\n' % (link_extra_opt, maybe_disable_dynamic_base, link_extra_opt)) @@ -2467,7 +2733,7 @@ def mk_config(): extra_opt = '%s /D _TRACE ' % extra_opt if VS_X64: config.write( - 'CXXFLAGS=/c%s /Zi /nologo /W3 /WX- /O2 /D _EXTERNAL_RELEASE /D WIN32 /D NDEBUG /D _LIB /D _WINDOWS /D _AMD64_ /D _UNICODE /D UNICODE /Gm- /EHsc /GS /fp:precise /Zc:wchar_t /Zc:forScope /Gd /TP %s %s\n' % (GL, extra_opt, static_opt)) + 'CXXFLAGS=/c%s /Zi /nologo /W3 /WX- /O2 /D _EXTERNAL_RELEASE /D WIN32 /D NDEBUG /D _LIB /D _WINDOWS /D _UNICODE /D UNICODE /Gm- /EHsc /GS /fp:precise /Zc:wchar_t /Zc:forScope /Gd /TP %s %s\n' % (GL, extra_opt, static_opt)) config.write( 'LINK_EXTRA_FLAGS=/link%s /MACHINE:X64 /SUBSYSTEM:CONSOLE /INCREMENTAL:NO /STACK:8388608 %s\n' 'SLINK_EXTRA_FLAGS=/link%s /MACHINE:X64 /SUBSYSTEM:WINDOWS /INCREMENTAL:NO /STACK:8388608 %s\n' % (LTCG, link_extra_opt, LTCG, link_extra_opt)) @@ -2589,7 +2855,6 @@ def mk_config(): if is64(): if not sysname.startswith('CYGWIN') and not sysname.startswith('MSYS') and not sysname.startswith('MINGW'): CXXFLAGS = '%s -fPIC' % CXXFLAGS - CPPFLAGS = '%s -D_AMD64_' % CPPFLAGS if sysname == 'Linux': CPPFLAGS = '%s -D_USE_THREAD_LOCAL' % CPPFLAGS elif not LINUX_X64: @@ -2657,6 +2922,8 @@ def mk_config(): if is_dotnet_enabled(): print('C# Compiler: %s' % CSC) print('GAC utility: %s' % GACUTIL) + if is_dotnet_core_enabled(): + print('C# Compiler: %s' % DOTNET) config.close() @@ -2805,8 +3072,8 @@ def get_full_version_string(major, minor, build, revision): # Update files with the version number def mk_version_dot_h(major, minor, build, revision): c = get_component(UTIL_COMPONENT) - version_template = os.path.join(c.src_dir, 'version.h.in') - version_header_output = os.path.join(c.src_dir, 'version.h') + version_template = os.path.join(c.src_dir, 'z3_version.h.in') + version_header_output = os.path.join(c.src_dir, 'z3_version.h') # Note the substitution names are what is used by the CMake # builds system. If you change these you should change them # in the CMake build too @@ -2982,6 +3249,9 @@ def mk_bindings(api_files): dotnet_output_dir = None if is_dotnet_enabled(): dotnet_output_dir = get_component('dotnet').src_dir + elif is_dotnet_core_enabled(): + dotnet_output_dir = os.path.join(BUILD_DIR, 'dotnet') + mk_dir(dotnet_output_dir) java_output_dir = None java_package_name = None if is_java_enabled(): @@ -3010,7 +3280,10 @@ def mk_bindings(api_files): mk_z3consts_ml(api_files) if is_dotnet_enabled(): check_dotnet() - mk_z3consts_dotnet(api_files) + mk_z3consts_dotnet(api_files, dotnet_output_dir) + if is_dotnet_core_enabled(): + check_dotnet_core() + mk_z3consts_dotnet(api_files, dotnet_output_dir) # Extract enumeration types from API files, and add python definitions. def mk_z3consts_py(api_files): @@ -3027,14 +3300,16 @@ def mk_z3consts_py(api_files): print("Generated '{}".format(generated_file)) # Extract enumeration types from z3_api.h, and add .Net definitions -def mk_z3consts_dotnet(api_files): +def mk_z3consts_dotnet(api_files, output_dir): dotnet = get_component(DOTNET_COMPONENT) + if not dotnet: + dotnet = get_component(DOTNET_CORE_COMPONENT) full_path_api_files = [] for api_file in api_files: api_file_c = dotnet.find_file(api_file, dotnet.name) api_file = os.path.join(api_file_c.src_dir, api_file) full_path_api_files.append(api_file) - generated_file = mk_genfile_common.mk_z3consts_dotnet_internal(full_path_api_files, dotnet.src_dir) + generated_file = mk_genfile_common.mk_z3consts_dotnet_internal(full_path_api_files, output_dir) if VERBOSE: print("Generated '{}".format(generated_file)) @@ -3279,7 +3554,7 @@ class MakeRuleCmd(object): needed commands used in Makefile rules Note that several of the method are meant for use during ``make install`` and ``make uninstall``. These methods correctly use - ``$(PREFIX)`` and ``$(DESTDIR)`` and therefore are preferrable + ``$(PREFIX)`` and ``$(DESTDIR)`` and therefore are preferable to writing commands manually which can be error prone. """ @classmethod diff --git a/scripts/mk_win_dist.py b/scripts/mk_win_dist.py index 384e1d080..2a88c625c 100644 --- a/scripts/mk_win_dist.py +++ b/scripts/mk_win_dist.py @@ -25,6 +25,8 @@ VERBOSE=True DIST_DIR='dist' FORCE_MK=False DOTNET_ENABLED=True +DOTNET_CORE_ENABLED=False +ESRP_SIGN=False DOTNET_KEY_FILE=None JAVA_ENABLED=True GIT_HASH=False @@ -62,7 +64,9 @@ def display_help(): print(" -b , --build= subdirectory where x86 and x64 Z3 versions will be built (default: build-dist).") print(" -f, --force force script to regenerate Makefiles.") print(" --nodotnet do not include .NET bindings in the binary distribution files.") + print(" --dotnetcore build for dotnet core.") print(" --dotnet-key= sign the .NET assembly with the private key in .") + print(" --esrp sign with esrp.") print(" --nojava do not include Java bindings in the binary distribution files.") print(" --nopython do not include Python bindings in the binary distribution files.") print(" --githash include git hash in the Zip file.") @@ -72,7 +76,7 @@ def display_help(): # Parse configuration option for mk_make script def parse_options(): - global FORCE_MK, JAVA_ENABLED, GIT_HASH, DOTNET_ENABLED, DOTNET_KEY_FILE, PYTHON_ENABLED, X86ONLY, X64ONLY + global FORCE_MK, JAVA_ENABLED, GIT_HASH, DOTNET_ENABLED, DOTNET_CORE_ENABLED, DOTNET_KEY_FILE, PYTHON_ENABLED, X86ONLY, X64ONLY, ESRP_SIGN path = BUILD_DIR options, remainder = getopt.gnu_getopt(sys.argv[1:], 'b:hsf', ['build=', 'help', @@ -80,7 +84,9 @@ def parse_options(): 'force', 'nojava', 'nodotnet', + 'dotnetcore', 'dotnet-key=', + 'esrp', 'githash', 'nopython', 'x86-only', @@ -99,10 +105,15 @@ def parse_options(): FORCE_MK = True elif opt == '--nodotnet': DOTNET_ENABLED = False + elif opt == '--dotnetcore': + DOTNET_CORE_ENABLED = True + DOTNET_ENABLED = False elif opt == '--nopython': PYTHON_ENABLED = False elif opt == '--dotnet-key': DOTNET_KEY_FILE = arg + elif opt == '--esrp': + ESRP_SIGN = True elif opt == '--nojava': JAVA_ENABLED = False elif opt == '--githash': @@ -124,7 +135,11 @@ def mk_build_dir(path, x64): if not check_build_dir(path) or FORCE_MK: parallel = '--parallel=' + MAKEJOBS opts = ["python", os.path.join('scripts', 'mk_make.py'), parallel, "-b", path] - if DOTNET_ENABLED: + if DOTNET_CORE_ENABLED: + opts.append('--dotnetcore') + if not DOTNET_KEY_FILE is None: + opts.append('--dotnet-key=' + DOTNET_KEY_FILE) + elif DOTNET_ENABLED: opts.append('--dotnet') if not DOTNET_KEY_FILE is None: opts.append('--dotnet-key=' + DOTNET_KEY_FILE) @@ -132,6 +147,8 @@ def mk_build_dir(path, x64): opts.append('--java') if x64: opts.append('-x') + if ESRP_SIGN: + opts.append('--esrp') if GIT_HASH: opts.append('--githash=%s' % mk_util.git_hash()) opts.append('--git-describe') @@ -200,6 +217,7 @@ def get_z3_name(x64): return 'z3-%s.%s.%s-%s-win' % (major, minor, build, platform) def mk_dist_dir(x64): + global ESRP_SIGN if x64: platform = "x64" build_path = BUILD_X64_DIR @@ -208,7 +226,11 @@ def mk_dist_dir(x64): build_path = BUILD_X86_DIR dist_path = os.path.join(DIST_DIR, get_z3_name(x64)) mk_dir(dist_path) - mk_util.DOTNET_ENABLED = DOTNET_ENABLED + mk_util.ESRP_SIGN = ESRP_SIGN + if DOTNET_CORE_ENABLED: + mk_util.DOTNET_CORE_ENABLED = True + else: + mk_util.DOTNET_ENABLED = DOTNET_ENABLED mk_util.DOTNET_KEY_FILE = DOTNET_KEY_FILE mk_util.JAVA_ENABLED = JAVA_ENABLED mk_util.PYTHON_ENABLED = PYTHON_ENABLED @@ -257,19 +279,30 @@ def cp_vs_runtime(x64): else: platform = "x86" vcdir = os.environ['VCINSTALLDIR'] - path = '%sredist\\%s' % (vcdir, platform) - VS_RUNTIME_FILES = [] + path = '%sredist' % vcdir + vs_runtime_files = [] + print("Walking %s" % path) + # Everything changes with every release of VS + # Prior versions of VS had DLLs under "redist\x64" + # There are now several variants of redistributables + # The naming convention defies my understanding so + # we use a "check_root" filter to find some hopefully suitable + # redistributable. + def check_root(root): + return platform in root and ("CRT" in root or "MP" in root) and "onecore" not in root and "debug" not in root for root, dirs, files in os.walk(path): for filename in files: - if fnmatch(filename, '*.dll'): + if fnmatch(filename, '*.dll') and check_root(root): + print("Checking %s %s" % (root, filename)) for pat in VS_RUNTIME_PATS: if pat.match(filename): fname = os.path.join(root, filename) if not os.path.isdir(fname): - VS_RUNTIME_FILES.append(fname) - + vs_runtime_files.append(fname) + if not vs_runtime_files: + raise MKException("Did not find any runtime files to include") bin_dist_path = os.path.join(DIST_DIR, get_dist_path(x64), 'bin') - for f in VS_RUNTIME_FILES: + for f in vs_runtime_files: shutil.copy(f, bin_dist_path) if is_verbose(): print("Copied '%s' to '%s'" % (f, bin_dist_path)) diff --git a/scripts/update_api.py b/scripts/update_api.py index 917df94a2..161c783e8 100755 --- a/scripts/update_api.py +++ b/scripts/update_api.py @@ -61,7 +61,7 @@ def is_obj(ty): return ty >= FIRST_OBJ_ID Type2Str = { VOID : 'void', VOID_PTR : 'void*', INT : 'int', UINT : 'unsigned', INT64 : 'int64_t', UINT64 : 'uint64_t', DOUBLE : 'double', - FLOAT : 'float', STRING : 'Z3_string', STRING_PTR : 'Z3_string_ptr', BOOL : 'Z3_bool', SYMBOL : 'Z3_symbol', + FLOAT : 'float', STRING : 'Z3_string', STRING_PTR : 'Z3_string_ptr', BOOL : 'bool', SYMBOL : 'Z3_symbol', PRINT_MODE : 'Z3_ast_print_mode', ERROR_CODE : 'Z3_error_code' } @@ -584,7 +584,7 @@ def mk_java(java_dir, package_name): java_wrapper.write('extern "C" {\n') java_wrapper.write('#endif\n\n') java_wrapper.write('#ifdef __GNUC__\n#if __GNUC__ >= 4\n#define DLL_VIS __attribute__ ((visibility ("default")))\n#else\n#define DLL_VIS\n#endif\n#else\n#define DLL_VIS\n#endif\n\n') - java_wrapper.write('#if defined(_M_X64) || defined(_AMD64_)\n\n') + java_wrapper.write('#if defined(__LP64__) || defined(_WIN64)\n\n') java_wrapper.write('#define GETLONGAELEMS(T,OLD,NEW) \\\n') java_wrapper.write(' T * NEW = (OLD == 0) ? 0 : (T*) jenv->GetLongArrayElements(OLD, NULL);\n') java_wrapper.write('#define RELEASELONGAELEMS(OLD,NEW) \\\n') @@ -1227,7 +1227,7 @@ def ml_has_plus_type(ts): def ml_unwrap(t, ts, s): if t == STRING: return '(' + ts + ') String_val(' + s + ')' - elif t == BOOL or (type2str(t) == 'Z3_bool'): + elif t == BOOL or (type2str(t) == 'bool'): return '(' + ts + ') Bool_val(' + s + ')' elif t == INT or t == PRINT_MODE or t == ERROR_CODE: return '(' + ts + ') Int_val(' + s + ')' @@ -1248,7 +1248,7 @@ def ml_unwrap(t, ts, s): def ml_set_wrap(t, d, n): if t == VOID: return d + ' = Val_unit;' - elif t == BOOL or (type2str(t) == 'Z3_bool'): + elif t == BOOL or (type2str(t) == 'bool'): return d + ' = Val_bool(' + n + ');' elif t == INT or t == UINT or t == PRINT_MODE or t == ERROR_CODE: return d + ' = Val_int(' + n + ');' @@ -1263,7 +1263,7 @@ def ml_set_wrap(t, d, n): return '*(' + pts + '*)Data_custom_val(' + d + ') = ' + n + ';' def ml_alloc_and_store(t, lhs, rhs): - if t == VOID or t == BOOL or t == INT or t == UINT or t == PRINT_MODE or t == ERROR_CODE or t == INT64 or t == UINT64 or t == DOUBLE or t == STRING or (type2str(t) == 'Z3_bool'): + if t == VOID or t == BOOL or t == INT or t == UINT or t == PRINT_MODE or t == ERROR_CODE or t == INT64 or t == UINT64 or t == DOUBLE or t == STRING or (type2str(t) == 'bool'): return ml_set_wrap(t, lhs, rhs) else: pts = ml_plus_type(type2str(t)) @@ -1328,6 +1328,17 @@ def mk_ml(ml_src_dir, ml_output_dir): mk_z3native_stubs_c(ml_src_dir, ml_output_dir) +z3_long_funs = frozenset([ + 'Z3_solver_check', + 'Z3_solver_check_assumptions', + 'Z3_simplify', + 'Z3_simplify_ex', + ]) + +z3_ml_overrides = frozenset([ + 'Z3_mk_config' + ]) + def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface ml_wrapperf = os.path.join(ml_output_dir, 'z3native_stubs.c') ml_wrapper = open(ml_wrapperf, 'w') @@ -1339,6 +1350,10 @@ def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface ml_pref.close() for name, result, params in _dotnet_decls: + + if name in z3_ml_overrides: + continue + ip = inparams(params) op = outparams(params) ap = arrayparams(params) @@ -1491,6 +1506,10 @@ def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface ml_wrapper.write(' assert(_iter == Val_emptylist);\n\n') i = i + 1 + release_caml_gc= name in z3_long_funs + if release_caml_gc: + ml_wrapper.write('\n caml_release_runtime_system();\n') + ml_wrapper.write('\n /* invoke Z3 function */\n ') if result != VOID: ts = type2str(result) @@ -1499,6 +1518,7 @@ def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface else: ml_wrapper.write('z3rv = ') + # invoke procedure ml_wrapper.write('%s(' % name) i = 0 @@ -1516,6 +1536,14 @@ def mk_z3native_stubs_c(ml_src_dir, ml_output_dir): # C interface i = i + 1 ml_wrapper.write(');\n') + if name in NULLWrapped: + ml_wrapper.write(' if (z3rv_m == NULL) {\n') + ml_wrapper.write(' caml_raise_with_string(*caml_named_value("Z3EXCEPTION"), "Object allocation failed");\n') + ml_wrapper.write(' }\n') + + if release_caml_gc: + ml_wrapper.write('\n caml_acquire_runtime_system();\n') + if have_context and name not in Unwrapped: ml_wrapper.write(' ec = Z3_get_error_code(ctx_p->ctx);\n') ml_wrapper.write(' if (ec != Z3_OK) {\n') @@ -1868,7 +1896,7 @@ def generate_files(api_files, mk_dotnet_wrappers(dotnet_file) if mk_util.is_verbose(): print("Generated '{}'".format(dotnet_file.name)) - + if java_output_dir: mk_java(java_output_dir, java_package_name) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 826f87e8c..c497c19ee 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -166,6 +166,8 @@ foreach (header ${libz3_public_headers}) set_property(TARGET libz3 APPEND PROPERTY PUBLIC_HEADER "${CMAKE_SOURCE_DIR}/src/api/${header}") endforeach() +set_property(TARGET libz3 APPEND PROPERTY + PUBLIC_HEADER "${CMAKE_CURRENT_BINARY_DIR}/util/z3_version.h") install(TARGETS libz3 EXPORT Z3_EXPORTED_TARGETS diff --git a/src/ackermannization/lackr.cpp b/src/ackermannization/lackr.cpp index 8c18df7b2..9130d628c 100644 --- a/src/ackermannization/lackr.cpp +++ b/src/ackermannization/lackr.cpp @@ -220,7 +220,7 @@ lbool lackr::lazy() { lackr_model_constructor mc(m_m, m_info); push_abstraction(); unsigned ackr_head = 0; - while (1) { + while (true) { m_st.m_it++; checkpoint(); TRACE("lackr", tout << "lazy check: " << m_st.m_it << "\n";); diff --git a/src/ackermannization/lackr.h b/src/ackermannization/lackr.h index 98c1988f7..049fb8bb3 100644 --- a/src/ackermannization/lackr.h +++ b/src/ackermannization/lackr.h @@ -102,7 +102,7 @@ class lackr { // // Introduce congruence ackermann lemma for the two given terms. // - bool ackr(app * const t1, app * const t2); + bool ackr(app * t1, app * t2); // // Introduce the ackermann lemma for each pair of terms. diff --git a/src/ackermannization/lackr_model_constructor.cpp b/src/ackermannization/lackr_model_constructor.cpp index 420fbda10..df0aac15e 100644 --- a/src/ackermannization/lackr_model_constructor.cpp +++ b/src/ackermannization/lackr_model_constructor.cpp @@ -276,7 +276,7 @@ struct lackr_model_constructor::imp { SASSERT(a->get_num_args() == 0); func_decl * const fd = a->get_decl(); expr * val = m_abstr_model->get_const_interp(fd); - if (val == nullptr) { // TODO: avoid model completetion? + if (val == nullptr) { // TODO: avoid model completion? sort * s = fd->get_range(); val = m_abstr_model->get_some_value(s); } diff --git a/src/api/api_algebraic.cpp b/src/api/api_algebraic.cpp index 1bb1b6a51..7d08ade35 100644 --- a/src/api/api_algebraic.cpp +++ b/src/api/api_algebraic.cpp @@ -79,23 +79,23 @@ extern "C" { _c->autil().is_irrational_algebraic_numeral(to_expr(a))); } - Z3_bool Z3_API Z3_algebraic_is_value(Z3_context c, Z3_ast a) { + bool Z3_API Z3_algebraic_is_value(Z3_context c, Z3_ast a) { Z3_TRY; LOG_Z3_algebraic_is_value(c, a); RESET_ERROR_CODE(); - return Z3_algebraic_is_value_core(c, a) ? Z3_TRUE : Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return Z3_algebraic_is_value_core(c, a); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_algebraic_is_pos(Z3_context c, Z3_ast a) { + bool Z3_API Z3_algebraic_is_pos(Z3_context c, Z3_ast a) { return Z3_algebraic_sign(c, a) > 0; } - Z3_bool Z3_API Z3_algebraic_is_neg(Z3_context c, Z3_ast a) { + bool Z3_API Z3_algebraic_is_neg(Z3_context c, Z3_ast a) { return Z3_algebraic_sign(c, a) < 0; } - Z3_bool Z3_API Z3_algebraic_is_zero(Z3_context c, Z3_ast a) { + bool Z3_API Z3_algebraic_is_zero(Z3_context c, Z3_ast a) { return Z3_algebraic_sign(c, a) == 0; } @@ -283,32 +283,32 @@ extern "C" { r = _am.IRAT_PRED(av, bv); \ } \ } \ - return r ? Z3_TRUE : Z3_FALSE; + return r; - Z3_bool Z3_API Z3_algebraic_lt(Z3_context c, Z3_ast a, Z3_ast b) { + bool Z3_API Z3_algebraic_lt(Z3_context c, Z3_ast a, Z3_ast b) { Z3_TRY; LOG_Z3_algebraic_lt(c, a, b); RESET_ERROR_CODE(); CHECK_IS_ALGEBRAIC(a, 0); CHECK_IS_ALGEBRAIC(b, 0); BIN_PRED(<,lt); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_algebraic_gt(Z3_context c, Z3_ast a, Z3_ast b) { + bool Z3_API Z3_algebraic_gt(Z3_context c, Z3_ast a, Z3_ast b) { return Z3_algebraic_lt(c, b, a); } - Z3_bool Z3_API Z3_algebraic_le(Z3_context c, Z3_ast a, Z3_ast b) { + bool Z3_API Z3_algebraic_le(Z3_context c, Z3_ast a, Z3_ast b) { return !Z3_algebraic_lt(c, b, a); } - Z3_bool Z3_API Z3_algebraic_ge(Z3_context c, Z3_ast a, Z3_ast b) { + bool Z3_API Z3_algebraic_ge(Z3_context c, Z3_ast a, Z3_ast b) { return !Z3_algebraic_lt(c, a, b); } - Z3_bool Z3_API Z3_algebraic_eq(Z3_context c, Z3_ast a, Z3_ast b) { + bool Z3_API Z3_algebraic_eq(Z3_context c, Z3_ast a, Z3_ast b) { Z3_TRY; LOG_Z3_algebraic_eq(c, a, b); RESET_ERROR_CODE(); @@ -318,7 +318,7 @@ extern "C" { Z3_CATCH_RETURN(0); } - Z3_bool Z3_API Z3_algebraic_neq(Z3_context c, Z3_ast a, Z3_ast b) { + bool Z3_API Z3_algebraic_neq(Z3_context c, Z3_ast a, Z3_ast b) { return !Z3_algebraic_eq(c, a, b); } diff --git a/src/api/api_arith.cpp b/src/api/api_arith.cpp index f46f56ef2..69fde33a7 100644 --- a/src/api/api_arith.cpp +++ b/src/api/api_arith.cpp @@ -119,9 +119,9 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a) { + bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a) { LOG_Z3_is_algebraic_number(c, a); - return mk_c(c)->autil().is_irrational_algebraic_numeral(to_expr(a)) ? Z3_TRUE : Z3_FALSE; + return mk_c(c)->autil().is_irrational_algebraic_numeral(to_expr(a)); } Z3_ast Z3_API Z3_get_algebraic_number_lower(Z3_context c, Z3_ast a, unsigned precision) { diff --git a/src/api/api_ast.cpp b/src/api/api_ast.cpp index 52be66e77..eeb85687d 100644 --- a/src/api/api_ast.cpp +++ b/src/api/api_ast.cpp @@ -33,11 +33,15 @@ Revision History: #include "ast/rewriter/th_rewriter.h" #include "ast/rewriter/var_subst.h" #include "ast/rewriter/expr_safe_replace.h" +#include "ast/rewriter/recfun_replace.h" +#include "ast/rewriter/seq_rewriter.h" #include "ast/pp.h" #include "util/scoped_ctrl_c.h" #include "util/cancel_eh.h" #include "util/scoped_timer.h" #include "ast/pp_params.hpp" +#include "ast/expr_abstract.h" + extern bool is_numeral_sort(Z3_context c, Z3_sort ty); @@ -70,7 +74,7 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_is_eq_sort(Z3_context c, Z3_sort s1, Z3_sort s2) { + bool Z3_API Z3_is_eq_sort(Z3_context c, Z3_sort s1, Z3_sort s2) { RESET_ERROR_CODE(); return s1 == s2; } @@ -85,12 +89,12 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast s1, Z3_ast s2) { + bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast s1, Z3_ast s2) { RESET_ERROR_CODE(); return s1 == s2; } - Z3_bool Z3_API Z3_is_eq_func_decl(Z3_context c, Z3_func_decl s1, Z3_func_decl s2) { + bool Z3_API Z3_is_eq_func_decl(Z3_context c, Z3_func_decl s1, Z3_func_decl s2) { RESET_ERROR_CODE(); return s1 == s2; } @@ -110,6 +114,55 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } + Z3_func_decl Z3_API Z3_mk_rec_func_decl(Z3_context c, Z3_symbol s, unsigned domain_size, Z3_sort const* domain, + Z3_sort range) { + Z3_TRY; + LOG_Z3_mk_rec_func_decl(c, s, domain_size, domain, range); + RESET_ERROR_CODE(); + // + recfun::promise_def def = + mk_c(c)->recfun().get_plugin().mk_def(to_symbol(s), + domain_size, + to_sorts(domain), + to_sort(range)); + func_decl* d = def.get_def()->get_decl(); + mk_c(c)->save_ast_trail(d); + RETURN_Z3(of_func_decl(d)); + Z3_CATCH_RETURN(nullptr); + } + + void Z3_API Z3_add_rec_def(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast args[], Z3_ast body) { + Z3_TRY; + LOG_Z3_add_rec_def(c, f, n, args, body); + func_decl* d = to_func_decl(f); + ast_manager& m = mk_c(c)->m(); + recfun::decl::plugin& p = mk_c(c)->recfun().get_plugin(); + expr_ref abs_body(m); + expr_ref_vector _args(m); + var_ref_vector _vars(m); + for (unsigned i = 0; i < n; ++i) { + _args.push_back(to_expr(args[i])); + _vars.push_back(m.mk_var(n - i - 1, m.get_sort(_args.back()))); + if (m.get_sort(_args.back()) != d->get_domain(i)) { + SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); + return; + } + } + expr_abstract(m, 0, n, _args.c_ptr(), to_expr(body), abs_body); + recfun::promise_def pd = p.get_promise_def(d); + if (!pd.get_def()) { + SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); + return; + } + if (m.get_sort(abs_body) != d->get_range()) { + SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); + return; + } + recfun_replace replace(m); + p.set_definition(replace, pd, n, _vars.c_ptr(), abs_body); + Z3_CATCH; + } + Z3_ast Z3_API Z3_mk_app(Z3_context c, Z3_func_decl d, unsigned num_args, Z3_ast const * args) { Z3_TRY; LOG_Z3_mk_app(c, d, num_args, args); @@ -256,12 +309,12 @@ extern "C" { return to_sort(s)->get_id(); } - Z3_bool Z3_API Z3_is_well_sorted(Z3_context c, Z3_ast t) { + bool Z3_API Z3_is_well_sorted(Z3_context c, Z3_ast t) { Z3_TRY; LOG_Z3_is_well_sorted(c, t); RESET_ERROR_CODE(); return is_well_sorted(mk_c(c)->m(), to_expr(t)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } Z3_symbol_kind Z3_API Z3_get_symbol_kind(Z3_context c, Z3_symbol s) { @@ -331,7 +384,7 @@ extern "C" { return to_ast(a)->hash(); } - Z3_bool Z3_API Z3_is_app(Z3_context c, Z3_ast a) { + bool Z3_API Z3_is_app(Z3_context c, Z3_ast a) { LOG_Z3_is_app(c, a); RESET_ERROR_CODE(); return a != nullptr && is_app(reinterpret_cast(a)); @@ -468,7 +521,7 @@ extern "C" { Z3_TRY; LOG_Z3_get_decl_symbol_parameter(c, d, idx); RESET_ERROR_CODE(); - CHECK_VALID_AST(d, 0); + CHECK_VALID_AST(d, nullptr); if (idx >= to_func_decl(d)->get_num_parameters()) { SET_ERROR_CODE(Z3_IOB, nullptr); return nullptr; @@ -486,7 +539,7 @@ extern "C" { Z3_TRY; LOG_Z3_get_decl_sort_parameter(c, d, idx); RESET_ERROR_CODE(); - CHECK_VALID_AST(d, 0); + CHECK_VALID_AST(d, nullptr); if (idx >= to_func_decl(d)->get_num_parameters()) { SET_ERROR_CODE(Z3_IOB, nullptr); RETURN_Z3(nullptr); @@ -504,7 +557,7 @@ extern "C" { Z3_TRY; LOG_Z3_get_decl_ast_parameter(c, d, idx); RESET_ERROR_CODE(); - CHECK_VALID_AST(d, 0); + CHECK_VALID_AST(d, nullptr); if (idx >= to_func_decl(d)->get_num_parameters()) { SET_ERROR_CODE(Z3_IOB, nullptr); RETURN_Z3(nullptr); @@ -522,7 +575,7 @@ extern "C" { Z3_TRY; LOG_Z3_get_decl_func_decl_parameter(c, d, idx); RESET_ERROR_CODE(); - CHECK_VALID_AST(d, 0); + CHECK_VALID_AST(d, nullptr); if (idx >= to_func_decl(d)->get_num_parameters()) { SET_ERROR_CODE(Z3_IOB, nullptr); RETURN_Z3(nullptr); @@ -596,7 +649,7 @@ extern "C" { Z3_TRY; LOG_Z3_get_domain(c, d, i); RESET_ERROR_CODE(); - CHECK_VALID_AST(d, 0); + CHECK_VALID_AST(d, nullptr); if (i >= to_func_decl(d)->get_arity()) { SET_ERROR_CODE(Z3_IOB, nullptr); RETURN_Z3(nullptr); @@ -681,6 +734,7 @@ extern "C" { Z3_CATCH_RETURN(Z3_L_UNDEF); } + static Z3_ast simplify(Z3_context c, Z3_ast _a, Z3_params _p) { Z3_TRY; RESET_ERROR_CODE(); @@ -690,6 +744,7 @@ extern "C" { unsigned timeout = p.get_uint("timeout", mk_c(c)->get_timeout()); bool use_ctrl_c = p.get_bool("ctrl_c", false); th_rewriter m_rw(m, p); + m_rw.set_solver(alloc(api::seq_expr_solver, m, p)); expr_ref result(m); cancel_eh eh(m.limit()); api::context::set_interruptable si(*(mk_c(c)), eh); diff --git a/src/api/api_ast_map.cpp b/src/api/api_ast_map.cpp index 44cadc691..aaece1621 100644 --- a/src/api/api_ast_map.cpp +++ b/src/api/api_ast_map.cpp @@ -57,12 +57,12 @@ extern "C" { Z3_CATCH; } - Z3_bool Z3_API Z3_ast_map_contains(Z3_context c, Z3_ast_map m, Z3_ast k) { + bool Z3_API Z3_ast_map_contains(Z3_context c, Z3_ast_map m, Z3_ast k) { Z3_TRY; LOG_Z3_ast_map_contains(c, m, k); RESET_ERROR_CODE(); return to_ast_map_ref(m).contains(to_ast(k)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } Z3_ast Z3_API Z3_ast_map_find(Z3_context c, Z3_ast_map m, Z3_ast k) { diff --git a/src/api/api_bv.cpp b/src/api/api_bv.cpp index bd603aa6d..e56371bb5 100644 --- a/src/api/api_bv.cpp +++ b/src/api/api_bv.cpp @@ -106,7 +106,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \ MK_BV_PUNARY(Z3_mk_rotate_right, OP_ROTATE_RIGHT); MK_BV_PUNARY(Z3_mk_int2bv, OP_INT2BV); - Z3_ast Z3_API Z3_mk_bv2int(Z3_context c, Z3_ast n, Z3_bool is_signed) { + Z3_ast Z3_API Z3_mk_bv2int(Z3_context c, Z3_ast n, bool is_signed) { Z3_TRY; LOG_Z3_mk_bv2int(c, n, is_signed); RESET_ERROR_CODE(); @@ -186,7 +186,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \ return Z3_mk_int(c, -1, s); } - Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_bool is_signed) { + Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed) { Z3_TRY; RESET_ERROR_CODE(); if (is_signed) { @@ -286,7 +286,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \ Z3_CATCH_RETURN(nullptr); } - Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_bool is_signed) { + Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed) { Z3_TRY; RESET_ERROR_CODE(); if (is_signed) { @@ -311,7 +311,7 @@ Z3_ast Z3_API NAME(Z3_context c, unsigned i, Z3_ast n) { \ Z3_CATCH_RETURN(nullptr); } - Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast n1, Z3_ast n2, Z3_bool is_signed) { + Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast n1, Z3_ast n2, bool is_signed) { LOG_Z3_mk_bvmul_no_overflow(c, n1, n2, is_signed); RESET_ERROR_CODE(); if (is_signed) { diff --git a/src/api/api_config_params.cpp b/src/api/api_config_params.cpp index 604177561..60d5fa556 100644 --- a/src/api/api_config_params.cpp +++ b/src/api/api_config_params.cpp @@ -57,21 +57,28 @@ extern "C" { try { g_Z3_global_param_get_buffer = gparams::get_value(param_id); *param_value = g_Z3_global_param_get_buffer.c_str(); - return Z3_TRUE; + return true; } catch (z3_exception & ex) { // The error handler is only available for contexts // Just throw a warning. warning_msg("%s", ex.msg()); - return Z3_FALSE; + return false; } } Z3_config Z3_API Z3_mk_config(void) { - memory::initialize(UINT_MAX); - LOG_Z3_mk_config(); - Z3_config r = reinterpret_cast(alloc(context_params)); - RETURN_Z3(r); + try { + memory::initialize(UINT_MAX); + LOG_Z3_mk_config(); + Z3_config r = reinterpret_cast(alloc(context_params)); + RETURN_Z3(r); + } catch (z3_exception & ex) { + // The error handler is only available for contexts + // Just throw a warning. + warning_msg("%s", ex.msg()); + return nullptr; + } } void Z3_API Z3_del_config(Z3_config c) { diff --git a/src/api/api_context.cpp b/src/api/api_context.cpp index cc2a13aed..a2492cb1a 100644 --- a/src/api/api_context.cpp +++ b/src/api/api_context.cpp @@ -19,7 +19,7 @@ Revision History: --*/ #include #include "api/api_context.h" -#include "util/version.h" +#include "util/z3_version.h" #include "ast/ast_pp.h" #include "ast/ast_ll_pp.h" #include "api/api_log_macros.h" @@ -79,6 +79,7 @@ namespace api { m_datalog_util(m()), m_fpa_util(m()), m_sutil(m()), + m_recfun(m()), m_last_result(m()), m_ast_trail(m()), m_pmanager(m_limit) { @@ -108,13 +109,10 @@ namespace api { context::~context() { m_last_obj = nullptr; - u_map::iterator it = m_allocated_objects.begin(); - while (it != m_allocated_objects.end()) { - api::object* val = it->m_value; - DEBUG_CODE(warning_msg("Uncollected memory: %d: %s", it->m_key, typeid(*val).name());); - m_allocated_objects.remove(it->m_key); + for (auto& kv : m_allocated_objects) { + api::object* val = kv.m_value; + DEBUG_CODE(warning_msg("Uncollected memory: %d: %s", kv.m_key, typeid(*val).name());); dealloc(val); - it = m_allocated_objects.begin(); } } @@ -219,7 +217,7 @@ namespace api { if (m_user_ref_count) { // Corner case bug: n may be in m_last_result, and this is the only reference to n. // When, we execute reset() it is deleted - // To avoid this bug, I bump the reference counter before reseting m_last_result + // To avoid this bug, I bump the reference counter before resetting m_last_result ast_ref node(n, m()); m_last_result.reset(); m_last_result.push_back(std::move(node)); @@ -362,7 +360,7 @@ extern "C" { Z3_CATCH; } - void Z3_API Z3_toggle_warning_messages(Z3_bool enabled) { + void Z3_API Z3_toggle_warning_messages(bool enabled) { LOG_Z3_toggle_warning_messages(enabled); enable_warning_messages(enabled != 0); } @@ -439,7 +437,6 @@ extern "C" { void Z3_API Z3_set_error_handler(Z3_context c, Z3_error_handler h) { RESET_ERROR_CODE(); mk_c(c)->set_error_handler(h); - // [Leo]: using exception handling, we don't need global error handlers anymore } void Z3_API Z3_set_error(Z3_context c, Z3_error_code e) { @@ -489,9 +486,3 @@ extern "C" { } }; - -Z3_API ast_manager& Z3_get_manager(Z3_context c) { - return mk_c(c)->m(); -} - - diff --git a/src/api/api_context.h b/src/api/api_context.h index a6f55d1aa..aacd4edd3 100644 --- a/src/api/api_context.h +++ b/src/api/api_context.h @@ -29,6 +29,7 @@ Revision History: #include "ast/datatype_decl_plugin.h" #include "ast/dl_decl_plugin.h" #include "ast/fpa_decl_plugin.h" +#include "ast/recfun_decl_plugin.h" #include "smt/smt_kernel.h" #include "smt/params/smt_params.h" #include "util/event_handler.h" @@ -37,6 +38,9 @@ Revision History: #include "cmd_context/cmd_context.h" #include "api/api_polynomial.h" #include "util/hashtable.h" +#include "ast/rewriter/seq_rewriter.h" +#include "smt/smt_solver.h" +#include "solver/solver.h" namespace smtlib { class parser; @@ -48,6 +52,24 @@ namespace realclosure { namespace api { + class seq_expr_solver : public expr_solver { + ast_manager& m; + params_ref const& p; + solver_ref s; + public: + seq_expr_solver(ast_manager& m, params_ref const& p): m(m), p(p) {} + lbool check_sat(expr* e) { + if (!s) { + s = mk_smt_solver(m, p, symbol("ALL")); + } + s->push(); + s->assert_expr(e); + lbool r = s->check_sat(); + s->pop(1); + return r; + } + }; + class context : public tactic_manager { struct add_plugins { add_plugins(ast_manager & m); }; @@ -62,6 +84,7 @@ namespace api { datalog::dl_decl_util m_datalog_util; fpa_util m_fpa_util; seq_util m_sutil; + recfun::util m_recfun; // Support for old solver API smt_params m_fparams; @@ -128,6 +151,7 @@ namespace api { fpa_util & fpautil() { return m_fpa_util; } datatype_util& dtutil() { return m_dt_plugin->u(); } seq_util& sutil() { return m_sutil; } + recfun::util& recfun() { return m_recfun; } family_id get_basic_fid() const { return m_basic_fid; } family_id get_array_fid() const { return m_array_fid; } family_id get_arith_fid() const { return m_arith_fid; } diff --git a/src/api/api_datalog.cpp b/src/api/api_datalog.cpp index a95f1d8b1..790470275 100644 --- a/src/api/api_datalog.cpp +++ b/src/api/api_datalog.cpp @@ -199,23 +199,23 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_get_finite_domain_sort_size(Z3_context c, Z3_sort s, uint64_t * out) { + bool Z3_API Z3_get_finite_domain_sort_size(Z3_context c, Z3_sort s, uint64_t * out) { Z3_TRY; if (out) { *out = 0; } if (Z3_get_sort_kind(c, s) != Z3_FINITE_DOMAIN_SORT) { - return Z3_FALSE; + return false; } if (!out) { - return Z3_FALSE; + return false; } - // must start loggging here, since function uses Z3_get_sort_kind above + // must start logging here, since function uses Z3_get_sort_kind above LOG_Z3_get_finite_domain_sort_size(c, s, out); RESET_ERROR_CODE(); VERIFY(mk_c(c)->datalog_util().try_get_size(to_sort(s), *out)); - return Z3_TRUE; - Z3_CATCH_RETURN(Z3_FALSE); + return true; + Z3_CATCH_RETURN(false); } Z3_fixedpoint Z3_API Z3_mk_fixedpoint(Z3_context c) { @@ -379,10 +379,8 @@ extern "C" { for (unsigned i = 0; i < coll.m_rules.size(); ++i) { to_fixedpoint_ref(d)->add_rule(coll.m_rules[i].get(), coll.m_names[i]); } - ptr_vector::const_iterator it = ctx.begin_assertions(); - ptr_vector::const_iterator end = ctx.end_assertions(); - for (; it != end; ++it) { - to_fixedpoint_ref(d)->ctx().assert_expr(*it); + for (expr * e : ctx.assertions()) { + to_fixedpoint_ref(d)->ctx().assert_expr(e); } return of_ast_vector(v); @@ -717,6 +715,4 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - - }; diff --git a/src/api/api_fpa.cpp b/src/api/api_fpa.cpp index cdc592527..8301ea604 100644 --- a/src/api/api_fpa.cpp +++ b/src/api/api_fpa.cpp @@ -232,7 +232,7 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, Z3_bool negative) { + Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, bool negative) { Z3_TRY; LOG_Z3_mk_fpa_inf(c, s, negative); RESET_ERROR_CODE(); @@ -242,14 +242,14 @@ extern "C" { RETURN_Z3(nullptr); } api::context * ctx = mk_c(c); - expr * a = negative != 0 ? ctx->fpautil().mk_ninf(to_sort(s)) : - ctx->fpautil().mk_pinf(to_sort(s)); + expr * a = negative ? ctx->fpautil().mk_ninf(to_sort(s)) : + ctx->fpautil().mk_pinf(to_sort(s)); ctx->save_ast_trail(a); RETURN_Z3(of_expr(a)); Z3_CATCH_RETURN(nullptr); } - Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, Z3_bool negative) { + Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative) { Z3_TRY; LOG_Z3_mk_fpa_inf(c, s, negative); RESET_ERROR_CODE(); @@ -259,8 +259,8 @@ extern "C" { RETURN_Z3(nullptr); } api::context * ctx = mk_c(c); - expr * a = negative != 0 ? ctx->fpautil().mk_nzero(to_sort(s)) : - ctx->fpautil().mk_pzero(to_sort(s)); + expr * a = negative ? ctx->fpautil().mk_nzero(to_sort(s)) : + ctx->fpautil().mk_pzero(to_sort(s)); ctx->save_ast_trail(a); RETURN_Z3(of_expr(a)); Z3_CATCH_RETURN(nullptr); @@ -338,7 +338,7 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_ast Z3_API Z3_mk_fpa_numeral_int_uint(Z3_context c, Z3_bool sgn, signed exp, unsigned sig, Z3_sort ty) { + Z3_ast Z3_API Z3_mk_fpa_numeral_int_uint(Z3_context c, bool sgn, signed exp, unsigned sig, Z3_sort ty) { Z3_TRY; LOG_Z3_mk_fpa_numeral_int64_uint64(c, sgn, exp, sig, ty); RESET_ERROR_CODE(); @@ -351,14 +351,14 @@ extern "C" { ctx->fpautil().fm().set(tmp, ctx->fpautil().get_ebits(to_sort(ty)), ctx->fpautil().get_sbits(to_sort(ty)), - sgn != 0, exp, sig); + sgn, exp, sig); expr * a = ctx->fpautil().mk_value(tmp); ctx->save_ast_trail(a); RETURN_Z3(of_expr(a)); Z3_CATCH_RETURN(nullptr); } - Z3_ast Z3_API Z3_mk_fpa_numeral_int64_uint64(Z3_context c, Z3_bool sgn, int64_t exp, uint64_t sig, Z3_sort ty) { + Z3_ast Z3_API Z3_mk_fpa_numeral_int64_uint64(Z3_context c, bool sgn, int64_t exp, uint64_t sig, Z3_sort ty) { Z3_TRY; LOG_Z3_mk_fpa_numeral_int64_uint64(c, sgn, exp, sig, ty); RESET_ERROR_CODE(); @@ -371,7 +371,7 @@ extern "C" { ctx->fpautil().fm().set(tmp, ctx->fpautil().get_ebits(to_sort(ty)), ctx->fpautil().get_sbits(to_sort(ty)), - sgn != 0, exp, sig); + sgn, exp, sig); expr * a = ctx->fpautil().mk_value(tmp); ctx->save_ast_trail(a); RETURN_Z3(of_expr(a)); @@ -905,7 +905,7 @@ extern "C" { Z3_CATCH_RETURN(0); } - Z3_bool Z3_API Z3_fpa_get_numeral_sign(Z3_context c, Z3_ast t, int * sgn) { + bool Z3_API Z3_fpa_get_numeral_sign(Z3_context c, Z3_ast t, int * sgn) { Z3_TRY; LOG_Z3_fpa_get_numeral_sign(c, t, sgn); RESET_ERROR_CODE(); @@ -913,7 +913,7 @@ extern "C" { CHECK_VALID_AST(t, 0); if (sgn == nullptr) { SET_ERROR_CODE(Z3_INVALID_ARG, "sign cannot be a nullpointer"); - return 0; + return false; } ast_manager & m = mk_c(c)->m(); mpf_manager & mpfm = mk_c(c)->fpautil().fm(); @@ -922,13 +922,13 @@ extern "C" { expr * e = to_expr(t); if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) { SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN"); - return 0; + return false; } scoped_mpf val(mpfm); bool r = plugin->is_numeral(to_expr(t), val); if (!r || mpfm.is_nan(val)) { SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN"); - return 0; + return false; } *sgn = mpfm.sgn(val); return r; @@ -1035,7 +1035,7 @@ extern "C" { Z3_CATCH_RETURN(""); } - Z3_bool Z3_API Z3_fpa_get_numeral_significand_uint64(Z3_context c, Z3_ast t, uint64_t * n) { + bool Z3_API Z3_fpa_get_numeral_significand_uint64(Z3_context c, Z3_ast t, uint64_t * n) { Z3_TRY; LOG_Z3_fpa_get_numeral_significand_uint64(c, t, n); RESET_ERROR_CODE(); @@ -1043,7 +1043,7 @@ extern "C" { CHECK_VALID_AST(t, 0); if (n == nullptr) { SET_ERROR_CODE(Z3_INVALID_ARG, "invalid nullptr argument"); - return 0; + return false; } ast_manager & m = mk_c(c)->m(); mpf_manager & mpfm = mk_c(c)->fpautil().fm(); @@ -1055,7 +1055,7 @@ extern "C" { if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) { SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN"); *n = 0; - return 0; + return false; } scoped_mpf val(mpfm); bool r = plugin->is_numeral(e, val); @@ -1065,14 +1065,14 @@ extern "C" { !mpzm.is_uint64(z)) { SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN"); *n = 0; - return 0; + return false; } *n = mpzm.get_uint64(z); - return 1; + return true; Z3_CATCH_RETURN(0); } - Z3_string Z3_API Z3_fpa_get_numeral_exponent_string(Z3_context c, Z3_ast t, Z3_bool biased) { + Z3_string Z3_API Z3_fpa_get_numeral_exponent_string(Z3_context c, Z3_ast t, bool biased) { Z3_TRY; LOG_Z3_fpa_get_numeral_exponent_string(c, t, biased); RESET_ERROR_CODE(); @@ -1113,7 +1113,7 @@ extern "C" { Z3_CATCH_RETURN(""); } - Z3_bool Z3_API Z3_fpa_get_numeral_exponent_int64(Z3_context c, Z3_ast t, int64_t * n, Z3_bool biased) { + bool Z3_API Z3_fpa_get_numeral_exponent_int64(Z3_context c, Z3_ast t, int64_t * n, bool biased) { Z3_TRY; LOG_Z3_fpa_get_numeral_exponent_int64(c, t, n, biased); RESET_ERROR_CODE(); @@ -1121,7 +1121,7 @@ extern "C" { CHECK_VALID_AST(t, 0); if (n == nullptr) { SET_ERROR_CODE(Z3_INVALID_ARG, "invalid null argument"); - return 0; + return false; } ast_manager & m = mk_c(c)->m(); mpf_manager & mpfm = mk_c(c)->fpautil().fm(); @@ -1132,14 +1132,14 @@ extern "C" { if (!is_app(e) || is_app_of(e, fid, OP_FPA_NAN) || !is_fp(c, t)) { SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN"); *n = 0; - return 0; + return false; } scoped_mpf val(mpfm); bool r = plugin->is_numeral(e, val); if (!r || !(mpfm.is_normal(val) || mpfm.is_denormal(val) || mpfm.is_zero(val) || mpfm.is_inf(val))) { SET_ERROR_CODE(Z3_INVALID_ARG, "invalid expression argument, expecting a valid fp, not a NaN"); *n = 0; - return 0; + return false; } unsigned ebits = val.get().get_ebits(); if (biased) { @@ -1153,11 +1153,11 @@ extern "C" { mpfm.is_denormal(val) ? mpfm.mk_min_exp(ebits) : mpfm.exp(val); } - return 1; + return true; Z3_CATCH_RETURN(0); } - Z3_ast Z3_API Z3_fpa_get_numeral_exponent_bv(Z3_context c, Z3_ast t, Z3_bool biased) { + Z3_ast Z3_API Z3_fpa_get_numeral_exponent_bv(Z3_context c, Z3_ast t, bool biased) { Z3_TRY; LOG_Z3_fpa_get_numeral_exponent_bv(c, t, biased); RESET_ERROR_CODE(); @@ -1232,7 +1232,7 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_fpa_is_numeral_nan(Z3_context c, Z3_ast t) { + bool Z3_API Z3_fpa_is_numeral_nan(Z3_context c, Z3_ast t) { Z3_TRY; LOG_Z3_fpa_is_numeral_nan(c, t); RESET_ERROR_CODE(); @@ -1240,13 +1240,13 @@ extern "C" { fpa_util & fu = ctx->fpautil(); if (!is_expr(t) || !fu.is_numeral(to_expr(t))) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return 0; + return false; } return fu.is_nan(to_expr(t)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_fpa_is_numeral_inf(Z3_context c, Z3_ast t) { + bool Z3_API Z3_fpa_is_numeral_inf(Z3_context c, Z3_ast t) { Z3_TRY; LOG_Z3_fpa_is_numeral_inf(c, t); RESET_ERROR_CODE(); @@ -1254,13 +1254,13 @@ extern "C" { fpa_util & fu = ctx->fpautil(); if (!is_expr(t) || !fu.is_numeral(to_expr(t))) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return 0; + return false; } return fu.is_inf(to_expr(t)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_fpa_is_numeral_zero(Z3_context c, Z3_ast t) { + bool Z3_API Z3_fpa_is_numeral_zero(Z3_context c, Z3_ast t) { Z3_TRY; LOG_Z3_fpa_is_numeral_zero(c, t); RESET_ERROR_CODE(); @@ -1268,13 +1268,13 @@ extern "C" { fpa_util & fu = ctx->fpautil(); if (!is_expr(t) || !fu.is_numeral(to_expr(t))) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return 0; + return false; } return fu.is_zero(to_expr(t)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_fpa_is_numeral_normal(Z3_context c, Z3_ast t) { + bool Z3_API Z3_fpa_is_numeral_normal(Z3_context c, Z3_ast t) { Z3_TRY; LOG_Z3_fpa_is_numeral_normal(c, t); RESET_ERROR_CODE(); @@ -1282,13 +1282,13 @@ extern "C" { fpa_util & fu = ctx->fpautil(); if (!is_expr(t) || !fu.is_numeral(to_expr(t))) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return 0; + return false; } return fu.is_normal(to_expr(t)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_fpa_is_numeral_subnormal(Z3_context c, Z3_ast t) { + bool Z3_API Z3_fpa_is_numeral_subnormal(Z3_context c, Z3_ast t) { Z3_TRY; LOG_Z3_fpa_is_numeral_subnormal(c, t); RESET_ERROR_CODE(); @@ -1296,13 +1296,13 @@ extern "C" { fpa_util & fu = ctx->fpautil(); if (!is_expr(t) || !fu.is_numeral(to_expr(t))) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return 0; + return false; } return fu.is_subnormal(to_expr(t)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_fpa_is_numeral_positive(Z3_context c, Z3_ast t) { + bool Z3_API Z3_fpa_is_numeral_positive(Z3_context c, Z3_ast t) { Z3_TRY; LOG_Z3_fpa_is_numeral_positive(c, t); RESET_ERROR_CODE(); @@ -1310,13 +1310,13 @@ extern "C" { fpa_util & fu = ctx->fpautil(); if (!is_expr(t) || !fu.is_numeral(to_expr(t))) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return 0; + return false; } return fu.is_positive(to_expr(t)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_fpa_is_numeral_negative(Z3_context c, Z3_ast t) { + bool Z3_API Z3_fpa_is_numeral_negative(Z3_context c, Z3_ast t) { Z3_TRY; LOG_Z3_fpa_is_numeral_negative(c, t); RESET_ERROR_CODE(); @@ -1324,10 +1324,10 @@ extern "C" { fpa_util & fu = ctx->fpautil(); if (!is_expr(t) || !fu.is_numeral(to_expr(t))) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return 0; + return false; } return fu.is_negative(to_expr(t)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } }; diff --git a/src/api/api_goal.cpp b/src/api/api_goal.cpp index cb3bb7478..c70d241e0 100644 --- a/src/api/api_goal.cpp +++ b/src/api/api_goal.cpp @@ -25,7 +25,7 @@ Revision History: extern "C" { - Z3_goal Z3_API Z3_mk_goal(Z3_context c, Z3_bool models, Z3_bool unsat_cores, Z3_bool proofs) { + Z3_goal Z3_API Z3_mk_goal(Z3_context c, bool models, bool unsat_cores, bool proofs) { Z3_TRY; LOG_Z3_mk_goal(c, models, unsat_cores, proofs); RESET_ERROR_CODE(); @@ -82,12 +82,12 @@ extern "C" { Z3_CATCH; } - Z3_bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g) { + bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g) { Z3_TRY; LOG_Z3_goal_inconsistent(c, g); RESET_ERROR_CODE(); return to_goal_ref(g)->inconsistent(); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } unsigned Z3_API Z3_goal_depth(Z3_context c, Z3_goal g) { @@ -136,20 +136,20 @@ extern "C" { Z3_CATCH_RETURN(0); } - Z3_bool Z3_API Z3_goal_is_decided_sat(Z3_context c, Z3_goal g) { + bool Z3_API Z3_goal_is_decided_sat(Z3_context c, Z3_goal g) { Z3_TRY; LOG_Z3_goal_is_decided_sat(c, g); RESET_ERROR_CODE(); return to_goal_ref(g)->is_decided_sat(); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_goal_is_decided_unsat(Z3_context c, Z3_goal g) { + bool Z3_API Z3_goal_is_decided_unsat(Z3_context c, Z3_goal g) { Z3_TRY; LOG_Z3_goal_is_decided_unsat(c, g); RESET_ERROR_CODE(); return to_goal_ref(g)->is_decided_unsat(); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } Z3_model Z3_API Z3_goal_convert_model(Z3_context c, Z3_goal g, Z3_model m) { @@ -163,7 +163,7 @@ extern "C" { if (to_goal_ref(g)->mc()) (*to_goal_ref(g)->mc())(m_ref->m_model); RETURN_Z3(of_model(m_ref)); - Z3_CATCH_RETURN(0); + Z3_CATCH_RETURN(nullptr); } Z3_goal Z3_API Z3_goal_translate(Z3_context c, Z3_goal g, Z3_context target) { diff --git a/src/api/api_log.cpp b/src/api/api_log.cpp index 1bdbb8735..d338407bf 100644 --- a/src/api/api_log.cpp +++ b/src/api/api_log.cpp @@ -19,7 +19,7 @@ Revision History: #include "api/z3.h" #include "api/api_log_macros.h" #include "util/util.h" -#include "util/version.h" +#include "util/z3_version.h" std::ostream * g_z3_log = nullptr; bool g_z3_log_enabled = false; @@ -33,8 +33,8 @@ extern "C" { } } - Z3_bool Z3_API Z3_open_log(Z3_string filename) { - Z3_bool res = Z3_TRUE; + bool Z3_API Z3_open_log(Z3_string filename) { + bool res = true; #ifdef Z3_LOG_SYNC #pragma omp critical (z3_log) @@ -46,7 +46,7 @@ extern "C" { if (g_z3_log->bad() || g_z3_log->fail()) { dealloc(g_z3_log); g_z3_log = nullptr; - res = Z3_FALSE; + res = false; } else { *g_z3_log << "V \"" << Z3_MAJOR_VERSION << "." << Z3_MINOR_VERSION << "." << Z3_BUILD_NUMBER << "." << Z3_REVISION_NUMBER << " " << __DATE__ << "\"\n"; diff --git a/src/api/api_model.cpp b/src/api/api_model.cpp index 939cccdca..0937e668e 100644 --- a/src/api/api_model.cpp +++ b/src/api/api_model.cpp @@ -75,16 +75,12 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_model_has_interp(Z3_context c, Z3_model m, Z3_func_decl a) { + bool Z3_API Z3_model_has_interp(Z3_context c, Z3_model m, Z3_func_decl a) { Z3_TRY; LOG_Z3_model_has_interp(c, m, a); CHECK_NON_NULL(m, 0); - if (to_model_ref(m)->has_interpretation(to_func_decl(a))) { - return Z3_TRUE; - } else { - return Z3_FALSE; - } - Z3_CATCH_RETURN(Z3_FALSE); + return to_model_ref(m)->has_interpretation(to_func_decl(a)); + Z3_CATCH_RETURN(false); } Z3_func_interp Z3_API Z3_model_get_func_interp(Z3_context c, Z3_model m, Z3_func_decl f) { @@ -157,20 +153,23 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, Z3_bool model_completion, Z3_ast * v) { + bool Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, bool model_completion, Z3_ast * v) { Z3_TRY; LOG_Z3_model_eval(c, m, t, model_completion, v); if (v) *v = nullptr; RESET_ERROR_CODE(); - CHECK_NON_NULL(m, Z3_FALSE); - CHECK_IS_EXPR(t, Z3_FALSE); + CHECK_NON_NULL(m, false); + CHECK_IS_EXPR(t, false); model * _m = to_model_ref(m); - expr_ref result(mk_c(c)->m()); - model::scoped_model_completion _scm(*_m, model_completion == Z3_TRUE); + params_ref p; + ast_manager& mgr = mk_c(c)->m(); + _m->set_solver(alloc(api::seq_expr_solver, mgr, p)); + expr_ref result(mgr); + model::scoped_model_completion _scm(*_m, model_completion); result = (*_m)(to_expr(t)); mk_c(c)->save_ast_trail(result.get()); *v = of_ast(result.get()); - RETURN_Z3_model_eval Z3_TRUE; + RETURN_Z3_model_eval true; Z3_CATCH_RETURN(0); } @@ -225,12 +224,12 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a) { + bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a) { Z3_TRY; LOG_Z3_is_as_array(c, a); RESET_ERROR_CODE(); return a && is_expr(to_ast(a)) && is_app_of(to_expr(a), mk_c(c)->get_array_fid(), OP_AS_ARRAY); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } Z3_func_decl Z3_API Z3_get_as_array_func_decl(Z3_context c, Z3_ast a) { @@ -472,7 +471,7 @@ extern "C" { model_smt2_pp(buffer, mk_c(c)->m(), *(to_model_ref(m)), 0); // Hack for removing the trailing '\n' result = buffer.str(); - if (result.size() != 0) + if (!result.empty()) result.resize(result.size()-1); } else { diff --git a/src/api/api_numeral.cpp b/src/api/api_numeral.cpp index 2891e8cc4..90d5998f3 100644 --- a/src/api/api_numeral.cpp +++ b/src/api/api_numeral.cpp @@ -142,11 +142,11 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a) { + bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a) { Z3_TRY; LOG_Z3_is_numeral_ast(c, a); RESET_ERROR_CODE(); - CHECK_IS_EXPR(a, Z3_FALSE); + CHECK_IS_EXPR(a, false); expr* e = to_expr(a); return mk_c(c)->autil().is_numeral(e) || @@ -154,29 +154,29 @@ extern "C" { mk_c(c)->fpautil().is_numeral(e) || mk_c(c)->fpautil().is_rm_numeral(e) || mk_c(c)->datalog_util().is_numeral_ext(e); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_get_numeral_rational(Z3_context c, Z3_ast a, rational& r) { + bool Z3_API Z3_get_numeral_rational(Z3_context c, Z3_ast a, rational& r) { Z3_TRY; // This function is not part of the public API RESET_ERROR_CODE(); - CHECK_IS_EXPR(a, Z3_FALSE); + CHECK_IS_EXPR(a, false); expr* e = to_expr(a); if (mk_c(c)->autil().is_numeral(e, r)) { - return Z3_TRUE; + return true; } unsigned bv_size; if (mk_c(c)->bvutil().is_numeral(e, r, bv_size)) { - return Z3_TRUE; + return true; } uint64_t v; if (mk_c(c)->datalog_util().is_numeral(e, v)) { r = rational(v, rational::ui64()); - return Z3_TRUE; + return true; } - return Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return false; + Z3_CATCH_RETURN(false); } @@ -187,8 +187,8 @@ extern "C" { RESET_ERROR_CODE(); CHECK_IS_EXPR(a, ""); rational r; - Z3_bool ok = Z3_get_numeral_rational(c, a, r); - if (ok == Z3_TRUE) { + bool ok = Z3_get_numeral_rational(c, a, r); + if (ok) { return mk_c(c)->mk_external_string(r.to_string()); } else { @@ -198,19 +198,19 @@ extern "C" { mpf_rounding_mode rm; if (mk_c(c)->fpautil().is_rm_numeral(to_expr(a), rm)) { switch (rm) { - case OP_FPA_RM_NEAREST_TIES_TO_EVEN: + case MPF_ROUND_NEAREST_TEVEN: return mk_c(c)->mk_external_string("roundNearestTiesToEven"); break; - case OP_FPA_RM_NEAREST_TIES_TO_AWAY: + case MPF_ROUND_NEAREST_TAWAY: return mk_c(c)->mk_external_string("roundNearestTiesToAway"); break; - case OP_FPA_RM_TOWARD_POSITIVE: + case MPF_ROUND_TOWARD_POSITIVE: return mk_c(c)->mk_external_string("roundTowardPositive"); break; - case OP_FPA_RM_TOWARD_NEGATIVE: + case MPF_ROUND_TOWARD_NEGATIVE: return mk_c(c)->mk_external_string("roundTowardNegative"); break; - case OP_FPA_RM_TOWARD_ZERO: + case MPF_ROUND_TOWARD_ZERO: default: return mk_c(c)->mk_external_string("roundTowardZero"); break; @@ -227,6 +227,11 @@ extern "C" { Z3_CATCH_RETURN(""); } + double Z3_API Z3_get_numeral_double(Z3_context c, Z3_ast a) { + Z3_string s = Z3_get_numeral_decimal_string(c, a, 12); + return std::stod(std::string(s)); + } + Z3_string Z3_API Z3_get_numeral_decimal_string(Z3_context c, Z3_ast a, unsigned precision) { Z3_TRY; LOG_Z3_get_numeral_decimal_string(c, a, precision); @@ -247,8 +252,8 @@ extern "C" { am.display_decimal(buffer, n, precision); return mk_c(c)->mk_external_string(buffer.str()); } - Z3_bool ok = Z3_get_numeral_rational(c, a, r); - if (ok == Z3_TRUE) { + bool ok = Z3_get_numeral_rational(c, a, r); + if (ok) { return mk_c(c)->mk_external_string(r.to_string()); } else { @@ -258,124 +263,124 @@ extern "C" { Z3_CATCH_RETURN(""); } - Z3_bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, int64_t* num, int64_t* den) { + bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, int64_t* num, int64_t* den) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_small(c, a, num, den); RESET_ERROR_CODE(); - CHECK_IS_EXPR(a, Z3_FALSE); + CHECK_IS_EXPR(a, false); rational r; - Z3_bool ok = Z3_get_numeral_rational(c, a, r); - if (ok == Z3_TRUE) { + bool ok = Z3_get_numeral_rational(c, a, r); + if (ok) { rational n = numerator(r); rational d = denominator(r); if (n.is_int64() && d.is_int64()) { *num = n.get_int64(); *den = d.get_int64(); - return Z3_TRUE; + return true; } else { - return Z3_FALSE; + return false; } } SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return false; + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_get_numeral_int(Z3_context c, Z3_ast v, int* i) { + bool Z3_API Z3_get_numeral_int(Z3_context c, Z3_ast v, int* i) { Z3_TRY; // This function invokes Z3_get_numeral_int64, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_int(c, v, i); RESET_ERROR_CODE(); - CHECK_IS_EXPR(v, Z3_FALSE); + CHECK_IS_EXPR(v, false); if (!i) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return Z3_FALSE; + return false; } int64_t l; if (Z3_get_numeral_int64(c, v, &l) && l >= INT_MIN && l <= INT_MAX) { *i = static_cast(l); - return Z3_TRUE; + return true; } - return Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return false; + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_get_numeral_uint(Z3_context c, Z3_ast v, unsigned* u) { + bool Z3_API Z3_get_numeral_uint(Z3_context c, Z3_ast v, unsigned* u) { Z3_TRY; // This function invokes Z3_get_numeral_uint64, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_uint(c, v, u); RESET_ERROR_CODE(); - CHECK_IS_EXPR(v, Z3_FALSE); + CHECK_IS_EXPR(v, false); if (!u) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return Z3_FALSE; + return false; } uint64_t l; if (Z3_get_numeral_uint64(c, v, &l) && (l <= 0xFFFFFFFF)) { *u = static_cast(l); - return Z3_TRUE; + return true; } - return Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return false; + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, uint64_t* u) { + bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, uint64_t* u) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_uint64(c, v, u); RESET_ERROR_CODE(); - CHECK_IS_EXPR(v, Z3_FALSE); + CHECK_IS_EXPR(v, false); if (!u) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return Z3_FALSE; + return false; } rational r; - Z3_bool ok = Z3_get_numeral_rational(c, v, r); + bool ok = Z3_get_numeral_rational(c, v, r); SASSERT(u); - if (ok == Z3_TRUE && r.is_uint64()) { + if (ok && r.is_uint64()) { *u = r.get_uint64(); return ok; } - return Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return false; + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, int64_t* i) { + bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, int64_t* i) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_int64(c, v, i); RESET_ERROR_CODE(); - CHECK_IS_EXPR(v, Z3_FALSE); + CHECK_IS_EXPR(v, false); if (!i) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return Z3_FALSE; + return false; } rational r; - Z3_bool ok = Z3_get_numeral_rational(c, v, r); - if (ok == Z3_TRUE && r.is_int64()) { + bool ok = Z3_get_numeral_rational(c, v, r); + if (ok && r.is_int64()) { *i = r.get_int64(); return ok; } - return Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return false; + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, int64_t* num, int64_t* den) { + bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, int64_t* num, int64_t* den) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_rational_int64(c, v, num, den); RESET_ERROR_CODE(); - CHECK_IS_EXPR(v, Z3_FALSE); + CHECK_IS_EXPR(v, false); if (!num || !den) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); - return Z3_FALSE; + return false; } rational r; - Z3_bool ok = Z3_get_numeral_rational(c, v, r); - if (ok != Z3_TRUE) { + bool ok = Z3_get_numeral_rational(c, v, r); + if (ok != true) { return ok; } rational n = numerator(r); @@ -385,11 +390,11 @@ extern "C" { *den = d.get_int64(); return ok; } - return Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return false; + Z3_CATCH_RETURN(false); } - Z3_ast Z3_API Z3_mk_bv_numeral(Z3_context c, unsigned sz, Z3_bool const* bits) { + Z3_ast Z3_API Z3_mk_bv_numeral(Z3_context c, unsigned sz, bool const* bits) { Z3_TRY; LOG_Z3_mk_bv_numeral(c, sz, bits); RESET_ERROR_CODE(); diff --git a/src/api/api_opt.cpp b/src/api/api_opt.cpp index 71f92eeba..0b56b788d 100644 --- a/src/api/api_opt.cpp +++ b/src/api/api_opt.cpp @@ -124,10 +124,16 @@ extern "C" { } - Z3_lbool Z3_API Z3_optimize_check(Z3_context c, Z3_optimize o) { + Z3_lbool Z3_API Z3_optimize_check(Z3_context c, Z3_optimize o, unsigned num_assumptions, Z3_ast const assumptions[]) { Z3_TRY; - LOG_Z3_optimize_check(c, o); + LOG_Z3_optimize_check(c, o, num_assumptions, assumptions); RESET_ERROR_CODE(); + for (unsigned i = 0; i < num_assumptions; i++) { + if (!is_expr(to_ast(assumptions[i]))) { + SET_ERROR_CODE(Z3_INVALID_ARG, "assumption is not an expression"); + return Z3_L_UNDEF; + } + } lbool r = l_undef; cancel_eh eh(mk_c(c)->m().limit()); unsigned timeout = to_optimize_ptr(o)->get_params().get_uint("timeout", mk_c(c)->get_timeout()); @@ -137,7 +143,9 @@ extern "C" { scoped_timer timer(timeout, &eh); scoped_rlimit _rlimit(mk_c(c)->m().limit(), rlimit); try { - r = to_optimize_ptr(o)->optimize(); + expr_ref_vector asms(mk_c(c)->m()); + asms.append(num_assumptions, to_exprs(assumptions)); + r = to_optimize_ptr(o)->optimize(asms); } catch (z3_exception& ex) { if (!mk_c(c)->m().canceled()) { @@ -157,6 +165,22 @@ extern "C" { Z3_CATCH_RETURN(Z3_L_UNDEF); } + Z3_ast_vector Z3_API Z3_optimize_get_unsat_core(Z3_context c, Z3_optimize o) { + Z3_TRY; + LOG_Z3_optimize_get_unsat_core(c, o); + RESET_ERROR_CODE(); + expr_ref_vector core(mk_c(c)->m()); + to_optimize_ptr(o)->get_unsat_core(core); + Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m()); + mk_c(c)->save_object(v); + for (expr* e : core) { + v->m_ast_vector.push_back(e); + } + RETURN_Z3(of_ast_vector(v)); + Z3_CATCH_RETURN(nullptr); + } + + Z3_string Z3_API Z3_optimize_get_reason_unknown(Z3_context c, Z3_optimize o) { Z3_TRY; LOG_Z3_optimize_to_string(c, o); @@ -330,10 +354,8 @@ extern "C" { return; } - ptr_vector::const_iterator it = ctx->begin_assertions(); - ptr_vector::const_iterator end = ctx->end_assertions(); - for (; it != end; ++it) { - to_optimize_ptr(opt)->add_hard_constraint(*it); + for (expr * e : ctx->assertions()) { + to_optimize_ptr(opt)->add_hard_constraint(e); } } diff --git a/src/api/api_params.cpp b/src/api/api_params.cpp index 9d9f5157c..b2fa2e815 100644 --- a/src/api/api_params.cpp +++ b/src/api/api_params.cpp @@ -62,11 +62,11 @@ extern "C" { /** \brief Add a Boolean parameter \c k with value \c v to the parameter set \c p. */ - void Z3_API Z3_params_set_bool(Z3_context c, Z3_params p, Z3_symbol k, Z3_bool v) { + void Z3_API Z3_params_set_bool(Z3_context c, Z3_params p, Z3_symbol k, bool v) { Z3_TRY; LOG_Z3_params_set_bool(c, p, k, v); RESET_ERROR_CODE(); - to_params(p)->m_params.set_bool(norm_param_name(to_symbol(k)).c_str(), v != 0); + to_params(p)->m_params.set_bool(norm_param_name(to_symbol(k)).c_str(), v); Z3_CATCH; } diff --git a/src/api/api_parsers.cpp b/src/api/api_parsers.cpp index b88f273f9..32c133d2b 100644 --- a/src/api/api_parsers.cpp +++ b/src/api/api_parsers.cpp @@ -71,10 +71,8 @@ extern "C" { SET_ERROR_CODE(Z3_PARSER_ERROR, errstrm.str().c_str()); return of_ast_vector(v); } - ptr_vector::const_iterator it = ctx->begin_assertions(); - ptr_vector::const_iterator end = ctx->end_assertions(); - for (; it != end; ++it) { - v->m_ast_vector.push_back(*it); + for (expr * e : ctx->assertions()) { + v->m_ast_vector.push_back(e); } return of_ast_vector(v); Z3_CATCH_RETURN(nullptr); diff --git a/src/api/api_qe.cpp b/src/api/api_qe.cpp index 10ba9faa0..0b0c694d7 100644 --- a/src/api/api_qe.cpp +++ b/src/api/api_qe.cpp @@ -1,5 +1,5 @@ /*++ -Copyright (c) Microsoft Corporation, Arive Gurfinkel 2017 +Copyright (c) Microsoft Corporation, Arie Gurfinkel 2017 Module Name: diff --git a/src/api/api_quant.cpp b/src/api/api_quant.cpp index 6d6d19d56..546f4174a 100644 --- a/src/api/api_quant.cpp +++ b/src/api/api_quant.cpp @@ -26,7 +26,7 @@ extern "C" { Z3_ast Z3_API Z3_mk_quantifier( Z3_context c, - Z3_bool is_forall, + bool is_forall, unsigned weight, unsigned num_patterns, Z3_pattern const patterns[], unsigned num_decls, Z3_sort const sorts[], @@ -50,7 +50,7 @@ extern "C" { Z3_ast mk_quantifier_ex_core( Z3_context c, - Z3_bool is_forall, + bool is_forall, unsigned weight, Z3_symbol quantifier_id, Z3_symbol skolem_id, @@ -109,7 +109,7 @@ extern "C" { Z3_ast Z3_API Z3_mk_quantifier_ex( Z3_context c, - Z3_bool is_forall, + bool is_forall, unsigned weight, Z3_symbol quantifier_id, Z3_symbol skolem_id, @@ -132,7 +132,7 @@ extern "C" { unsigned num_decls, Z3_sort const types[], Z3_symbol const decl_names[], Z3_ast body) { - return Z3_mk_quantifier(c, 1, weight, num_patterns, patterns, num_decls, types, decl_names, body); + return Z3_mk_quantifier(c, true, weight, num_patterns, patterns, num_decls, types, decl_names, body); } Z3_ast Z3_API Z3_mk_exists(Z3_context c, @@ -141,7 +141,7 @@ extern "C" { unsigned num_decls, Z3_sort const types[], Z3_symbol const decl_names[], Z3_ast body) { - return Z3_mk_quantifier(c, 0, weight, num_patterns, patterns, num_decls, types, decl_names, body); + return Z3_mk_quantifier(c, false, weight, num_patterns, patterns, num_decls, types, decl_names, body); } Z3_ast Z3_API Z3_mk_lambda(Z3_context c, @@ -155,7 +155,7 @@ extern "C" { expr_ref result(mk_c(c)->m()); if (num_decls == 0) { SET_ERROR_CODE(Z3_INVALID_USAGE, nullptr); - RETURN_Z3(0); + RETURN_Z3(nullptr); } sort* const* ts = reinterpret_cast(types); @@ -166,7 +166,7 @@ extern "C" { result = mk_c(c)->m().mk_lambda(names.size(), ts, names.c_ptr(), to_expr(body)); mk_c(c)->save_ast_trail(result.get()); return of_ast(result.get()); - Z3_CATCH_RETURN(0); + Z3_CATCH_RETURN(nullptr); } Z3_ast Z3_API Z3_mk_lambda_const(Z3_context c, @@ -178,7 +178,7 @@ extern "C" { RESET_ERROR_CODE(); if (num_decls == 0) { SET_ERROR_CODE(Z3_INVALID_USAGE, nullptr); - RETURN_Z3(0); + RETURN_Z3(nullptr); } svector _names; @@ -196,12 +196,12 @@ extern "C" { result = mk_c(c)->m().mk_lambda(_vars.size(), _vars.c_ptr(), _names.c_ptr(), result); mk_c(c)->save_ast_trail(result.get()); return of_ast(result.get()); - Z3_CATCH_RETURN(0); + Z3_CATCH_RETURN(nullptr); } Z3_ast Z3_API Z3_mk_quantifier_const_ex(Z3_context c, - Z3_bool is_forall, + bool is_forall, unsigned weight, Z3_symbol quantifier_id, Z3_symbol skolem_id, @@ -283,7 +283,7 @@ extern "C" { } Z3_ast Z3_API Z3_mk_quantifier_const(Z3_context c, - Z3_bool is_forall, + bool is_forall, unsigned weight, unsigned num_bound, Z3_app const bound[], @@ -343,28 +343,28 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a) { + bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a) { Z3_TRY; LOG_Z3_is_quantifier_forall(c, a); RESET_ERROR_CODE(); - return ::is_forall(to_ast(a)) ? Z3_TRUE : Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return ::is_forall(to_ast(a)); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a) { + bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a) { Z3_TRY; LOG_Z3_is_quantifier_exists(c, a); RESET_ERROR_CODE(); - return ::is_exists(to_ast(a)) ? Z3_TRUE : Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return ::is_exists(to_ast(a)); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_is_lambda(Z3_context c, Z3_ast a) { + bool Z3_API Z3_is_lambda(Z3_context c, Z3_ast a) { Z3_TRY; LOG_Z3_is_lambda(c, a); RESET_ERROR_CODE(); - return ::is_lambda(to_ast(a)) ? Z3_TRUE : Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return ::is_lambda(to_ast(a)); + Z3_CATCH_RETURN(false); } diff --git a/src/api/api_rcf.cpp b/src/api/api_rcf.cpp index d92ff155b..840f6d3a8 100644 --- a/src/api/api_rcf.cpp +++ b/src/api/api_rcf.cpp @@ -214,67 +214,67 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_rcf_lt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { + bool Z3_API Z3_rcf_lt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { Z3_TRY; LOG_Z3_rcf_lt(c, a, b); RESET_ERROR_CODE(); reset_rcf_cancel(c); return rcfm(c).lt(to_rcnumeral(a), to_rcnumeral(b)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_rcf_gt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { + bool Z3_API Z3_rcf_gt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { Z3_TRY; LOG_Z3_rcf_gt(c, a, b); RESET_ERROR_CODE(); reset_rcf_cancel(c); return rcfm(c).gt(to_rcnumeral(a), to_rcnumeral(b)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_rcf_le(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { + bool Z3_API Z3_rcf_le(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { Z3_TRY; LOG_Z3_rcf_le(c, a, b); RESET_ERROR_CODE(); reset_rcf_cancel(c); return rcfm(c).le(to_rcnumeral(a), to_rcnumeral(b)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_rcf_ge(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { + bool Z3_API Z3_rcf_ge(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { Z3_TRY; LOG_Z3_rcf_ge(c, a, b); RESET_ERROR_CODE(); reset_rcf_cancel(c); return rcfm(c).ge(to_rcnumeral(a), to_rcnumeral(b)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_rcf_eq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { + bool Z3_API Z3_rcf_eq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { Z3_TRY; LOG_Z3_rcf_eq(c, a, b); RESET_ERROR_CODE(); reset_rcf_cancel(c); return rcfm(c).eq(to_rcnumeral(a), to_rcnumeral(b)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_rcf_neq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { + bool Z3_API Z3_rcf_neq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b) { Z3_TRY; LOG_Z3_rcf_neq(c, a, b); RESET_ERROR_CODE(); reset_rcf_cancel(c); return rcfm(c).neq(to_rcnumeral(a), to_rcnumeral(b)); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } - Z3_string Z3_API Z3_rcf_num_to_string(Z3_context c, Z3_rcf_num a, Z3_bool compact, Z3_bool html) { + Z3_string Z3_API Z3_rcf_num_to_string(Z3_context c, Z3_rcf_num a, bool compact, bool html) { Z3_TRY; LOG_Z3_rcf_num_to_string(c, a, compact, html); RESET_ERROR_CODE(); reset_rcf_cancel(c); std::ostringstream buffer; - rcfm(c).display(buffer, to_rcnumeral(a), compact != 0, html != 0); + rcfm(c).display(buffer, to_rcnumeral(a), compact, html); return mk_c(c)->mk_external_string(buffer.str()); Z3_CATCH_RETURN(""); } diff --git a/src/api/api_seq.cpp b/src/api/api_seq.cpp index 42979d1ed..19e298ee8 100644 --- a/src/api/api_seq.cpp +++ b/src/api/api_seq.cpp @@ -65,40 +65,36 @@ extern "C" { Z3_CATCH_RETURN(nullptr); } - Z3_bool Z3_API Z3_is_seq_sort(Z3_context c, Z3_sort s) { + bool Z3_API Z3_is_seq_sort(Z3_context c, Z3_sort s) { Z3_TRY; LOG_Z3_is_seq_sort(c, s); RESET_ERROR_CODE(); - bool result = mk_c(c)->sutil().is_seq(to_sort(s)); - return result?Z3_TRUE:Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return mk_c(c)->sutil().is_seq(to_sort(s)); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_is_re_sort(Z3_context c, Z3_sort s) { + bool Z3_API Z3_is_re_sort(Z3_context c, Z3_sort s) { Z3_TRY; LOG_Z3_is_re_sort(c, s); RESET_ERROR_CODE(); - bool result = mk_c(c)->sutil().is_re(to_sort(s)); - return result?Z3_TRUE:Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return mk_c(c)->sutil().is_re(to_sort(s)); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_is_string_sort(Z3_context c, Z3_sort s) { + bool Z3_API Z3_is_string_sort(Z3_context c, Z3_sort s) { Z3_TRY; LOG_Z3_is_string_sort(c, s); RESET_ERROR_CODE(); - bool result = mk_c(c)->sutil().is_string(to_sort(s)); - return result?Z3_TRUE:Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return mk_c(c)->sutil().is_string(to_sort(s)); + Z3_CATCH_RETURN(false); } - Z3_bool Z3_API Z3_is_string(Z3_context c, Z3_ast s) { + bool Z3_API Z3_is_string(Z3_context c, Z3_ast s) { Z3_TRY; LOG_Z3_is_string(c, s); RESET_ERROR_CODE(); - bool result = mk_c(c)->sutil().str.is_string(to_expr(s)); - return result?Z3_TRUE:Z3_FALSE; - Z3_CATCH_RETURN(Z3_FALSE); + return mk_c(c)->sutil().str.is_string(to_expr(s)); + Z3_CATCH_RETURN(false); } Z3_string Z3_API Z3_get_string(Z3_context c, Z3_ast s) { @@ -110,8 +106,8 @@ extern "C" { SET_ERROR_CODE(Z3_INVALID_ARG, "expression is not a string literal"); return ""; } - std::string result = str.encode(); - return mk_c(c)->mk_external_string(result); + std::string s = str.encode(); + return mk_c(c)->mk_external_string(s); Z3_CATCH_RETURN(""); } diff --git a/src/api/api_solver.cpp b/src/api/api_solver.cpp index 9ad51aaf4..a5ad7b525 100644 --- a/src/api/api_solver.cpp +++ b/src/api/api_solver.cpp @@ -157,10 +157,8 @@ extern "C" { bool initialized = to_solver(s)->m_solver.get() != nullptr; if (!initialized) init_solver(c, s); - ptr_vector::const_iterator it = ctx->begin_assertions(); - ptr_vector::const_iterator end = ctx->end_assertions(); - for (; it != end; ++it) { - to_solver_ref(s)->assert_expr(*it); + for (expr * e : ctx->assertions()) { + to_solver_ref(s)->assert_expr(e); } to_solver_ref(s)->set_model_converter(ctx->get_model_converter()); } @@ -179,16 +177,24 @@ extern "C" { LOG_Z3_solver_from_file(c, s, file_name); char const* ext = get_extension(file_name); std::ifstream is(file_name); + init_solver(c, s); if (!is) { SET_ERROR_CODE(Z3_FILE_ACCESS_ERROR, nullptr); } else if (ext && std::string("dimacs") == ext) { ast_manager& m = to_solver_ref(s)->get_manager(); + std::stringstream err; sat::solver solver(to_solver_ref(s)->get_params(), m.limit()); - parse_dimacs(is, solver); + if (!parse_dimacs(is, err, solver)) { + SET_ERROR_CODE(Z3_PARSER_ERROR, err.str().c_str()); + return; + } sat2goal s2g; ref mc; atom2bool_var a2b(m); + for (unsigned v = 0; v < solver.num_vars(); ++v) { + a2b.insert(m.mk_const(symbol(v), m.mk_bool_sort()), v); + } goal g(m); s2g(solver, a2b, to_solver_ref(s)->get_params(), g, mc); for (unsigned i = 0; i < g.size(); ++i) { @@ -368,7 +374,22 @@ extern "C" { v->m_ast_vector.push_back(f); } RETURN_Z3(of_ast_vector(v)); - Z3_CATCH_RETURN(0); + Z3_CATCH_RETURN(nullptr); + } + + Z3_ast_vector Z3_API Z3_solver_get_non_units(Z3_context c, Z3_solver s) { + Z3_TRY; + LOG_Z3_solver_get_non_units(c, s); + RESET_ERROR_CODE(); + init_solver(c, s); + Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m()); + mk_c(c)->save_object(v); + expr_ref_vector fmls = to_solver_ref(s)->get_non_units(mk_c(c)->m()); + for (expr* f : fmls) { + v->m_ast_vector.push_back(f); + } + RETURN_Z3(of_ast_vector(v)); + Z3_CATCH_RETURN(nullptr); } static Z3_lbool _solver_check(Z3_context c, Z3_solver s, unsigned num_assumptions, Z3_ast const assumptions[]) { @@ -615,7 +636,7 @@ extern "C" { } catch (z3_exception & ex) { mk_c(c)->handle_exception(ex); - return 0; + return nullptr; } } Z3_ast_vector_ref * v = alloc(Z3_ast_vector_ref, *mk_c(c), mk_c(c)->m()); @@ -628,7 +649,7 @@ extern "C" { to_ast_vector_ref(vs).push_back(a); } RETURN_Z3(of_ast_vector(v)); - Z3_CATCH_RETURN(0); + Z3_CATCH_RETURN(nullptr); } diff --git a/src/api/api_stats.cpp b/src/api/api_stats.cpp index 2014d57b8..3ff87039f 100644 --- a/src/api/api_stats.cpp +++ b/src/api/api_stats.cpp @@ -74,28 +74,28 @@ extern "C" { Z3_CATCH_RETURN(""); } - Z3_bool Z3_API Z3_stats_is_uint(Z3_context c, Z3_stats s, unsigned idx) { + bool Z3_API Z3_stats_is_uint(Z3_context c, Z3_stats s, unsigned idx) { Z3_TRY; LOG_Z3_stats_is_uint(c, s, idx); RESET_ERROR_CODE(); if (idx >= to_stats_ref(s).size()) { SET_ERROR_CODE(Z3_IOB, nullptr); - return Z3_FALSE; + return false; } return to_stats_ref(s).is_uint(idx); Z3_CATCH_RETURN(0); } - Z3_bool Z3_API Z3_stats_is_double(Z3_context c, Z3_stats s, unsigned idx) { + bool Z3_API Z3_stats_is_double(Z3_context c, Z3_stats s, unsigned idx) { Z3_TRY; LOG_Z3_stats_is_double(c, s, idx); RESET_ERROR_CODE(); if (idx >= to_stats_ref(s).size()) { SET_ERROR_CODE(Z3_IOB, nullptr); - return Z3_FALSE; + return false; } return !to_stats_ref(s).is_uint(idx); - Z3_CATCH_RETURN(Z3_FALSE); + Z3_CATCH_RETURN(false); } unsigned Z3_API Z3_stats_get_uint_value(Z3_context c, Z3_stats s, unsigned idx) { diff --git a/src/api/c++/z3++.h b/src/api/c++/z3++.h index e1f263e17..7d45c9707 100644 --- a/src/api/c++/z3++.h +++ b/src/api/c++/z3++.h @@ -28,6 +28,9 @@ Notes: #include #include +#undef min +#undef max + /** \defgroup cppapi C++ API @@ -127,6 +130,14 @@ namespace z3 { unsat, sat, unknown }; + enum rounding_mode { + RNA, + RNE, + RTP, + RTN, + RTZ + }; + inline check_result to_check_result(Z3_lbool l) { if (l == Z3_L_TRUE) return sat; else if (l == Z3_L_FALSE) return unsat; @@ -137,12 +148,17 @@ namespace z3 { /** \brief A Context manages all other Z3 objects, global configuration options, etc. */ + + class context { + private: bool m_enable_exceptions; + rounding_mode m_rounding_mode; Z3_context m_ctx; void init(config & c) { m_ctx = Z3_mk_context_rc(c); m_enable_exceptions = true; + m_rounding_mode = RNA; Z3_set_error_handler(m_ctx, 0); Z3_set_ast_print_mode(m_ctx, Z3_PRINT_SMTLIB2_COMPLIANT); } @@ -171,7 +187,7 @@ namespace z3 { } /** - \brief The C++ API uses by defaults exceptions on errors. + \brief The C++ API uses by defaults exceptions on errors. For applications that don't work well with exceptions (there should be only few) you have the ability to turn off exceptions. The tradeoffs are that applications have to be very careful about using check_error() after calls that may result in an @@ -247,6 +263,26 @@ namespace z3 { */ sort array_sort(sort d, sort r); sort array_sort(sort_vector const& d, sort r); + /** + \brief Return a floating point sort. + \c ebits is a number of exponent bits, + \c sbits is a number of significand bits, + \pre where ebits must be larger than 1 and sbits must be larger than 2. + */ + sort fpa_sort(unsigned ebits, unsigned sbits); + /** + \brief Return a FloatingPoint sort with given precision bitwidth (16, 32, 64 or 128). + */ + template + sort fpa_sort(); + /** + \brief Return a RoundingMode sort. + */ + sort fpa_rounding_mode(); + /** + \brief Sets RoundingMode of FloatingPoints. + */ + void set_rounding_mode(rounding_mode rm); /** \brief Return an enumeration sort: enum_names[0], ..., enum_names[n-1]. \c cs and \c ts are output parameters. The method stores in \c cs the constants corresponding to the enumerated elements, @@ -258,7 +294,7 @@ namespace z3 { \brief Return a tuple constructor. \c name is the name of the returned constructor, \c n are the number of arguments, \c names and \c sorts are their projected sorts. - \c projs is an output paramter. It contains the set of projection functions. + \c projs is an output parameter. It contains the set of projection functions. */ func_decl tuple_sort(char const * name, unsigned n, char const * const * names, sort const* sorts, func_decl_vector & projs); @@ -278,12 +314,23 @@ namespace z3 { func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & range); func_decl function(char const * name, sort const & d1, sort const & d2, sort const & d3, sort const & d4, sort const & d5, sort const & range); + func_decl recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range); + func_decl recfun(char const * name, unsigned arity, sort const * domain, sort const & range); + func_decl recfun(char const * name, sort const & domain, sort const & range); + func_decl recfun(char const * name, sort const & d1, sort const & d2, sort const & range); + + void recdef(func_decl, expr_vector const& args, expr const& body); + expr constant(symbol const & name, sort const & s); expr constant(char const * name, sort const & s); expr bool_const(char const * name); expr int_const(char const * name); expr real_const(char const * name); expr bv_const(char const * name, unsigned sz); + expr fpa_const(char const * name, unsigned ebits, unsigned sbits); + + template + expr fpa_const(char const * name); expr bool_val(bool b); @@ -307,6 +354,9 @@ namespace z3 { expr bv_val(char const * n, unsigned sz); expr bv_val(unsigned n, bool const* bits); + expr fpa_val(double n); + expr fpa_val(float n); + expr string_val(char const* s); expr string_val(std::string const& s); @@ -455,7 +505,7 @@ namespace z3 { out << Z3_ast_to_string(n.ctx(), n.m_ast); return out; } - inline bool eq(ast const & a, ast const & b) { return Z3_is_eq_ast(a.ctx(), a, b) != 0; } + inline bool eq(ast const & a, ast const & b) { return Z3_is_eq_ast(a.ctx(), a, b); } /** @@ -465,6 +515,7 @@ namespace z3 { public: sort(context & c):ast(c) {} sort(context & c, Z3_sort s):ast(c, reinterpret_cast(s)) {} + sort(context & c, Z3_ast a):ast(c, a) {} sort(sort const & s):ast(s) {} operator Z3_sort() const { return reinterpret_cast(m_ast); } /** @@ -523,6 +574,10 @@ namespace z3 { \brief Return true if this sort is a Finite domain sort. */ bool is_finite_domain() const { return sort_kind() == Z3_FINITE_DOMAIN_SORT; } + /** + \brief Return true if this sort is a Floating point sort. + */ + bool is_fpa() const { return sort_kind() == Z3_FLOATING_POINT_SORT; } /** \brief Return the size of this Bit-vector sort. @@ -531,6 +586,9 @@ namespace z3 { */ unsigned bv_size() const { assert(is_bv()); unsigned r = Z3_get_bv_sort_size(ctx(), *this); check_error(); return r; } + unsigned fpa_ebits() const { assert(is_fpa()); unsigned r = Z3_fpa_get_ebits(ctx(), *this); check_error(); return r; } + + unsigned fpa_sbits() const { assert(is_fpa()); unsigned r = Z3_fpa_get_sbits(ctx(), *this); check_error(); return r; } /** \brief Return the domain of this Array sort. @@ -634,7 +692,7 @@ namespace z3 { \brief Return true if this is a regular expression. */ bool is_re() const { return get_sort().is_re(); } - + /** \brief Return true if this is a Finite-domain expression. @@ -644,6 +702,10 @@ namespace z3 { */ bool is_finite_domain() const { return get_sort().is_finite_domain(); } + /** + \brief Return true if this is a FloatingPoint expression. . + */ + bool is_fpa() const { return get_sort().is_fpa(); } /** \brief Return true if this expression is a numeral. @@ -651,12 +713,13 @@ namespace z3 { small integers, 64 bit integers or rational or decimal strings. */ bool is_numeral() const { return kind() == Z3_NUMERAL_AST; } - bool is_numeral_i64(int64_t& i) const { bool r = 0 != Z3_get_numeral_int64(ctx(), m_ast, &i); check_error(); return r;} - bool is_numeral_u64(uint64_t& i) const { bool r = 0 != Z3_get_numeral_uint64(ctx(), m_ast, &i); check_error(); return r;} - bool is_numeral_i(int& i) const { bool r = 0 != Z3_get_numeral_int(ctx(), m_ast, &i); check_error(); return r;} - bool is_numeral_u(unsigned& i) const { bool r = 0 != Z3_get_numeral_uint(ctx(), m_ast, &i); check_error(); return r;} + bool is_numeral_i64(int64_t& i) const { bool r = Z3_get_numeral_int64(ctx(), m_ast, &i); check_error(); return r;} + bool is_numeral_u64(uint64_t& i) const { bool r = Z3_get_numeral_uint64(ctx(), m_ast, &i); check_error(); return r;} + bool is_numeral_i(int& i) const { bool r = Z3_get_numeral_int(ctx(), m_ast, &i); check_error(); return r;} + bool is_numeral_u(unsigned& i) const { bool r = Z3_get_numeral_uint(ctx(), m_ast, &i); check_error(); return r;} bool is_numeral(std::string& s) const { if (!is_numeral()) return false; s = Z3_get_numeral_string(ctx(), m_ast); check_error(); return true; } bool is_numeral(std::string& s, unsigned precision) const { if (!is_numeral()) return false; s = Z3_get_numeral_decimal_string(ctx(), m_ast, precision); check_error(); return true; } + bool is_numeral(double& d) const { if (!is_numeral()) return false; d = Z3_get_numeral_double(ctx(), m_ast); check_error(); return true; } /** \brief Return true if this expression is an application. */ @@ -673,15 +736,15 @@ namespace z3 { /** \brief Return true if this expression is a universal quantifier. */ - bool is_forall() const { return 0 != Z3_is_quantifier_forall(ctx(), m_ast); } + bool is_forall() const { return Z3_is_quantifier_forall(ctx(), m_ast); } /** \brief Return true if this expression is an existential quantifier. */ - bool is_exists() const { return 0 != Z3_is_quantifier_exists(ctx(), m_ast); } + bool is_exists() const { return Z3_is_quantifier_exists(ctx(), m_ast); } /** \brief Return true if this expression is a lambda expression. */ - bool is_lambda() const { return 0 != Z3_is_lambda(ctx(), m_ast); } + bool is_lambda() const { return Z3_is_lambda(ctx(), m_ast); } /** \brief Return true if this expression is a variable. @@ -690,35 +753,35 @@ namespace z3 { /** \brief Return true if expression is an algebraic number. */ - bool is_algebraic() const { return 0 != Z3_is_algebraic_number(ctx(), m_ast); } + bool is_algebraic() const { return Z3_is_algebraic_number(ctx(), m_ast); } /** \brief Return true if this expression is well sorted (aka type correct). */ - bool is_well_sorted() const { bool r = Z3_is_well_sorted(ctx(), m_ast) != 0; check_error(); return r; } - + bool is_well_sorted() const { bool r = Z3_is_well_sorted(ctx(), m_ast); check_error(); return r; } + /** \brief Return string representation of numeral or algebraic number This method assumes the expression is numeral or algebraic - + \pre is_numeral() || is_algebraic() */ std::string get_decimal_string(int precision) const { assert(is_numeral() || is_algebraic()); return std::string(Z3_get_numeral_decimal_string(ctx(), m_ast, precision)); } - + /** \brief Return int value of numeral, throw if result cannot fit in machine int It only makes sense to use this function if the caller can ensure that - the result is an integer or if exceptions are enabled. + the result is an integer or if exceptions are enabled. If exceptions are disabled, then use the is_numeral_i function. - + \pre is_numeral() */ - int get_numeral_int() const { + int get_numeral_int() const { int result = 0; if (!is_numeral_i(result)) { assert(ctx().enable_exceptions()); @@ -727,13 +790,13 @@ namespace z3 { } return result; } - + /** \brief Return uint value of numeral, throw if result cannot fit in machine uint It only makes sense to use this function if the caller can ensure that - the result is an integer or if exceptions are enabled. + the result is an integer or if exceptions are enabled. If exceptions are disabled, then use the is_numeral_u function. \pre is_numeral() */ @@ -747,11 +810,11 @@ namespace z3 { } return result; } - + /** \brief Return \c int64_t value of numeral, throw if result cannot fit in \c int64_t. - + \pre is_numeral() */ int64_t get_numeral_int64() const { @@ -764,11 +827,11 @@ namespace z3 { } return result; } - + /** \brief Return \c uint64_t value of numeral, throw if result cannot fit in \c uint64_t. - + \pre is_numeral() */ uint64_t get_numeral_uint64() const { @@ -786,7 +849,7 @@ namespace z3 { return Z3_get_bool_value(ctx(), m_ast); } - expr numerator() const { + expr numerator() const { assert(is_numeral()); Z3_ast r = Z3_get_numerator(ctx(), m_ast); check_error(); @@ -794,7 +857,7 @@ namespace z3 { } - expr denominator() const { + expr denominator() const { assert(is_numeral()); Z3_ast r = Z3_get_denominator(ctx(), m_ast); check_error(); @@ -803,6 +866,17 @@ namespace z3 { operator Z3_app() const { assert(is_app()); return reinterpret_cast(m_ast); } + /** + \brief Return a RoundingMode sort. + */ + sort fpa_rounding_mode() { + assert(is_fpa()); + Z3_sort s = ctx().fpa_rounding_mode(); + check_error(); + return sort(ctx(), s); + } + + /** \brief Return the declaration associated with this application. This method assumes the expression is an application. @@ -905,7 +979,7 @@ namespace z3 { bool is_implies() const { return is_app() && Z3_OP_IMPLIES == decl().decl_kind(); } bool is_eq() const { return is_app() && Z3_OP_EQ == decl().decl_kind(); } bool is_ite() const { return is_app() && Z3_OP_ITE == decl().decl_kind(); } - + friend expr distinct(expr_vector const& args); friend expr concat(expr const& a, expr const& b); friend expr concat(expr_vector const& args); @@ -992,23 +1066,34 @@ namespace z3 { friend expr nor(expr const& a, expr const& b); friend expr xnor(expr const& a, expr const& b); + friend expr min(expr const& a, expr const& b); + friend expr max(expr const& a, expr const& b); + expr rotate_left(unsigned i) { Z3_ast r = Z3_mk_rotate_left(ctx(), i, *this); ctx().check_error(); return expr(ctx(), r); } expr rotate_right(unsigned i) { Z3_ast r = Z3_mk_rotate_right(ctx(), i, *this); ctx().check_error(); return expr(ctx(), r); } expr repeat(unsigned i) { Z3_ast r = Z3_mk_repeat(ctx(), i, *this); ctx().check_error(); return expr(ctx(), r); } + friend expr abs(expr const & a); + friend expr sqrt(expr const & a, expr const & rm); + friend expr operator~(expr const & a); - expr extract(unsigned hi, unsigned lo) const { Z3_ast r = Z3_mk_extract(ctx(), hi, lo, *this); ctx().check_error(); return expr(ctx(), r); } + expr extract(unsigned hi, unsigned lo) const { Z3_ast r = Z3_mk_extract(ctx(), hi, lo, *this); ctx().check_error(); return expr(ctx(), r); } unsigned lo() const { assert (is_app() && Z3_get_decl_num_parameters(ctx(), decl()) == 2); return static_cast(Z3_get_decl_int_parameter(ctx(), decl(), 1)); } unsigned hi() const { assert (is_app() && Z3_get_decl_num_parameters(ctx(), decl()) == 2); return static_cast(Z3_get_decl_int_parameter(ctx(), decl(), 0)); } + /** + \brief FloatingPoint fused multiply-add. + */ + friend expr fma(expr const& a, expr const& b, expr const& c); + /** \brief sequence and regular expression operations. + is overloaded as sequence concatenation and regular expression union. concat is overloaded to handle sequences and regular expressions */ - expr extract(expr const& offset, expr const& length) const { + expr extract(expr const& offset, expr const& length) const { check_context(*this, offset); check_context(offset, length); - Z3_ast r = Z3_mk_seq_extract(ctx(), *this, offset, length); check_error(); return expr(ctx(), r); + Z3_ast r = Z3_mk_seq_extract(ctx(), *this, offset, length); check_error(); return expr(ctx(), r); } expr replace(expr const& src, expr const& dst) const { check_context(*this, src); check_context(src, dst); @@ -1049,19 +1134,19 @@ namespace z3 { return expr(ctx(), r); } - friend expr range(expr const& lo, expr const& hi); + friend expr range(expr const& lo, expr const& hi); /** \brief create a looping regular expression. */ expr loop(unsigned lo) { - Z3_ast r = Z3_mk_re_loop(ctx(), m_ast, lo, 0); - check_error(); - return expr(ctx(), r); + Z3_ast r = Z3_mk_re_loop(ctx(), m_ast, lo, 0); + check_error(); + return expr(ctx(), r); } expr loop(unsigned lo, unsigned hi) { - Z3_ast r = Z3_mk_re_loop(ctx(), m_ast, lo, hi); - check_error(); - return expr(ctx(), r); + Z3_ast r = Z3_mk_re_loop(ctx(), m_ast, lo, hi); + check_error(); + return expr(ctx(), r); } @@ -1094,7 +1179,7 @@ namespace z3 { inline expr implies(expr const & a, expr const & b) { - assert(a.is_bool() && b.is_bool()); + assert(a.is_bool() && b.is_bool()); _Z3_MK_BIN_(a, b, Z3_mk_implies); } inline expr implies(expr const & a, bool b) { return implies(a, a.ctx().bool_val(b)); } @@ -1109,7 +1194,13 @@ namespace z3 { inline expr mod(expr const & a, int b) { return mod(a, a.ctx().num_val(b, a.get_sort())); } inline expr mod(int a, expr const & b) { return mod(b.ctx().num_val(a, b.get_sort()), b); } - inline expr rem(expr const& a, expr const& b) { _Z3_MK_BIN_(a, b, Z3_mk_rem); } + inline expr rem(expr const& a, expr const& b) { + if (a.is_fpa() && b.is_fpa()) { + _Z3_MK_BIN_(a, b, Z3_mk_fpa_rem); + } else { + _Z3_MK_BIN_(a, b, Z3_mk_rem); + } + } inline expr rem(expr const & a, int b) { return rem(a, a.ctx().num_val(b, a.get_sort())); } inline expr rem(int a, expr const & b) { return rem(b.ctx().num_val(a, b.get_sort()), b); } @@ -1158,8 +1249,8 @@ namespace z3 { a.check_error(); return expr(a.ctx(), r); } - inline expr operator==(expr const & a, int b) { assert(a.is_arith() || a.is_bv()); return a == a.ctx().num_val(b, a.get_sort()); } - inline expr operator==(int a, expr const & b) { assert(b.is_arith() || b.is_bv()); return b.ctx().num_val(a, b.get_sort()) == b; } + inline expr operator==(expr const & a, int b) { assert(a.is_arith() || a.is_bv() || a.is_fpa()); return a == a.ctx().num_val(b, a.get_sort()); } + inline expr operator==(int a, expr const & b) { assert(b.is_arith() || b.is_bv() || b.is_fpa()); return b.ctx().num_val(a, b.get_sort()) == b; } inline expr operator!=(expr const & a, expr const & b) { check_context(a, b); @@ -1168,8 +1259,8 @@ namespace z3 { a.check_error(); return expr(a.ctx(), r); } - inline expr operator!=(expr const & a, int b) { assert(a.is_arith() || a.is_bv()); return a != a.ctx().num_val(b, a.get_sort()); } - inline expr operator!=(int a, expr const & b) { assert(b.is_arith() || b.is_bv()); return b.ctx().num_val(a, b.get_sort()) != b; } + inline expr operator!=(expr const & a, int b) { assert(a.is_arith() || a.is_bv() || a.is_fpa()); return a != a.ctx().num_val(b, a.get_sort()); } + inline expr operator!=(int a, expr const & b) { assert(b.is_arith() || b.is_bv() || b.is_fpa()); return b.ctx().num_val(a, b.get_sort()) != b; } inline expr operator+(expr const & a, expr const & b) { check_context(a, b); @@ -1188,6 +1279,9 @@ namespace z3 { Z3_ast _args[2] = { a, b }; r = Z3_mk_re_union(a.ctx(), 2, _args); } + else if (a.is_fpa() && b.is_fpa()) { + r = Z3_mk_fpa_add(a.ctx(), a.ctx().fpa_rounding_mode(), a, b); + } else { // operator is not supported by given arguments. assert(false); @@ -1208,6 +1302,9 @@ namespace z3 { else if (a.is_bv() && b.is_bv()) { r = Z3_mk_bvmul(a.ctx(), a, b); } + else if (a.is_fpa() && b.is_fpa()) { + r = Z3_mk_fpa_mul(a.ctx(), a.ctx().fpa_rounding_mode(), a, b); + } else { // operator is not supported by given arguments. assert(false); @@ -1245,6 +1342,9 @@ namespace z3 { else if (a.is_bv() && b.is_bv()) { r = Z3_mk_bvsdiv(a.ctx(), a, b); } + else if (a.is_fpa() && b.is_fpa()) { + r = Z3_mk_fpa_div(a.ctx(), a.ctx().fpa_rounding_mode(), a, b); + } else { // operator is not supported by given arguments. assert(false); @@ -1263,6 +1363,9 @@ namespace z3 { else if (a.is_bv()) { r = Z3_mk_bvneg(a.ctx(), a); } + else if (a.is_fpa()) { + r = Z3_mk_fpa_neg(a.ctx(), a); + } else { // operator is not supported by given arguments. assert(false); @@ -1281,6 +1384,9 @@ namespace z3 { else if (a.is_bv() && b.is_bv()) { r = Z3_mk_bvsub(a.ctx(), a, b); } + else if (a.is_fpa() && b.is_fpa()) { + r = Z3_mk_fpa_sub(a.ctx(), a.ctx().fpa_rounding_mode(), a, b); + } else { // operator is not supported by given arguments. assert(false); @@ -1300,6 +1406,9 @@ namespace z3 { else if (a.is_bv() && b.is_bv()) { r = Z3_mk_bvsle(a.ctx(), a, b); } + else if (a.is_fpa() && b.is_fpa()) { + r = Z3_mk_fpa_leq(a.ctx(), a, b); + } else { // operator is not supported by given arguments. assert(false); @@ -1322,6 +1431,9 @@ namespace z3 { else if (a.is_bv() && b.is_bv()) { r = Z3_mk_bvslt(a.ctx(), a, b); } + else if (a.is_fpa() && b.is_fpa()) { + r = Z3_mk_fpa_lt(a.ctx(), a, b); + } else { // operator is not supported by given arguments. assert(false); @@ -1341,6 +1453,9 @@ namespace z3 { else if (a.is_bv() && b.is_bv()) { r = Z3_mk_bvsgt(a.ctx(), a, b); } + else if (a.is_fpa() && b.is_fpa()) { + r = Z3_mk_fpa_gt(a.ctx(), a, b); + } else { // operator is not supported by given arguments. assert(false); @@ -1366,17 +1481,72 @@ namespace z3 { inline expr nand(expr const& a, expr const& b) { check_context(a, b); Z3_ast r = Z3_mk_bvnand(a.ctx(), a, b); return expr(a.ctx(), r); } inline expr nor(expr const& a, expr const& b) { check_context(a, b); Z3_ast r = Z3_mk_bvnor(a.ctx(), a, b); return expr(a.ctx(), r); } inline expr xnor(expr const& a, expr const& b) { check_context(a, b); Z3_ast r = Z3_mk_bvxnor(a.ctx(), a, b); return expr(a.ctx(), r); } - + inline expr min(expr const& a, expr const& b) { + check_context(a, b); + Z3_ast r; + if (a.is_arith()) { + r = Z3_mk_ite(a.ctx(), Z3_mk_ge(a.ctx(), a, b), b, a); + } + else if (a.is_bv()) { + r = Z3_mk_ite(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b), b, a); + } + else { + assert(a.is_fpa()); + r = Z3_mk_fpa_min(a.ctx(), a, b); + } + return expr(a.ctx(), r); + } + inline expr max(expr const& a, expr const& b) { + check_context(a, b); + Z3_ast r; + if (a.is_arith()) { + r = Z3_mk_ite(a.ctx(), Z3_mk_ge(a.ctx(), a, b), a, b); + } + else if (a.is_bv()) { + r = Z3_mk_ite(a.ctx(), Z3_mk_bvuge(a.ctx(), a, b), a, b); + } + else { + assert(a.is_fpa()); + r = Z3_mk_fpa_max(a.ctx(), a, b); + } + return expr(a.ctx(), r); + } + inline expr abs(expr const & a) { + Z3_ast r; + if (a.is_int()) { + expr zero = a.ctx().int_val(0); + r = Z3_mk_ite(a.ctx(), Z3_mk_ge(a.ctx(), a, zero), a, -a); + } + else if (a.is_real()) { + expr zero = a.ctx().real_val(0); + r = Z3_mk_ite(a.ctx(), Z3_mk_ge(a.ctx(), a, zero), a, -a); + } + else { + r = Z3_mk_fpa_abs(a.ctx(), a); + } + return expr(a.ctx(), r); + } + inline expr sqrt(expr const & a, expr const& rm) { + check_context(a, rm); + assert(a.is_fpa()); + Z3_ast r = Z3_mk_fpa_sqrt(a.ctx(), rm, a); + return expr(a.ctx(), r); + } inline expr operator~(expr const & a) { Z3_ast r = Z3_mk_bvnot(a.ctx(), a); return expr(a.ctx(), r); } - + inline expr fma(expr const& a, expr const& b, expr const& c, expr const& rm) { + check_context(a, b); check_context(a, c); check_context(a, rm); + assert(a.is_fpa() && b.is_fpa() && c.is_fpa()); + Z3_ast r = Z3_mk_fpa_fma(a.ctx(), rm, a, b, c); + a.check_error(); + return expr(a.ctx(), r); + } /** \brief Create the if-then-else expression ite(c, t, e) \pre c.is_bool() */ - inline expr ite(expr const & c, expr const & t, expr const & e) { check_context(c, t); check_context(c, e); assert(c.is_bool()); @@ -1453,45 +1623,45 @@ namespace z3 { inline expr smod(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvsmod(a.ctx(), a, b)); } inline expr smod(expr const & a, int b) { return smod(a, a.ctx().num_val(b, a.get_sort())); } inline expr smod(int a, expr const & b) { return smod(b.ctx().num_val(a, b.get_sort()), b); } - + /** \brief unsigned reminder operator for bitvectors */ inline expr urem(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvurem(a.ctx(), a, b)); } inline expr urem(expr const & a, int b) { return urem(a, a.ctx().num_val(b, a.get_sort())); } inline expr urem(int a, expr const & b) { return urem(b.ctx().num_val(a, b.get_sort()), b); } - + /** \brief shift left operator for bitvectors */ inline expr shl(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvshl(a.ctx(), a, b)); } inline expr shl(expr const & a, int b) { return shl(a, a.ctx().num_val(b, a.get_sort())); } inline expr shl(int a, expr const & b) { return shl(b.ctx().num_val(a, b.get_sort()), b); } - + /** \brief logic shift right operator for bitvectors */ inline expr lshr(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvlshr(a.ctx(), a, b)); } inline expr lshr(expr const & a, int b) { return lshr(a, a.ctx().num_val(b, a.get_sort())); } inline expr lshr(int a, expr const & b) { return lshr(b.ctx().num_val(a, b.get_sort()), b); } - + /** \brief arithmetic shift right operator for bitvectors */ inline expr ashr(expr const & a, expr const & b) { return to_expr(a.ctx(), Z3_mk_bvashr(a.ctx(), a, b)); } inline expr ashr(expr const & a, int b) { return ashr(a, a.ctx().num_val(b, a.get_sort())); } inline expr ashr(int a, expr const & b) { return ashr(b.ctx().num_val(a, b.get_sort()), b); } - + /** \brief Extend the given bit-vector with zeros to the (unsigned) equivalent bitvector of size m+i, where m is the size of the given bit-vector. */ inline expr zext(expr const & a, unsigned i) { return to_expr(a.ctx(), Z3_mk_zero_ext(a.ctx(), i, a)); } - + /** \brief Sign-extend of the given bit-vector to the (signed) equivalent bitvector of size m+i, where m is the size of the given bit-vector. */ inline expr sext(expr const & a, unsigned i) { return to_expr(a.ctx(), Z3_mk_sign_ext(a.ctx(), i, a)); } - + template class cast_ast; template<> class cast_ast { @@ -1563,7 +1733,7 @@ namespace z3 { unsigned m_index; public: iterator(ast_vector_tpl const* v, unsigned i): m_vector(v), m_index(i) {} - iterator(iterator& other): m_vector(other.m_vector), m_index(other.m_index) {} + iterator(iterator& other): m_vector(other.m_vector), m_index(other.m_index) {} iterator operator=(iterator const& other) { m_vector = other.m_vector; m_index = other.m_index; return *this; } bool operator==(iterator const& other) { @@ -1773,7 +1943,7 @@ namespace z3 { return expr(ctx, r); } - inline expr mk_or(expr_vector const& args) { + inline expr mk_or(expr_vector const& args) { array _args(args); Z3_ast r = Z3_mk_or(args.ctx(), _args.size(), _args.ptr()); args.check_error(); @@ -1852,7 +2022,7 @@ namespace z3 { model(context & c):object(c) { init(Z3_mk_model(c)); } model(context & c, Z3_model m):object(c) { init(m); } model(model const & s):object(s) { init(s.m_model); } - model(model& src, context& dst, translate) : object(dst) { init(Z3_model_translate(src.ctx(), src, dst)); } + model(model& src, context& dst, translate) : object(dst) { init(Z3_model_translate(src.ctx(), src, dst)); } ~model() { Z3_model_dec_ref(ctx(), m_model); } operator Z3_model() const { return m_model; } model & operator=(model const & s) { @@ -1866,9 +2036,9 @@ namespace z3 { expr eval(expr const & n, bool model_completion=false) const { check_context(*this, n); Z3_ast r = 0; - Z3_bool status = Z3_model_eval(ctx(), m_model, n, model_completion, &r); + bool status = Z3_model_eval(ctx(), m_model, n, model_completion, &r); check_error(); - if (status == Z3_FALSE && ctx().enable_exceptions()) + if (status == false && ctx().enable_exceptions()) Z3_THROW(exception("failed to evaluate expression")); return expr(ctx(), r); } @@ -1884,7 +2054,7 @@ namespace z3 { } // returns interpretation of constant declaration c. - // If c is not assigned any value in the model it returns + // If c is not assigned any value in the model it returns // an expression with a null ast reference. expr get_const_interp(func_decl c) const { check_context(*this, c); @@ -1898,12 +2068,12 @@ namespace z3 { check_error(); return func_interp(ctx(), r); } - + // returns true iff the model contains an interpretation // for function f. bool has_interp(func_decl f) const { check_context(*this, f); - return 0 != Z3_model_has_interp(ctx(), m_model, f); + return Z3_model_has_interp(ctx(), m_model, f); } func_interp add_func_interp(func_decl& f, expr& else_val) { @@ -1942,10 +2112,10 @@ namespace z3 { } unsigned size() const { return Z3_stats_size(ctx(), m_stats); } std::string key(unsigned i) const { Z3_string s = Z3_stats_get_key(ctx(), m_stats, i); check_error(); return s; } - bool is_uint(unsigned i) const { Z3_bool r = Z3_stats_is_uint(ctx(), m_stats, i); check_error(); return r != 0; } - bool is_double(unsigned i) const { Z3_bool r = Z3_stats_is_double(ctx(), m_stats, i); check_error(); return r != 0; } + bool is_uint(unsigned i) const { bool r = Z3_stats_is_uint(ctx(), m_stats, i); check_error(); return r; } + bool is_double(unsigned i) const { bool r = Z3_stats_is_double(ctx(), m_stats, i); check_error(); return r; } unsigned uint_value(unsigned i) const { unsigned r = Z3_stats_get_uint_value(ctx(), m_stats, i); check_error(); return r; } - double double_value(unsigned i) const { double r = Z3_stats_get_double_value(ctx(), m_stats, i); check_error(); return r; } + double double_value(unsigned i) const { double r = Z3_stats_get_double_value(ctx(), m_stats, i); check_error(); return r; } friend std::ostream & operator<<(std::ostream & out, stats const & s); }; inline std::ostream & operator<<(std::ostream & out, stats const & s) { out << Z3_stats_to_string(s.ctx(), s); return out; } @@ -2001,7 +2171,7 @@ namespace z3 { void add(expr const & e, char const * p) { add(e, ctx().bool_const(p)); } - // fails for some compilers: + // fails for some compilers: // void add(expr_vector const& v) { check_context(*this, v); for (expr e : v) add(e); } void from_file(char const* file) { Z3_solver_from_file(ctx(), m_solver, file); ctx().check_parser_error(); } void from_string(char const* s) { Z3_solver_from_string(ctx(), m_solver, s); ctx().check_parser_error(); } @@ -2038,6 +2208,8 @@ namespace z3 { stats statistics() const { Z3_stats r = Z3_solver_get_statistics(ctx(), m_solver); check_error(); return stats(ctx(), r); } expr_vector unsat_core() const { Z3_ast_vector r = Z3_solver_get_unsat_core(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); } expr_vector assertions() const { Z3_ast_vector r = Z3_solver_get_assertions(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); } + expr_vector non_units() const { Z3_ast_vector r = Z3_solver_get_non_units(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); } + expr_vector units() const { Z3_ast_vector r = Z3_solver_get_units(ctx(), m_solver); check_error(); return expr_vector(ctx(), r); } expr proof() const { Z3_ast r = Z3_solver_get_proof(ctx(), m_solver); check_error(); return expr(ctx(), r); } friend std::ostream & operator<<(std::ostream & out, solver const & s); @@ -2064,11 +2236,11 @@ namespace z3 { param_descrs get_param_descrs() { return param_descrs(ctx(), Z3_solver_get_param_descrs(ctx(), m_solver)); } - expr_vector cube(expr_vector& vars, unsigned cutoff) { - Z3_ast_vector r = Z3_solver_cube(ctx(), m_solver, vars, cutoff); - check_error(); - return expr_vector(ctx(), r); - } + expr_vector cube(expr_vector& vars, unsigned cutoff) { + Z3_ast_vector r = Z3_solver_cube(ctx(), m_solver, vars, cutoff); + check_error(); + return expr_vector(ctx(), r); + } class cube_iterator { solver& m_solver; @@ -2116,7 +2288,7 @@ namespace z3 { cube_iterator operator++(int) { assert(false); return *this; } expr_vector const * operator->() const { return &(operator*()); } expr_vector const& operator*() const { return m_cube; } - + bool operator==(cube_iterator const& other) { return other.m_end == m_end; }; @@ -2181,12 +2353,12 @@ namespace z3 { unsigned size() const { return Z3_goal_size(ctx(), m_goal); } expr operator[](int i) const { assert(0 <= i); Z3_ast r = Z3_goal_formula(ctx(), m_goal, i); check_error(); return expr(ctx(), r); } Z3_goal_prec precision() const { return Z3_goal_precision(ctx(), m_goal); } - bool inconsistent() const { return Z3_goal_inconsistent(ctx(), m_goal) != 0; } + bool inconsistent() const { return Z3_goal_inconsistent(ctx(), m_goal); } unsigned depth() const { return Z3_goal_depth(ctx(), m_goal); } void reset() { Z3_goal_reset(ctx(), m_goal); } unsigned num_exprs() const { return Z3_goal_num_exprs(ctx(), m_goal); } - bool is_decided_sat() const { return Z3_goal_is_decided_sat(ctx(), m_goal) != 0; } - bool is_decided_unsat() const { return Z3_goal_is_decided_unsat(ctx(), m_goal) != 0; } + bool is_decided_sat() const { return Z3_goal_is_decided_sat(ctx(), m_goal); } + bool is_decided_unsat() const { return Z3_goal_is_decided_unsat(ctx(), m_goal); } model convert_model(model const & m) const { check_context(*this, m); Z3_model new_m = Z3_goal_convert_model(ctx(), m_goal, m); @@ -2405,7 +2577,7 @@ namespace z3 { class optimize : public object { Z3_optimize m_opt; - + public: class handle { unsigned m_h; @@ -2453,8 +2625,20 @@ namespace z3 { void pop() { Z3_optimize_pop(ctx(), m_opt); } - check_result check() { Z3_lbool r = Z3_optimize_check(ctx(), m_opt); check_error(); return to_check_result(r); } + check_result check() { Z3_lbool r = Z3_optimize_check(ctx(), m_opt, 0, 0); check_error(); return to_check_result(r); } + check_result check(expr_vector const& asms) { + unsigned n = asms.size(); + array _asms(n); + for (unsigned i = 0; i < n; i++) { + check_context(*this, asms[i]); + _asms[i] = asms[i]; + } + Z3_lbool r = Z3_optimize_check(ctx(), m_opt, n, _asms.ptr()); + check_error(); + return to_check_result(r); + } model get_model() const { Z3_model m = Z3_optimize_get_model(ctx(), m_opt); check_error(); return model(ctx(), m); } + expr_vector unsat_core() const { Z3_ast_vector r = Z3_optimize_get_unsat_core(ctx(), m_opt); check_error(); return expr_vector(ctx(), r); } void set(params const & p) { Z3_optimize_set_params(ctx(), m_opt, p); check_error(); } expr lower(handle const& h) { Z3_ast r = Z3_optimize_get_lower(ctx(), m_opt, h.h()); @@ -2481,25 +2665,25 @@ namespace z3 { public: fixedpoint(context& c):object(c) { m_fp = Z3_mk_fixedpoint(c); Z3_fixedpoint_inc_ref(c, m_fp); } ~fixedpoint() { Z3_fixedpoint_dec_ref(ctx(), m_fp); } - operator Z3_fixedpoint() const { return m_fp; } + operator Z3_fixedpoint() const { return m_fp; } void from_string(char const* s) { Z3_fixedpoint_from_string(ctx(), m_fp, s); check_error(); } void from_file(char const* s) { Z3_fixedpoint_from_file(ctx(), m_fp, s); check_error(); } void add_rule(expr& rule, symbol const& name) { Z3_fixedpoint_add_rule(ctx(), m_fp, rule, name); check_error(); } void add_fact(func_decl& f, unsigned * args) { Z3_fixedpoint_add_fact(ctx(), m_fp, f, f.arity(), args); check_error(); } check_result query(expr& q) { Z3_lbool r = Z3_fixedpoint_query(ctx(), m_fp, q); check_error(); return to_check_result(r); } - check_result query(func_decl_vector& relations) { + check_result query(func_decl_vector& relations) { array rs(relations); - Z3_lbool r = Z3_fixedpoint_query_relations(ctx(), m_fp, rs.size(), rs.ptr()); - check_error(); - return to_check_result(r); + Z3_lbool r = Z3_fixedpoint_query_relations(ctx(), m_fp, rs.size(), rs.ptr()); + check_error(); + return to_check_result(r); } expr get_answer() { Z3_ast r = Z3_fixedpoint_get_answer(ctx(), m_fp); check_error(); return expr(ctx(), r); } std::string reason_unknown() { return Z3_fixedpoint_get_reason_unknown(ctx(), m_fp); } void update_rule(expr& rule, symbol const& name) { Z3_fixedpoint_update_rule(ctx(), m_fp, rule, name); check_error(); } unsigned get_num_levels(func_decl& p) { unsigned r = Z3_fixedpoint_get_num_levels(ctx(), m_fp, p); check_error(); return r; } - expr get_cover_delta(int level, func_decl& p) { - Z3_ast r = Z3_fixedpoint_get_cover_delta(ctx(), m_fp, level, p); - check_error(); + expr get_cover_delta(int level, func_decl& p) { + Z3_ast r = Z3_fixedpoint_get_cover_delta(ctx(), m_fp, level, p); + check_error(); return expr(ctx(), r); } void add_cover(int level, func_decl& p, expr& property) { Z3_fixedpoint_add_cover(ctx(), m_fp, level, p, property); check_error(); } @@ -2513,7 +2697,7 @@ namespace z3 { std::string to_string() { return Z3_fixedpoint_to_string(ctx(), m_fp, 0, 0); } std::string to_string(expr_vector const& queries) { array qs(queries); - return Z3_fixedpoint_to_string(ctx(), m_fp, qs.size(), qs.ptr()); + return Z3_fixedpoint_to_string(ctx(), m_fp, qs.size(), qs.ptr()); } void push() { Z3_fixedpoint_push(ctx(), m_fp); check_error(); } void pop() { Z3_fixedpoint_pop(ctx(), m_fp); check_error(); } @@ -2548,11 +2732,37 @@ namespace z3 { inline sort context::string_sort() { Z3_sort s = Z3_mk_string_sort(m_ctx); check_error(); return sort(*this, s); } inline sort context::seq_sort(sort& s) { Z3_sort r = Z3_mk_seq_sort(m_ctx, s); check_error(); return sort(*this, r); } inline sort context::re_sort(sort& s) { Z3_sort r = Z3_mk_re_sort(m_ctx, s); check_error(); return sort(*this, r); } + inline sort context::fpa_sort(unsigned ebits, unsigned sbits) { Z3_sort s = Z3_mk_fpa_sort(m_ctx, ebits, sbits); check_error(); return sort(*this, s); } + + template<> + inline sort context::fpa_sort<16>() { return fpa_sort(5, 11); } + + template<> + inline sort context::fpa_sort<32>() { return fpa_sort(8, 24); } + + template<> + inline sort context::fpa_sort<64>() { return fpa_sort(11, 53); } + + template<> + inline sort context::fpa_sort<128>() { return fpa_sort(15, 113); } + + inline sort context::fpa_rounding_mode() { + switch (m_rounding_mode) { + case RNA: return sort(*this, Z3_mk_fpa_rna(m_ctx)); + case RNE: return sort(*this, Z3_mk_fpa_rne(m_ctx)); + case RTP: return sort(*this, Z3_mk_fpa_rtp(m_ctx)); + case RTN: return sort(*this, Z3_mk_fpa_rtn(m_ctx)); + case RTZ: return sort(*this, Z3_mk_fpa_rtz(m_ctx)); + default: return sort(*this); + } + } + + inline void context::set_rounding_mode(rounding_mode rm) { m_rounding_mode = rm; } inline sort context::array_sort(sort d, sort r) { Z3_sort s = Z3_mk_array_sort(m_ctx, d, r); check_error(); return sort(*this, s); } inline sort context::array_sort(sort_vector const& d, sort r) { array dom(d); - Z3_sort s = Z3_mk_array_sort_n(m_ctx, dom.size(), dom.ptr(), r); check_error(); return sort(*this, s); + Z3_sort s = Z3_mk_array_sort_n(m_ctx, dom.size(), dom.ptr(), r); check_error(); return sort(*this, s); } inline sort context::enumeration_sort(char const * name, unsigned n, char const * const * enum_names, func_decl_vector & cs, func_decl_vector & ts) { array _enum_names(n); @@ -2657,6 +2867,37 @@ namespace z3 { return func_decl(*this, f); } + inline func_decl context::recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range) { + array args(arity); + for (unsigned i = 0; i < arity; i++) { + check_context(domain[i], range); + args[i] = domain[i]; + } + Z3_func_decl f = Z3_mk_rec_func_decl(m_ctx, name, arity, args.ptr(), range); + check_error(); + return func_decl(*this, f); + + } + + inline func_decl context::recfun(char const * name, unsigned arity, sort const * domain, sort const & range) { + return recfun(str_symbol(name), arity, domain, range); + } + + inline func_decl context::recfun(char const * name, sort const& d1, sort const & range) { + return recfun(str_symbol(name), 1, &d1, range); + } + + inline func_decl context::recfun(char const * name, sort const& d1, sort const& d2, sort const & range) { + sort dom[2] = { d1, d2 }; + return recfun(str_symbol(name), 2, dom, range); + } + + inline void context::recdef(func_decl f, expr_vector const& args, expr const& body) { + check_context(f, args); check_context(f, body); + array vars(args); + Z3_add_rec_def(f.ctx(), f, vars.size(), vars.ptr(), body); + } + inline expr context::constant(symbol const & name, sort const & s) { Z3_ast r = Z3_mk_const(m_ctx, name, s); check_error(); @@ -2667,6 +2908,10 @@ namespace z3 { inline expr context::int_const(char const * name) { return constant(name, int_sort()); } inline expr context::real_const(char const * name) { return constant(name, real_sort()); } inline expr context::bv_const(char const * name, unsigned sz) { return constant(name, bv_sort(sz)); } + inline expr context::fpa_const(char const * name, unsigned ebits, unsigned sbits) { return constant(name, fpa_sort(ebits, sbits)); } + + template + inline expr context::fpa_const(char const * name) { return constant(name, fpa_sort()); } inline expr context::bool_val(bool b) { return b ? expr(*this, Z3_mk_true(m_ctx)) : expr(*this, Z3_mk_false(m_ctx)); } @@ -2688,12 +2933,15 @@ namespace z3 { inline expr context::bv_val(int64_t n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_int64(m_ctx, n, s); check_error(); return expr(*this, r); } inline expr context::bv_val(uint64_t n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_unsigned_int64(m_ctx, n, s); check_error(); return expr(*this, r); } inline expr context::bv_val(char const * n, unsigned sz) { sort s = bv_sort(sz); Z3_ast r = Z3_mk_numeral(m_ctx, n, s); check_error(); return expr(*this, r); } - inline expr context::bv_val(unsigned n, bool const* bits) { - array _bits(n); + inline expr context::bv_val(unsigned n, bool const* bits) { + array _bits(n); for (unsigned i = 0; i < n; ++i) _bits[i] = bits[i] ? 1 : 0; - Z3_ast r = Z3_mk_bv_numeral(m_ctx, n, _bits.ptr()); check_error(); return expr(*this, r); + Z3_ast r = Z3_mk_bv_numeral(m_ctx, n, _bits.ptr()); check_error(); return expr(*this, r); } + inline expr context::fpa_val(double n) { sort s = fpa_sort<64>(); Z3_ast r = Z3_mk_fpa_numeral_double(m_ctx, n, s); check_error(); return expr(*this, r); } + inline expr context::fpa_val(float n) { sort s = fpa_sort<32>(); Z3_ast r = Z3_mk_fpa_numeral_float(m_ctx, n, s); check_error(); return expr(*this, r); } + inline expr context::string_val(char const* s) { Z3_ast r = Z3_mk_string(m_ctx, s); check_error(); return expr(*this, r); } inline expr context::string_val(std::string const& s) { Z3_ast r = Z3_mk_string(m_ctx, s.c_str()); check_error(); return expr(*this, r); } @@ -2811,14 +3059,27 @@ namespace z3 { return range.ctx().function(name.c_str(), domain, range); } + inline func_decl recfun(symbol const & name, unsigned arity, sort const * domain, sort const & range) { + return range.ctx().recfun(name, arity, domain, range); + } + inline func_decl recfun(char const * name, unsigned arity, sort const * domain, sort const & range) { + return range.ctx().recfun(name, arity, domain, range); + } + inline func_decl recfun(char const * name, sort const& d1, sort const & range) { + return range.ctx().recfun(name, d1, range); + } + inline func_decl recfun(char const * name, sort const& d1, sort const& d2, sort const & range) { + return range.ctx().recfun(name, d1, d2, range); + } + inline expr select(expr const & a, expr const & i) { check_context(a, i); Z3_ast r = Z3_mk_select(a.ctx(), a, i); a.check_error(); return expr(a.ctx(), r); } - inline expr select(expr const & a, int i) { - return select(a, a.ctx().num_val(i, a.get_sort().array_domain())); + inline expr select(expr const & a, int i) { + return select(a, a.ctx().num_val(i, a.get_sort().array_domain())); } inline expr select(expr const & a, expr_vector const & i) { check_context(a, i); @@ -2848,10 +3109,10 @@ namespace z3 { return expr(a.ctx(), r); } - inline expr as_array(func_decl & f) { - Z3_ast r = Z3_mk_as_array(f.ctx(), f); - f.check_error(); - return expr(f.ctx(), r); + inline expr as_array(func_decl & f) { + Z3_ast r = Z3_mk_as_array(f.ctx(), f); + f.check_error(); + return expr(f.ctx(), r); } #define MK_EXPR1(_fn, _arg) \ @@ -2883,21 +3144,21 @@ namespace z3 { inline expr set_del(expr const& s, expr const& e) { MK_EXPR2(Z3_mk_set_del, s, e); - } + } inline expr set_union(expr const& a, expr const& b) { - check_context(a, b); + check_context(a, b); Z3_ast es[2] = { a, b }; Z3_ast r = Z3_mk_set_union(a.ctx(), 2, es); - a.check_error(); + a.check_error(); return expr(a.ctx(), r); } inline expr set_intersect(expr const& a, expr const& b) { - check_context(a, b); + check_context(a, b); Z3_ast es[2] = { a, b }; Z3_ast r = Z3_mk_set_intersect(a.ctx(), 2, es); - a.check_error(); + a.check_error(); return expr(a.ctx(), r); } @@ -2981,10 +3242,10 @@ namespace z3 { MK_EXPR1(Z3_mk_re_complement, a); } inline expr range(expr const& lo, expr const& hi) { - check_context(lo, hi); - Z3_ast r = Z3_mk_re_range(lo.ctx(), lo, hi); - lo.check_error(); - return expr(lo.ctx(), r); + check_context(lo, hi); + Z3_ast r = Z3_mk_re_range(lo.ctx(), lo, hi); + lo.check_error(); + return expr(lo.ctx(), r); } @@ -2995,7 +3256,7 @@ namespace z3 { Z3_ast_vector r = Z3_parse_smtlib2_string(*this, s, 0, 0, 0, 0, 0, 0); check_error(); return expr_vector(*this, r); - + } inline expr_vector context::parse_file(char const* s) { Z3_ast_vector r = Z3_parse_smtlib2_file(*this, s, 0, 0, 0, 0, 0, 0); diff --git a/src/api/dotnet/AST.cs b/src/api/dotnet/AST.cs index 2460c50f0..0afff2c42 100644 --- a/src/api/dotnet/AST.cs +++ b/src/api/dotnet/AST.cs @@ -17,17 +17,16 @@ Notes: --*/ +using System.Diagnostics; using System; using System.Collections; using System.Collections.Generic; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// The abstract syntax tree (AST) class. /// - [ContractVerification(true)] public class AST : Z3Object, IComparable { /// @@ -114,8 +113,7 @@ namespace Microsoft.Z3 /// A copy of the AST which is associated with public AST Translate(Context ctx) { - Contract.Requires(ctx != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ctx != null); if (ReferenceEquals(Context, ctx)) return this; @@ -202,14 +200,13 @@ namespace Microsoft.Z3 /// public string SExpr() { - Contract.Ensures(Contract.Result() != null); return Native.Z3_ast_to_string(Context.nCtx, NativeObject); } #region Internal - internal AST(Context ctx) : base(ctx) { Contract.Requires(ctx != null); } - internal AST(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal AST(Context ctx) : base(ctx) { Debug.Assert(ctx != null); } + internal AST(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue { @@ -246,8 +243,7 @@ namespace Microsoft.Z3 internal static AST Create(Context ctx, IntPtr obj) { - Contract.Requires(ctx != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ctx != null); switch ((Z3_ast_kind)Native.Z3_get_ast_kind(ctx.nCtx, obj)) { diff --git a/src/api/dotnet/ASTMap.cs b/src/api/dotnet/ASTMap.cs index f7c1c5914..f678f71c3 100644 --- a/src/api/dotnet/ASTMap.cs +++ b/src/api/dotnet/ASTMap.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Map from AST to AST /// - [ContractVerification(true)] internal class ASTMap : Z3Object { /// @@ -35,7 +34,7 @@ namespace Microsoft.Z3 /// True if is a key in the map, false otherwise. public bool Contains(AST k) { - Contract.Requires(k != null); + Debug.Assert(k != null); return 0 != Native.Z3_ast_map_contains(Context.nCtx, NativeObject, k.NativeObject); } @@ -49,8 +48,7 @@ namespace Microsoft.Z3 /// An AST public AST Find(AST k) { - Contract.Requires(k != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(k != null); return new AST(Context, Native.Z3_ast_map_find(Context.nCtx, NativeObject, k.NativeObject)); } @@ -62,8 +60,8 @@ namespace Microsoft.Z3 /// The value AST public void Insert(AST k, AST v) { - Contract.Requires(k != null); - Contract.Requires(v != null); + Debug.Assert(k != null); + Debug.Assert(v != null); Native.Z3_ast_map_insert(Context.nCtx, NativeObject, k.NativeObject, v.NativeObject); } @@ -74,7 +72,7 @@ namespace Microsoft.Z3 /// An AST public void Erase(AST k) { - Contract.Requires(k != null); + Debug.Assert(k != null); Native.Z3_ast_map_erase(Context.nCtx, NativeObject, k.NativeObject); } @@ -119,12 +117,12 @@ namespace Microsoft.Z3 internal ASTMap(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal ASTMap(Context ctx) : base(ctx, Native.Z3_mk_ast_map(ctx.nCtx)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/ASTVector.cs b/src/api/dotnet/ASTVector.cs index 8b599ca48..fcfa6bd65 100644 --- a/src/api/dotnet/ASTVector.cs +++ b/src/api/dotnet/ASTVector.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -45,13 +45,12 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new AST(Context, Native.Z3_ast_vector_get(Context.nCtx, NativeObject, i)); } set { - Contract.Requires(value != null); + Debug.Assert(value != null); Native.Z3_ast_vector_set(Context.nCtx, NativeObject, i, value.NativeObject); } @@ -73,7 +72,7 @@ namespace Microsoft.Z3 /// An AST public void Push(AST a) { - Contract.Requires(a != null); + Debug.Assert(a != null); Native.Z3_ast_vector_push(Context.nCtx, NativeObject, a.NativeObject); } @@ -85,8 +84,7 @@ namespace Microsoft.Z3 /// A new ASTVector public ASTVector Translate(Context ctx) { - Contract.Requires(ctx != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ctx != null); return new ASTVector(Context, Native.Z3_ast_vector_translate(Context.nCtx, NativeObject, ctx.nCtx)); } @@ -232,8 +230,8 @@ namespace Microsoft.Z3 } #region Internal - internal ASTVector(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } - internal ASTVector(Context ctx) : base(ctx, Native.Z3_mk_ast_vector(ctx.nCtx)) { Contract.Requires(ctx != null); } + internal ASTVector(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } + internal ASTVector(Context ctx) : base(ctx, Native.Z3_mk_ast_vector(ctx.nCtx)) { Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue { diff --git a/src/api/dotnet/AlgebraicNum.cs b/src/api/dotnet/AlgebraicNum.cs index 3687e1f83..cd1e4e922 100644 --- a/src/api/dotnet/AlgebraicNum.cs +++ b/src/api/dotnet/AlgebraicNum.cs @@ -16,8 +16,8 @@ Author: Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; #if !FRAMEWORK_LT_4 using System.Numerics; @@ -28,7 +28,6 @@ namespace Microsoft.Z3 /// /// Algebraic numbers /// - [ContractVerification(true)] public class AlgebraicNum : ArithExpr { /// @@ -40,7 +39,6 @@ namespace Microsoft.Z3 /// A numeral Expr of sort Real public RatNum ToUpper(uint precision) { - Contract.Ensures(Contract.Result() != null); return new RatNum(Context, Native.Z3_get_algebraic_number_upper(Context.nCtx, NativeObject, precision)); } @@ -54,7 +52,6 @@ namespace Microsoft.Z3 /// A numeral Expr of sort Real public RatNum ToLower(uint precision) { - Contract.Ensures(Contract.Result() != null); return new RatNum(Context, Native.Z3_get_algebraic_number_lower(Context.nCtx, NativeObject, precision)); } @@ -65,7 +62,6 @@ namespace Microsoft.Z3 /// The result has at most decimal places. public string ToDecimal(uint precision) { - Contract.Ensures(Contract.Result() != null); return Native.Z3_get_numeral_decimal_string(Context.nCtx, NativeObject, precision); } @@ -74,7 +70,7 @@ namespace Microsoft.Z3 internal AlgebraicNum(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/ApplyResult.cs b/src/api/dotnet/ApplyResult.cs index db2922460..342bf3216 100644 --- a/src/api/dotnet/ApplyResult.cs +++ b/src/api/dotnet/ApplyResult.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -26,7 +26,6 @@ namespace Microsoft.Z3 /// ApplyResult objects represent the result of an application of a /// tactic to a goal. It contains the subgoals that were produced. /// - [ContractVerification(true)] public class ApplyResult : Z3Object { /// @@ -44,8 +43,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); - Contract.Ensures(Contract.Result().Length == this.NumSubgoals); uint n = NumSubgoals; Goal[] res = new Goal[n]; @@ -67,7 +64,7 @@ namespace Microsoft.Z3 internal ApplyResult(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/ArithExpr.cs b/src/api/dotnet/ArithExpr.cs index b6beaef0c..53b9db21d 100644 --- a/src/api/dotnet/ArithExpr.cs +++ b/src/api/dotnet/ArithExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -35,7 +35,7 @@ namespace Microsoft.Z3 internal ArithExpr(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion @@ -45,7 +45,7 @@ namespace Microsoft.Z3 private static ArithExpr MkNum(ArithExpr e, double d) { return (ArithExpr)e.Context.MkNumeral(d.ToString(), e.Context.MkRealSort()); } - /// Operator overloading for arithmetical divsion operator (over reals) + /// Operator overloading for arithmetical division operator (over reals) public static ArithExpr operator /(ArithExpr a, ArithExpr b) { return a.Context.MkDiv(a, b); } /// Operator overloading for arithmetical operator diff --git a/src/api/dotnet/ArithSort.cs b/src/api/dotnet/ArithSort.cs index f19774246..985aec7a9 100644 --- a/src/api/dotnet/ArithSort.cs +++ b/src/api/dotnet/ArithSort.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -28,7 +28,7 @@ namespace Microsoft.Z3 public class ArithSort : Sort { #region Internal - internal ArithSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal ArithSort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } #endregion }; } diff --git a/src/api/dotnet/ArrayExpr.cs b/src/api/dotnet/ArrayExpr.cs index 6c51bfc5b..c53763886 100644 --- a/src/api/dotnet/ArrayExpr.cs +++ b/src/api/dotnet/ArrayExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -35,7 +35,7 @@ namespace Microsoft.Z3 internal ArrayExpr(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/ArraySort.cs b/src/api/dotnet/ArraySort.cs index 47a73ae1f..c5d15938e 100644 --- a/src/api/dotnet/ArraySort.cs +++ b/src/api/dotnet/ArraySort.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Array sorts. /// - [ContractVerification(true)] public class ArraySort : Sort { /// @@ -35,7 +34,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Sort.Create(Context, Native.Z3_get_array_sort_domain(Context.nCtx, NativeObject)); } @@ -48,27 +46,26 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Sort.Create(Context, Native.Z3_get_array_sort_range(Context.nCtx, NativeObject)); } } #region Internal - internal ArraySort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal ArraySort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } internal ArraySort(Context ctx, Sort domain, Sort range) : base(ctx, Native.Z3_mk_array_sort(ctx.nCtx, domain.NativeObject, range.NativeObject)) { - Contract.Requires(ctx != null); - Contract.Requires(domain != null); - Contract.Requires(range != null); + Debug.Assert(ctx != null); + Debug.Assert(domain != null); + Debug.Assert(range != null); } internal ArraySort(Context ctx, Sort[] domain, Sort range) : base(ctx, Native.Z3_mk_array_sort_n(ctx.nCtx, (uint)domain.Length, AST.ArrayToNative(domain), range.NativeObject)) { - Contract.Requires(ctx != null); - Contract.Requires(domain != null); - Contract.Requires(range != null); + Debug.Assert(ctx != null); + Debug.Assert(domain != null); + Debug.Assert(range != null); } #endregion }; diff --git a/src/api/dotnet/BitVecExpr.cs b/src/api/dotnet/BitVecExpr.cs index b019f8845..3efa0e9bd 100644 --- a/src/api/dotnet/BitVecExpr.cs +++ b/src/api/dotnet/BitVecExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -41,7 +41,7 @@ namespace Microsoft.Z3 #region Internal /// Constructor for BitVecExpr - internal BitVecExpr(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal BitVecExpr(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } #endregion } } diff --git a/src/api/dotnet/BitVecNum.cs b/src/api/dotnet/BitVecNum.cs index 66054761a..5ee2d2ed8 100644 --- a/src/api/dotnet/BitVecNum.cs +++ b/src/api/dotnet/BitVecNum.cs @@ -16,8 +16,8 @@ Author: Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; #if !FRAMEWORK_LT_4 using System.Numerics; @@ -28,7 +28,6 @@ namespace Microsoft.Z3 /// /// Bit-vector numerals /// - [ContractVerification(true)] public class BitVecNum : BitVecExpr { /// @@ -109,7 +108,7 @@ namespace Microsoft.Z3 } #region Internal - internal BitVecNum(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal BitVecNum(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } #endregion } } diff --git a/src/api/dotnet/BitVecSort.cs b/src/api/dotnet/BitVecSort.cs index d865159f4..fb41e76fe 100644 --- a/src/api/dotnet/BitVecSort.cs +++ b/src/api/dotnet/BitVecSort.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -36,7 +36,7 @@ namespace Microsoft.Z3 } #region Internal - internal BitVecSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal BitVecSort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } #endregion }; } diff --git a/src/api/dotnet/BoolExpr.cs b/src/api/dotnet/BoolExpr.cs index c52109352..906090d2a 100644 --- a/src/api/dotnet/BoolExpr.cs +++ b/src/api/dotnet/BoolExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -32,7 +32,7 @@ namespace Microsoft.Z3 { #region Internal /// Constructor for BoolExpr - internal BoolExpr(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal BoolExpr(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } #endregion #region Operators diff --git a/src/api/dotnet/BoolSort.cs b/src/api/dotnet/BoolSort.cs index 50f44c858..7fd6706a3 100644 --- a/src/api/dotnet/BoolSort.cs +++ b/src/api/dotnet/BoolSort.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -28,8 +28,8 @@ namespace Microsoft.Z3 public class BoolSort : Sort { #region Internal - internal BoolSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } - internal BoolSort(Context ctx) : base(ctx, Native.Z3_mk_bool_sort(ctx.nCtx)) { Contract.Requires(ctx != null); } + internal BoolSort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } + internal BoolSort(Context ctx) : base(ctx, Native.Z3_mk_bool_sort(ctx.nCtx)) { Debug.Assert(ctx != null); } #endregion }; } diff --git a/src/api/dotnet/Constructor.cs b/src/api/dotnet/Constructor.cs index 527b8bc13..f635d78e4 100644 --- a/src/api/dotnet/Constructor.cs +++ b/src/api/dotnet/Constructor.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Constructors are used for datatype sorts. /// - [ContractVerification(true)] public class Constructor : Z3Object { /// @@ -46,7 +45,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); IntPtr constructor = IntPtr.Zero; IntPtr tester = IntPtr.Zero; IntPtr[] accessors = new IntPtr[n]; @@ -62,7 +60,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); IntPtr constructor = IntPtr.Zero; IntPtr tester = IntPtr.Zero; IntPtr[] accessors = new IntPtr[n]; @@ -78,7 +75,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); IntPtr constructor = IntPtr.Zero; IntPtr tester = IntPtr.Zero; IntPtr[] accessors = new IntPtr[n]; @@ -105,9 +101,9 @@ namespace Microsoft.Z3 Sort[] sorts, uint[] sortRefs) : base(ctx) { - Contract.Requires(ctx != null); - Contract.Requires(name != null); - Contract.Requires(recognizer != null); + Debug.Assert(ctx != null); + Debug.Assert(name != null); + Debug.Assert(recognizer != null); n = AST.ArrayLength(fieldNames); diff --git a/src/api/dotnet/ConstructorList.cs b/src/api/dotnet/ConstructorList.cs index d625b5ade..9b9ba8561 100644 --- a/src/api/dotnet/ConstructorList.cs +++ b/src/api/dotnet/ConstructorList.cs @@ -17,12 +17,12 @@ Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -43,14 +43,14 @@ namespace Microsoft.Z3 internal ConstructorList(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal ConstructorList(Context ctx, Constructor[] constructors) : base(ctx) { - Contract.Requires(ctx != null); - Contract.Requires(constructors != null); + Debug.Assert(ctx != null); + Debug.Assert(constructors != null); NativeObject = Native.Z3_mk_constructor_list(Context.nCtx, (uint)constructors.Length, Constructor.ArrayToNative(constructors)); } diff --git a/src/api/dotnet/Context.cs b/src/api/dotnet/Context.cs index c8decb59b..cdaae332b 100644 --- a/src/api/dotnet/Context.cs +++ b/src/api/dotnet/Context.cs @@ -18,9 +18,9 @@ Notes: --*/ using System; +using System.Diagnostics; using System.Collections.Generic; using System.Runtime.InteropServices; -using System.Diagnostics.Contracts; using System.Linq; namespace Microsoft.Z3 @@ -28,7 +28,6 @@ namespace Microsoft.Z3 /// /// The main interaction with Z3 happens via the Context. /// - [ContractVerification(true)] public class Context : IDisposable { #region Constructors @@ -66,7 +65,7 @@ namespace Microsoft.Z3 public Context(Dictionary settings) : base() { - Contract.Requires(settings != null); + Debug.Assert(settings != null); lock (creation_lock) { @@ -90,7 +89,6 @@ namespace Microsoft.Z3 /// public IntSymbol MkSymbol(int i) { - Contract.Ensures(Contract.Result() != null); return new IntSymbol(this, i); } @@ -100,7 +98,6 @@ namespace Microsoft.Z3 /// public StringSymbol MkSymbol(string name) { - Contract.Ensures(Contract.Result() != null); return new StringSymbol(this, name); } @@ -110,10 +107,6 @@ namespace Microsoft.Z3 /// internal Symbol[] MkSymbols(string[] names) { - Contract.Ensures(names == null || Contract.Result() != null); - Contract.Ensures(names != null || Contract.Result() == null); - Contract.Ensures(Contract.Result() == null || Contract.Result().Length == names.Length); - Contract.Ensures(Contract.Result() == null || Contract.ForAll(Contract.Result(), s => s != null)); if (names == null) return null; Symbol[] result = new Symbol[names.Length]; @@ -135,7 +128,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); if (m_boolSort == null) m_boolSort = new BoolSort(this); return m_boolSort; } } @@ -147,7 +139,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); if (m_intSort == null) m_intSort = new IntSort(this); return m_intSort; } } @@ -160,7 +151,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); if (m_realSort == null) m_realSort = new RealSort(this); return m_realSort; } } @@ -172,7 +162,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); if (m_stringSort == null) m_stringSort = new SeqSort(this, Native.Z3_mk_string_sort(nCtx)); return m_stringSort; } @@ -184,7 +173,6 @@ namespace Microsoft.Z3 /// public BoolSort MkBoolSort() { - Contract.Ensures(Contract.Result() != null); return new BoolSort(this); } @@ -193,8 +181,7 @@ namespace Microsoft.Z3 /// public UninterpretedSort MkUninterpretedSort(Symbol s) { - Contract.Requires(s != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); CheckContextMatch(s); return new UninterpretedSort(this, s); @@ -205,7 +192,6 @@ namespace Microsoft.Z3 /// public UninterpretedSort MkUninterpretedSort(string str) { - Contract.Ensures(Contract.Result() != null); return MkUninterpretedSort(MkSymbol(str)); } @@ -215,7 +201,6 @@ namespace Microsoft.Z3 /// public IntSort MkIntSort() { - Contract.Ensures(Contract.Result() != null); return new IntSort(this); } @@ -225,7 +210,6 @@ namespace Microsoft.Z3 /// public RealSort MkRealSort() { - Contract.Ensures(Contract.Result() != null); return new RealSort(this); } @@ -234,7 +218,6 @@ namespace Microsoft.Z3 /// public BitVecSort MkBitVecSort(uint size) { - Contract.Ensures(Contract.Result() != null); return new BitVecSort(this, Native.Z3_mk_bv_sort(nCtx, size)); } @@ -245,8 +228,7 @@ namespace Microsoft.Z3 /// public SeqSort MkSeqSort(Sort s) { - Contract.Requires(s != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); return new SeqSort(this, Native.Z3_mk_seq_sort(nCtx, s.NativeObject)); } @@ -255,8 +237,7 @@ namespace Microsoft.Z3 /// public ReSort MkReSort(SeqSort s) { - Contract.Requires(s != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); return new ReSort(this, Native.Z3_mk_re_sort(nCtx, s.NativeObject)); } @@ -265,9 +246,8 @@ namespace Microsoft.Z3 /// public ArraySort MkArraySort(Sort domain, Sort range) { - Contract.Requires(domain != null); - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(domain != null); + Debug.Assert(range != null); CheckContextMatch(domain); CheckContextMatch(range); @@ -279,9 +259,8 @@ namespace Microsoft.Z3 /// public ArraySort MkArraySort(Sort[] domain, Sort range) { - Contract.Requires(domain != null); - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(domain != null); + Debug.Assert(range != null); CheckContextMatch(domain); CheckContextMatch(range); @@ -293,11 +272,10 @@ namespace Microsoft.Z3 /// public TupleSort MkTupleSort(Symbol name, Symbol[] fieldNames, Sort[] fieldSorts) { - Contract.Requires(name != null); - Contract.Requires(fieldNames != null); - Contract.Requires(Contract.ForAll(fieldNames, fn => fn != null)); - Contract.Requires(fieldSorts == null || Contract.ForAll(fieldSorts, fs => fs != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); + Debug.Assert(fieldNames != null); + Debug.Assert(fieldNames.All(fn => fn != null)); + Debug.Assert(fieldSorts == null || fieldSorts.All(fs => fs != null)); CheckContextMatch(name); CheckContextMatch(fieldNames); @@ -310,11 +288,10 @@ namespace Microsoft.Z3 /// public EnumSort MkEnumSort(Symbol name, params Symbol[] enumNames) { - Contract.Requires(name != null); - Contract.Requires(enumNames != null); - Contract.Requires(Contract.ForAll(enumNames, f => f != null)); + Debug.Assert(name != null); + Debug.Assert(enumNames != null); + Debug.Assert(enumNames.All(f => f != null)); - Contract.Ensures(Contract.Result() != null); CheckContextMatch(name); CheckContextMatch(enumNames); @@ -326,8 +303,7 @@ namespace Microsoft.Z3 /// public EnumSort MkEnumSort(string name, params string[] enumNames) { - Contract.Requires(enumNames != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(enumNames != null); return new EnumSort(this, MkSymbol(name), MkSymbols(enumNames)); } @@ -337,9 +313,8 @@ namespace Microsoft.Z3 /// public ListSort MkListSort(Symbol name, Sort elemSort) { - Contract.Requires(name != null); - Contract.Requires(elemSort != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); + Debug.Assert(elemSort != null); CheckContextMatch(name); CheckContextMatch(elemSort); @@ -351,8 +326,7 @@ namespace Microsoft.Z3 /// public ListSort MkListSort(string name, Sort elemSort) { - Contract.Requires(elemSort != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(elemSort != null); CheckContextMatch(elemSort); return new ListSort(this, MkSymbol(name), elemSort); @@ -366,8 +340,7 @@ namespace Microsoft.Z3 /// The size of the sort public FiniteDomainSort MkFiniteDomainSort(Symbol name, ulong size) { - Contract.Requires(name != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); CheckContextMatch(name); return new FiniteDomainSort(this, name, size); @@ -383,7 +356,6 @@ namespace Microsoft.Z3 /// The size of the sort public FiniteDomainSort MkFiniteDomainSort(string name, ulong size) { - Contract.Ensures(Contract.Result() != null); return new FiniteDomainSort(this, MkSymbol(name), size); } @@ -402,9 +374,8 @@ namespace Microsoft.Z3 /// referring to one of the recursive datatypes that is declared. public Constructor MkConstructor(Symbol name, Symbol recognizer, Symbol[] fieldNames = null, Sort[] sorts = null, uint[] sortRefs = null) { - Contract.Requires(name != null); - Contract.Requires(recognizer != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); + Debug.Assert(recognizer != null); return new Constructor(this, name, recognizer, fieldNames, sorts, sortRefs); } @@ -420,7 +391,6 @@ namespace Microsoft.Z3 /// public Constructor MkConstructor(string name, string recognizer, string[] fieldNames = null, Sort[] sorts = null, uint[] sortRefs = null) { - Contract.Ensures(Contract.Result() != null); return new Constructor(this, MkSymbol(name), MkSymbol(recognizer), MkSymbols(fieldNames), sorts, sortRefs); } @@ -430,11 +400,10 @@ namespace Microsoft.Z3 /// public DatatypeSort MkDatatypeSort(Symbol name, Constructor[] constructors) { - Contract.Requires(name != null); - Contract.Requires(constructors != null); - Contract.Requires(Contract.ForAll(constructors, c => c != null)); + Debug.Assert(name != null); + Debug.Assert(constructors != null); + Debug.Assert(constructors.All(c => c != null)); - Contract.Ensures(Contract.Result() != null); CheckContextMatch(name); CheckContextMatch(constructors); @@ -446,9 +415,8 @@ namespace Microsoft.Z3 /// public DatatypeSort MkDatatypeSort(string name, Constructor[] constructors) { - Contract.Requires(constructors != null); - Contract.Requires(Contract.ForAll(constructors, c => c != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(constructors != null); + Debug.Assert(constructors.All(c => c != null)); CheckContextMatch(constructors); return new DatatypeSort(this, MkSymbol(name), constructors); @@ -461,12 +429,11 @@ namespace Microsoft.Z3 /// list of constructors, one list per sort. public DatatypeSort[] MkDatatypeSorts(Symbol[] names, Constructor[][] c) { - Contract.Requires(names != null); - Contract.Requires(c != null); - Contract.Requires(names.Length == c.Length); - Contract.Requires(Contract.ForAll(0, c.Length, j => c[j] != null)); - Contract.Requires(Contract.ForAll(names, name => name != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(names != null); + Debug.Assert(c != null); + Debug.Assert(names.Length == c.Length); + //Debug.Assert(Contract.ForAll(0, c.Length, j => c[j] != null)); + Debug.Assert(names.All(name => name != null)); CheckContextMatch(names); uint n = (uint)names.Length; @@ -475,7 +442,6 @@ namespace Microsoft.Z3 for (uint i = 0; i < n; i++) { Constructor[] constructor = c[i]; - Contract.Assume(Contract.ForAll(constructor, arr => arr != null), "Clousot does not support yet quantified formula on multidimensional arrays"); CheckContextMatch(constructor); cla[i] = new ConstructorList(this, constructor); n_constr[i] = cla[i].NativeObject; @@ -496,12 +462,11 @@ namespace Microsoft.Z3 /// public DatatypeSort[] MkDatatypeSorts(string[] names, Constructor[][] c) { - Contract.Requires(names != null); - Contract.Requires(c != null); - Contract.Requires(names.Length == c.Length); - Contract.Requires(Contract.ForAll(0, c.Length, j => c[j] != null)); - Contract.Requires(Contract.ForAll(names, name => name != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(names != null); + Debug.Assert(c != null); + Debug.Assert(names.Length == c.Length); + //Debug.Assert(Contract.ForAll(0, c.Length, j => c[j] != null)); + //Debug.Assert(names.All(name => name != null)); return MkDatatypeSorts(MkSymbols(names), c); } @@ -510,7 +475,7 @@ namespace Microsoft.Z3 /// Update a datatype field at expression t with value v. /// The function performs a record update at t. The field /// that is passed in as argument is updated with value v, - /// the remainig fields of t are unchanged. + /// the remaining fields of t are unchanged. /// public Expr MkUpdateField(FuncDecl field, Expr t, Expr v) { @@ -528,10 +493,9 @@ namespace Microsoft.Z3 /// public FuncDecl MkFuncDecl(Symbol name, Sort[] domain, Sort range) { - Contract.Requires(name != null); - Contract.Requires(range != null); - Contract.Requires(Contract.ForAll(domain, d => d != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); + Debug.Assert(range != null); + Debug.Assert(domain.All(d => d != null)); CheckContextMatch(name); CheckContextMatch(domain); @@ -544,10 +508,9 @@ namespace Microsoft.Z3 /// public FuncDecl MkFuncDecl(Symbol name, Sort domain, Sort range) { - Contract.Requires(name != null); - Contract.Requires(domain != null); - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); + Debug.Assert(domain != null); + Debug.Assert(range != null); CheckContextMatch(name); CheckContextMatch(domain); @@ -561,23 +524,49 @@ namespace Microsoft.Z3 /// public FuncDecl MkFuncDecl(string name, Sort[] domain, Sort range) { - Contract.Requires(range != null); - Contract.Requires(Contract.ForAll(domain, d => d != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(range != null); + Debug.Assert(domain.All(d => d != null)); CheckContextMatch(domain); CheckContextMatch(range); return new FuncDecl(this, MkSymbol(name), domain, range); } + /// + /// Creates a new recursive function declaration. + /// + public FuncDecl MkRecFuncDecl(string name, Sort[] domain, Sort range) + { + Debug.Assert(range != null); + Debug.Assert(domain.All(d => d != null)); + + CheckContextMatch(domain); + CheckContextMatch(range); + return new FuncDecl(this, MkSymbol(name), domain, range, true); + } + + /// + /// Bind a definition to a recursive function declaration. + /// The function must have previously been created using + /// MkRecFuncDecl. The body may contain recursive uses of the function or + /// other mutually recursive functions. + /// + public void AddRecDef(FuncDecl f, Expr[] args, Expr body) + { + CheckContextMatch(f); + CheckContextMatch(args); + CheckContextMatch(body); + IntPtr[] argsNative = AST.ArrayToNative(args); + Native.Z3_add_rec_def(nCtx, f.NativeObject, (uint)args.Length, argsNative, body.NativeObject); + } + /// /// Creates a new function declaration. /// public FuncDecl MkFuncDecl(string name, Sort domain, Sort range) { - Contract.Requires(range != null); - Contract.Requires(domain != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(range != null); + Debug.Assert(domain != null); CheckContextMatch(domain); CheckContextMatch(range); @@ -592,9 +581,8 @@ namespace Microsoft.Z3 /// public FuncDecl MkFreshFuncDecl(string prefix, Sort[] domain, Sort range) { - Contract.Requires(range != null); - Contract.Requires(Contract.ForAll(domain, d => d != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(range != null); + Debug.Assert(domain.All(d => d != null)); CheckContextMatch(domain); CheckContextMatch(range); @@ -606,9 +594,8 @@ namespace Microsoft.Z3 /// public FuncDecl MkConstDecl(Symbol name, Sort range) { - Contract.Requires(name != null); - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); + Debug.Assert(range != null); CheckContextMatch(name); CheckContextMatch(range); @@ -620,8 +607,7 @@ namespace Microsoft.Z3 /// public FuncDecl MkConstDecl(string name, Sort range) { - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(range != null); CheckContextMatch(range); return new FuncDecl(this, MkSymbol(name), null, range); @@ -634,8 +620,7 @@ namespace Microsoft.Z3 /// public FuncDecl MkFreshConstDecl(string prefix, Sort range) { - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(range != null); CheckContextMatch(range); return new FuncDecl(this, prefix, null, range); @@ -650,8 +635,7 @@ namespace Microsoft.Z3 /// The sort of the variable public Expr MkBound(uint index, Sort ty) { - Contract.Requires(ty != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ty != null); return Expr.Create(this, Native.Z3_mk_bound(nCtx, index, ty.NativeObject)); } @@ -663,14 +647,10 @@ namespace Microsoft.Z3 /// public Pattern MkPattern(params Expr[] terms) { - Contract.Requires(terms != null); + Debug.Assert(terms != null); if (terms.Length == 0) throw new Z3Exception("Cannot create a pattern from zero terms"); - Contract.Ensures(Contract.Result() != null); - - Contract.EndContractBlock(); - IntPtr[] termsNative = AST.ArrayToNative(terms); return new Pattern(this, Native.Z3_mk_pattern(nCtx, (uint)terms.Length, termsNative)); } @@ -682,9 +662,8 @@ namespace Microsoft.Z3 /// public Expr MkConst(Symbol name, Sort range) { - Contract.Requires(name != null); - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); + Debug.Assert(range != null); CheckContextMatch(name); CheckContextMatch(range); @@ -697,8 +676,7 @@ namespace Microsoft.Z3 /// public Expr MkConst(string name, Sort range) { - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(range != null); return MkConst(MkSymbol(name), range); } @@ -709,8 +687,7 @@ namespace Microsoft.Z3 /// public Expr MkFreshConst(string prefix, Sort range) { - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(range != null); CheckContextMatch(range); return Expr.Create(this, Native.Z3_mk_fresh_const(nCtx, prefix, range.NativeObject)); @@ -722,8 +699,7 @@ namespace Microsoft.Z3 /// A decl of a 0-arity function public Expr MkConst(FuncDecl f) { - Contract.Requires(f != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(f != null); return MkApp(f); } @@ -733,8 +709,7 @@ namespace Microsoft.Z3 /// public BoolExpr MkBoolConst(Symbol name) { - Contract.Requires(name != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); return (BoolExpr)MkConst(name, BoolSort); } @@ -744,7 +719,6 @@ namespace Microsoft.Z3 /// public BoolExpr MkBoolConst(string name) { - Contract.Ensures(Contract.Result() != null); return (BoolExpr)MkConst(MkSymbol(name), BoolSort); } @@ -754,8 +728,7 @@ namespace Microsoft.Z3 /// public IntExpr MkIntConst(Symbol name) { - Contract.Requires(name != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); return (IntExpr)MkConst(name, IntSort); } @@ -765,8 +738,7 @@ namespace Microsoft.Z3 /// public IntExpr MkIntConst(string name) { - Contract.Requires(name != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); return (IntExpr)MkConst(name, IntSort); } @@ -776,8 +748,7 @@ namespace Microsoft.Z3 /// public RealExpr MkRealConst(Symbol name) { - Contract.Requires(name != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); return (RealExpr)MkConst(name, RealSort); } @@ -787,7 +758,6 @@ namespace Microsoft.Z3 /// public RealExpr MkRealConst(string name) { - Contract.Ensures(Contract.Result() != null); return (RealExpr)MkConst(name, RealSort); } @@ -797,8 +767,7 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVConst(Symbol name, uint size) { - Contract.Requires(name != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); return (BitVecExpr)MkConst(name, MkBitVecSort(size)); } @@ -808,7 +777,6 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVConst(string name, uint size) { - Contract.Ensures(Contract.Result() != null); return (BitVecExpr)MkConst(name, MkBitVecSort(size)); } @@ -820,9 +788,8 @@ namespace Microsoft.Z3 /// public Expr MkApp(FuncDecl f, params Expr[] args) { - Contract.Requires(f != null); - Contract.Requires(args == null || Contract.ForAll(args, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(f != null); + Debug.Assert(args == null || args.All(a => a != null)); CheckContextMatch(f); CheckContextMatch(args); @@ -834,9 +801,8 @@ namespace Microsoft.Z3 /// public Expr MkApp(FuncDecl f, IEnumerable args) { - Contract.Requires(f != null); - Contract.Requires(args == null || Contract.ForAll(args, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(f != null); + Debug.Assert(args == null || args.All( a => a != null)); CheckContextMatch(f); CheckContextMatch(args); @@ -849,7 +815,6 @@ namespace Microsoft.Z3 /// public BoolExpr MkTrue() { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_true(nCtx)); } @@ -859,7 +824,6 @@ namespace Microsoft.Z3 /// public BoolExpr MkFalse() { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_false(nCtx)); } @@ -869,7 +833,6 @@ namespace Microsoft.Z3 /// public BoolExpr MkBool(bool value) { - Contract.Ensures(Contract.Result() != null); return value ? MkTrue() : MkFalse(); } @@ -879,9 +842,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkEq(Expr x, Expr y) { - Contract.Requires(x != null); - Contract.Requires(y != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(x != null); + Debug.Assert(y != null); CheckContextMatch(x); CheckContextMatch(y); @@ -893,10 +855,9 @@ namespace Microsoft.Z3 /// public BoolExpr MkDistinct(params Expr[] args) { - Contract.Requires(args != null); - Contract.Requires(Contract.ForAll(args, a => a != null)); + Debug.Assert(args != null); + Debug.Assert(args.All(a => a != null)); - Contract.Ensures(Contract.Result() != null); CheckContextMatch(args); return new BoolExpr(this, Native.Z3_mk_distinct(nCtx, (uint)args.Length, AST.ArrayToNative(args))); @@ -907,8 +868,7 @@ namespace Microsoft.Z3 /// public BoolExpr MkNot(BoolExpr a) { - Contract.Requires(a != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(a != null); CheckContextMatch(a); return new BoolExpr(this, Native.Z3_mk_not(nCtx, a.NativeObject)); @@ -922,10 +882,9 @@ namespace Microsoft.Z3 /// An expression with the same sort as public Expr MkITE(BoolExpr t1, Expr t2, Expr t3) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Requires(t3 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); + Debug.Assert(t3 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -938,9 +897,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkIff(BoolExpr t1, BoolExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -952,9 +910,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkImplies(BoolExpr t1, BoolExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -966,23 +923,41 @@ namespace Microsoft.Z3 /// public BoolExpr MkXor(BoolExpr t1, BoolExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); return new BoolExpr(this, Native.Z3_mk_xor(nCtx, t1.NativeObject, t2.NativeObject)); } + /// + /// Create an expression representing t1 xor t2 xor t3 ... . + /// + public BoolExpr MkXor(IEnumerable ts) + { + Debug.Assert(ts != null); + Debug.Assert(ts.All(a => a != null)); + CheckContextMatch(ts); + BoolExpr r = null; + foreach (var t in ts) { + if (r == null) + r = t; + else + r = MkXor(r, t); + } + if (r == null) + r = MkTrue(); + return r; + } + /// /// Create an expression representing t[0] and t[1] and .... /// public BoolExpr MkAnd(params BoolExpr[] t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return new BoolExpr(this, Native.Z3_mk_and(nCtx, (uint)t.Length, AST.ArrayToNative(t))); @@ -993,9 +968,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkAnd(IEnumerable t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return new BoolExpr(this, Native.Z3_mk_and(nCtx, (uint)t.Count(), AST.EnumToNative(t))); } @@ -1005,9 +979,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkOr(params BoolExpr[] t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return new BoolExpr(this, Native.Z3_mk_or(nCtx, (uint)t.Length, AST.ArrayToNative(t))); @@ -1019,9 +992,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkOr(IEnumerable t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return new BoolExpr(this, Native.Z3_mk_or(nCtx, (uint)t.Count(), AST.EnumToNative(t))); @@ -1035,9 +1007,8 @@ namespace Microsoft.Z3 /// public ArithExpr MkAdd(params ArithExpr[] t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return (ArithExpr)Expr.Create(this, Native.Z3_mk_add(nCtx, (uint)t.Length, AST.ArrayToNative(t))); @@ -1048,9 +1019,8 @@ namespace Microsoft.Z3 /// public ArithExpr MkAdd(IEnumerable t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return (ArithExpr)Expr.Create(this, Native.Z3_mk_add(nCtx, (uint)t.Count(), AST.EnumToNative(t))); @@ -1061,9 +1031,8 @@ namespace Microsoft.Z3 /// public ArithExpr MkMul(params ArithExpr[] t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return (ArithExpr)Expr.Create(this, Native.Z3_mk_mul(nCtx, (uint)t.Length, AST.ArrayToNative(t))); @@ -1074,9 +1043,8 @@ namespace Microsoft.Z3 /// public ArithExpr MkMul(IEnumerable t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return (ArithExpr)Expr.Create(this, Native.Z3_mk_mul(nCtx, (uint)t.Count(), AST.EnumToNative(t))); @@ -1087,9 +1055,8 @@ namespace Microsoft.Z3 /// public ArithExpr MkSub(params ArithExpr[] t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return (ArithExpr)Expr.Create(this, Native.Z3_mk_sub(nCtx, (uint)t.Length, AST.ArrayToNative(t))); @@ -1100,8 +1067,7 @@ namespace Microsoft.Z3 /// public ArithExpr MkUnaryMinus(ArithExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return (ArithExpr)Expr.Create(this, Native.Z3_mk_unary_minus(nCtx, t.NativeObject)); @@ -1112,9 +1078,8 @@ namespace Microsoft.Z3 /// public ArithExpr MkDiv(ArithExpr t1, ArithExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1127,9 +1092,8 @@ namespace Microsoft.Z3 /// The arguments must have int type. public IntExpr MkMod(IntExpr t1, IntExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1142,9 +1106,8 @@ namespace Microsoft.Z3 /// The arguments must have int type. public IntExpr MkRem(IntExpr t1, IntExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1156,9 +1119,8 @@ namespace Microsoft.Z3 /// public ArithExpr MkPower(ArithExpr t1, ArithExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1170,9 +1132,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkLt(ArithExpr t1, ArithExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1184,9 +1145,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkLe(ArithExpr t1, ArithExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1198,9 +1158,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkGt(ArithExpr t1, ArithExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1212,9 +1171,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkGe(ArithExpr t1, ArithExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1233,8 +1191,7 @@ namespace Microsoft.Z3 /// public RealExpr MkInt2Real(IntExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new RealExpr(this, Native.Z3_mk_int2real(nCtx, t.NativeObject)); @@ -1249,8 +1206,7 @@ namespace Microsoft.Z3 /// public IntExpr MkReal2Int(RealExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new IntExpr(this, Native.Z3_mk_real2int(nCtx, t.NativeObject)); @@ -1261,8 +1217,7 @@ namespace Microsoft.Z3 /// public BoolExpr MkIsInteger(RealExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BoolExpr(this, Native.Z3_mk_is_int(nCtx, t.NativeObject)); @@ -1276,8 +1231,7 @@ namespace Microsoft.Z3 /// The argument must have a bit-vector sort. public BitVecExpr MkBVNot(BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_bvnot(nCtx, t.NativeObject)); @@ -1289,8 +1243,7 @@ namespace Microsoft.Z3 /// The argument must have a bit-vector sort. public BitVecExpr MkBVRedAND(BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_bvredand(nCtx, t.NativeObject)); @@ -1302,8 +1255,7 @@ namespace Microsoft.Z3 /// The argument must have a bit-vector sort. public BitVecExpr MkBVRedOR(BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_bvredor(nCtx, t.NativeObject)); @@ -1315,9 +1267,8 @@ namespace Microsoft.Z3 /// The arguments must have a bit-vector sort. public BitVecExpr MkBVAND(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1330,9 +1281,8 @@ namespace Microsoft.Z3 /// The arguments must have a bit-vector sort. public BitVecExpr MkBVOR(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1345,9 +1295,8 @@ namespace Microsoft.Z3 /// The arguments must have a bit-vector sort. public BitVecExpr MkBVXOR(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1360,9 +1309,8 @@ namespace Microsoft.Z3 /// The arguments must have a bit-vector sort. public BitVecExpr MkBVNAND(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1375,9 +1323,8 @@ namespace Microsoft.Z3 /// The arguments must have a bit-vector sort. public BitVecExpr MkBVNOR(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1390,9 +1337,8 @@ namespace Microsoft.Z3 /// The arguments must have a bit-vector sort. public BitVecExpr MkBVXNOR(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1405,8 +1351,7 @@ namespace Microsoft.Z3 /// The arguments must have a bit-vector sort. public BitVecExpr MkBVNeg(BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_bvneg(nCtx, t.NativeObject)); @@ -1418,9 +1363,8 @@ namespace Microsoft.Z3 /// The arguments must have the same bit-vector sort. public BitVecExpr MkBVAdd(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1433,9 +1377,8 @@ namespace Microsoft.Z3 /// The arguments must have the same bit-vector sort. public BitVecExpr MkBVSub(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1448,9 +1391,8 @@ namespace Microsoft.Z3 /// The arguments must have the same bit-vector sort. public BitVecExpr MkBVMul(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1468,9 +1410,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVUDiv(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1492,9 +1433,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVSDiv(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1511,9 +1451,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVURem(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1532,9 +1471,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVSRem(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1550,9 +1488,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVSMod(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1567,9 +1504,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVULT(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1584,9 +1520,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVSLT(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1601,9 +1536,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVULE(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1618,9 +1552,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVSLE(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1635,9 +1568,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVUGE(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1652,9 +1584,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVSGE(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1669,9 +1600,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVUGT(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1686,9 +1616,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVSGT(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1707,9 +1636,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkConcat(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1727,8 +1655,7 @@ namespace Microsoft.Z3 /// public BitVecExpr MkExtract(uint high, uint low, BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_extract(nCtx, high, low, t.NativeObject)); @@ -1744,8 +1671,7 @@ namespace Microsoft.Z3 /// public BitVecExpr MkSignExt(uint i, BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_sign_ext(nCtx, i, t.NativeObject)); @@ -1762,8 +1688,7 @@ namespace Microsoft.Z3 /// public BitVecExpr MkZeroExt(uint i, BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_zero_ext(nCtx, i, t.NativeObject)); @@ -1777,8 +1702,7 @@ namespace Microsoft.Z3 /// public BitVecExpr MkRepeat(uint i, BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_repeat(nCtx, i, t.NativeObject)); @@ -1798,9 +1722,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVSHL(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1821,9 +1744,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVLSHR(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1846,9 +1768,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVASHR(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1864,8 +1785,7 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVRotateLeft(uint i, BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_rotate_left(nCtx, i, t.NativeObject)); @@ -1880,8 +1800,7 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVRotateRight(uint i, BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_rotate_right(nCtx, i, t.NativeObject)); @@ -1896,9 +1815,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVRotateLeft(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1914,9 +1832,8 @@ namespace Microsoft.Z3 /// public BitVecExpr MkBVRotateRight(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1935,8 +1852,7 @@ namespace Microsoft.Z3 /// public BitVecExpr MkInt2BV(uint n, IntExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BitVecExpr(this, Native.Z3_mk_int2bv(nCtx, n, t.NativeObject)); @@ -1959,8 +1875,7 @@ namespace Microsoft.Z3 /// public IntExpr MkBV2Int(BitVecExpr t, bool signed) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new IntExpr(this, Native.Z3_mk_bv2int(nCtx, t.NativeObject, (byte)(signed ? 1 : 0))); @@ -1974,9 +1889,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVAddNoOverflow(BitVecExpr t1, BitVecExpr t2, bool isSigned) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -1991,9 +1905,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVAddNoUnderflow(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -2008,9 +1921,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVSubNoOverflow(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -2025,9 +1937,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVSubNoUnderflow(BitVecExpr t1, BitVecExpr t2, bool isSigned) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -2042,9 +1953,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVSDivNoOverflow(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -2059,8 +1969,7 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVNegNoOverflow(BitVecExpr t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new BoolExpr(this, Native.Z3_mk_bvneg_no_overflow(nCtx, t.NativeObject)); @@ -2074,9 +1983,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVMulNoOverflow(BitVecExpr t1, BitVecExpr t2, bool isSigned) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -2091,9 +1999,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkBVMulNoUnderflow(BitVecExpr t1, BitVecExpr t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -2107,10 +2014,9 @@ namespace Microsoft.Z3 /// public ArrayExpr MkArrayConst(Symbol name, Sort domain, Sort range) { - Contract.Requires(name != null); - Contract.Requires(domain != null); - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(name != null); + Debug.Assert(domain != null); + Debug.Assert(range != null); return (ArrayExpr)MkConst(name, MkArraySort(domain, range)); } @@ -2120,9 +2026,8 @@ namespace Microsoft.Z3 /// public ArrayExpr MkArrayConst(string name, Sort domain, Sort range) { - Contract.Requires(domain != null); - Contract.Requires(range != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(domain != null); + Debug.Assert(range != null); return (ArrayExpr)MkConst(MkSymbol(name), MkArraySort(domain, range)); } @@ -2143,9 +2048,8 @@ namespace Microsoft.Z3 /// public Expr MkSelect(ArrayExpr a, Expr i) { - Contract.Requires(a != null); - Contract.Requires(i != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(a != null); + Debug.Assert(i != null); CheckContextMatch(a); CheckContextMatch(i); @@ -2167,9 +2071,8 @@ namespace Microsoft.Z3 /// public Expr MkSelect(ArrayExpr a, params Expr[] args) { - Contract.Requires(a != null); - Contract.Requires(args != null && Contract.ForAll(args, n => n != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(a != null); + Debug.Assert(args != null && args.All(n => n != null)); CheckContextMatch(a); CheckContextMatch(args); @@ -2196,10 +2099,9 @@ namespace Microsoft.Z3 /// public ArrayExpr MkStore(ArrayExpr a, Expr i, Expr v) { - Contract.Requires(a != null); - Contract.Requires(i != null); - Contract.Requires(v != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(a != null); + Debug.Assert(i != null); + Debug.Assert(v != null); CheckContextMatch(a); CheckContextMatch(i); @@ -2227,10 +2129,9 @@ namespace Microsoft.Z3 /// public ArrayExpr MkStore(ArrayExpr a, Expr[] args, Expr v) { - Contract.Requires(a != null); - Contract.Requires(args != null); - Contract.Requires(v != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(a != null); + Debug.Assert(args != null); + Debug.Assert(v != null); CheckContextMatch(args); CheckContextMatch(a); @@ -2249,9 +2150,8 @@ namespace Microsoft.Z3 /// public ArrayExpr MkConstArray(Sort domain, Expr v) { - Contract.Requires(domain != null); - Contract.Requires(v != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(domain != null); + Debug.Assert(v != null); CheckContextMatch(domain); CheckContextMatch(v); @@ -2271,9 +2171,8 @@ namespace Microsoft.Z3 /// public ArrayExpr MkMap(FuncDecl f, params ArrayExpr[] args) { - Contract.Requires(f != null); - Contract.Requires(args == null || Contract.ForAll(args, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(f != null); + Debug.Assert(args == null || args.All(a => a != null)); CheckContextMatch(f); CheckContextMatch(args); @@ -2289,8 +2188,7 @@ namespace Microsoft.Z3 /// public Expr MkTermArray(ArrayExpr array) { - Contract.Requires(array != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(array != null); CheckContextMatch(array); return Expr.Create(this, Native.Z3_mk_array_default(nCtx, array.NativeObject)); @@ -2301,9 +2199,8 @@ namespace Microsoft.Z3 /// public Expr MkArrayExt(ArrayExpr arg1, ArrayExpr arg2) { - Contract.Requires(arg1 != null); - Contract.Requires(arg2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(arg1 != null); + Debug.Assert(arg2 != null); CheckContextMatch(arg1); CheckContextMatch(arg2); @@ -2318,8 +2215,7 @@ namespace Microsoft.Z3 /// public SetSort MkSetSort(Sort ty) { - Contract.Requires(ty != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ty != null); CheckContextMatch(ty); return new SetSort(this, ty); @@ -2330,8 +2226,7 @@ namespace Microsoft.Z3 /// public ArrayExpr MkEmptySet(Sort domain) { - Contract.Requires(domain != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(domain != null); CheckContextMatch(domain); return (ArrayExpr)Expr.Create(this, Native.Z3_mk_empty_set(nCtx, domain.NativeObject)); @@ -2342,8 +2237,7 @@ namespace Microsoft.Z3 /// public ArrayExpr MkFullSet(Sort domain) { - Contract.Requires(domain != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(domain != null); CheckContextMatch(domain); return (ArrayExpr)Expr.Create(this, Native.Z3_mk_full_set(nCtx, domain.NativeObject)); @@ -2354,9 +2248,8 @@ namespace Microsoft.Z3 /// public ArrayExpr MkSetAdd(ArrayExpr set, Expr element) { - Contract.Requires(set != null); - Contract.Requires(element != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(set != null); + Debug.Assert(element != null); CheckContextMatch(set); CheckContextMatch(element); @@ -2369,9 +2262,8 @@ namespace Microsoft.Z3 /// public ArrayExpr MkSetDel(ArrayExpr set, Expr element) { - Contract.Requires(set != null); - Contract.Requires(element != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(set != null); + Debug.Assert(element != null); CheckContextMatch(set); CheckContextMatch(element); @@ -2383,8 +2275,8 @@ namespace Microsoft.Z3 /// public ArrayExpr MkSetUnion(params ArrayExpr[] args) { - Contract.Requires(args != null); - Contract.Requires(Contract.ForAll(args, a => a != null)); + Debug.Assert(args != null); + Debug.Assert(args.All(a => a != null)); CheckContextMatch(args); return (ArrayExpr)Expr.Create(this, Native.Z3_mk_set_union(nCtx, (uint)args.Length, AST.ArrayToNative(args))); @@ -2395,9 +2287,8 @@ namespace Microsoft.Z3 /// public ArrayExpr MkSetIntersection(params ArrayExpr[] args) { - Contract.Requires(args != null); - Contract.Requires(Contract.ForAll(args, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(args != null); + Debug.Assert(args.All(a => a != null)); CheckContextMatch(args); return (ArrayExpr)Expr.Create(this, Native.Z3_mk_set_intersect(nCtx, (uint)args.Length, AST.ArrayToNative(args))); @@ -2408,9 +2299,8 @@ namespace Microsoft.Z3 /// public ArrayExpr MkSetDifference(ArrayExpr arg1, ArrayExpr arg2) { - Contract.Requires(arg1 != null); - Contract.Requires(arg2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(arg1 != null); + Debug.Assert(arg2 != null); CheckContextMatch(arg1); CheckContextMatch(arg2); @@ -2422,8 +2312,7 @@ namespace Microsoft.Z3 /// public ArrayExpr MkSetComplement(ArrayExpr arg) { - Contract.Requires(arg != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(arg != null); CheckContextMatch(arg); return (ArrayExpr)Expr.Create(this, Native.Z3_mk_set_complement(nCtx, arg.NativeObject)); @@ -2434,9 +2323,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkSetMembership(Expr elem, ArrayExpr set) { - Contract.Requires(elem != null); - Contract.Requires(set != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(elem != null); + Debug.Assert(set != null); CheckContextMatch(elem); CheckContextMatch(set); @@ -2448,9 +2336,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkSetSubset(ArrayExpr arg1, ArrayExpr arg2) { - Contract.Requires(arg1 != null); - Contract.Requires(arg2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(arg1 != null); + Debug.Assert(arg2 != null); CheckContextMatch(arg1); CheckContextMatch(arg2); @@ -2459,15 +2346,14 @@ namespace Microsoft.Z3 #endregion - #region Sequence, string and regular expresions + #region Sequence, string and regular expressions /// /// Create the empty sequence. /// public SeqExpr MkEmptySeq(Sort s) { - Contract.Requires(s != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); return new SeqExpr(this, Native.Z3_mk_seq_empty(nCtx, s.NativeObject)); } @@ -2476,8 +2362,7 @@ namespace Microsoft.Z3 /// public SeqExpr MkUnit(Expr elem) { - Contract.Requires(elem != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(elem != null); return new SeqExpr(this, Native.Z3_mk_seq_unit(nCtx, elem.NativeObject)); } @@ -2486,8 +2371,7 @@ namespace Microsoft.Z3 /// public SeqExpr MkString(string s) { - Contract.Requires(s != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); return new SeqExpr(this, Native.Z3_mk_string(nCtx, s)); } @@ -2496,9 +2380,8 @@ namespace Microsoft.Z3 /// public SeqExpr IntToString(Expr e) { - Contract.Requires(e != null); - Contract.Requires(e is ArithExpr); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(e != null); + Debug.Assert(e is ArithExpr); return new SeqExpr(this, Native.Z3_mk_int_to_str(nCtx, e.NativeObject)); } @@ -2507,9 +2390,8 @@ namespace Microsoft.Z3 /// public IntExpr StringToInt(Expr e) { - Contract.Requires(e != null); - Contract.Requires(e is SeqExpr); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(e != null); + Debug.Assert(e is SeqExpr); return new IntExpr(this, Native.Z3_mk_str_to_int(nCtx, e.NativeObject)); } @@ -2519,9 +2401,8 @@ namespace Microsoft.Z3 /// public SeqExpr MkConcat(params SeqExpr[] t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return new SeqExpr(this, Native.Z3_mk_seq_concat(nCtx, (uint)t.Length, AST.ArrayToNative(t))); @@ -2533,8 +2414,7 @@ namespace Microsoft.Z3 /// public IntExpr MkLength(SeqExpr s) { - Contract.Requires(s != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); return (IntExpr) Expr.Create(this, Native.Z3_mk_seq_length(nCtx, s.NativeObject)); } @@ -2543,9 +2423,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkPrefixOf(SeqExpr s1, SeqExpr s2) { - Contract.Requires(s1 != null); - Contract.Requires(s2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s1 != null); + Debug.Assert(s2 != null); CheckContextMatch(s1, s2); return new BoolExpr(this, Native.Z3_mk_seq_prefix(nCtx, s1.NativeObject, s2.NativeObject)); } @@ -2555,9 +2434,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkSuffixOf(SeqExpr s1, SeqExpr s2) { - Contract.Requires(s1 != null); - Contract.Requires(s2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s1 != null); + Debug.Assert(s2 != null); CheckContextMatch(s1, s2); return new BoolExpr(this, Native.Z3_mk_seq_suffix(nCtx, s1.NativeObject, s2.NativeObject)); } @@ -2567,9 +2445,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkContains(SeqExpr s1, SeqExpr s2) { - Contract.Requires(s1 != null); - Contract.Requires(s2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s1 != null); + Debug.Assert(s2 != null); CheckContextMatch(s1, s2); return new BoolExpr(this, Native.Z3_mk_seq_contains(nCtx, s1.NativeObject, s2.NativeObject)); } @@ -2579,9 +2456,8 @@ namespace Microsoft.Z3 /// public SeqExpr MkAt(SeqExpr s, IntExpr index) { - Contract.Requires(s != null); - Contract.Requires(index != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); + Debug.Assert(index != null); CheckContextMatch(s, index); return new SeqExpr(this, Native.Z3_mk_seq_at(nCtx, s.NativeObject, index.NativeObject)); } @@ -2591,10 +2467,9 @@ namespace Microsoft.Z3 /// public SeqExpr MkExtract(SeqExpr s, IntExpr offset, IntExpr length) { - Contract.Requires(s != null); - Contract.Requires(offset != null); - Contract.Requires(length != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); + Debug.Assert(offset != null); + Debug.Assert(length != null); CheckContextMatch(s, offset, length); return new SeqExpr(this, Native.Z3_mk_seq_extract(nCtx, s.NativeObject, offset.NativeObject, length.NativeObject)); } @@ -2604,10 +2479,9 @@ namespace Microsoft.Z3 /// public IntExpr MkIndexOf(SeqExpr s, SeqExpr substr, ArithExpr offset) { - Contract.Requires(s != null); - Contract.Requires(offset != null); - Contract.Requires(substr != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); + Debug.Assert(offset != null); + Debug.Assert(substr != null); CheckContextMatch(s, substr, offset); return new IntExpr(this, Native.Z3_mk_seq_index(nCtx, s.NativeObject, substr.NativeObject, offset.NativeObject)); } @@ -2617,10 +2491,9 @@ namespace Microsoft.Z3 /// public SeqExpr MkReplace(SeqExpr s, SeqExpr src, SeqExpr dst) { - Contract.Requires(s != null); - Contract.Requires(src != null); - Contract.Requires(dst != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); + Debug.Assert(src != null); + Debug.Assert(dst != null); CheckContextMatch(s, src, dst); return new SeqExpr(this, Native.Z3_mk_seq_replace(nCtx, s.NativeObject, src.NativeObject, dst.NativeObject)); } @@ -2630,8 +2503,7 @@ namespace Microsoft.Z3 /// public ReExpr MkToRe(SeqExpr s) { - Contract.Requires(s != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); return new ReExpr(this, Native.Z3_mk_seq_to_re(nCtx, s.NativeObject)); } @@ -2641,9 +2513,8 @@ namespace Microsoft.Z3 /// public BoolExpr MkInRe(SeqExpr s, ReExpr re) { - Contract.Requires(s != null); - Contract.Requires(re != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); + Debug.Assert(re != null); CheckContextMatch(s, re); return new BoolExpr(this, Native.Z3_mk_seq_in_re(nCtx, s.NativeObject, re.NativeObject)); } @@ -2653,8 +2524,7 @@ namespace Microsoft.Z3 /// public ReExpr MkStar(ReExpr re) { - Contract.Requires(re != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(re != null); return new ReExpr(this, Native.Z3_mk_re_star(nCtx, re.NativeObject)); } @@ -2663,8 +2533,7 @@ namespace Microsoft.Z3 /// public ReExpr MkLoop(ReExpr re, uint lo, uint hi = 0) { - Contract.Requires(re != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(re != null); return new ReExpr(this, Native.Z3_mk_re_loop(nCtx, re.NativeObject, lo, hi)); } @@ -2673,8 +2542,7 @@ namespace Microsoft.Z3 /// public ReExpr MkPlus(ReExpr re) { - Contract.Requires(re != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(re != null); return new ReExpr(this, Native.Z3_mk_re_plus(nCtx, re.NativeObject)); } @@ -2683,8 +2551,7 @@ namespace Microsoft.Z3 /// public ReExpr MkOption(ReExpr re) { - Contract.Requires(re != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(re != null); return new ReExpr(this, Native.Z3_mk_re_option(nCtx, re.NativeObject)); } @@ -2693,8 +2560,7 @@ namespace Microsoft.Z3 /// public ReExpr MkComplement(ReExpr re) { - Contract.Requires(re != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(re != null); return new ReExpr(this, Native.Z3_mk_re_complement(nCtx, re.NativeObject)); } @@ -2703,9 +2569,8 @@ namespace Microsoft.Z3 /// public ReExpr MkConcat(params ReExpr[] t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return new ReExpr(this, Native.Z3_mk_re_concat(nCtx, (uint)t.Length, AST.ArrayToNative(t))); @@ -2716,9 +2581,8 @@ namespace Microsoft.Z3 /// public ReExpr MkUnion(params ReExpr[] t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return new ReExpr(this, Native.Z3_mk_re_union(nCtx, (uint)t.Length, AST.ArrayToNative(t))); @@ -2729,9 +2593,8 @@ namespace Microsoft.Z3 /// public ReExpr MkIntersect(params ReExpr[] t) { - Contract.Requires(t != null); - Contract.Requires(Contract.ForAll(t, a => a != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(t.All(a => a != null)); CheckContextMatch(t); return new ReExpr(this, Native.Z3_mk_re_intersect(nCtx, (uint)t.Length, AST.ArrayToNative(t))); @@ -2742,8 +2605,7 @@ namespace Microsoft.Z3 /// public ReExpr MkEmptyRe(Sort s) { - Contract.Requires(s != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); return new ReExpr(this, Native.Z3_mk_re_empty(nCtx, s.NativeObject)); } @@ -2752,8 +2614,7 @@ namespace Microsoft.Z3 /// public ReExpr MkFullRe(Sort s) { - Contract.Requires(s != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); return new ReExpr(this, Native.Z3_mk_re_full(nCtx, s.NativeObject)); } @@ -2763,9 +2624,8 @@ namespace Microsoft.Z3 /// public ReExpr MkRange(SeqExpr lo, SeqExpr hi) { - Contract.Requires(lo != null); - Contract.Requires(hi != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(lo != null); + Debug.Assert(hi != null); CheckContextMatch(lo, hi); return new ReExpr(this, Native.Z3_mk_re_range(nCtx, lo.NativeObject, hi.NativeObject)); } @@ -2779,8 +2639,7 @@ namespace Microsoft.Z3 /// public BoolExpr MkAtMost(IEnumerable args, uint k) { - Contract.Requires(args != null); - Contract.Requires(Contract.Result() != null); + Debug.Assert(args != null); CheckContextMatch(args); return new BoolExpr(this, Native.Z3_mk_atmost(nCtx, (uint) args.Count(), AST.EnumToNative(args), k)); @@ -2791,8 +2650,7 @@ namespace Microsoft.Z3 /// public BoolExpr MkAtLeast(IEnumerable args, uint k) { - Contract.Requires(args != null); - Contract.Requires(Contract.Result() != null); + Debug.Assert(args != null); CheckContextMatch(args); return new BoolExpr(this, Native.Z3_mk_atleast(nCtx, (uint) args.Count(), AST.EnumToNative(args), k)); @@ -2803,10 +2661,9 @@ namespace Microsoft.Z3 /// public BoolExpr MkPBLe(int[] coeffs, BoolExpr[] args, int k) { - Contract.Requires(args != null); - Contract.Requires(coeffs != null); - Contract.Requires(args.Length == coeffs.Length); - Contract.Requires(Contract.Result() != null); + Debug.Assert(args != null); + Debug.Assert(coeffs != null); + Debug.Assert(args.Length == coeffs.Length); CheckContextMatch(args); return new BoolExpr(this, Native.Z3_mk_pble(nCtx, (uint) args.Length, AST.ArrayToNative(args), @@ -2818,10 +2675,9 @@ namespace Microsoft.Z3 /// public BoolExpr MkPBGe(int[] coeffs, BoolExpr[] args, int k) { - Contract.Requires(args != null); - Contract.Requires(coeffs != null); - Contract.Requires(args.Length == coeffs.Length); - Contract.Requires(Contract.Result() != null); + Debug.Assert(args != null); + Debug.Assert(coeffs != null); + Debug.Assert(args.Length == coeffs.Length); CheckContextMatch(args); return new BoolExpr(this, Native.Z3_mk_pbge(nCtx, (uint) args.Length, AST.ArrayToNative(args), @@ -2832,10 +2688,9 @@ namespace Microsoft.Z3 /// public BoolExpr MkPBEq(int[] coeffs, BoolExpr[] args, int k) { - Contract.Requires(args != null); - Contract.Requires(coeffs != null); - Contract.Requires(args.Length == coeffs.Length); - Contract.Requires(Contract.Result() != null); + Debug.Assert(args != null); + Debug.Assert(coeffs != null); + Debug.Assert(args.Length == coeffs.Length); CheckContextMatch(args); return new BoolExpr(this, Native.Z3_mk_pbeq(nCtx, (uint) args.Length, AST.ArrayToNative(args), @@ -2854,8 +2709,7 @@ namespace Microsoft.Z3 /// A Term with value and sort public Expr MkNumeral(string v, Sort ty) { - Contract.Requires(ty != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ty != null); CheckContextMatch(ty); return Expr.Create(this, Native.Z3_mk_numeral(nCtx, v, ty.NativeObject)); @@ -2870,8 +2724,7 @@ namespace Microsoft.Z3 /// A Term with value and type public Expr MkNumeral(int v, Sort ty) { - Contract.Requires(ty != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ty != null); CheckContextMatch(ty); return Expr.Create(this, Native.Z3_mk_int(nCtx, v, ty.NativeObject)); @@ -2886,8 +2739,7 @@ namespace Microsoft.Z3 /// A Term with value and type public Expr MkNumeral(uint v, Sort ty) { - Contract.Requires(ty != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ty != null); CheckContextMatch(ty); return Expr.Create(this, Native.Z3_mk_unsigned_int(nCtx, v, ty.NativeObject)); @@ -2902,8 +2754,7 @@ namespace Microsoft.Z3 /// A Term with value and type public Expr MkNumeral(long v, Sort ty) { - Contract.Requires(ty != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ty != null); CheckContextMatch(ty); return Expr.Create(this, Native.Z3_mk_int64(nCtx, v, ty.NativeObject)); @@ -2918,8 +2769,7 @@ namespace Microsoft.Z3 /// A Term with value and type public Expr MkNumeral(ulong v, Sort ty) { - Contract.Requires(ty != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ty != null); CheckContextMatch(ty); return Expr.Create(this, Native.Z3_mk_unsigned_int64(nCtx, v, ty.NativeObject)); @@ -2939,9 +2789,6 @@ namespace Microsoft.Z3 if (den == 0) throw new Z3Exception("Denominator is zero"); - Contract.Ensures(Contract.Result() != null); - Contract.EndContractBlock(); - return new RatNum(this, Native.Z3_mk_real(nCtx, num, den)); } @@ -2952,7 +2799,6 @@ namespace Microsoft.Z3 /// A Term with value and sort Real public RatNum MkReal(string v) { - Contract.Ensures(Contract.Result() != null); return new RatNum(this, Native.Z3_mk_numeral(nCtx, v, RealSort.NativeObject)); } @@ -2964,7 +2810,6 @@ namespace Microsoft.Z3 /// A Term with value and sort Real public RatNum MkReal(int v) { - Contract.Ensures(Contract.Result() != null); return new RatNum(this, Native.Z3_mk_int(nCtx, v, RealSort.NativeObject)); } @@ -2976,7 +2821,6 @@ namespace Microsoft.Z3 /// A Term with value and sort Real public RatNum MkReal(uint v) { - Contract.Ensures(Contract.Result() != null); return new RatNum(this, Native.Z3_mk_unsigned_int(nCtx, v, RealSort.NativeObject)); } @@ -2988,7 +2832,6 @@ namespace Microsoft.Z3 /// A Term with value and sort Real public RatNum MkReal(long v) { - Contract.Ensures(Contract.Result() != null); return new RatNum(this, Native.Z3_mk_int64(nCtx, v, RealSort.NativeObject)); } @@ -3000,7 +2843,6 @@ namespace Microsoft.Z3 /// A Term with value and sort Real public RatNum MkReal(ulong v) { - Contract.Ensures(Contract.Result() != null); return new RatNum(this, Native.Z3_mk_unsigned_int64(nCtx, v, RealSort.NativeObject)); } @@ -3013,7 +2855,6 @@ namespace Microsoft.Z3 /// A string representing the Term value in decimal notation. public IntNum MkInt(string v) { - Contract.Ensures(Contract.Result() != null); return new IntNum(this, Native.Z3_mk_numeral(nCtx, v, IntSort.NativeObject)); } @@ -3025,7 +2866,6 @@ namespace Microsoft.Z3 /// A Term with value and sort Integer public IntNum MkInt(int v) { - Contract.Ensures(Contract.Result() != null); return new IntNum(this, Native.Z3_mk_int(nCtx, v, IntSort.NativeObject)); } @@ -3037,7 +2877,6 @@ namespace Microsoft.Z3 /// A Term with value and sort Integer public IntNum MkInt(uint v) { - Contract.Ensures(Contract.Result() != null); return new IntNum(this, Native.Z3_mk_unsigned_int(nCtx, v, IntSort.NativeObject)); } @@ -3049,7 +2888,6 @@ namespace Microsoft.Z3 /// A Term with value and sort Integer public IntNum MkInt(long v) { - Contract.Ensures(Contract.Result() != null); return new IntNum(this, Native.Z3_mk_int64(nCtx, v, IntSort.NativeObject)); } @@ -3061,7 +2899,6 @@ namespace Microsoft.Z3 /// A Term with value and sort Integer public IntNum MkInt(ulong v) { - Contract.Ensures(Contract.Result() != null); return new IntNum(this, Native.Z3_mk_unsigned_int64(nCtx, v, IntSort.NativeObject)); } @@ -3075,7 +2912,6 @@ namespace Microsoft.Z3 /// the size of the bit-vector public BitVecNum MkBV(string v, uint size) { - Contract.Ensures(Contract.Result() != null); return (BitVecNum)MkNumeral(v, MkBitVecSort(size)); } @@ -3087,7 +2923,6 @@ namespace Microsoft.Z3 /// the size of the bit-vector public BitVecNum MkBV(int v, uint size) { - Contract.Ensures(Contract.Result() != null); return (BitVecNum)MkNumeral(v, MkBitVecSort(size)); } @@ -3099,7 +2934,6 @@ namespace Microsoft.Z3 /// the size of the bit-vector public BitVecNum MkBV(uint v, uint size) { - Contract.Ensures(Contract.Result() != null); return (BitVecNum)MkNumeral(v, MkBitVecSort(size)); } @@ -3111,7 +2945,6 @@ namespace Microsoft.Z3 /// the size of the bit-vector public BitVecNum MkBV(long v, uint size) { - Contract.Ensures(Contract.Result() != null); return (BitVecNum)MkNumeral(v, MkBitVecSort(size)); } @@ -3123,7 +2956,6 @@ namespace Microsoft.Z3 /// the size of the bit-vector public BitVecNum MkBV(ulong v, uint size) { - Contract.Ensures(Contract.Result() != null); return (BitVecNum)MkNumeral(v, MkBitVecSort(size)); } @@ -3131,10 +2963,9 @@ namespace Microsoft.Z3 /// /// Create a bit-vector numeral. /// - /// An array of bits representing the bit-vector. Least signficant bit is at position 0. + /// An array of bits representing the bit-vector. Least significant bit is at position 0. public BitVecNum MkBV(bool[] bits) { - Contract.Ensures(Contract.Result() != null); byte[] _bits = new byte[bits.Length]; for (int i = 0; i < bits.Length; ++i) _bits[i] = (byte)(bits[i] ? 1 : 0); return (BitVecNum)Expr.Create(this, Native.Z3_mk_bv_numeral(nCtx, (uint)bits.Length, _bits)); @@ -3172,16 +3003,15 @@ namespace Microsoft.Z3 /// optional symbol to track skolem constants. public Quantifier MkForall(Sort[] sorts, Symbol[] names, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null) { - Contract.Requires(sorts != null); - Contract.Requires(names != null); - Contract.Requires(body != null); - Contract.Requires(sorts.Length == names.Length); - Contract.Requires(Contract.ForAll(sorts, s => s != null)); - Contract.Requires(Contract.ForAll(names, n => n != null)); - Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null)); - Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null)); + Debug.Assert(sorts != null); + Debug.Assert(names != null); + Debug.Assert(body != null); + Debug.Assert(sorts.Length == names.Length); + Debug.Assert(sorts.All(s => s != null)); + Debug.Assert(names.All(n => n != null)); + Debug.Assert(patterns == null || patterns.All(p => p != null)); + Debug.Assert(noPatterns == null || noPatterns.All(np => np != null)); - Contract.Ensures(Contract.Result() != null); return new Quantifier(this, true, sorts, names, body, weight, patterns, noPatterns, quantifierID, skolemID); } @@ -3197,12 +3027,11 @@ namespace Microsoft.Z3 /// public Quantifier MkForall(Expr[] boundConstants, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null) { - Contract.Requires(body != null); - Contract.Requires(boundConstants == null || Contract.ForAll(boundConstants, b => b != null)); - Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null)); - Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null)); + Debug.Assert(body != null); + Debug.Assert(boundConstants == null || boundConstants.All(b => b != null)); + Debug.Assert(patterns == null || patterns.All(p => p != null)); + Debug.Assert(noPatterns == null || noPatterns.All(np => np != null)); - Contract.Ensures(Contract.Result() != null); return new Quantifier(this, true, boundConstants, body, weight, patterns, noPatterns, quantifierID, skolemID); } @@ -3216,15 +3045,14 @@ namespace Microsoft.Z3 /// public Quantifier MkExists(Sort[] sorts, Symbol[] names, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null) { - Contract.Requires(sorts != null); - Contract.Requires(names != null); - Contract.Requires(body != null); - Contract.Requires(sorts.Length == names.Length); - Contract.Requires(Contract.ForAll(sorts, s => s != null)); - Contract.Requires(Contract.ForAll(names, n => n != null)); - Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null)); - Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(sorts != null); + Debug.Assert(names != null); + Debug.Assert(body != null); + Debug.Assert(sorts.Length == names.Length); + Debug.Assert(sorts.All(s => s != null)); + Debug.Assert(names.All(n => n != null)); + Debug.Assert(patterns == null || patterns.All(p => p != null)); + Debug.Assert(noPatterns == null || noPatterns.All(np => np != null)); return new Quantifier(this, false, sorts, names, body, weight, patterns, noPatterns, quantifierID, skolemID); } @@ -3239,11 +3067,10 @@ namespace Microsoft.Z3 /// public Quantifier MkExists(Expr[] boundConstants, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null) { - Contract.Requires(body != null); - Contract.Requires(boundConstants == null || Contract.ForAll(boundConstants, n => n != null)); - Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null)); - Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(body != null); + Debug.Assert(boundConstants == null || boundConstants.All(n => n != null)); + Debug.Assert(patterns == null || patterns.All(p => p != null)); + Debug.Assert(noPatterns == null || noPatterns.All(np => np != null)); return new Quantifier(this, false, boundConstants, body, weight, patterns, noPatterns, quantifierID, skolemID); } @@ -3255,16 +3082,15 @@ namespace Microsoft.Z3 /// public Quantifier MkQuantifier(bool universal, Sort[] sorts, Symbol[] names, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null) { - Contract.Requires(body != null); - Contract.Requires(names != null); - Contract.Requires(sorts != null); - Contract.Requires(sorts.Length == names.Length); - Contract.Requires(Contract.ForAll(sorts, s => s != null)); - Contract.Requires(Contract.ForAll(names, n => n != null)); - Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null)); - Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null)); + Debug.Assert(body != null); + Debug.Assert(names != null); + Debug.Assert(sorts != null); + Debug.Assert(sorts.Length == names.Length); + Debug.Assert(sorts.All(s => s != null)); + Debug.Assert(names.All(n => n != null)); + Debug.Assert(patterns == null || patterns.All(p => p != null)); + Debug.Assert(noPatterns == null || noPatterns.All(np => np != null)); - Contract.Ensures(Contract.Result() != null); if (universal) return MkForall(sorts, names, body, weight, patterns, noPatterns, quantifierID, skolemID); @@ -3279,12 +3105,11 @@ namespace Microsoft.Z3 /// public Quantifier MkQuantifier(bool universal, Expr[] boundConstants, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null) { - Contract.Requires(body != null); - Contract.Requires(boundConstants == null || Contract.ForAll(boundConstants, n => n != null)); - Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null)); - Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null)); + Debug.Assert(body != null); + Debug.Assert(boundConstants == null || boundConstants.All(n => n != null)); + Debug.Assert(patterns == null || patterns.All(p => p != null)); + Debug.Assert(noPatterns == null || noPatterns.All(np => np != null)); - Contract.Ensures(Contract.Result() != null); if (universal) return MkForall(boundConstants, body, weight, patterns, noPatterns, quantifierID, skolemID); @@ -3312,13 +3137,12 @@ namespace Microsoft.Z3 /// the body of the quantifier. public Lambda MkLambda(Sort[] sorts, Symbol[] names, Expr body) { - Contract.Requires(sorts != null); - Contract.Requires(names != null); - Contract.Requires(body != null); - Contract.Requires(sorts.Length == names.Length); - Contract.Requires(Contract.ForAll(sorts, s => s != null)); - Contract.Requires(Contract.ForAll(names, n => n != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(sorts != null); + Debug.Assert(names != null); + Debug.Assert(body != null); + Debug.Assert(sorts.Length == names.Length); + Debug.Assert(sorts.All(s => s != null)); + Debug.Assert(names.All(n => n != null)); return new Lambda(this, sorts, names, body); } @@ -3332,9 +3156,8 @@ namespace Microsoft.Z3 /// public Lambda MkLambda(Expr[] boundConstants, Expr body) { - Contract.Requires(body != null); - Contract.Requires(boundConstants != null && Contract.ForAll(boundConstants, b => b != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(body != null); + Debug.Assert(boundConstants != null && boundConstants.All(b => b != null)); return new Lambda(this, boundConstants, body); } @@ -3374,7 +3197,6 @@ namespace Microsoft.Z3 /// A conjunction of assertions in the scope (up to push/pop) at the end of the string. public BoolExpr[] ParseSMTLIB2String(string str, Symbol[] sortNames = null, Sort[] sorts = null, Symbol[] declNames = null, FuncDecl[] decls = null) { - Contract.Ensures(Contract.Result() != null); uint csn = Symbol.ArrayLength(sortNames); uint cs = Sort.ArrayLength(sorts); @@ -3394,7 +3216,6 @@ namespace Microsoft.Z3 /// public BoolExpr[] ParseSMTLIB2File(string fileName, Symbol[] sortNames = null, Sort[] sorts = null, Symbol[] declNames = null, FuncDecl[] decls = null) { - Contract.Ensures(Contract.Result() != null); uint csn = Symbol.ArrayLength(sortNames); uint cs = Sort.ArrayLength(sorts); @@ -3422,7 +3243,6 @@ namespace Microsoft.Z3 /// Indicates whether proof generation should be enabled. public Goal MkGoal(bool models = true, bool unsatCores = false, bool proofs = false) { - Contract.Ensures(Contract.Result() != null); return new Goal(this, models, unsatCores, proofs); } @@ -3434,7 +3254,6 @@ namespace Microsoft.Z3 /// public Params MkParams() { - Contract.Ensures(Contract.Result() != null); return new Params(this); } @@ -3456,7 +3275,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumTactics; string[] res = new string[n]; @@ -3471,7 +3289,6 @@ namespace Microsoft.Z3 /// public string TacticDescription(string name) { - Contract.Ensures(Contract.Result() != null); return Native.Z3_tactic_get_descr(nCtx, name); } @@ -3481,7 +3298,6 @@ namespace Microsoft.Z3 /// public Tactic MkTactic(string name) { - Contract.Ensures(Contract.Result() != null); return new Tactic(this, name); } @@ -3492,10 +3308,9 @@ namespace Microsoft.Z3 /// public Tactic AndThen(Tactic t1, Tactic t2, params Tactic[] ts) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Requires(ts == null || Contract.ForAll(0, ts.Length, j => ts[j] != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); + // Debug.Assert(ts == null || Contract.ForAll(0, ts.Length, j => ts[j] != null)); CheckContextMatch(t1); @@ -3527,10 +3342,9 @@ namespace Microsoft.Z3 /// public Tactic Then(Tactic t1, Tactic t2, params Tactic[] ts) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Requires(ts == null || Contract.ForAll(0, ts.Length, j => ts[j] != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); + // Debug.Assert(ts == null || Contract.ForAll(0, ts.Length, j => ts[j] != null)); return AndThen(t1, t2, ts); } @@ -3541,9 +3355,8 @@ namespace Microsoft.Z3 /// public Tactic OrElse(Tactic t1, Tactic t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -3558,8 +3371,7 @@ namespace Microsoft.Z3 /// public Tactic TryFor(Tactic t, uint ms) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new Tactic(this, Native.Z3_tactic_try_for(nCtx, t.NativeObject, ms)); @@ -3574,9 +3386,8 @@ namespace Microsoft.Z3 /// public Tactic When(Probe p, Tactic t) { - Contract.Requires(p != null); - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p != null); + Debug.Assert(t != null); CheckContextMatch(t); CheckContextMatch(p); @@ -3589,10 +3400,9 @@ namespace Microsoft.Z3 /// public Tactic Cond(Probe p, Tactic t1, Tactic t2) { - Contract.Requires(p != null); - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(p); CheckContextMatch(t1); @@ -3606,8 +3416,7 @@ namespace Microsoft.Z3 /// public Tactic Repeat(Tactic t, uint max = uint.MaxValue) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); CheckContextMatch(t); return new Tactic(this, Native.Z3_tactic_repeat(nCtx, t.NativeObject, max)); @@ -3618,7 +3427,6 @@ namespace Microsoft.Z3 /// public Tactic Skip() { - Contract.Ensures(Contract.Result() != null); return new Tactic(this, Native.Z3_tactic_skip(nCtx)); } @@ -3628,7 +3436,6 @@ namespace Microsoft.Z3 /// public Tactic Fail() { - Contract.Ensures(Contract.Result() != null); return new Tactic(this, Native.Z3_tactic_fail(nCtx)); } @@ -3638,8 +3445,7 @@ namespace Microsoft.Z3 /// public Tactic FailIf(Probe p) { - Contract.Requires(p != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p != null); CheckContextMatch(p); return new Tactic(this, Native.Z3_tactic_fail_if(nCtx, p.NativeObject)); @@ -3651,7 +3457,6 @@ namespace Microsoft.Z3 /// public Tactic FailIfNotDecided() { - Contract.Ensures(Contract.Result() != null); return new Tactic(this, Native.Z3_tactic_fail_if_not_decided(nCtx)); } @@ -3661,9 +3466,8 @@ namespace Microsoft.Z3 /// public Tactic UsingParams(Tactic t, Params p) { - Contract.Requires(t != null); - Contract.Requires(p != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(p != null); CheckContextMatch(t); CheckContextMatch(p); @@ -3676,9 +3480,8 @@ namespace Microsoft.Z3 /// Alias for UsingParams public Tactic With(Tactic t, Params p) { - Contract.Requires(t != null); - Contract.Requires(p != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); + Debug.Assert(p != null); return UsingParams(t, p); } @@ -3688,8 +3491,7 @@ namespace Microsoft.Z3 /// public Tactic ParOr(params Tactic[] t) { - Contract.Requires(t == null || Contract.ForAll(t, tactic => tactic != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t == null || t.All(tactic => tactic != null)); CheckContextMatch(t); return new Tactic(this, Native.Z3_tactic_par_or(nCtx, Tactic.ArrayLength(t), Tactic.ArrayToNative(t))); @@ -3701,9 +3503,8 @@ namespace Microsoft.Z3 /// public Tactic ParAndThen(Tactic t1, Tactic t2) { - Contract.Requires(t1 != null); - Contract.Requires(t2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t1 != null); + Debug.Assert(t2 != null); CheckContextMatch(t1); CheckContextMatch(t2); @@ -3736,7 +3537,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumProbes; string[] res = new string[n]; @@ -3751,7 +3551,6 @@ namespace Microsoft.Z3 /// public string ProbeDescription(string name) { - Contract.Ensures(Contract.Result() != null); return Native.Z3_probe_get_descr(nCtx, name); } @@ -3761,7 +3560,6 @@ namespace Microsoft.Z3 /// public Probe MkProbe(string name) { - Contract.Ensures(Contract.Result() != null); return new Probe(this, name); } @@ -3771,7 +3569,6 @@ namespace Microsoft.Z3 /// public Probe ConstProbe(double val) { - Contract.Ensures(Contract.Result() != null); return new Probe(this, Native.Z3_probe_const(nCtx, val)); } @@ -3782,9 +3579,8 @@ namespace Microsoft.Z3 /// public Probe Lt(Probe p1, Probe p2) { - Contract.Requires(p1 != null); - Contract.Requires(p2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p1 != null); + Debug.Assert(p2 != null); CheckContextMatch(p1); CheckContextMatch(p2); @@ -3797,9 +3593,8 @@ namespace Microsoft.Z3 /// public Probe Gt(Probe p1, Probe p2) { - Contract.Requires(p1 != null); - Contract.Requires(p2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p1 != null); + Debug.Assert(p2 != null); CheckContextMatch(p1); CheckContextMatch(p2); @@ -3812,9 +3607,8 @@ namespace Microsoft.Z3 /// public Probe Le(Probe p1, Probe p2) { - Contract.Requires(p1 != null); - Contract.Requires(p2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p1 != null); + Debug.Assert(p2 != null); CheckContextMatch(p1); CheckContextMatch(p2); @@ -3827,9 +3621,8 @@ namespace Microsoft.Z3 /// public Probe Ge(Probe p1, Probe p2) { - Contract.Requires(p1 != null); - Contract.Requires(p2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p1 != null); + Debug.Assert(p2 != null); CheckContextMatch(p1); CheckContextMatch(p2); @@ -3842,9 +3635,8 @@ namespace Microsoft.Z3 /// public Probe Eq(Probe p1, Probe p2) { - Contract.Requires(p1 != null); - Contract.Requires(p2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p1 != null); + Debug.Assert(p2 != null); CheckContextMatch(p1); CheckContextMatch(p2); @@ -3857,9 +3649,8 @@ namespace Microsoft.Z3 /// public Probe And(Probe p1, Probe p2) { - Contract.Requires(p1 != null); - Contract.Requires(p2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p1 != null); + Debug.Assert(p2 != null); CheckContextMatch(p1); CheckContextMatch(p2); @@ -3872,9 +3663,8 @@ namespace Microsoft.Z3 /// public Probe Or(Probe p1, Probe p2) { - Contract.Requires(p1 != null); - Contract.Requires(p2 != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p1 != null); + Debug.Assert(p2 != null); CheckContextMatch(p1); CheckContextMatch(p2); @@ -3887,8 +3677,7 @@ namespace Microsoft.Z3 /// public Probe Not(Probe p) { - Contract.Requires(p != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(p != null); CheckContextMatch(p); return new Probe(this, Native.Z3_probe_not(nCtx, p.NativeObject)); @@ -3906,7 +3695,6 @@ namespace Microsoft.Z3 /// public Solver MkSolver(Symbol logic = null) { - Contract.Ensures(Contract.Result() != null); if (logic == null) return new Solver(this, Native.Z3_mk_solver(nCtx)); @@ -3920,7 +3708,6 @@ namespace Microsoft.Z3 /// public Solver MkSolver(string logic) { - Contract.Ensures(Contract.Result() != null); return MkSolver(MkSymbol(logic)); } @@ -3930,7 +3717,6 @@ namespace Microsoft.Z3 /// public Solver MkSimpleSolver() { - Contract.Ensures(Contract.Result() != null); return new Solver(this, Native.Z3_mk_simple_solver(nCtx)); } @@ -3944,8 +3730,7 @@ namespace Microsoft.Z3 /// public Solver MkSolver(Tactic t) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); return new Solver(this, Native.Z3_mk_solver_from_tactic(nCtx, t.NativeObject)); } @@ -3957,7 +3742,6 @@ namespace Microsoft.Z3 /// public Fixedpoint MkFixedpoint() { - Contract.Ensures(Contract.Result() != null); return new Fixedpoint(this); } @@ -3969,7 +3753,6 @@ namespace Microsoft.Z3 /// public Optimize MkOptimize() { - Contract.Ensures(Contract.Result() != null); return new Optimize(this); } @@ -3984,7 +3767,6 @@ namespace Microsoft.Z3 /// public FPRMSort MkFPRoundingModeSort() { - Contract.Ensures(Contract.Result() != null); return new FPRMSort(this); } #endregion @@ -3995,7 +3777,6 @@ namespace Microsoft.Z3 /// public FPRMExpr MkFPRoundNearestTiesToEven() { - Contract.Ensures(Contract.Result() != null); return new FPRMExpr(this, Native.Z3_mk_fpa_round_nearest_ties_to_even(nCtx)); } @@ -4004,7 +3785,6 @@ namespace Microsoft.Z3 /// public FPRMNum MkFPRNE() { - Contract.Ensures(Contract.Result() != null); return new FPRMNum(this, Native.Z3_mk_fpa_rne(nCtx)); } @@ -4013,7 +3793,6 @@ namespace Microsoft.Z3 /// public FPRMNum MkFPRoundNearestTiesToAway() { - Contract.Ensures(Contract.Result() != null); return new FPRMNum(this, Native.Z3_mk_fpa_round_nearest_ties_to_away(nCtx)); } @@ -4022,7 +3801,6 @@ namespace Microsoft.Z3 /// public FPRMNum MkFPRNA() { - Contract.Ensures(Contract.Result() != null); return new FPRMNum(this, Native.Z3_mk_fpa_rna(nCtx)); } @@ -4031,7 +3809,6 @@ namespace Microsoft.Z3 /// public FPRMNum MkFPRoundTowardPositive() { - Contract.Ensures(Contract.Result() != null); return new FPRMNum(this, Native.Z3_mk_fpa_round_toward_positive(nCtx)); } @@ -4040,7 +3817,6 @@ namespace Microsoft.Z3 /// public FPRMNum MkFPRTP() { - Contract.Ensures(Contract.Result() != null); return new FPRMNum(this, Native.Z3_mk_fpa_rtp(nCtx)); } @@ -4049,7 +3825,6 @@ namespace Microsoft.Z3 /// public FPRMNum MkFPRoundTowardNegative() { - Contract.Ensures(Contract.Result() != null); return new FPRMNum(this, Native.Z3_mk_fpa_round_toward_negative(nCtx)); } @@ -4058,7 +3833,6 @@ namespace Microsoft.Z3 /// public FPRMNum MkFPRTN() { - Contract.Ensures(Contract.Result() != null); return new FPRMNum(this, Native.Z3_mk_fpa_rtn(nCtx)); } @@ -4067,7 +3841,6 @@ namespace Microsoft.Z3 /// public FPRMNum MkFPRoundTowardZero() { - Contract.Ensures(Contract.Result() != null); return new FPRMNum(this, Native.Z3_mk_fpa_round_toward_zero(nCtx)); } @@ -4076,7 +3849,6 @@ namespace Microsoft.Z3 /// public FPRMNum MkFPRTZ() { - Contract.Ensures(Contract.Result() != null); return new FPRMNum(this, Native.Z3_mk_fpa_rtz(nCtx)); } #endregion @@ -4090,7 +3862,6 @@ namespace Microsoft.Z3 /// significand bits in the FloatingPoint sort. public FPSort MkFPSort(uint ebits, uint sbits) { - Contract.Ensures(Contract.Result() != null); return new FPSort(this, ebits, sbits); } @@ -4099,7 +3870,6 @@ namespace Microsoft.Z3 /// public FPSort MkFPSortHalf() { - Contract.Ensures(Contract.Result() != null); return new FPSort(this, Native.Z3_mk_fpa_sort_half(nCtx)); } @@ -4108,7 +3878,6 @@ namespace Microsoft.Z3 /// public FPSort MkFPSort16() { - Contract.Ensures(Contract.Result() != null); return new FPSort(this, Native.Z3_mk_fpa_sort_16(nCtx)); } @@ -4117,7 +3886,6 @@ namespace Microsoft.Z3 /// public FPSort MkFPSortSingle() { - Contract.Ensures(Contract.Result() != null); return new FPSort(this, Native.Z3_mk_fpa_sort_single(nCtx)); } @@ -4126,7 +3894,6 @@ namespace Microsoft.Z3 /// public FPSort MkFPSort32() { - Contract.Ensures(Contract.Result() != null); return new FPSort(this, Native.Z3_mk_fpa_sort_32(nCtx)); } @@ -4135,7 +3902,6 @@ namespace Microsoft.Z3 /// public FPSort MkFPSortDouble() { - Contract.Ensures(Contract.Result() != null); return new FPSort(this, Native.Z3_mk_fpa_sort_double(nCtx)); } @@ -4144,7 +3910,6 @@ namespace Microsoft.Z3 /// public FPSort MkFPSort64() { - Contract.Ensures(Contract.Result() != null); return new FPSort(this, Native.Z3_mk_fpa_sort_64(nCtx)); } @@ -4153,7 +3918,6 @@ namespace Microsoft.Z3 /// public FPSort MkFPSortQuadruple() { - Contract.Ensures(Contract.Result() != null); return new FPSort(this, Native.Z3_mk_fpa_sort_quadruple(nCtx)); } @@ -4162,7 +3926,6 @@ namespace Microsoft.Z3 /// public FPSort MkFPSort128() { - Contract.Ensures(Contract.Result() != null); return new FPSort(this, Native.Z3_mk_fpa_sort_128(nCtx)); } #endregion @@ -4174,7 +3937,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFPNaN(FPSort s) { - Contract.Ensures(Contract.Result() != null); return new FPNum(this, Native.Z3_mk_fpa_nan(nCtx, s.NativeObject)); } @@ -4185,7 +3947,6 @@ namespace Microsoft.Z3 /// indicates whether the result should be negative. public FPNum MkFPInf(FPSort s, bool negative) { - Contract.Ensures(Contract.Result() != null); return new FPNum(this, Native.Z3_mk_fpa_inf(nCtx, s.NativeObject, (byte)(negative ? 1 : 0))); } @@ -4196,7 +3957,6 @@ namespace Microsoft.Z3 /// indicates whether the result should be negative. public FPNum MkFPZero(FPSort s, bool negative) { - Contract.Ensures(Contract.Result() != null); return new FPNum(this, Native.Z3_mk_fpa_zero(nCtx, s.NativeObject, (byte)(negative ? 1 : 0))); } @@ -4207,7 +3967,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFPNumeral(float v, FPSort s) { - Contract.Ensures(Contract.Result() != null); return new FPNum(this, Native.Z3_mk_fpa_numeral_float(nCtx, v, s.NativeObject)); } @@ -4218,7 +3977,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFPNumeral(double v, FPSort s) { - Contract.Ensures(Contract.Result() != null); return new FPNum(this, Native.Z3_mk_fpa_numeral_double(nCtx, v, s.NativeObject)); } @@ -4229,7 +3987,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFPNumeral(int v, FPSort s) { - Contract.Ensures(Contract.Result() != null); return new FPNum(this, Native.Z3_mk_fpa_numeral_int(nCtx, v, s.NativeObject)); } @@ -4242,7 +3999,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFPNumeral(bool sgn, uint sig, int exp, FPSort s) { - Contract.Ensures(Contract.Result() != null); return new FPNum(this, Native.Z3_mk_fpa_numeral_int_uint(nCtx, (byte)(sgn ? 1 : 0), exp, sig, s.NativeObject)); } @@ -4255,7 +4011,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFPNumeral(bool sgn, Int64 exp, UInt64 sig, FPSort s) { - Contract.Ensures(Contract.Result() != null); return new FPNum(this, Native.Z3_mk_fpa_numeral_int64_uint64(nCtx, (byte)(sgn ? 1 : 0), exp, sig, s.NativeObject)); } @@ -4266,7 +4021,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFP(float v, FPSort s) { - Contract.Ensures(Contract.Result() != null); return MkFPNumeral(v, s); } @@ -4277,7 +4031,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFP(double v, FPSort s) { - Contract.Ensures(Contract.Result() != null); return MkFPNumeral(v, s); } @@ -4288,7 +4041,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFP(int v, FPSort s) { - Contract.Ensures(Contract.Result() != null); return MkFPNumeral(v, s); } @@ -4301,7 +4053,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFP(bool sgn, int exp, uint sig, FPSort s) { - Contract.Ensures(Contract.Result() != null); return MkFPNumeral(sgn, exp, sig, s); } @@ -4314,7 +4065,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPNum MkFP(bool sgn, Int64 exp, UInt64 sig, FPSort s) { - Contract.Ensures(Contract.Result() != null); return MkFPNumeral(sgn, exp, sig, s); } @@ -4327,7 +4077,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPAbs(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_abs(this.nCtx, t.NativeObject)); } @@ -4337,7 +4086,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPNeg(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_neg(this.nCtx, t.NativeObject)); } @@ -4349,7 +4097,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPAdd(FPRMExpr rm, FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_add(this.nCtx, rm.NativeObject, t1.NativeObject, t2.NativeObject)); } @@ -4361,7 +4108,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPSub(FPRMExpr rm, FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_sub(this.nCtx, rm.NativeObject, t1.NativeObject, t2.NativeObject)); } @@ -4373,7 +4119,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPMul(FPRMExpr rm, FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_mul(this.nCtx, rm.NativeObject, t1.NativeObject, t2.NativeObject)); } @@ -4385,7 +4130,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPDiv(FPRMExpr rm, FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_div(this.nCtx, rm.NativeObject, t1.NativeObject, t2.NativeObject)); } @@ -4401,7 +4145,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPFMA(FPRMExpr rm, FPExpr t1, FPExpr t2, FPExpr t3) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_fma(this.nCtx, rm.NativeObject, t1.NativeObject, t2.NativeObject, t3.NativeObject)); } @@ -4412,7 +4155,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPSqrt(FPRMExpr rm, FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_sqrt(this.nCtx, rm.NativeObject, t.NativeObject)); } @@ -4423,7 +4165,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPRem(FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_rem(this.nCtx, t1.NativeObject, t2.NativeObject)); } @@ -4435,7 +4176,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPRoundToIntegral(FPRMExpr rm, FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_round_to_integral(this.nCtx, rm.NativeObject, t.NativeObject)); } @@ -4446,7 +4186,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPMin(FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_min(this.nCtx, t1.NativeObject, t2.NativeObject)); } @@ -4457,7 +4196,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPMax(FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_max(this.nCtx, t1.NativeObject, t2.NativeObject)); } @@ -4468,7 +4206,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPLEq(FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_leq(this.nCtx, t1.NativeObject, t2.NativeObject)); } @@ -4479,7 +4216,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPLt(FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_lt(this.nCtx, t1.NativeObject, t2.NativeObject)); } @@ -4490,7 +4226,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPGEq(FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_geq(this.nCtx, t1.NativeObject, t2.NativeObject)); } @@ -4501,7 +4236,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPGt(FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_gt(this.nCtx, t1.NativeObject, t2.NativeObject)); } @@ -4515,7 +4249,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPEq(FPExpr t1, FPExpr t2) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_eq(this.nCtx, t1.NativeObject, t2.NativeObject)); } @@ -4525,7 +4258,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPIsNormal(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_is_normal(this.nCtx, t.NativeObject)); } @@ -4535,7 +4267,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPIsSubnormal(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_is_subnormal(this.nCtx, t.NativeObject)); } @@ -4545,7 +4276,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPIsZero(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_is_zero(this.nCtx, t.NativeObject)); } @@ -4555,7 +4285,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPIsInfinite(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_is_infinite(this.nCtx, t.NativeObject)); } @@ -4565,7 +4294,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPIsNaN(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_is_nan(this.nCtx, t.NativeObject)); } @@ -4575,7 +4303,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPIsNegative(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_is_negative(this.nCtx, t.NativeObject)); } @@ -4585,7 +4312,6 @@ namespace Microsoft.Z3 /// floating-point term public BoolExpr MkFPIsPositive(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(this, Native.Z3_mk_fpa_is_positive(this.nCtx, t.NativeObject)); } #endregion @@ -4606,7 +4332,6 @@ namespace Microsoft.Z3 /// bit-vector term representing the exponent. public FPExpr MkFP(BitVecExpr sgn, BitVecExpr sig, BitVecExpr exp) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_fp(this.nCtx, sgn.NativeObject, sig.NativeObject, exp.NativeObject)); } @@ -4623,7 +4348,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort (ebits+sbits == m) public FPExpr MkFPToFP(BitVecExpr bv, FPSort s) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_to_fp_bv(this.nCtx, bv.NativeObject, s.NativeObject)); } @@ -4640,7 +4364,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPExpr MkFPToFP(FPRMExpr rm, FPExpr t, FPSort s) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_to_fp_float(this.nCtx, rm.NativeObject, t.NativeObject, s.NativeObject)); } @@ -4657,7 +4380,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public FPExpr MkFPToFP(FPRMExpr rm, RealExpr t, FPSort s) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_to_fp_real(this.nCtx, rm.NativeObject, t.NativeObject, s.NativeObject)); } @@ -4676,7 +4398,6 @@ namespace Microsoft.Z3 /// flag indicating whether t is interpreted as signed or unsigned bit-vector. public FPExpr MkFPToFP(FPRMExpr rm, BitVecExpr t, FPSort s, bool signed) { - Contract.Ensures(Contract.Result() != null); if (signed) return new FPExpr(this, Native.Z3_mk_fpa_to_fp_signed(this.nCtx, rm.NativeObject, t.NativeObject, s.NativeObject)); else @@ -4695,7 +4416,6 @@ namespace Microsoft.Z3 /// floating-point term public FPExpr MkFPToFP(FPSort s, FPRMExpr rm, FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new FPExpr(this, Native.Z3_mk_fpa_to_fp_float(this.nCtx, s.NativeObject, rm.NativeObject, t.NativeObject)); } #endregion @@ -4715,7 +4435,6 @@ namespace Microsoft.Z3 /// Indicates whether the result is a signed or unsigned bit-vector. public BitVecExpr MkFPToBV(FPRMExpr rm, FPExpr t, uint sz, bool signed) { - Contract.Ensures(Contract.Result() != null); if (signed) return new BitVecExpr(this, Native.Z3_mk_fpa_to_sbv(this.nCtx, rm.NativeObject, t.NativeObject, sz)); else @@ -4733,7 +4452,6 @@ namespace Microsoft.Z3 /// FloatingPoint term public RealExpr MkFPToReal(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new RealExpr(this, Native.Z3_mk_fpa_to_real(this.nCtx, t.NativeObject)); } #endregion @@ -4751,7 +4469,6 @@ namespace Microsoft.Z3 /// FloatingPoint term. public BitVecExpr MkFPToIEEEBV(FPExpr t) { - Contract.Ensures(Contract.Result() != null); return new BitVecExpr(this, Native.Z3_mk_fpa_to_ieee_bv(this.nCtx, t.NativeObject)); } @@ -4769,7 +4486,6 @@ namespace Microsoft.Z3 /// FloatingPoint sort. public BitVecExpr MkFPToFP(FPRMExpr rm, IntExpr exp, RealExpr sig, FPSort s) { - Contract.Ensures(Contract.Result() != null); return new BitVecExpr(this, Native.Z3_mk_fpa_to_fp_int_real(this.nCtx, rm.NativeObject, exp.NativeObject, sig.NativeObject, s.NativeObject)); } #endregion @@ -4788,7 +4504,6 @@ namespace Microsoft.Z3 /// The native pointer to wrap. public AST WrapAST(IntPtr nativeObject) { - Contract.Ensures(Contract.Result() != null); return AST.Create(this, nativeObject); } @@ -4813,7 +4528,6 @@ namespace Microsoft.Z3 /// public string SimplifyHelp() { - Contract.Ensures(Contract.Result() != null); return Native.Z3_simplify_get_help(nCtx); } @@ -4879,84 +4593,78 @@ namespace Microsoft.Z3 GC.SuppressFinalize(this); } - [Pure] internal void CheckContextMatch(Z3Object other) { - Contract.Requires(other != null); + Debug.Assert(other != null); if (!ReferenceEquals(this, other.Context)) throw new Z3Exception("Context mismatch"); } - [Pure] internal void CheckContextMatch(Z3Object other1, Z3Object other2) { - Contract.Requires(other1 != null); - Contract.Requires(other2 != null); + Debug.Assert(other1 != null); + Debug.Assert(other2 != null); CheckContextMatch(other1); CheckContextMatch(other2); } - [Pure] internal void CheckContextMatch(Z3Object other1, Z3Object other2, Z3Object other3) { - Contract.Requires(other1 != null); - Contract.Requires(other2 != null); - Contract.Requires(other3 != null); + Debug.Assert(other1 != null); + Debug.Assert(other2 != null); + Debug.Assert(other3 != null); CheckContextMatch(other1); CheckContextMatch(other2); CheckContextMatch(other3); } - [Pure] internal void CheckContextMatch(Z3Object[] arr) { - Contract.Requires(arr == null || Contract.ForAll(arr, a => a != null)); + Debug.Assert(arr == null || arr.All(a => a != null)); if (arr != null) { foreach (Z3Object a in arr) { - Contract.Assert(a != null); // It was an assume, now we added the precondition, and we made it into an assert + Debug.Assert(a != null); // It was an assume, now we added the precondition, and we made it into an assert CheckContextMatch(a); } } } - [Pure] internal void CheckContextMatch(IEnumerable arr) where T : Z3Object { - Contract.Requires(arr == null || Contract.ForAll(arr, a => a != null)); + Debug.Assert(arr == null || arr.All(a => a != null)); if (arr != null) { foreach (Z3Object a in arr) { - Contract.Assert(a != null); // It was an assume, now we added the precondition, and we made it into an assert + Debug.Assert(a != null); // It was an assume, now we added the precondition, and we made it into an assert CheckContextMatch(a); } } } - [ContractInvariantMethod] private void ObjectInvariant() { - Contract.Invariant(m_AST_DRQ != null); - Contract.Invariant(m_ASTMap_DRQ != null); - Contract.Invariant(m_ASTVector_DRQ != null); - Contract.Invariant(m_ApplyResult_DRQ != null); - Contract.Invariant(m_FuncEntry_DRQ != null); - Contract.Invariant(m_FuncInterp_DRQ != null); - Contract.Invariant(m_Goal_DRQ != null); - Contract.Invariant(m_Model_DRQ != null); - Contract.Invariant(m_Params_DRQ != null); - Contract.Invariant(m_ParamDescrs_DRQ != null); - Contract.Invariant(m_Probe_DRQ != null); - Contract.Invariant(m_Solver_DRQ != null); - Contract.Invariant(m_Statistics_DRQ != null); - Contract.Invariant(m_Tactic_DRQ != null); - Contract.Invariant(m_Fixedpoint_DRQ != null); - Contract.Invariant(m_Optimize_DRQ != null); + Debug.Assert(m_AST_DRQ != null); + Debug.Assert(m_ASTMap_DRQ != null); + Debug.Assert(m_ASTVector_DRQ != null); + Debug.Assert(m_ApplyResult_DRQ != null); + Debug.Assert(m_FuncEntry_DRQ != null); + Debug.Assert(m_FuncInterp_DRQ != null); + Debug.Assert(m_Goal_DRQ != null); + Debug.Assert(m_Model_DRQ != null); + Debug.Assert(m_Params_DRQ != null); + Debug.Assert(m_ParamDescrs_DRQ != null); + Debug.Assert(m_Probe_DRQ != null); + Debug.Assert(m_Solver_DRQ != null); + Debug.Assert(m_Statistics_DRQ != null); + Debug.Assert(m_Tactic_DRQ != null); + Debug.Assert(m_Fixedpoint_DRQ != null); + Debug.Assert(m_Optimize_DRQ != null); } readonly private AST.DecRefQueue m_AST_DRQ = new AST.DecRefQueue(); @@ -4979,83 +4687,82 @@ namespace Microsoft.Z3 /// /// AST DRQ /// - public IDecRefQueue AST_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_AST_DRQ; } } + public IDecRefQueue AST_DRQ { get { return m_AST_DRQ; } } /// /// ASTMap DRQ /// - public IDecRefQueue ASTMap_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_ASTMap_DRQ; } } + public IDecRefQueue ASTMap_DRQ { get { return m_ASTMap_DRQ; } } /// /// ASTVector DRQ /// - public IDecRefQueue ASTVector_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_ASTVector_DRQ; } } + public IDecRefQueue ASTVector_DRQ { get { return m_ASTVector_DRQ; } } /// /// ApplyResult DRQ /// - public IDecRefQueue ApplyResult_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_ApplyResult_DRQ; } } + public IDecRefQueue ApplyResult_DRQ { get { return m_ApplyResult_DRQ; } } /// /// FuncEntry DRQ /// - public IDecRefQueue FuncEntry_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_FuncEntry_DRQ; } } + public IDecRefQueue FuncEntry_DRQ { get { return m_FuncEntry_DRQ; } } /// /// FuncInterp DRQ /// - public IDecRefQueue FuncInterp_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_FuncInterp_DRQ; } } + public IDecRefQueue FuncInterp_DRQ { get { return m_FuncInterp_DRQ; } } /// /// Goal DRQ /// - public IDecRefQueue Goal_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_Goal_DRQ; } } + public IDecRefQueue Goal_DRQ { get { return m_Goal_DRQ; } } /// /// Model DRQ /// - public IDecRefQueue Model_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_Model_DRQ; } } + public IDecRefQueue Model_DRQ { get { return m_Model_DRQ; } } /// /// Params DRQ /// - public IDecRefQueue Params_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_Params_DRQ; } } + public IDecRefQueue Params_DRQ { get { return m_Params_DRQ; } } /// /// ParamDescrs DRQ /// - public IDecRefQueue ParamDescrs_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_ParamDescrs_DRQ; } } + public IDecRefQueue ParamDescrs_DRQ { get { return m_ParamDescrs_DRQ; } } /// /// Probe DRQ /// - public IDecRefQueue Probe_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_Probe_DRQ; } } + public IDecRefQueue Probe_DRQ { get { return m_Probe_DRQ; } } /// /// Solver DRQ /// - public IDecRefQueue Solver_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_Solver_DRQ; } } + public IDecRefQueue Solver_DRQ { get { return m_Solver_DRQ; } } /// /// Statistics DRQ /// - public IDecRefQueue Statistics_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_Statistics_DRQ; } } + public IDecRefQueue Statistics_DRQ { get { return m_Statistics_DRQ; } } /// /// Tactic DRQ /// - public IDecRefQueue Tactic_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_Tactic_DRQ; } } + public IDecRefQueue Tactic_DRQ { get { return m_Tactic_DRQ; } } /// /// FixedPoint DRQ /// - public IDecRefQueue Fixedpoint_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_Fixedpoint_DRQ; } } + public IDecRefQueue Fixedpoint_DRQ { get { return m_Fixedpoint_DRQ; } } /// /// Optimize DRQ /// - public IDecRefQueue Optimize_DRQ { get { Contract.Ensures(Contract.Result() != null); return m_Fixedpoint_DRQ; } } - + public IDecRefQueue Optimize_DRQ { get { return m_Fixedpoint_DRQ; } } internal long refCount = 0; diff --git a/src/api/dotnet/DatatypeExpr.cs b/src/api/dotnet/DatatypeExpr.cs index ba3a9d478..03595c349 100644 --- a/src/api/dotnet/DatatypeExpr.cs +++ b/src/api/dotnet/DatatypeExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -35,7 +35,7 @@ namespace Microsoft.Z3 internal DatatypeExpr(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/DatatypeSort.cs b/src/api/dotnet/DatatypeSort.cs index e47545d68..943d3753f 100644 --- a/src/api/dotnet/DatatypeSort.cs +++ b/src/api/dotnet/DatatypeSort.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Datatype sorts. /// - [ContractVerification(true)] public class DatatypeSort : Sort { /// @@ -43,7 +42,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumConstructors; FuncDecl[] res = new FuncDecl[n]; @@ -60,7 +58,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumConstructors; FuncDecl[] res = new FuncDecl[n]; @@ -77,7 +74,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumConstructors; FuncDecl[][] res = new FuncDecl[n][]; @@ -95,14 +91,14 @@ namespace Microsoft.Z3 } #region Internal - internal DatatypeSort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal DatatypeSort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } internal DatatypeSort(Context ctx, Symbol name, Constructor[] constructors) : base(ctx, Native.Z3_mk_datatype(ctx.nCtx, name.NativeObject, (uint)constructors.Length, ArrayToNative(constructors))) { - Contract.Requires(ctx != null); - Contract.Requires(name != null); - Contract.Requires(constructors != null); + Debug.Assert(ctx != null); + Debug.Assert(name != null); + Debug.Assert(constructors != null); } #endregion }; diff --git a/src/api/dotnet/Deprecated.cs b/src/api/dotnet/Deprecated.cs index feb5b1555..64255cea2 100644 --- a/src/api/dotnet/Deprecated.cs +++ b/src/api/dotnet/Deprecated.cs @@ -17,17 +17,16 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Runtime.InteropServices; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// The main interaction with Z3 happens via the Context. /// - [ContractVerification(true)] public class Deprecated { diff --git a/src/api/dotnet/EnumSort.cs b/src/api/dotnet/EnumSort.cs index 62be48a2c..08c85361e 100644 --- a/src/api/dotnet/EnumSort.cs +++ b/src/api/dotnet/EnumSort.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Enumeration sorts. /// - [ContractVerification(true)] public class EnumSort : Sort { /// @@ -35,7 +34,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = Native.Z3_get_datatype_sort_num_constructors(Context.nCtx, NativeObject); FuncDecl[] t = new FuncDecl[n]; for (uint i = 0; i < n; i++) @@ -61,7 +59,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); FuncDecl[] cds = ConstDecls; Expr[] t = new Expr[cds.Length]; for (uint i = 0; i < t.Length; i++) @@ -87,7 +84,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = Native.Z3_get_datatype_sort_num_constructors(Context.nCtx, NativeObject); FuncDecl[] t = new FuncDecl[n]; for (uint i = 0; i < n; i++) @@ -110,9 +106,9 @@ namespace Microsoft.Z3 internal EnumSort(Context ctx, Symbol name, Symbol[] enumNames) : base(ctx, IntPtr.Zero) { - Contract.Requires(ctx != null); - Contract.Requires(name != null); - Contract.Requires(enumNames != null); + Debug.Assert(ctx != null); + Debug.Assert(name != null); + Debug.Assert(enumNames != null); int n = enumNames.Length; IntPtr[] n_constdecls = new IntPtr[n]; diff --git a/src/api/dotnet/Expr.cs b/src/api/dotnet/Expr.cs index 99baaa8e4..f735401d8 100644 --- a/src/api/dotnet/Expr.cs +++ b/src/api/dotnet/Expr.cs @@ -17,15 +17,16 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; +using System.Linq; + namespace Microsoft.Z3 { /// /// Expressions are terms. /// - [ContractVerification(true)] public class Expr : AST { /// @@ -35,7 +36,6 @@ namespace Microsoft.Z3 /// public Expr Simplify(Params p = null) { - Contract.Ensures(Contract.Result() != null); if (p == null) return Expr.Create(Context, Native.Z3_simplify(Context.nCtx, NativeObject)); @@ -50,7 +50,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new FuncDecl(Context, Native.Z3_get_app_decl(Context.nCtx, NativeObject)); } } @@ -79,7 +78,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumArgs; Expr[] res = new Expr[n]; @@ -94,7 +92,6 @@ namespace Microsoft.Z3 /// public Expr Arg(uint i) { - Contract.Ensures(Contract.Result() != null); return Expr.Create(Context, Native.Z3_get_app_arg(Context.nCtx, NativeObject, i)); } @@ -104,8 +101,8 @@ namespace Microsoft.Z3 /// public void Update(Expr[] args) { - Contract.Requires(args != null); - Contract.Requires(Contract.ForAll(args, a => a != null)); + Debug.Assert(args != null); + Debug.Assert(args.All(a => a != null)); Context.CheckContextMatch(args); if (IsApp && args.Length != NumArgs) @@ -123,11 +120,10 @@ namespace Microsoft.Z3 /// public Expr Substitute(Expr[] from, Expr[] to) { - Contract.Requires(from != null); - Contract.Requires(to != null); - Contract.Requires(Contract.ForAll(from, f => f != null)); - Contract.Requires(Contract.ForAll(to, t => t != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(from != null); + Debug.Assert(to != null); + Debug.Assert(from.All(f => f != null)); + Debug.Assert(to.All(t => t != null)); Context.CheckContextMatch(from); Context.CheckContextMatch(to); @@ -142,9 +138,8 @@ namespace Microsoft.Z3 /// public Expr Substitute(Expr from, Expr to) { - Contract.Requires(from != null); - Contract.Requires(to != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(from != null); + Debug.Assert(to != null); return Substitute(new Expr[] { from }, new Expr[] { to }); } @@ -157,9 +152,8 @@ namespace Microsoft.Z3 /// public Expr SubstituteVars(Expr[] to) { - Contract.Requires(to != null); - Contract.Requires(Contract.ForAll(to, t => t != null)); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(to != null); + Debug.Assert(to.All(t => t != null)); Context.CheckContextMatch(to); return Expr.Create(Context, Native.Z3_substitute_vars(Context.nCtx, NativeObject, (uint)to.Length, Expr.ArrayToNative(to))); @@ -207,7 +201,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Sort.Create(Context, Native.Z3_get_sort(Context.nCtx, NativeObject)); } } @@ -332,7 +325,7 @@ namespace Microsoft.Z3 /// /// Retrieve bound of at-most /// - public uint AtMostBound { get { Contract.Requires(IsAtMost); return (uint)FuncDecl.Parameters[0].Int; } } + public uint AtMostBound { get { Debug.Assert(IsAtMost); return (uint)FuncDecl.Parameters[0].Int; } } /// /// Indicates whether the term is at-least @@ -342,7 +335,7 @@ namespace Microsoft.Z3 /// /// Retrieve bound of at-least /// - public uint AtLeastBound { get { Contract.Requires(IsAtLeast); return (uint)FuncDecl.Parameters[0].Int; } } + public uint AtLeastBound { get { Debug.Assert(IsAtLeast); return (uint)FuncDecl.Parameters[0].Int; } } /// /// Indicates whether the term is pbeq @@ -842,7 +835,7 @@ namespace Microsoft.Z3 public string String { get { return Native.Z3_get_string(Context.nCtx, NativeObject); } } /// - /// Check whether expression is a concatentation. + /// Check whether expression is a concatenation. /// /// a Boolean public bool IsConcat { get { return IsApp && FuncDecl.DeclKind == Z3_decl_kind.Z3_OP_SEQ_CONCAT; } } @@ -1816,8 +1809,6 @@ namespace Microsoft.Z3 if (!IsVar) throw new Z3Exception("Term is not a bound variable."); - Contract.EndContractBlock(); - return Native.Z3_get_index_value(Context.nCtx, NativeObject); } } @@ -1827,10 +1818,9 @@ namespace Microsoft.Z3 /// /// Constructor for Expr /// - internal protected Expr(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal protected Expr(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } #if DEBUG - [Pure] internal override void CheckNativeObject(IntPtr obj) { if (Native.Z3_is_app(Context.nCtx, obj) == 0 && @@ -1841,12 +1831,10 @@ namespace Microsoft.Z3 } #endif - [Pure] internal static Expr Create(Context ctx, FuncDecl f, params Expr[] arguments) { - Contract.Requires(ctx != null); - Contract.Requires(f != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ctx != null); + Debug.Assert(f != null); IntPtr obj = Native.Z3_mk_app(ctx.nCtx, f.NativeObject, AST.ArrayLength(arguments), @@ -1854,11 +1842,9 @@ namespace Microsoft.Z3 return Create(ctx, obj); } - [Pure] new internal static Expr Create(Context ctx, IntPtr obj) { - Contract.Requires(ctx != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ctx != null); Z3_ast_kind k = (Z3_ast_kind)Native.Z3_get_ast_kind(ctx.nCtx, obj); if (k == Z3_ast_kind.Z3_QUANTIFIER_AST) diff --git a/src/api/dotnet/FPExpr.cs b/src/api/dotnet/FPExpr.cs index 85fdf2603..03ae0bff1 100644 --- a/src/api/dotnet/FPExpr.cs +++ b/src/api/dotnet/FPExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -45,7 +45,7 @@ namespace Microsoft.Z3 internal FPExpr(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/FPNum.cs b/src/api/dotnet/FPNum.cs index b6d349149..e21355f72 100644 --- a/src/api/dotnet/FPNum.cs +++ b/src/api/dotnet/FPNum.cs @@ -16,15 +16,14 @@ Author: Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// FloatiungPoint Numerals /// - [ContractVerification(true)] public class FPNum : FPExpr { /// @@ -175,7 +174,7 @@ namespace Microsoft.Z3 internal FPNum(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion diff --git a/src/api/dotnet/FPRMExpr.cs b/src/api/dotnet/FPRMExpr.cs index 896c3e6b9..4c4ae602f 100644 --- a/src/api/dotnet/FPRMExpr.cs +++ b/src/api/dotnet/FPRMExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -35,7 +35,7 @@ namespace Microsoft.Z3 internal FPRMExpr(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/FPRMNum.cs b/src/api/dotnet/FPRMNum.cs index 81cff167e..af1c8b888 100644 --- a/src/api/dotnet/FPRMNum.cs +++ b/src/api/dotnet/FPRMNum.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -93,7 +93,7 @@ namespace Microsoft.Z3 internal FPRMNum(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/FPRMSort.cs b/src/api/dotnet/FPRMSort.cs index 1d8334eb5..4e04a2586 100644 --- a/src/api/dotnet/FPRMSort.cs +++ b/src/api/dotnet/FPRMSort.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -31,12 +31,12 @@ namespace Microsoft.Z3 internal FPRMSort(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal FPRMSort(Context ctx) : base(ctx, Native.Z3_mk_fpa_rounding_mode_sort(ctx.nCtx)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/FPSort.cs b/src/api/dotnet/FPSort.cs index e1ad62d49..56a738e65 100644 --- a/src/api/dotnet/FPSort.cs +++ b/src/api/dotnet/FPSort.cs @@ -16,8 +16,8 @@ Author: Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -40,12 +40,12 @@ namespace Microsoft.Z3 internal FPSort(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal FPSort(Context ctx, uint ebits, uint sbits) : base(ctx, Native.Z3_mk_fpa_sort(ctx.nCtx, ebits, sbits)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/FiniteDomainExpr.cs b/src/api/dotnet/FiniteDomainExpr.cs index 59ccb9f32..1a689d59f 100644 --- a/src/api/dotnet/FiniteDomainExpr.cs +++ b/src/api/dotnet/FiniteDomainExpr.cs @@ -16,8 +16,8 @@ Author: Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -31,7 +31,7 @@ namespace Microsoft.Z3 internal FiniteDomainExpr(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/FiniteDomainNum.cs b/src/api/dotnet/FiniteDomainNum.cs index 52c0af8bd..39d94ddbd 100644 --- a/src/api/dotnet/FiniteDomainNum.cs +++ b/src/api/dotnet/FiniteDomainNum.cs @@ -16,8 +16,8 @@ Author: Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; #if !FRAMEWORK_LT_4 using System.Numerics; @@ -28,7 +28,6 @@ namespace Microsoft.Z3 /// /// Finite-domain numerals /// - [ContractVerification(true)] public class FiniteDomainNum : FiniteDomainExpr { /// @@ -109,7 +108,7 @@ namespace Microsoft.Z3 } #region Internal - internal FiniteDomainNum(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal FiniteDomainNum(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } #endregion } } diff --git a/src/api/dotnet/FiniteDomainSort.cs b/src/api/dotnet/FiniteDomainSort.cs index 93540ff87..5392aede2 100644 --- a/src/api/dotnet/FiniteDomainSort.cs +++ b/src/api/dotnet/FiniteDomainSort.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Finite domain sorts. /// - [ContractVerification(true)] public class FiniteDomainSort : Sort { /// @@ -45,13 +44,13 @@ namespace Microsoft.Z3 internal FiniteDomainSort(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal FiniteDomainSort(Context ctx, Symbol name, ulong size) : base(ctx, Native.Z3_mk_finite_domain_sort(ctx.nCtx, name.NativeObject, size)) { - Contract.Requires(ctx != null); - Contract.Requires(name != null); + Debug.Assert(ctx != null); + Debug.Assert(name != null); } #endregion diff --git a/src/api/dotnet/Fixedpoint.cs b/src/api/dotnet/Fixedpoint.cs index 102a96ac5..51ee79b55 100644 --- a/src/api/dotnet/Fixedpoint.cs +++ b/src/api/dotnet/Fixedpoint.cs @@ -18,14 +18,14 @@ Notes: --*/ using System; -using System.Diagnostics.Contracts; +using System.Diagnostics; +using System.Linq; namespace Microsoft.Z3 { /// /// Object for managing fixedpoints /// - [ContractVerification(true)] public class Fixedpoint : Z3Object { @@ -36,7 +36,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Native.Z3_fixedpoint_get_help(Context.nCtx, NativeObject); } } @@ -48,7 +47,7 @@ namespace Microsoft.Z3 { set { - Contract.Requires(value != null); + Debug.Assert(value != null); Context.CheckContextMatch(value); Native.Z3_fixedpoint_set_params(Context.nCtx, NativeObject, value.NativeObject); } @@ -68,8 +67,8 @@ namespace Microsoft.Z3 /// public void Assert(params BoolExpr[] constraints) { - Contract.Requires(constraints != null); - Contract.Requires(Contract.ForAll(constraints, c => c != null)); + Debug.Assert(constraints != null); + Debug.Assert(constraints.All(c => c != null)); Context.CheckContextMatch(constraints); foreach (BoolExpr a in constraints) @@ -91,7 +90,7 @@ namespace Microsoft.Z3 /// public void RegisterRelation(FuncDecl f) { - Contract.Requires(f != null); + Debug.Assert(f != null); Context.CheckContextMatch(f); Native.Z3_fixedpoint_register_relation(Context.nCtx, NativeObject, f.NativeObject); @@ -102,7 +101,7 @@ namespace Microsoft.Z3 /// public void AddRule(BoolExpr rule, Symbol name = null) { - Contract.Requires(rule != null); + Debug.Assert(rule != null); Context.CheckContextMatch(rule); Native.Z3_fixedpoint_add_rule(Context.nCtx, NativeObject, rule.NativeObject, AST.GetNativeObject(name)); @@ -113,8 +112,8 @@ namespace Microsoft.Z3 /// public void AddFact(FuncDecl pred, params uint[] args) { - Contract.Requires(pred != null); - Contract.Requires(args != null); + Debug.Assert(pred != null); + Debug.Assert(args != null); Context.CheckContextMatch(pred); Native.Z3_fixedpoint_add_fact(Context.nCtx, NativeObject, pred.NativeObject, (uint)args.Length, args); @@ -128,7 +127,7 @@ namespace Microsoft.Z3 /// public Status Query(BoolExpr query) { - Contract.Requires(query != null); + Debug.Assert(query != null); Context.CheckContextMatch(query); Z3_lbool r = (Z3_lbool)Native.Z3_fixedpoint_query(Context.nCtx, NativeObject, query.NativeObject); @@ -148,8 +147,8 @@ namespace Microsoft.Z3 /// public Status Query(params FuncDecl[] relations) { - Contract.Requires(relations != null); - Contract.Requires(Contract.ForAll(0, relations.Length, i => relations[i] != null)); + Debug.Assert(relations != null); + Debug.Assert(relations.All(rel => rel != null)); Context.CheckContextMatch(relations); Z3_lbool r = (Z3_lbool)Native.Z3_fixedpoint_query_relations(Context.nCtx, NativeObject, @@ -187,7 +186,7 @@ namespace Microsoft.Z3 /// public void UpdateRule(BoolExpr rule, Symbol name) { - Contract.Requires(rule != null); + Debug.Assert(rule != null); Context.CheckContextMatch(rule); Native.Z3_fixedpoint_update_rule(Context.nCtx, NativeObject, rule.NativeObject, AST.GetNativeObject(name)); @@ -208,7 +207,6 @@ namespace Microsoft.Z3 /// public string GetReasonUnknown() { - Contract.Ensures(Contract.Result() != null); return Native.Z3_fixedpoint_get_reason_unknown(Context.nCtx, NativeObject); } @@ -252,7 +250,7 @@ namespace Microsoft.Z3 /// public void SetPredicateRepresentation(FuncDecl f, Symbol[] kinds) { - Contract.Requires(f != null); + Debug.Assert(f != null); Native.Z3_fixedpoint_set_predicate_representation(Context.nCtx, NativeObject, f.NativeObject, AST.ArrayLength(kinds), Symbol.ArrayToNative(kinds)); @@ -276,7 +274,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); ASTVector av = new ASTVector(Context, Native.Z3_fixedpoint_get_rules(Context.nCtx, NativeObject)); return av.ToBoolExprArray(); @@ -290,7 +287,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); ASTVector av = new ASTVector(Context, Native.Z3_fixedpoint_get_assertions(Context.nCtx, NativeObject)); return av.ToBoolExprArray(); @@ -304,7 +300,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new Statistics(Context, Native.Z3_fixedpoint_get_statistics(Context.nCtx, NativeObject)); } @@ -335,12 +330,12 @@ namespace Microsoft.Z3 internal Fixedpoint(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal Fixedpoint(Context ctx) : base(ctx, Native.Z3_mk_fixedpoint(ctx.nCtx)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/FuncDecl.cs b/src/api/dotnet/FuncDecl.cs index 0587a2276..30ed790db 100644 --- a/src/api/dotnet/FuncDecl.cs +++ b/src/api/dotnet/FuncDecl.cs @@ -18,14 +18,15 @@ Notes: --*/ using System; -using System.Diagnostics.Contracts; +using System.Diagnostics; +using System.Linq; + namespace Microsoft.Z3 { /// /// Function declarations. /// - [ContractVerification(true)] public class FuncDecl : AST { /// @@ -108,7 +109,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = DomainSize; @@ -126,7 +126,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Sort.Create(Context, Native.Z3_get_range(Context.nCtx, NativeObject)); } } @@ -146,7 +145,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Symbol.Create(Context, Native.Z3_get_decl_name(Context.nCtx, NativeObject)); } } @@ -166,7 +164,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint num = NumParameters; Parameter[] res = new Parameter[num]; @@ -287,24 +284,33 @@ namespace Microsoft.Z3 internal FuncDecl(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal FuncDecl(Context ctx, Symbol name, Sort[] domain, Sort range) : base(ctx, Native.Z3_mk_func_decl(ctx.nCtx, name.NativeObject, AST.ArrayLength(domain), AST.ArrayToNative(domain), range.NativeObject)) { - Contract.Requires(ctx != null); - Contract.Requires(name != null); - Contract.Requires(range != null); + Debug.Assert(ctx != null); + Debug.Assert(name != null); + Debug.Assert(range != null); } internal FuncDecl(Context ctx, string prefix, Sort[] domain, Sort range) : base(ctx, Native.Z3_mk_fresh_func_decl(ctx.nCtx, prefix, AST.ArrayLength(domain), AST.ArrayToNative(domain), range.NativeObject)) { - Contract.Requires(ctx != null); - Contract.Requires(range != null); + Debug.Assert(ctx != null); + Debug.Assert(range != null); } + internal FuncDecl(Context ctx, Symbol name, Sort[] domain, Sort range, bool is_rec) + : base(ctx, Native.Z3_mk_rec_func_decl(ctx.nCtx, name.NativeObject, AST.ArrayLength(domain), AST.ArrayToNative(domain), range.NativeObject)) + { + Debug.Assert(ctx != null); + Debug.Assert(name != null); + Debug.Assert(range != null); + } + + #if DEBUG internal override void CheckNativeObject(IntPtr obj) { @@ -335,7 +341,7 @@ namespace Microsoft.Z3 { get { - Contract.Requires(args == null || Contract.ForAll(args, a => a != null)); + Debug.Assert(args == null || args.All(a => a != null)); return Apply(args); } @@ -348,7 +354,7 @@ namespace Microsoft.Z3 /// public Expr Apply(params Expr[] args) { - Contract.Requires(args == null || Contract.ForAll(args, a => a != null)); + Debug.Assert(args == null || args.All(a => a != null)); Context.CheckContextMatch(args); return Expr.Create(Context, this, args); diff --git a/src/api/dotnet/FuncInterp.cs b/src/api/dotnet/FuncInterp.cs index 449d460f9..6924049d3 100644 --- a/src/api/dotnet/FuncInterp.cs +++ b/src/api/dotnet/FuncInterp.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -26,7 +26,6 @@ namespace Microsoft.Z3 /// A function interpretation is represented as a finite map and an 'else' value. /// Each entry in the finite map represents the value of a function given a set of arguments. /// - [ContractVerification(true)] public class FuncInterp : Z3Object { /// @@ -42,7 +41,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Expr.Create(Context, Native.Z3_func_entry_get_value(Context.nCtx, NativeObject)); } } @@ -62,8 +60,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); - Contract.Ensures(Contract.Result().Length == this.NumArgs); uint n = NumArgs; Expr[] res = new Expr[n]; @@ -87,7 +83,7 @@ namespace Microsoft.Z3 } #region Internal - internal Entry(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal Entry(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue { @@ -133,8 +129,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); - Contract.Ensures(Contract.ForAll(0, Contract.Result().Length, j => Contract.Result()[j] != null)); uint n = NumEntries; Entry[] res = new Entry[n]; @@ -151,7 +145,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Expr.Create(Context, Native.Z3_func_interp_get_else(Context.nCtx, NativeObject)); } @@ -194,7 +187,7 @@ namespace Microsoft.Z3 internal FuncInterp(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/Global.cs b/src/api/dotnet/Global.cs index 17963b33d..207498760 100644 --- a/src/api/dotnet/Global.cs +++ b/src/api/dotnet/Global.cs @@ -17,9 +17,9 @@ Notes: --*/ +using System.Diagnostics; using System; using System.Runtime.InteropServices; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { diff --git a/src/api/dotnet/Goal.cs b/src/api/dotnet/Goal.cs index ef2e9a5da..4dbc78b7e 100644 --- a/src/api/dotnet/Goal.cs +++ b/src/api/dotnet/Goal.cs @@ -18,7 +18,8 @@ Notes: --*/ using System; -using System.Diagnostics.Contracts; +using System.Diagnostics; +using System.Linq; namespace Microsoft.Z3 { @@ -27,7 +28,6 @@ namespace Microsoft.Z3 /// of formulas, that can be solved and/or transformed using /// tactics and solvers. /// - [ContractVerification(true)] public class Goal : Z3Object { /// @@ -79,13 +79,13 @@ namespace Microsoft.Z3 /// public void Assert(params BoolExpr[] constraints) { - Contract.Requires(constraints != null); - Contract.Requires(Contract.ForAll(constraints, c => c != null)); + Debug.Assert(constraints != null); + Debug.Assert(constraints.All(c => c != null)); Context.CheckContextMatch(constraints); foreach (BoolExpr c in constraints) { - Contract.Assert(c != null); // It was an assume, now made an assert just to be sure we do not regress + Debug.Assert(c != null); // It was an assume, now made an assert just to be sure we do not regress Native.Z3_goal_assert(Context.nCtx, NativeObject, c.NativeObject); } } @@ -140,7 +140,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = Size; BoolExpr[] res = new BoolExpr[n]; @@ -181,7 +180,6 @@ namespace Microsoft.Z3 /// A model for g public Model ConvertModel(Model m) { - Contract.Ensures(Contract.Result() != null); if (m != null) return new Model(Context, Native.Z3_goal_convert_model(Context.nCtx, NativeObject, m.NativeObject)); else @@ -194,7 +192,7 @@ namespace Microsoft.Z3 /// public Goal Translate(Context ctx) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); return new Goal(ctx, Native.Z3_goal_translate(Context.nCtx, NativeObject, ctx.nCtx)); } @@ -248,12 +246,12 @@ namespace Microsoft.Z3 } #region Internal - internal Goal(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal Goal(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } internal Goal(Context ctx, bool models, bool unsatCores, bool proofs) : base(ctx, Native.Z3_mk_goal(ctx.nCtx, (byte)(models ? 1 : 0), (byte)(unsatCores ? 1 : 0), (byte)(proofs ? 1 : 0))) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/IDecRefQueue.cs b/src/api/dotnet/IDecRefQueue.cs index 43506fabf..8af0973d6 100644 --- a/src/api/dotnet/IDecRefQueue.cs +++ b/src/api/dotnet/IDecRefQueue.cs @@ -17,26 +17,24 @@ Notes: --*/ +using System.Diagnostics; using System; using System.Collections; using System.Collections.Generic; using System.Threading; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// DecRefQueue interface /// - [ContractClass(typeof(DecRefQueueContracts))] public abstract class IDecRefQueue { #region Object invariant - [ContractInvariantMethod] private void ObjectInvariant() { - Contract.Invariant(this.m_queue != null); + Debug.Assert(this.m_queue != null); } #endregion @@ -61,7 +59,7 @@ namespace Microsoft.Z3 internal void IncAndClear(Context ctx, IntPtr o) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); IncRef(ctx, o); if (m_queue.Count >= m_move_limit) Clear(ctx); @@ -79,7 +77,7 @@ namespace Microsoft.Z3 internal void Clear(Context ctx) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); lock (m_lock) { @@ -90,17 +88,16 @@ namespace Microsoft.Z3 } } - [ContractClassFor(typeof(IDecRefQueue))] abstract class DecRefQueueContracts : IDecRefQueue { internal override void IncRef(Context ctx, IntPtr obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal override void DecRef(Context ctx, IntPtr obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } } } diff --git a/src/api/dotnet/IntExpr.cs b/src/api/dotnet/IntExpr.cs index 622be7bd5..3ca5398ea 100644 --- a/src/api/dotnet/IntExpr.cs +++ b/src/api/dotnet/IntExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -35,7 +35,7 @@ namespace Microsoft.Z3 internal IntExpr(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/IntNum.cs b/src/api/dotnet/IntNum.cs index 64fd78ad2..36f209cab 100644 --- a/src/api/dotnet/IntNum.cs +++ b/src/api/dotnet/IntNum.cs @@ -16,8 +16,8 @@ Author: Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; #if !FRAMEWORK_LT_4 using System.Numerics; @@ -28,7 +28,6 @@ namespace Microsoft.Z3 /// /// Integer Numerals /// - [ContractVerification(true)] public class IntNum : IntExpr { @@ -36,7 +35,7 @@ namespace Microsoft.Z3 internal IntNum(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion diff --git a/src/api/dotnet/IntSort.cs b/src/api/dotnet/IntSort.cs index d0c25ac79..289be4bcc 100644 --- a/src/api/dotnet/IntSort.cs +++ b/src/api/dotnet/IntSort.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -31,12 +31,12 @@ namespace Microsoft.Z3 internal IntSort(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal IntSort(Context ctx) : base(ctx, Native.Z3_mk_int_sort(ctx.nCtx)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/IntSymbol.cs b/src/api/dotnet/IntSymbol.cs index df2d9da52..1bb3b3f13 100644 --- a/src/api/dotnet/IntSymbol.cs +++ b/src/api/dotnet/IntSymbol.cs @@ -18,15 +18,14 @@ Notes: --*/ using System; +using System.Diagnostics; using System.Runtime.InteropServices; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Numbered symbols /// - [ContractVerification(true)] public class IntSymbol : Symbol { /// @@ -47,12 +46,12 @@ namespace Microsoft.Z3 internal IntSymbol(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal IntSymbol(Context ctx, int i) : base(ctx, Native.Z3_mk_int_symbol(ctx.nCtx, i)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #if DEBUG diff --git a/src/api/dotnet/Lambda.cs b/src/api/dotnet/Lambda.cs index b3dc6c01c..35497f88f 100644 --- a/src/api/dotnet/Lambda.cs +++ b/src/api/dotnet/Lambda.cs @@ -18,14 +18,14 @@ Notes: --*/ using System; -using System.Diagnostics.Contracts; +using System.Diagnostics; +using System.Linq; namespace Microsoft.Z3 { /// /// Lambda expressions. /// - [ContractVerification(true)] public class Lambda : ArrayExpr { /// @@ -43,7 +43,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumBound; Symbol[] res = new Symbol[n]; @@ -60,7 +59,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumBound; Sort[] res = new Sort[n]; @@ -77,7 +75,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(Context, Native.Z3_get_quantifier_body(Context.nCtx, NativeObject)); } @@ -94,17 +91,16 @@ namespace Microsoft.Z3 } #region Internal - [ContractVerification(false)] // F: Clousot ForAll decompilation gets confused below. Setting verification off until I fixed the bug internal Lambda(Context ctx, Sort[] sorts, Symbol[] names, Expr body) : base(ctx, IntPtr.Zero) { - Contract.Requires(ctx != null); - Contract.Requires(sorts != null); - Contract.Requires(names != null); - Contract.Requires(body != null); - Contract.Requires(sorts.Length == names.Length); - Contract.Requires(Contract.ForAll(sorts, s => s != null)); - Contract.Requires(Contract.ForAll(names, n => n != null)); + Debug.Assert(ctx != null); + Debug.Assert(sorts != null); + Debug.Assert(names != null); + Debug.Assert(body != null); + Debug.Assert(sorts.Length == names.Length); + Debug.Assert(sorts.All(s => s != null)); + Debug.Assert(names.All(n => n != null)); Context.CheckContextMatch(sorts); Context.CheckContextMatch(names); Context.CheckContextMatch(body); @@ -119,14 +115,13 @@ namespace Microsoft.Z3 } - [ContractVerification(false)] // F: Clousot ForAll decompilation gets confused below. Setting verification off until I fixed the bug internal Lambda(Context ctx, Expr[] bound, Expr body) : base(ctx, IntPtr.Zero) { - Contract.Requires(ctx != null); - Contract.Requires(body != null); + Debug.Assert(ctx != null); + Debug.Assert(body != null); - Contract.Requires(bound != null && bound.Length > 0 && Contract.ForAll(bound, n => n != null)); + Debug.Assert(bound != null && bound.Length > 0 && bound.All(n => n != null)); Context.CheckContextMatch(bound); Context.CheckContextMatch(body); @@ -137,7 +132,7 @@ namespace Microsoft.Z3 } - internal Lambda(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal Lambda(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } #if DEBUG internal override void CheckNativeObject(IntPtr obj) diff --git a/src/api/dotnet/ListSort.cs b/src/api/dotnet/ListSort.cs index e860e4d4b..575f2a9bb 100644 --- a/src/api/dotnet/ListSort.cs +++ b/src/api/dotnet/ListSort.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// List sorts. /// - [ContractVerification(true)] public class ListSort : Sort { /// @@ -35,7 +34,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new FuncDecl(Context, Native.Z3_get_datatype_sort_constructor(Context.nCtx, NativeObject, 0)); } } @@ -47,7 +45,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Context.MkApp(NilDecl); } } @@ -59,7 +56,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new FuncDecl(Context, Native.Z3_get_datatype_sort_recognizer(Context.nCtx, NativeObject, 0)); } } @@ -71,7 +67,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new FuncDecl(Context, Native.Z3_get_datatype_sort_constructor(Context.nCtx, NativeObject, 1)); } } @@ -84,7 +79,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new FuncDecl(Context, Native.Z3_get_datatype_sort_recognizer(Context.nCtx, NativeObject, 1)); } } @@ -96,7 +90,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new FuncDecl(Context, Native.Z3_get_datatype_sort_constructor_accessor(Context.nCtx, NativeObject, 1, 0)); } } @@ -108,7 +101,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new FuncDecl(Context, Native.Z3_get_datatype_sort_constructor_accessor(Context.nCtx, NativeObject, 1, 1)); } } @@ -117,9 +109,9 @@ namespace Microsoft.Z3 internal ListSort(Context ctx, Symbol name, Sort elemSort) : base(ctx, IntPtr.Zero) { - Contract.Requires(ctx != null); - Contract.Requires(name != null); - Contract.Requires(elemSort != null); + Debug.Assert(ctx != null); + Debug.Assert(name != null); + Debug.Assert(elemSort != null); IntPtr inil = IntPtr.Zero, iisnil = IntPtr.Zero, icons = IntPtr.Zero, iiscons = IntPtr.Zero, diff --git a/src/api/dotnet/Log.cs b/src/api/dotnet/Log.cs index f8b2ea88b..a94c29bc6 100644 --- a/src/api/dotnet/Log.cs +++ b/src/api/dotnet/Log.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -29,7 +29,6 @@ namespace Microsoft.Z3 /// Note that this is a global, static log and if multiple Context /// objects are created, it logs the interaction with all of them. /// - [ContractVerification(true)] public static class Log { private static bool m_is_open = false; @@ -59,7 +58,7 @@ namespace Microsoft.Z3 /// public static void Append(string s) { - Contract.Requires(isOpen()); + Debug.Assert(isOpen()); if (!m_is_open) throw new Z3Exception("Log cannot be closed."); @@ -70,7 +69,6 @@ namespace Microsoft.Z3 /// Checks whether the interaction log is opened. /// /// True if the interaction log is open, false otherwise. - [Pure] public static bool isOpen() { return m_is_open; diff --git a/src/api/dotnet/Microsoft.Z3.csproj.in b/src/api/dotnet/Microsoft.Z3.csproj.in index 01d18def9..ee7b9237d 100644 --- a/src/api/dotnet/Microsoft.Z3.csproj.in +++ b/src/api/dotnet/Microsoft.Z3.csproj.in @@ -5,6 +5,7 @@ Microsoft.Z3 Microsoft.Z3 + Microsoft.Z3 Z3 .NET Interface Z3 .NET Interface @@ -29,6 +30,159 @@ ${DOTNET_PACKAGE_VERSION} + + + false + + false + + + False + False + True + False + False + True + False + True + True + False + False + False + True + False + False + False + True + False + False + True + True + True + False + False + + + + + + + True + Full + %28none%29 + 2 + + + true + GlobalSuppressions.cs + MinimumRecommendedRules.ruleset + ;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets + true + ;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules + true + True + False + True + False + False + False + False + False + False + False + False + False + False + False + False + False + True + False + False + True + False + False + False + + + + + + + False + Full + %28none%29 + 0 + + + true + GlobalSuppressions.cs + MinimumRecommendedRules.ruleset + ;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets + true + ;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules + True + False + True + False + False + True + True + True + False + False + False + True + True + False + False + False + True + False + False + True + True + False + False + + + + + -repro + + True + Full + %28none%29 + 2 + + + true + GlobalSuppressions.cs + MinimumRecommendedRules.ruleset + ;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets + true + ;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules + true + DELAYSIGN + + + true + GlobalSuppressions.cs + MinimumRecommendedRules.ruleset + ;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets + true + ;C:\Program Files\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules + true + false + + + true + GlobalSuppressions.cs + MinimumRecommendedRules.ruleset + ;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets + ;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules + + @@ -39,6 +193,8 @@ 1701,1702 4 FRAMEWORK_LT_4 + true + $(OutputPath)\Microsoft.Z3.xml @@ -56,9 +212,10 @@ ${Z3_DOTNET_COMPILE_ITEMS} - - - + + + + runtimes\win-x64\native @@ -67,6 +224,17 @@ ${Z3_DOTNET_COMPILE_ITEMS} + + + + runtimes\win-x86\native + + + runtimes\linux-x86\native + + + + diff --git a/src/api/dotnet/Model.cs b/src/api/dotnet/Model.cs index 96f62c9fb..c0cb091b0 100644 --- a/src/api/dotnet/Model.cs +++ b/src/api/dotnet/Model.cs @@ -18,7 +18,7 @@ Notes: --*/ using System; -using System.Diagnostics.Contracts; +using System.Diagnostics; using System.Collections.Generic; namespace Microsoft.Z3 @@ -26,7 +26,6 @@ namespace Microsoft.Z3 /// /// A Model contains interpretations (assignments) of constants and functions. /// - [ContractVerification(true)] public class Model : Z3Object { /// @@ -36,7 +35,7 @@ namespace Microsoft.Z3 /// An expression if the constant has an interpretation in the model, null otherwise. public Expr ConstInterp(Expr a) { - Contract.Requires(a != null); + Debug.Assert(a != null); Context.CheckContextMatch(a); return ConstInterp(a.FuncDecl); @@ -49,7 +48,7 @@ namespace Microsoft.Z3 /// An expression if the function has an interpretation in the model, null otherwise. public Expr ConstInterp(FuncDecl f) { - Contract.Requires(f != null); + Debug.Assert(f != null); Context.CheckContextMatch(f); if (f.Arity != 0 || @@ -70,7 +69,7 @@ namespace Microsoft.Z3 /// A FunctionInterpretation if the function has an interpretation in the model, null otherwise. public FuncInterp FuncInterp(FuncDecl f) { - Contract.Requires(f != null); + Debug.Assert(f != null); Context.CheckContextMatch(f); @@ -122,7 +121,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumConsts; FuncDecl[] res = new FuncDecl[n]; @@ -165,7 +163,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumFuncs; FuncDecl[] res = new FuncDecl[n]; @@ -182,7 +179,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint nFuncs = NumFuncs; uint nConsts = NumConsts; @@ -223,8 +219,7 @@ namespace Microsoft.Z3 /// The evaluation of in the model. public Expr Eval(Expr t, bool completion = false) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); IntPtr v = IntPtr.Zero; if (Native.Z3_model_eval(Context.nCtx, NativeObject, t.NativeObject, (byte)(completion ? 1 : 0), ref v) == (byte)0) @@ -238,12 +233,19 @@ namespace Microsoft.Z3 /// public Expr Evaluate(Expr t, bool completion = false) { - Contract.Requires(t != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(t != null); return Eval(t, completion); } + /// + /// Evaluate expression to a double, assuming it is a numeral already. + /// + public double Double(Expr t) { + var r = Eval(t, true); + return Native.Z3_get_numeral_double(Context.nCtx, r.NativeObject); + } + /// /// The number of uninterpreted sorts that the model has an interpretation for. /// @@ -263,7 +265,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumSorts; Sort[] res = new Sort[n]; @@ -281,8 +282,7 @@ namespace Microsoft.Z3 /// An array of expressions, where each is an element of the universe of public Expr[] SortUniverse(Sort s) { - Contract.Requires(s != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(s != null); ASTVector av = new ASTVector(Context, Native.Z3_model_get_sort_universe(Context.nCtx, NativeObject, s.NativeObject)); return av.ToExprArray(); @@ -301,7 +301,7 @@ namespace Microsoft.Z3 internal Model(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/Optimize.cs b/src/api/dotnet/Optimize.cs index 29e5e869a..9a7bd3bd1 100644 --- a/src/api/dotnet/Optimize.cs +++ b/src/api/dotnet/Optimize.cs @@ -19,14 +19,14 @@ Notes: using System; using System.Collections.Generic; -using System.Diagnostics.Contracts; +using System.Diagnostics; +using System.Linq; namespace Microsoft.Z3 { /// - /// Object for managing optimizization context + /// Object for managing optimization context /// - [ContractVerification(true)] public class Optimize : Z3Object { /// @@ -36,7 +36,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Native.Z3_optimize_get_help(Context.nCtx, NativeObject); } } @@ -48,7 +47,7 @@ namespace Microsoft.Z3 { set { - Contract.Requires(value != null); + Debug.Assert(value != null); Context.CheckContextMatch(value); Native.Z3_optimize_set_params(Context.nCtx, NativeObject, value.NativeObject); } @@ -99,8 +98,8 @@ namespace Microsoft.Z3 /// private void AddConstraints(IEnumerable constraints) { - Contract.Requires(constraints != null); - Contract.Requires(Contract.ForAll(constraints, c => c != null)); + Debug.Assert(constraints != null); + Debug.Assert(constraints.All(c => c != null)); Context.CheckContextMatch(constraints); foreach (BoolExpr a in constraints) @@ -183,9 +182,9 @@ namespace Microsoft.Z3 /// don't use strict inequalities) meets the objectives. /// /// - public Status Check() + public Status Check(params Expr[] assumptions) { - Z3_lbool r = (Z3_lbool)Native.Z3_optimize_check(Context.nCtx, NativeObject); + Z3_lbool r = (Z3_lbool)Native.Z3_optimize_check(Context.nCtx, NativeObject, (uint)assumptions.Length, AST.ArrayToNative(assumptions)); switch (r) { case Z3_lbool.Z3_L_TRUE: @@ -236,6 +235,24 @@ namespace Microsoft.Z3 } } + /// + /// The unsat core of the last Check. + /// + /// + /// The unsat core is a subset of assumptions + /// The result is empty if Check was not invoked before, + /// if its results was not UNSATISFIABLE, or if core production is disabled. + /// + public BoolExpr[] UnsatCore + { + get + { + + ASTVector core = new ASTVector(Context, Native.Z3_optimize_get_unsat_core(Context.nCtx, NativeObject)); + return core.ToBoolExprArray(); + } + } + /// /// Declare an arithmetical maximization objective. /// Return a handle to the objective. The handle is used as @@ -300,7 +317,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Native.Z3_optimize_get_reason_unknown(Context.nCtx, NativeObject); } } @@ -338,7 +354,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); ASTVector assertions = new ASTVector(Context, Native.Z3_optimize_get_assertions(Context.nCtx, NativeObject)); return assertions.ToBoolExprArray(); @@ -352,7 +367,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); ASTVector objectives = new ASTVector(Context, Native.Z3_optimize_get_objectives(Context.nCtx, NativeObject)); return objectives.ToExprArray(); @@ -367,7 +381,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new Statistics(Context, Native.Z3_optimize_get_statistics(Context.nCtx, NativeObject)); } @@ -378,12 +391,12 @@ namespace Microsoft.Z3 internal Optimize(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal Optimize(Context ctx) : base(ctx, Native.Z3_mk_optimize(ctx.nCtx)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/ParamDescrs.cs b/src/api/dotnet/ParamDescrs.cs index 1809518e1..fbfb9cd16 100644 --- a/src/api/dotnet/ParamDescrs.cs +++ b/src/api/dotnet/ParamDescrs.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// A ParamDescrs describes a set of parameters. /// - [ContractVerification(true)] public class ParamDescrs : Z3Object { /// @@ -33,7 +32,7 @@ namespace Microsoft.Z3 /// public void Validate(Params p) { - Contract.Requires(p != null); + Debug.Assert(p != null); Native.Z3_params_validate(Context.nCtx, p.NativeObject, NativeObject); } @@ -42,7 +41,7 @@ namespace Microsoft.Z3 /// public Z3_param_kind GetKind(Symbol name) { - Contract.Requires(name != null); + Debug.Assert(name != null); return (Z3_param_kind)Native.Z3_param_descrs_get_kind(Context.nCtx, NativeObject, name.NativeObject); } @@ -51,7 +50,7 @@ namespace Microsoft.Z3 /// public string GetDocumentation(Symbol name) { - Contract.Requires(name != null); + Debug.Assert(name != null); return Native.Z3_param_descrs_get_documentation(Context.nCtx, NativeObject, name.NativeObject); } @@ -91,7 +90,7 @@ namespace Microsoft.Z3 internal ParamDescrs(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/Params.cs b/src/api/dotnet/Params.cs index f0f28d8d3..e5926934a 100644 --- a/src/api/dotnet/Params.cs +++ b/src/api/dotnet/Params.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// A Params objects represents a configuration in the form of Symbol/value pairs. /// - [ContractVerification(true)] public class Params : Z3Object { /// @@ -33,7 +32,7 @@ namespace Microsoft.Z3 /// public Params Add(Symbol name, bool value) { - Contract.Requires(name != null); + Debug.Assert(name != null); Native.Z3_params_set_bool(Context.nCtx, NativeObject, name.NativeObject, (byte)(value ? 1 : 0)); return this; @@ -44,7 +43,7 @@ namespace Microsoft.Z3 /// public Params Add(Symbol name, uint value) { - Contract.Requires(name != null); + Debug.Assert(name != null); Native.Z3_params_set_uint(Context.nCtx, NativeObject, name.NativeObject, value); return this; @@ -55,7 +54,7 @@ namespace Microsoft.Z3 /// public Params Add(Symbol name, double value) { - Contract.Requires(name != null); + Debug.Assert(name != null); Native.Z3_params_set_double(Context.nCtx, NativeObject, name.NativeObject, value); return this; @@ -66,7 +65,7 @@ namespace Microsoft.Z3 /// public Params Add(Symbol name, string value) { - Contract.Requires(value != null); + Debug.Assert(value != null); Native.Z3_params_set_symbol(Context.nCtx, NativeObject, name.NativeObject, Context.MkSymbol(value).NativeObject); return this; @@ -77,8 +76,8 @@ namespace Microsoft.Z3 /// public Params Add(Symbol name, Symbol value) { - Contract.Requires(name != null); - Contract.Requires(value != null); + Debug.Assert(name != null); + Debug.Assert(value != null); Native.Z3_params_set_symbol(Context.nCtx, NativeObject, name.NativeObject, value.NativeObject); return this; @@ -117,7 +116,7 @@ namespace Microsoft.Z3 /// public Params Add(string name, Symbol value) { - Contract.Requires(value != null); + Debug.Assert(value != null); Native.Z3_params_set_symbol(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, value.NativeObject); return this; @@ -128,8 +127,8 @@ namespace Microsoft.Z3 /// public Params Add(string name, string value) { - Contract.Requires(name != null); - Contract.Requires(value != null); + Debug.Assert(name != null); + Debug.Assert(value != null); Native.Z3_params_set_symbol(Context.nCtx, NativeObject, Context.MkSymbol(name).NativeObject, Context.MkSymbol(value).NativeObject); return this; @@ -147,7 +146,7 @@ namespace Microsoft.Z3 internal Params(Context ctx) : base(ctx, Native.Z3_mk_params(ctx.nCtx)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/Pattern.cs b/src/api/dotnet/Pattern.cs index 1ea7bdb38..c33a38a1d 100644 --- a/src/api/dotnet/Pattern.cs +++ b/src/api/dotnet/Pattern.cs @@ -17,9 +17,9 @@ Notes: --*/ +using System.Diagnostics; using System; using System.Runtime.InteropServices; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -28,7 +28,6 @@ namespace Microsoft.Z3 /// non-empty. If the list comprises of more than one term, it is /// also called a multi-pattern. /// - [ContractVerification(true)] public class Pattern : AST { /// @@ -46,7 +45,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumTerms; Expr[] res = new Expr[n]; @@ -68,7 +66,7 @@ namespace Microsoft.Z3 internal Pattern(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/Probe.cs b/src/api/dotnet/Probe.cs index 3c5e5adc9..5cdee79a2 100644 --- a/src/api/dotnet/Probe.cs +++ b/src/api/dotnet/Probe.cs @@ -17,9 +17,9 @@ Notes: --*/ +using System.Diagnostics; using System; using System.Runtime.InteropServices; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -30,7 +30,6 @@ namespace Microsoft.Z3 /// and Context.ProbeNames. /// It may also be obtained using the command (help-tactic) in the SMT 2.0 front-end. /// - [ContractVerification(true)] public class Probe : Z3Object { /// @@ -40,7 +39,7 @@ namespace Microsoft.Z3 /// "Boolean" probes return 0.0 for false, and a value different from 0.0 for true. public double Apply(Goal g) { - Contract.Requires(g != null); + Debug.Assert(g != null); Context.CheckContextMatch(g); return Native.Z3_probe_apply(Context.nCtx, NativeObject, g.NativeObject); @@ -53,7 +52,7 @@ namespace Microsoft.Z3 { get { - Contract.Requires(g != null); + Debug.Assert(g != null); return Apply(g); } @@ -63,12 +62,12 @@ namespace Microsoft.Z3 internal Probe(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal Probe(Context ctx, string name) : base(ctx, Native.Z3_mk_probe(ctx.nCtx, name)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/Quantifier.cs b/src/api/dotnet/Quantifier.cs index d13ca4003..f4a889092 100644 --- a/src/api/dotnet/Quantifier.cs +++ b/src/api/dotnet/Quantifier.cs @@ -18,14 +18,14 @@ Notes: --*/ using System; -using System.Diagnostics.Contracts; +using System.Diagnostics; +using System.Linq; namespace Microsoft.Z3 { /// /// Quantifier expressions. /// - [ContractVerification(true)] public class Quantifier : BoolExpr { /// @@ -67,7 +67,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumPatterns; Pattern[] res = new Pattern[n]; @@ -92,7 +91,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumNoPatterns; Pattern[] res = new Pattern[n]; @@ -117,7 +115,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumBound; Symbol[] res = new Symbol[n]; @@ -134,7 +131,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumBound; Sort[] res = new Sort[n]; @@ -151,7 +147,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new BoolExpr(Context, Native.Z3_get_quantifier_body(Context.nCtx, NativeObject)); } @@ -168,19 +163,18 @@ namespace Microsoft.Z3 } #region Internal - [ContractVerification(false)] // F: Clousot ForAll decompilation gets confused below. Setting verification off until I fixed the bug internal Quantifier(Context ctx, bool isForall, Sort[] sorts, Symbol[] names, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null) : base(ctx, IntPtr.Zero) { - Contract.Requires(ctx != null); - Contract.Requires(sorts != null); - Contract.Requires(names != null); - Contract.Requires(body != null); - Contract.Requires(sorts.Length == names.Length); - Contract.Requires(Contract.ForAll(sorts, s => s != null)); - Contract.Requires(Contract.ForAll(names, n => n != null)); - Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null)); - Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null)); + Debug.Assert(ctx != null); + Debug.Assert(sorts != null); + Debug.Assert(names != null); + Debug.Assert(body != null); + Debug.Assert(sorts.Length == names.Length); + Debug.Assert(sorts.All(s => s != null)); + Debug.Assert(names.All(n => n != null)); + Debug.Assert(patterns == null || patterns.All(p => p != null)); + Debug.Assert(noPatterns == null || noPatterns.All(np => np != null)); Context.CheckContextMatch(patterns); Context.CheckContextMatch(noPatterns); @@ -211,16 +205,15 @@ namespace Microsoft.Z3 } } - [ContractVerification(false)] // F: Clousot ForAll decompilation gets confused below. Setting verification off until I fixed the bug internal Quantifier(Context ctx, bool isForall, Expr[] bound, Expr body, uint weight = 1, Pattern[] patterns = null, Expr[] noPatterns = null, Symbol quantifierID = null, Symbol skolemID = null) : base(ctx, IntPtr.Zero) { - Contract.Requires(ctx != null); - Contract.Requires(body != null); + Debug.Assert(ctx != null); + Debug.Assert(body != null); - Contract.Requires(patterns == null || Contract.ForAll(patterns, p => p != null)); - Contract.Requires(noPatterns == null || Contract.ForAll(noPatterns, np => np != null)); - Contract.Requires(bound == null || Contract.ForAll(bound, n => n != null)); + Debug.Assert(patterns == null || patterns.All(p => p != null)); + Debug.Assert(noPatterns == null || noPatterns.All(np => np != null)); + Debug.Assert(bound == null || bound.All(n => n != null)); Context.CheckContextMatch(noPatterns); Context.CheckContextMatch(patterns); @@ -246,7 +239,7 @@ namespace Microsoft.Z3 } - internal Quantifier(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal Quantifier(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } #if DEBUG internal override void CheckNativeObject(IntPtr obj) diff --git a/src/api/dotnet/RatNum.cs b/src/api/dotnet/RatNum.cs index bad6b323d..1d485a347 100644 --- a/src/api/dotnet/RatNum.cs +++ b/src/api/dotnet/RatNum.cs @@ -16,8 +16,8 @@ Author: Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; #if !FRAMEWORK_LT_4 using System.Numerics; @@ -28,7 +28,6 @@ namespace Microsoft.Z3 /// /// Rational Numerals /// - [ContractVerification(true)] public class RatNum : RealExpr { /// @@ -38,7 +37,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new IntNum(Context, Native.Z3_get_numerator(Context.nCtx, NativeObject)); } @@ -51,7 +49,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new IntNum(Context, Native.Z3_get_denominator(Context.nCtx, NativeObject)); } @@ -92,6 +89,14 @@ namespace Microsoft.Z3 return Native.Z3_get_numeral_decimal_string(Context.nCtx, NativeObject, precision); } + /// + /// Returns a double representing the value. + /// + public double Double + { + get { return Native.Z3_get_numeral_double(Context.nCtx, NativeObject); } + } + /// /// Returns a string representation of the numeral. /// @@ -104,7 +109,7 @@ namespace Microsoft.Z3 internal RatNum(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/ReExpr.cs b/src/api/dotnet/ReExpr.cs index 6a10d535f..7ab9aaffc 100644 --- a/src/api/dotnet/ReExpr.cs +++ b/src/api/dotnet/ReExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -35,7 +35,7 @@ namespace Microsoft.Z3 internal ReExpr(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/ReSort.cs b/src/api/dotnet/ReSort.cs index bc420603d..98659c697 100644 --- a/src/api/dotnet/ReSort.cs +++ b/src/api/dotnet/ReSort.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -31,12 +31,12 @@ namespace Microsoft.Z3 internal ReSort(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal ReSort(Context ctx) : base(ctx, Native.Z3_mk_int_sort(ctx.nCtx)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/RealExpr.cs b/src/api/dotnet/RealExpr.cs index 8ee8c8e76..1c3a55189 100644 --- a/src/api/dotnet/RealExpr.cs +++ b/src/api/dotnet/RealExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -35,7 +35,7 @@ namespace Microsoft.Z3 internal RealExpr(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/RealSort.cs b/src/api/dotnet/RealSort.cs index 97f1cae11..38fe469ce 100644 --- a/src/api/dotnet/RealSort.cs +++ b/src/api/dotnet/RealSort.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -31,12 +31,12 @@ namespace Microsoft.Z3 internal RealSort(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal RealSort(Context ctx) : base(ctx, Native.Z3_mk_real_sort(ctx.nCtx)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/RelationSort.cs b/src/api/dotnet/RelationSort.cs index cfd7a592a..6bea5c6e1 100644 --- a/src/api/dotnet/RelationSort.cs +++ b/src/api/dotnet/RelationSort.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Relation sorts. /// - [ContractVerification(true)] public class RelationSort : Sort { /// @@ -43,7 +42,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); if (m_columnSorts != null) return m_columnSorts; @@ -62,7 +60,7 @@ namespace Microsoft.Z3 internal RelationSort(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/SeqExpr.cs b/src/api/dotnet/SeqExpr.cs index c9fdd03a8..bfab1fa36 100644 --- a/src/api/dotnet/SeqExpr.cs +++ b/src/api/dotnet/SeqExpr.cs @@ -16,12 +16,12 @@ Author: Notes: --*/ +using System.Diagnostics; using System; using System.Collections.Generic; using System.Linq; using System.Text; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -35,7 +35,7 @@ namespace Microsoft.Z3 internal SeqExpr(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/SeqSort.cs b/src/api/dotnet/SeqSort.cs index b2be11291..2902b1e9e 100644 --- a/src/api/dotnet/SeqSort.cs +++ b/src/api/dotnet/SeqSort.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -31,12 +31,12 @@ namespace Microsoft.Z3 internal SeqSort(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal SeqSort(Context ctx) : base(ctx, Native.Z3_mk_int_sort(ctx.nCtx)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #endregion } diff --git a/src/api/dotnet/SetSort.cs b/src/api/dotnet/SetSort.cs index bdba3899f..9f55c8edb 100644 --- a/src/api/dotnet/SetSort.cs +++ b/src/api/dotnet/SetSort.cs @@ -17,28 +17,27 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Set sorts. /// - [ContractVerification(true)] public class SetSort : Sort { #region Internal internal SetSort(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal SetSort(Context ctx, Sort ty) : base(ctx, Native.Z3_mk_set_sort(ctx.nCtx, ty.NativeObject)) { - Contract.Requires(ctx != null); - Contract.Requires(ty != null); + Debug.Assert(ctx != null); + Debug.Assert(ty != null); } #endregion } diff --git a/src/api/dotnet/Solver.cs b/src/api/dotnet/Solver.cs index a288990a2..ec53b14de 100644 --- a/src/api/dotnet/Solver.cs +++ b/src/api/dotnet/Solver.cs @@ -18,16 +18,15 @@ Notes: --*/ using System; +using System.Diagnostics; using System.Linq; using System.Collections.Generic; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Solvers. /// - [ContractVerification(true)] public class Solver : Z3Object { /// @@ -37,7 +36,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Native.Z3_solver_get_help(Context.nCtx, NativeObject); } @@ -50,7 +48,7 @@ namespace Microsoft.Z3 { set { - Contract.Requires(value != null); + Debug.Assert(value != null); Context.CheckContextMatch(value); Native.Z3_solver_set_params(Context.nCtx, NativeObject, value.NativeObject); @@ -152,8 +150,8 @@ namespace Microsoft.Z3 /// public void Assert(params BoolExpr[] constraints) { - Contract.Requires(constraints != null); - Contract.Requires(Contract.ForAll(constraints, c => c != null)); + Debug.Assert(constraints != null); + Debug.Assert(constraints.All(c => c != null)); Context.CheckContextMatch(constraints); foreach (BoolExpr a in constraints) @@ -191,9 +189,9 @@ namespace Microsoft.Z3 /// public void AssertAndTrack(BoolExpr[] constraints, BoolExpr[] ps) { - Contract.Requires(constraints != null); - Contract.Requires(Contract.ForAll(constraints, c => c != null)); - Contract.Requires(Contract.ForAll(ps, c => c != null)); + Debug.Assert(constraints != null); + Debug.Assert(constraints.All(c => c != null)); + Debug.Assert(ps.All(c => c != null)); Context.CheckContextMatch(constraints); Context.CheckContextMatch(ps); if (constraints.Length != ps.Length) @@ -216,8 +214,8 @@ namespace Microsoft.Z3 /// public void AssertAndTrack(BoolExpr constraint, BoolExpr p) { - Contract.Requires(constraint != null); - Contract.Requires(p != null); + Debug.Assert(constraint != null); + Debug.Assert(p != null); Context.CheckContextMatch(constraint); Context.CheckContextMatch(p); @@ -259,7 +257,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); ASTVector assertions = new ASTVector(Context, Native.Z3_solver_get_assertions(Context.nCtx, NativeObject)); return assertions.ToBoolExprArray(); @@ -273,7 +270,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); ASTVector assertions = new ASTVector(Context, Native.Z3_solver_get_units(Context.nCtx, NativeObject)); return assertions.ToBoolExprArray(); @@ -394,7 +390,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); ASTVector core = new ASTVector(Context, Native.Z3_solver_get_unsat_core(Context.nCtx, NativeObject)); return core.ToBoolExprArray(); @@ -408,7 +403,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Native.Z3_solver_get_reason_unknown(Context.nCtx, NativeObject); } @@ -455,8 +449,7 @@ namespace Microsoft.Z3 /// public Solver Translate(Context ctx) { - Contract.Requires(ctx != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ctx != null); return new Solver(ctx, Native.Z3_solver_translate(Context.nCtx, NativeObject, ctx.nCtx)); } @@ -475,7 +468,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new Statistics(Context, Native.Z3_solver_get_statistics(Context.nCtx, NativeObject)); } @@ -493,7 +485,7 @@ namespace Microsoft.Z3 internal Solver(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); this.BacktrackLevel = uint.MaxValue; } diff --git a/src/api/dotnet/Sort.cs b/src/api/dotnet/Sort.cs index e32fd1eb3..cf70bbf73 100644 --- a/src/api/dotnet/Sort.cs +++ b/src/api/dotnet/Sort.cs @@ -17,15 +17,14 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// The Sort class implements type information for ASTs. /// - [ContractVerification(true)] public class Sort : AST { /// @@ -100,7 +99,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Symbol.Create(Context, Native.Z3_get_sort_name(Context.nCtx, NativeObject)); } } @@ -127,7 +125,7 @@ namespace Microsoft.Z3 /// /// Sort constructor /// - internal Sort(Context ctx, IntPtr obj) : base(ctx, obj) { Contract.Requires(ctx != null); } + internal Sort(Context ctx, IntPtr obj) : base(ctx, obj) { Debug.Assert(ctx != null); } #if DEBUG internal override void CheckNativeObject(IntPtr obj) @@ -138,11 +136,9 @@ namespace Microsoft.Z3 } #endif - [ContractVerification(true)] new internal static Sort Create(Context ctx, IntPtr obj) { - Contract.Requires(ctx != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ctx != null); switch ((Z3_sort_kind)Native.Z3_get_sort_kind(ctx.nCtx, obj)) { diff --git a/src/api/dotnet/Statistics.cs b/src/api/dotnet/Statistics.cs index c94af625c..8b664913a 100644 --- a/src/api/dotnet/Statistics.cs +++ b/src/api/dotnet/Statistics.cs @@ -18,14 +18,14 @@ Notes: --*/ using System; -using System.Diagnostics.Contracts; +using System.Diagnostics; + namespace Microsoft.Z3 { /// /// Objects of this class track statistical information about solvers. /// - [ContractVerification(true)] public class Statistics : Z3Object { /// @@ -62,7 +62,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); if (IsUInt) return m_uint.ToString(); @@ -124,9 +123,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); - Contract.Ensures(Contract.Result().Length == this.Size); - Contract.Ensures(Contract.ForAll(0, Contract.Result().Length, j => Contract.Result()[j] != null)); uint n = Size; Entry[] res = new Entry[n]; @@ -153,7 +149,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = Size; string[] res = new string[n]; @@ -184,7 +179,7 @@ namespace Microsoft.Z3 internal Statistics(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal class DecRefQueue : IDecRefQueue diff --git a/src/api/dotnet/Status.cs b/src/api/dotnet/Status.cs index 5847f098b..d44cffd56 100644 --- a/src/api/dotnet/Status.cs +++ b/src/api/dotnet/Status.cs @@ -17,6 +17,7 @@ Notes: --*/ +using System.Diagnostics; using System; namespace Microsoft.Z3 diff --git a/src/api/dotnet/StringSymbol.cs b/src/api/dotnet/StringSymbol.cs index e311fb958..447e0be5f 100644 --- a/src/api/dotnet/StringSymbol.cs +++ b/src/api/dotnet/StringSymbol.cs @@ -18,8 +18,8 @@ Notes: --*/ using System; +using System.Diagnostics; using System.Runtime.InteropServices; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -27,7 +27,6 @@ namespace Microsoft.Z3 /// /// Named symbols /// - [ContractVerification(true)] public class StringSymbol : Symbol { /// @@ -38,7 +37,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); if (!IsStringSymbol()) throw new Z3Exception("String requested from non-String symbol"); @@ -50,13 +48,13 @@ namespace Microsoft.Z3 internal StringSymbol(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal StringSymbol(Context ctx, string s) : base(ctx, Native.Z3_mk_string_symbol(ctx.nCtx, s)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } #if DEBUG diff --git a/src/api/dotnet/Symbol.cs b/src/api/dotnet/Symbol.cs index 2a1fdf6c5..afefdf3df 100644 --- a/src/api/dotnet/Symbol.cs +++ b/src/api/dotnet/Symbol.cs @@ -18,15 +18,14 @@ Notes: --*/ using System; +using System.Diagnostics; using System.Runtime.InteropServices; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { /// /// Symbols are used to name several term and type constructors. /// - [ContractVerification(true)] public class Symbol : Z3Object { /// @@ -84,7 +83,7 @@ namespace Microsoft.Z3 /// public static bool operator !=(Symbol s1, Symbol s2) { - return !(s1.NativeObject == s2.NativeObject); + return !(s1 == s2); } /// @@ -113,13 +112,12 @@ namespace Microsoft.Z3 /// internal protected Symbol(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal static Symbol Create(Context ctx, IntPtr obj) { - Contract.Requires(ctx != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(ctx != null); switch ((Z3_symbol_kind)Native.Z3_get_symbol_kind(ctx.nCtx, obj)) { diff --git a/src/api/dotnet/Tactic.cs b/src/api/dotnet/Tactic.cs index 0a6f79494..96b6da170 100644 --- a/src/api/dotnet/Tactic.cs +++ b/src/api/dotnet/Tactic.cs @@ -18,7 +18,7 @@ Notes: --*/ using System; -using System.Diagnostics.Contracts; +using System.Diagnostics; namespace Microsoft.Z3 { @@ -28,7 +28,6 @@ namespace Microsoft.Z3 /// and Context.TacticNames. /// It may also be obtained using the command (help-tactic) in the SMT 2.0 front-end. /// - [ContractVerification(true)] public class Tactic : Z3Object { /// @@ -38,7 +37,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Native.Z3_tactic_get_help(Context.nCtx, NativeObject); } @@ -59,8 +57,7 @@ namespace Microsoft.Z3 /// public ApplyResult Apply(Goal g, Params p = null) { - Contract.Requires(g != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(g != null); Context.CheckContextMatch(g); if (p == null) @@ -79,8 +76,7 @@ namespace Microsoft.Z3 { get { - Contract.Requires(g != null); - Contract.Ensures(Contract.Result() != null); + Debug.Assert(g != null); return Apply(g); } @@ -94,7 +90,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return Context.MkSolver(this); } @@ -104,12 +99,12 @@ namespace Microsoft.Z3 internal Tactic(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal Tactic(Context ctx, string name) : base(ctx, Native.Z3_mk_tactic(ctx.nCtx, name)) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } /// diff --git a/src/api/dotnet/TupleSort.cs b/src/api/dotnet/TupleSort.cs index ea99f3855..adbc4f904 100644 --- a/src/api/dotnet/TupleSort.cs +++ b/src/api/dotnet/TupleSort.cs @@ -18,14 +18,13 @@ Notes: --*/ using System; -using System.Diagnostics.Contracts; +using System.Diagnostics; namespace Microsoft.Z3 { /// /// Tuple sorts. /// - [ContractVerification(true)] public class TupleSort : Sort { /// @@ -35,7 +34,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return new FuncDecl(Context, Native.Z3_get_tuple_sort_mk_decl(Context.nCtx, NativeObject)); } @@ -56,7 +54,6 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); uint n = NumFields; FuncDecl[] res = new FuncDecl[n]; @@ -70,8 +67,8 @@ namespace Microsoft.Z3 internal TupleSort(Context ctx, Symbol name, uint numFields, Symbol[] fieldNames, Sort[] fieldSorts) : base(ctx, IntPtr.Zero) { - Contract.Requires(ctx != null); - Contract.Requires(name != null); + Debug.Assert(ctx != null); + Debug.Assert(name != null); IntPtr t = IntPtr.Zero; IntPtr[] f = new IntPtr[numFields]; diff --git a/src/api/dotnet/UninterpretedSort.cs b/src/api/dotnet/UninterpretedSort.cs index 154818faf..9f940468d 100644 --- a/src/api/dotnet/UninterpretedSort.cs +++ b/src/api/dotnet/UninterpretedSort.cs @@ -18,7 +18,7 @@ Notes: --*/ using System; -using System.Diagnostics.Contracts; +using System.Diagnostics; namespace Microsoft.Z3 { @@ -31,13 +31,13 @@ namespace Microsoft.Z3 internal UninterpretedSort(Context ctx, IntPtr obj) : base(ctx, obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); } internal UninterpretedSort(Context ctx, Symbol s) : base(ctx, Native.Z3_mk_uninterpreted_sort(ctx.nCtx, s.NativeObject)) { - Contract.Requires(ctx != null); - Contract.Requires(s != null); + Debug.Assert(ctx != null); + Debug.Assert(s != null); } #endregion } diff --git a/src/api/dotnet/Version.cs b/src/api/dotnet/Version.cs index 364ada781..2099959eb 100644 --- a/src/api/dotnet/Version.cs +++ b/src/api/dotnet/Version.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; namespace Microsoft.Z3 { @@ -26,7 +26,6 @@ namespace Microsoft.Z3 /// Version information. /// /// Note that this class is static. - [ContractVerification(true)] public static class Version { static Version() { } @@ -99,7 +98,6 @@ namespace Microsoft.Z3 /// new public static string ToString() { - Contract.Ensures(Contract.Result() != null); uint major = 0, minor = 0, build = 0, revision = 0; Native.Z3_get_version(ref major, ref minor, ref build, ref revision); diff --git a/src/api/dotnet/Z3Exception.cs b/src/api/dotnet/Z3Exception.cs index b0e05900c..79f6185da 100644 --- a/src/api/dotnet/Z3Exception.cs +++ b/src/api/dotnet/Z3Exception.cs @@ -17,6 +17,7 @@ Notes: --*/ +using System.Diagnostics; using System; namespace Microsoft.Z3 diff --git a/src/api/dotnet/Z3Object.cs b/src/api/dotnet/Z3Object.cs index f32ba30af..9a61a0119 100644 --- a/src/api/dotnet/Z3Object.cs +++ b/src/api/dotnet/Z3Object.cs @@ -17,8 +17,8 @@ Notes: --*/ +using System.Diagnostics; using System; -using System.Diagnostics.Contracts; using System.Threading; using System.Collections.Generic; using System.Linq; @@ -29,7 +29,6 @@ namespace Microsoft.Z3 /// Internal base class for interfacing with native Z3 objects. /// Should not be used externally. /// - [ContractVerification(true)] public class Z3Object : IDisposable { /// @@ -63,10 +62,9 @@ namespace Microsoft.Z3 #region Object Invariant - [ContractInvariantMethod] private void ObjectInvariant() { - Contract.Invariant(this.m_ctx != null); + Debug.Assert(this.m_ctx != null); } #endregion @@ -77,7 +75,7 @@ namespace Microsoft.Z3 internal Z3Object(Context ctx) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); Interlocked.Increment(ref ctx.refCount); m_ctx = ctx; @@ -85,7 +83,7 @@ namespace Microsoft.Z3 internal Z3Object(Context ctx, IntPtr obj) { - Contract.Requires(ctx != null); + Debug.Assert(ctx != null); Interlocked.Increment(ref ctx.refCount); m_ctx = ctx; @@ -119,16 +117,12 @@ namespace Microsoft.Z3 { get { - Contract.Ensures(Contract.Result() != null); return m_ctx; } } - [Pure] internal static IntPtr[] ArrayToNative(Z3Object[] a) { - Contract.Ensures(a == null || Contract.Result() != null); - Contract.Ensures(a == null || Contract.Result().Length == a.Length); if (a == null) return null; IntPtr[] an = new IntPtr[a.Length]; @@ -137,11 +131,8 @@ namespace Microsoft.Z3 return an; } - [Pure] internal static IntPtr[] EnumToNative(IEnumerable a) where T : Z3Object { - Contract.Ensures(a == null || Contract.Result() != null); - Contract.Ensures(a == null || Contract.Result().Length == a.Count()); if (a == null) return null; IntPtr[] an = new IntPtr[a.Count()]; @@ -154,7 +145,6 @@ namespace Microsoft.Z3 return an; } - [Pure] internal static uint ArrayLength(Z3Object[] a) { return (a == null)?0:(uint)a.Length; diff --git a/src/api/dotnet/core/README.txt b/src/api/dotnet/core/README.txt new file mode 100644 index 000000000..fa274f72b --- /dev/null +++ b/src/api/dotnet/core/README.txt @@ -0,0 +1,15 @@ +Z3 API for .NET Core + +Z3's .NET API uses Code Contracts, which are not included in .NET Core. The +enclosed file called DummyContracts.cs provides stubs for the Code Contracts +functions, so that the API will compile, but not perform any contract +checking. To build this using .NET core, run (in this directory): + +dotnet restore +dotnet build core.csproj -c Release + +If you are building with the cmake system, you should first +copy over files that are produced by the compiler into +this directory. You need to copy over Native.cs and Enumeration.cs + +-- good luck! diff --git a/src/api/dotnet/core/core.csproj b/src/api/dotnet/core/core.csproj new file mode 100644 index 000000000..5fa3275cf --- /dev/null +++ b/src/api/dotnet/core/core.csproj @@ -0,0 +1,18 @@ + + + + netcoreapp1.0 + $(DefineConstants);DOTNET_CORE + portable + Microsoft.Z3 + Library + core + $(PackageTargetFallback);dnxcore50 + 1.0.4 + + + + + + + diff --git a/src/api/dotnet/dotnet35/Readme.NET35 b/src/api/dotnet/dotnet35/Readme.NET35 new file mode 100644 index 000000000..75210f8b6 --- /dev/null +++ b/src/api/dotnet/dotnet35/Readme.NET35 @@ -0,0 +1,10 @@ +The default Z3 bindings for .NET are built for the .NET framework version 4. +Should the need arise, it is also possible to build them for .NET 3.5; the +instructions are as follows: + +In the project properties of Microsoft.Z3.csproj: +- Under 'Application': Change Target framework to .NET Framework 3.5 +- Under 'Build': Add FRAMEWORK_LT_4 to the conditional compilation symbols +- Remove the reference to System.Numerics +- Install the NuGet Package "Microsoft Code Contracts for Net3.5": + In the Package Manager Console enter Install-Package Code.Contract diff --git a/src/api/java/CMakeLists.txt b/src/api/java/CMakeLists.txt index 302b3d5bd..c2d73ffb1 100644 --- a/src/api/java/CMakeLists.txt +++ b/src/api/java/CMakeLists.txt @@ -39,8 +39,7 @@ add_library(z3java SHARED ${Z3_JAVA_NATIVE_CPP}) target_link_libraries(z3java PRIVATE libz3) # FIXME: # Not sure if using all the flags used by the Z3 components is really necessary -# here. At the bare minimum setting _AMD64_ depending on the target is -# necessary but seeing as the Python build system uses all the flags used for building +# here. The Python build system uses all the flags used for building # Z3's components to build ``Native.cpp`` lets do the same for now. target_compile_options(z3java PRIVATE ${Z3_COMPONENT_CXX_FLAGS}) target_compile_definitions(z3java PRIVATE ${Z3_COMPONENT_CXX_DEFINES}) diff --git a/src/api/java/Context.java b/src/api/java/Context.java index 57085a09e..20c1c3737 100644 --- a/src/api/java/Context.java +++ b/src/api/java/Context.java @@ -1976,6 +1976,22 @@ public class Context implements AutoCloseable { { return (SeqExpr) Expr.create(this, Native.mkString(nCtx(), s)); } + + /** + * Convert an integer expression to a string. + */ + public SeqExpr intToString(Expr e) + { + return (SeqExpr) Expr.create(this, Native.mkIntToStr(nCtx(), e.getNativeObject())); + } + + /** + * Convert an integer expression to a string. + */ + public IntExpr stringToInt(Expr e) + { + return (IntExpr) Expr.create(this, Native.mkStrToInt(nCtx(), e.getNativeObject())); + } /** * Concatenate sequences. @@ -2157,6 +2173,22 @@ public class Context implements AutoCloseable { { checkContextMatch(t); return (ReExpr) Expr.create(this, Native.mkReIntersect(nCtx(), t.length, AST.arrayToNative(t))); + } + + /** + * Create the empty regular expression. + */ + public ReExpr mkEmptyRe(Sort s) + { + return (ReExpr) Expr.create(this, Native.mkReEmpty(nCtx(), s.getNativeObject())); + } + + /** + * Create the full regular expression. + */ + public ReExpr mkFullRe(Sort s) + { + return (ReExpr) Expr.create(this, Native.mkReFull(nCtx(), s.getNativeObject())); } /** @@ -3324,7 +3356,7 @@ public class Context implements AutoCloseable { } /** - * Create a numeral of FloatingPoint sort from a float. + * Create a numeral of FloatingPoint sort from a double. * @param v numeral value. * @param s FloatingPoint sort. * @throws Z3Exception @@ -3336,7 +3368,7 @@ public class Context implements AutoCloseable { /** * Create a numeral of FloatingPoint sort from an int. - * * @param v numeral value. + * @param v numeral value. * @param s FloatingPoint sort. * @throws Z3Exception **/ @@ -3348,8 +3380,8 @@ public class Context implements AutoCloseable { /** * Create a numeral of FloatingPoint sort from a sign bit and two integers. * @param sgn the sign. - * @param sig the significand. * @param exp the exponent. + * @param sig the significand. * @param s FloatingPoint sort. * @throws Z3Exception **/ @@ -3361,8 +3393,8 @@ public class Context implements AutoCloseable { /** * Create a numeral of FloatingPoint sort from a sign bit and two 64-bit integers. * @param sgn the sign. - * @param sig the significand. * @param exp the exponent. + * @param sig the significand. * @param s FloatingPoint sort. * @throws Z3Exception **/ @@ -3383,7 +3415,7 @@ public class Context implements AutoCloseable { } /** - * Create a numeral of FloatingPoint sort from a float. + * Create a numeral of FloatingPoint sort from a double. * @param v numeral value. * @param s FloatingPoint sort. * @throws Z3Exception @@ -3415,7 +3447,7 @@ public class Context implements AutoCloseable { **/ public FPNum mkFP(boolean sgn, int exp, int sig, FPSort s) { - return mkFPNumeral(sgn, sig, exp, s); + return mkFPNumeral(sgn, exp, sig, s); } /** @@ -3428,7 +3460,7 @@ public class Context implements AutoCloseable { **/ public FPNum mkFP(boolean sgn, long exp, long sig, FPSort s) { - return mkFPNumeral(sgn, sig, exp, s); + return mkFPNumeral(sgn, exp, sig, s); } diff --git a/src/api/java/Optimize.java b/src/api/java/Optimize.java index c5f8f9449..ae50d7f33 100644 --- a/src/api/java/Optimize.java +++ b/src/api/java/Optimize.java @@ -161,9 +161,23 @@ public class Optimize extends Z3Object { * Produce a model that (when the objectives are bounded and * don't use strict inequalities) meets the objectives. **/ - public Status Check() + public Status Check(Expr... assumptions) { - Z3_lbool r = Z3_lbool.fromInt(Native.optimizeCheck(getContext().nCtx(), getNativeObject())); + Z3_lbool r; + if (assumptions == null) { + r = Z3_lbool.fromInt( + Native.optimizeCheck( + getContext().nCtx(), + getNativeObject(), 0, null)); + } + else { + r = Z3_lbool.fromInt( + Native.optimizeCheck( + getContext().nCtx(), + getNativeObject(), + assumptions.length, + AST.arrayToNative(assumptions))); + } switch (r) { case Z3_L_TRUE: return Status.SATISFIABLE; @@ -209,6 +223,21 @@ public class Optimize extends Z3Object { } } + /** + * The unsat core of the last {@code Check}. + * Remarks: The unsat core + * is a subset of {@code Assumptions} The result is empty if + * {@code Check} was not invoked before, if its results was not + * {@code UNSATISFIABLE}, or if core production is disabled. + * + * @throws Z3Exception + **/ + public BoolExpr[] getUnsatCore() + { + ASTVector core = new ASTVector(getContext(), Native.optimizeGetUnsatCore(getContext().nCtx(), getNativeObject())); + return core.ToBoolExprArray(); + } + /** * Declare an arithmetical maximization objective. * Return a handle to the objective. The handle is used as diff --git a/src/api/ml/META.in b/src/api/ml/META.in index 1951e60b3..e58ebf722 100644 --- a/src/api/ml/META.in +++ b/src/api/ml/META.in @@ -1,7 +1,7 @@ # META file for the "z3" package: version = "@VERSION@" description = "Z3 Theorem Prover (OCaml API)" -requires = "num" +requires = "num threads" archive(byte) = "z3ml.cma" archive(native) = "z3ml.cmxa" archive(byte,plugin) = "z3ml.cma" diff --git a/src/api/ml/z3.ml b/src/api/ml/z3.ml index 25b437bc4..5fb87bf64 100644 --- a/src/api/ml/z3.ml +++ b/src/api/ml/z3.ml @@ -705,6 +705,11 @@ struct let mk_forall_const = _internal_mk_quantifier_const ~universal:true let mk_exists = _internal_mk_quantifier ~universal:false let mk_exists_const = _internal_mk_quantifier_const ~universal:false + let mk_lambda_const ctx bound body = Z3native.mk_lambda_const ctx (List.length bound) bound body + let mk_lambda ctx bound body = + let names = List.map (fun (x,_) -> x) bound in + let sorts = List.map (fun (_,y) -> y) bound in + Z3native.mk_lambda ctx (List.length bound) sorts names body let mk_quantifier (ctx:context) (universal:bool) (sorts:Sort.sort list) (names:Symbol.symbol list) (body:expr) (weight:int option) (patterns:Pattern.pattern list) (nopatterns:expr list) (quantifier_id:Symbol.symbol option) (skolem_id:Symbol.symbol option) = if universal then @@ -1815,8 +1820,10 @@ struct | _ -> UNKNOWN let get_model x = - let q = Z3native.solver_get_model (gc x) x in - if Z3native.is_null_model q then None else Some q + try + let q = Z3native.solver_get_model (gc x) x in + if Z3native.is_null_model q then None else Some q + with | _ -> None let get_proof x = let q = Z3native.solver_get_proof (gc x) x in @@ -1945,15 +1952,17 @@ struct let minimize (x:optimize) (e:Expr.expr) = mk_handle x (Z3native.optimize_minimize (gc x) x e) let check (x:optimize) = - let r = lbool_of_int (Z3native.optimize_check (gc x) x) in + let r = lbool_of_int (Z3native.optimize_check (gc x) x 0 []) in match r with | L_TRUE -> Solver.SATISFIABLE | L_FALSE -> Solver.UNSATISFIABLE | _ -> Solver.UNKNOWN let get_model (x:optimize) = - let q = Z3native.optimize_get_model (gc x) x in - if Z3native.is_null_model q then None else Some q + try + let q = Z3native.optimize_get_model (gc x) x in + if Z3native.is_null_model q then None else Some q + with | _ -> None let get_lower (x:handle) = Z3native.optimize_get_lower (gc x.opt) x.opt x.h let get_upper (x:handle) = Z3native.optimize_get_upper (gc x.opt) x.opt x.h @@ -2014,3 +2023,7 @@ let toggle_warning_messages = Z3native.toggle_warning_messages let enable_trace = Z3native.enable_trace let disable_trace = Z3native.enable_trace + +module Memory = struct + let reset = Z3native.reset_memory +end diff --git a/src/api/ml/z3.mli b/src/api/ml/z3.mli index f67966a0f..4b6d8bc25 100644 --- a/src/api/ml/z3.mli +++ b/src/api/ml/z3.mli @@ -736,6 +736,12 @@ sig (** Create an existential Quantifier. *) val mk_exists_const : context -> Expr.expr list -> Expr.expr -> int option -> Pattern.pattern list -> Expr.expr list -> Symbol.symbol option -> Symbol.symbol option -> quantifier + (** Create a lambda binding. *) + val mk_lambda_const : context -> Expr.expr list -> Expr.expr -> quantifier + + (** Create a lambda binding where bound variables are given by symbols and sorts *) + val mk_lambda : context -> (Symbol.symbol * Sort.sort) list -> Expr.expr -> quantifier + (** Create a Quantifier. *) val mk_quantifier : context -> Sort.sort list -> Symbol.symbol list -> Expr.expr -> int option -> Pattern.pattern list -> Expr.expr list -> Symbol.symbol option -> Symbol.symbol option -> quantifier @@ -3407,10 +3413,10 @@ sig (** Parse the given string using the SMT-LIB2 parser. @return A conjunction of assertions in the scope (up to push/pop) at the end of the string. *) - val parse_smtlib2_string : context -> string -> Symbol.symbol list -> Sort.sort list -> Symbol.symbol list -> FuncDecl.func_decl list -> Expr.expr + val parse_smtlib2_string : context -> string -> Symbol.symbol list -> Sort.sort list -> Symbol.symbol list -> FuncDecl.func_decl list -> AST.ASTVector.ast_vector (** Parse the given file using the SMT-LIB2 parser. *) - val parse_smtlib2_file : context -> string -> Symbol.symbol list -> Sort.sort list -> Symbol.symbol list -> FuncDecl.func_decl list -> Expr.expr + val parse_smtlib2_file : context -> string -> Symbol.symbol list -> Sort.sort list -> Symbol.symbol list -> FuncDecl.func_decl list -> AST.ASTVector.ast_vector end @@ -3466,3 +3472,11 @@ val enable_trace : string -> unit Remarks: It is a NOOP otherwise. *) val disable_trace : string -> unit + + +(** Memory management **) +module Memory : +sig + (** Reset all allocated resources **) + val reset : unit -> unit +end diff --git a/src/api/ml/z3native_stubs.c.pre b/src/api/ml/z3native_stubs.c.pre index c1c772c85..5c1a3bd06 100644 --- a/src/api/ml/z3native_stubs.c.pre +++ b/src/api/ml/z3native_stubs.c.pre @@ -11,6 +11,7 @@ extern "C" { #include #include #include +#include #ifdef Custom_tag #include @@ -447,3 +448,21 @@ CAMLprim value DLL_PUBLIC n_set_internal_error_handler(value ctx_v) Z3_set_error_handler(ctx_p->ctx, MLErrorHandler); CAMLreturn(Val_unit); } + +CAMLprim DLL_PUBLIC value n_mk_config() { + CAMLparam0(); + CAMLlocal1(result); + Z3_config z3rv; + + /* invoke Z3 function */ + z3rv = Z3_mk_config(); + + if (z3rv == NULL) { + caml_raise_with_string(*caml_named_value("Z3EXCEPTION"), "Object allocation failed"); + } + + /* construct simple return value */ + result = caml_alloc_custom(&default_custom_ops, sizeof(Z3_config), 0, 1); *(Z3_config*)Data_custom_val(result) = z3rv; + /* cleanup and return */ + CAMLreturn(result); +} diff --git a/src/api/python/README.txt b/src/api/python/README.txt index 9831c6fc6..9312b1119 100644 --- a/src/api/python/README.txt +++ b/src/api/python/README.txt @@ -12,8 +12,8 @@ If you are using a 64-bit Python interpreter, you should use msbuild /p:configuration=external /p:platform=x64 -On Linux and OSX, you must install Z3Py, before trying example.py. -To install Z3Py on Linux and OSX, you should execute the following +On Linux and macOS, you must install Z3Py, before trying example.py. +To install Z3Py on Linux and macOS, you should execute the following command in the Z3 root directory sudo make install-z3py diff --git a/src/api/python/setup.py b/src/api/python/setup.py index bce681584..2a750fee6 100644 --- a/src/api/python/setup.py +++ b/src/api/python/setup.py @@ -73,7 +73,7 @@ def _build_z3(): if subprocess.call(['nmake'], env=build_env, cwd=BUILD_DIR) != 0: raise LibError("Unable to build Z3.") - else: # linux and osx + else: # linux and macOS if subprocess.call(['make', '-j', str(multiprocessing.cpu_count())], env=build_env, cwd=BUILD_DIR) != 0: raise LibError("Unable to build Z3.") diff --git a/src/api/python/z3/z3.py b/src/api/python/z3/z3.py index 0eeeeaecc..523d40842 100644 --- a/src/api/python/z3/z3.py +++ b/src/api/python/z3/z3.py @@ -1,4 +1,5 @@ + ############################################ # Copyright (c) 2012 Microsoft Corporation # @@ -799,6 +800,49 @@ def Function(name, *sig): def _to_func_decl_ref(a, ctx): return FuncDeclRef(a, ctx) +def RecFunction(name, *sig): + """Create a new Z3 recursive with the given sorts.""" + sig = _get_args(sig) + if __debug__: + _z3_assert(len(sig) > 0, "At least two arguments expected") + arity = len(sig) - 1 + rng = sig[arity] + if __debug__: + _z3_assert(is_sort(rng), "Z3 sort expected") + dom = (Sort * arity)() + for i in range(arity): + if __debug__: + _z3_assert(is_sort(sig[i]), "Z3 sort expected") + dom[i] = sig[i].ast + ctx = rng.ctx + return FuncDeclRef(Z3_mk_rec_func_decl(ctx.ref(), to_symbol(name, ctx), arity, dom, rng.ast), ctx) + +def RecAddDefinition(f, args, body): + """Set the body of a recursive function. + Recursive definitions are only unfolded during search. + >>> ctx = Context() + >>> fac = RecFunction('fac', IntSort(ctx), IntSort(ctx)) + >>> n = Int('n', ctx) + >>> RecAddDefinition(fac, n, If(n == 0, 1, n*fac(n-1))) + >>> simplify(fac(5)) + fac(5) + >>> s = Solver(ctx=ctx) + >>> s.add(fac(n) < 3) + >>> s.check() + sat + >>> s.model().eval(fac(5)) + 120 + """ + if is_app(args): + args = [args] + ctx = body.ctx + args = _get_args(args) + n = len(args) + _args = (Ast * n)() + for i in range(n): + _args[i] = args[i].ast + Z3_add_rec_def(ctx.ref(), f.ast, n, _args, body.ast) + ######################################### # # Expressions @@ -1258,6 +1302,11 @@ def Consts(names, sort): names = names.split(" ") return [Const(name, sort) for name in names] +def FreshConst(sort, prefix='c'): + """Create a fresh constant of a specified sort""" + ctx = _get_ctx(sort.ctx) + return _to_expr_ref(Z3_mk_fresh_const(ctx.ref(), prefix, sort.ast), ctx) + def Var(idx, s): """Create a Z3 free variable. Free variables are used to create quantified formulas. @@ -1596,6 +1645,12 @@ def Not(a, ctx=None): a = s.cast(a) return BoolRef(Z3_mk_not(ctx.ref(), a.as_ast()), ctx) +def mk_not(a): + if is_not(a): + return a.arg(0) + else: + return Not(a) + def _has_probe(args): """Return `True` if one of the elements of the given collection is a Z3 probe.""" for arg in args: @@ -1744,7 +1799,9 @@ class QuantifierRef(BoolRef): return Z3_get_ast_id(self.ctx_ref(), self.as_ast()) def sort(self): - """Return the Boolean sort.""" + """Return the Boolean sort or sort of Lambda.""" + if self.is_lambda(): + return _sort(self.ctx, self.as_ast()) return BoolSort(self.ctx) def is_forall(self): @@ -2176,6 +2233,8 @@ class ArithRef(ExprRef): >>> (x * y).sort() Real """ + if isinstance(other, BoolRef): + return If(other, self, 0) a, b = _coerce_exprs(self, other) return ArithRef(_mk_bin(Z3_mk_mul, a, b), self.ctx) @@ -2747,7 +2806,7 @@ class RatNumRef(ArithRef): return self.denominator().is_int() and self.denominator_as_long() == 1 def as_long(self): - _z3_assert(self.is_int(), "Expected integer fraction") + _z3_assert(self.is_int_value(), "Expected integer fraction") return self.numerator_as_long() def as_decimal(self, prec): @@ -3777,7 +3836,7 @@ def Extract(high, low, a): >>> Extract(6, 2, x).sort() BitVec(5) >>> simplify(Extract(StringVal("abcd"),2,1)) - "c" + c """ if isinstance(high, str): high = StringVal(high) @@ -4278,7 +4337,7 @@ def get_map_func(a): _z3_assert(is_map(a), "Z3 array map expression expected.") return FuncDeclRef(Z3_to_func_decl(a.ctx_ref(), Z3_get_decl_ast_parameter(a.ctx_ref(), a.decl().ast, 0)), a.ctx) -def ArraySort(d, r): +def ArraySort(*sig): """Return the Z3 array sort with the given domain and range sorts. >>> A = ArraySort(IntSort(), BoolSort()) @@ -4292,12 +4351,23 @@ def ArraySort(d, r): >>> AA Array(Int, Array(Int, Bool)) """ + sig = _get_args(sig) if __debug__: - _z3_assert(is_sort(d), "Z3 sort expected") - _z3_assert(is_sort(r), "Z3 sort expected") - _z3_assert(d.ctx == r.ctx, "Context mismatch") + _z3_assert(len(sig) > 1, "At least two arguments expected") + arity = len(sig) - 1 + r = sig[arity] + d = sig[0] + if __debug__: + for s in sig: + _z3_assert(is_sort(s), "Z3 sort expected") + _z3_assert(s.ctx == r.ctx, "Context mismatch") ctx = d.ctx - return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx) + if len(sig) == 2: + return ArraySortRef(Z3_mk_array_sort(ctx.ref(), d.ast, r.ast), ctx) + dom = (Sort * arity)() + for i in range(arity): + dom[i] = sig[i].ast + return ArraySortRef(Z3_mk_array_sort_n(ctx.ref(), arity, dom, r.ast), ctx) def Array(name, dom, rng): """Return an array constant named `name` with the given domain and range sorts. @@ -6100,6 +6170,10 @@ class ModelRef(Z3PPObject): def __deepcopy__(self): return self.translate(self.ctx) +def Model(ctx = None): + ctx = _get_ctx(ctx) + return ModelRef(Z3_mk_model(ctx.ref()), ctx) + def is_as_array(n): """Return true if n is a Z3 expression of the form (_ as-array f).""" return isinstance(n, ExprRef) and Z3_is_as_array(n.ctx.ref(), n.as_ast()) @@ -6491,8 +6565,8 @@ class Solver(Z3PPObject): >>> s.add(x > 0, x < 2) >>> s.check() sat - >>> s.model() - [x = 1] + >>> s.model().eval(x) + 1 >>> s.add(x < 1) >>> s.check() unsat @@ -6603,7 +6677,12 @@ class Solver(Z3PPObject): _handle_parse_error(e, self.ctx) def cube(self, vars = None): - """Get set of cubes""" + """Get set of cubes + The method takes an optional set of variables that restrict which + variables may be used as a starting point for cubing. + If vars is not None, then the first case split is based on a variable in + this set. + """ self.cube_vs = AstVector(None, self.ctx) if vars is not None: for v in vars: @@ -6619,19 +6698,15 @@ class Solver(Z3PPObject): return def cube_vars(self): + """Access the set of variables that were touched by the most recently generated cube. + This set of variables can be used as a starting point for additional cubes. + The idea is that variables that appear in clauses that are reduced by the most recent + cube are likely more useful to cube on.""" return self.cube_vs def proof(self): """Return a proof for the last `check()`. Proof construction must be enabled.""" return _to_expr_ref(Z3_solver_get_proof(self.ctx.ref(), self.solver), self.ctx) - - def from_file(self, filename): - """Parse assertions from a file""" - Z3_solver_from_file(self.ctx.ref(), self.solver, filename) - - def from_string(self, s): - """Parse assertions from a string""" - Z3_solver_from_string(self.ctx.ref(), self.solver, s) def assertions(self): """Return an AST vector containing all added constraints. @@ -6652,6 +6727,11 @@ class Solver(Z3PPObject): """ return AstVector(Z3_solver_get_units(self.ctx.ref(), self.solver), self.ctx) + def non_units(self): + """Return an AST vector containing all atomic formulas in solver state that are not units. + """ + return AstVector(Z3_solver_get_non_units(self.ctx.ref(), self.solver), self.ctx) + def statistics(self): """Return statistics for the last `check()`. @@ -7285,10 +7365,15 @@ class Optimize(Z3PPObject): """restore to previously created backtracking point""" Z3_optimize_pop(self.ctx.ref(), self.optimize) - def check(self): + def check(self, *assumptions): """Check satisfiability while optimizing objective functions.""" - return CheckSatResult(Z3_optimize_check(self.ctx.ref(), self.optimize)) - + assumptions = _get_args(assumptions) + num = len(assumptions) + _assumptions = (Ast * num)() + for i in range(num): + _assumptions[i] = assumptions[i].as_ast() + return CheckSatResult(Z3_optimize_check(self.ctx.ref(), self.optimize, num, _assumptions)) + def reason_unknown(self): """Return a string that describes why the last `check()` returned `unknown`.""" return Z3_optimize_get_reason_unknown(self.ctx.ref(), self.optimize) @@ -7300,6 +7385,9 @@ class Optimize(Z3PPObject): except Z3Exception: raise Z3Exception("model is not available") + def unsat_core(self): + return AstVector(Z3_optimize_get_unsat_core(self.ctx.ref(), self.optimize), self.ctx) + def lower(self, obj): if not isinstance(obj, OptimizeObjective): raise Z3Exception("Expecting objective handle returned by maximize/minimize") @@ -8040,7 +8128,7 @@ def substitute(t, *m): """ if isinstance(m, tuple): m1 = _get_args(m) - if isinstance(m1, list): + if isinstance(m1, list) and all(isinstance(p, tuple) for p in m1): m = m1 if __debug__: _z3_assert(is_expr(t), "Z3 expression expected") @@ -8293,7 +8381,7 @@ def prove(claim, **keywords): print(s.model()) def _solve_html(*args, **keywords): - """Version of funcion `solve` used in RiSE4Fun.""" + """Version of function `solve` used in RiSE4Fun.""" s = Solver() s.set(**keywords) s.add(*args) @@ -8315,7 +8403,7 @@ def _solve_html(*args, **keywords): print(s.model()) def _solve_using_html(s, *args, **keywords): - """Version of funcion `solve_using` used in RiSE4Fun.""" + """Version of function `solve_using` used in RiSE4Fun.""" if __debug__: _z3_assert(isinstance(s, Solver), "Solver object expected") s.set(**keywords) @@ -8338,7 +8426,7 @@ def _solve_using_html(s, *args, **keywords): print(s.model()) def _prove_html(claim, **keywords): - """Version of funcion `prove` used in RiSE4Fun.""" + """Version of function `prove` used in RiSE4Fun.""" if __debug__: _z3_assert(is_bool(claim), "Z3 Boolean expression expected") s = Solver() @@ -9826,6 +9914,8 @@ class SeqRef(ExprRef): def as_string(self): """Return a string representation of sequence expression.""" + if self.is_string_value(): + return Z3_get_string(self.ctx_ref(), self.as_ast()) return Z3_ast_to_string(self.ctx_ref(), self.as_ast()) @@ -9905,8 +9995,6 @@ def Strings(names, ctx=None): def Empty(s): """Create the empty sequence of the given sort >>> e = Empty(StringSort()) - >>> print(e) - "" >>> e2 = StringVal("") >>> print(e.eq(e2)) True @@ -9992,7 +10080,7 @@ def Replace(s, src, dst): """Replace the first occurrence of 'src' by 'dst' in 's' >>> r = Replace("aaa", "a", "b") >>> simplify(r) - "baa" + baa """ ctx = _get_ctx2(dst, s) if ctx is None and is_expr(src): diff --git a/src/api/python/z3/z3util.py b/src/api/python/z3/z3util.py index fe7e76b86..6e5165c9a 100644 --- a/src/api/python/z3/z3util.py +++ b/src/api/python/z3/z3util.py @@ -199,7 +199,7 @@ def prove(claim,assume=None,verbose=0): >>> r,m = prove(True,assume=And(x,Not(x)),verbose=0) Traceback (most recent call last): ... - AssertionError: Assumption is alway False! + AssertionError: Assumption is always False! >>> r,m = prove(Implies(x,x),assume=y,verbose=2); r,model_str(m,as_str=False) assume: @@ -238,7 +238,7 @@ def prove(claim,assume=None,verbose=0): is_proved,_ = prove(Not(assume)) def _f(): - emsg = "Assumption is alway False!" + emsg = "Assumption is always False!" if verbose >= 2: emsg = "{}\n{}".format(assume,emsg) return emsg diff --git a/src/api/z3_algebraic.h b/src/api/z3_algebraic.h index 49c61afef..1ebc1ad8f 100644 --- a/src/api/z3_algebraic.h +++ b/src/api/z3_algebraic.h @@ -31,39 +31,39 @@ extern "C" { /** @name Algebraic Numbers */ /*@{*/ /** - \brief Return Z3_TRUE if \c a can be used as value in the Z3 real algebraic + \brief Return \c true if \c a can be used as value in the Z3 real algebraic number package. def_API('Z3_algebraic_is_value', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_algebraic_is_value(Z3_context c, Z3_ast a); + bool Z3_API Z3_algebraic_is_value(Z3_context c, Z3_ast a); /** - \brief Return the Z3_TRUE if \c a is positive, and Z3_FALSE otherwise. + \brief Return \c true if \c a is positive, and \c false otherwise. \pre Z3_algebraic_is_value(c, a) def_API('Z3_algebraic_is_pos', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_algebraic_is_pos(Z3_context c, Z3_ast a); + bool Z3_API Z3_algebraic_is_pos(Z3_context c, Z3_ast a); /** - \brief Return the Z3_TRUE if \c a is negative, and Z3_FALSE otherwise. + \brief Return \c true if \c a is negative, and \c false otherwise. \pre Z3_algebraic_is_value(c, a) def_API('Z3_algebraic_is_neg', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_algebraic_is_neg(Z3_context c, Z3_ast a); + bool Z3_API Z3_algebraic_is_neg(Z3_context c, Z3_ast a); /** - \brief Return the Z3_TRUE if \c a is zero, and Z3_FALSE otherwise. + \brief Return \c true if \c a is zero, and \c false otherwise. \pre Z3_algebraic_is_value(c, a) def_API('Z3_algebraic_is_zero', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_algebraic_is_zero(Z3_context c, Z3_ast a); + bool Z3_API Z3_algebraic_is_zero(Z3_context c, Z3_ast a); /** \brief Return 1 if \c a is positive, 0 if \c a is zero, and -1 if \c a is negative. @@ -141,64 +141,64 @@ extern "C" { Z3_ast Z3_API Z3_algebraic_power(Z3_context c, Z3_ast a, unsigned k); /** - \brief Return Z3_TRUE if a < b, and Z3_FALSE otherwise. + \brief Return \c true if a < b, and \c false otherwise. \pre Z3_algebraic_is_value(c, a) \pre Z3_algebraic_is_value(c, b) def_API('Z3_algebraic_lt', BOOL, (_in(CONTEXT), _in(AST), _in(AST))) */ - Z3_bool Z3_API Z3_algebraic_lt(Z3_context c, Z3_ast a, Z3_ast b); + bool Z3_API Z3_algebraic_lt(Z3_context c, Z3_ast a, Z3_ast b); /** - \brief Return Z3_TRUE if a > b, and Z3_FALSE otherwise. + \brief Return \c true if a > b, and \c false otherwise. \pre Z3_algebraic_is_value(c, a) \pre Z3_algebraic_is_value(c, b) def_API('Z3_algebraic_gt', BOOL, (_in(CONTEXT), _in(AST), _in(AST))) */ - Z3_bool Z3_API Z3_algebraic_gt(Z3_context c, Z3_ast a, Z3_ast b); + bool Z3_API Z3_algebraic_gt(Z3_context c, Z3_ast a, Z3_ast b); /** - \brief Return Z3_TRUE if a <= b, and Z3_FALSE otherwise. + \brief Return \c true if a <= b, and \c false otherwise. \pre Z3_algebraic_is_value(c, a) \pre Z3_algebraic_is_value(c, b) def_API('Z3_algebraic_le', BOOL, (_in(CONTEXT), _in(AST), _in(AST))) */ - Z3_bool Z3_API Z3_algebraic_le(Z3_context c, Z3_ast a, Z3_ast b); + bool Z3_API Z3_algebraic_le(Z3_context c, Z3_ast a, Z3_ast b); /** - \brief Return Z3_TRUE if a >= b, and Z3_FALSE otherwise. + \brief Return \c true if a >= b, and \c false otherwise. \pre Z3_algebraic_is_value(c, a) \pre Z3_algebraic_is_value(c, b) def_API('Z3_algebraic_ge', BOOL, (_in(CONTEXT), _in(AST), _in(AST))) */ - Z3_bool Z3_API Z3_algebraic_ge(Z3_context c, Z3_ast a, Z3_ast b); + bool Z3_API Z3_algebraic_ge(Z3_context c, Z3_ast a, Z3_ast b); /** - \brief Return Z3_TRUE if a == b, and Z3_FALSE otherwise. + \brief Return \c true if a == b, and \c false otherwise. \pre Z3_algebraic_is_value(c, a) \pre Z3_algebraic_is_value(c, b) def_API('Z3_algebraic_eq', BOOL, (_in(CONTEXT), _in(AST), _in(AST))) */ - Z3_bool Z3_API Z3_algebraic_eq(Z3_context c, Z3_ast a, Z3_ast b); + bool Z3_API Z3_algebraic_eq(Z3_context c, Z3_ast a, Z3_ast b); /** - \brief Return Z3_TRUE if a != b, and Z3_FALSE otherwise. + \brief Return \c true if a != b, and \c false otherwise. \pre Z3_algebraic_is_value(c, a) \pre Z3_algebraic_is_value(c, b) def_API('Z3_algebraic_neq', BOOL, (_in(CONTEXT), _in(AST), _in(AST))) */ - Z3_bool Z3_API Z3_algebraic_neq(Z3_context c, Z3_ast a, Z3_ast b); + bool Z3_API Z3_algebraic_neq(Z3_context c, Z3_ast a, Z3_ast b); /** \brief Given a multivariate polynomial p(x_0, ..., x_{n-1}, x_n), returns the diff --git a/src/api/z3_api.h b/src/api/z3_api.h index 2657e558d..5ee7fcb99 100644 --- a/src/api/z3_api.h +++ b/src/api/z3_api.h @@ -1435,7 +1435,7 @@ extern "C" { /** \brief Get a global (or module) parameter. - Returns \c Z3_FALSE if the parameter value does not exist. + Returns \c false if the parameter value does not exist. \sa Z3_global_param_set @@ -1515,19 +1515,19 @@ extern "C" { although some parameters can be changed using #Z3_update_param_value. All main interaction with Z3 happens in the context of a \c Z3_context. - In contrast to #Z3_mk_context_rc, the life time of Z3_ast objects + In contrast to #Z3_mk_context_rc, the life time of \c Z3_ast objects are determined by the scope level of #Z3_solver_push and #Z3_solver_pop. - In other words, a Z3_ast object remains valid until there is a - call to Z3_solver_pop that takes the current scope below the level where + In other words, a \c Z3_ast object remains valid until there is a + call to #Z3_solver_pop that takes the current scope below the level where the object was created. - Note that all other reference counted objects, including Z3_model, - Z3_solver, Z3_func_interp have to be managed by the caller. + Note that all other reference counted objects, including \c Z3_model, + \c Z3_solver, \c Z3_func_interp have to be managed by the caller. Their reference counts are not handled by the context. Further remarks: - - Z3_sort, Z3_func_decl, Z3_app, Z3_pattern are Z3_ast's. - - Z3 uses hash-consing, i.e., when the same Z3_ast is created twice, + - \c Z3_sort, \c Z3_func_decl, \c Z3_app, \c Z3_pattern are \c Z3_ast's. + - Z3 uses hash-consing, i.e., when the same \c Z3_ast is created twice, Z3 will return the same pointer twice. \sa Z3_del_context @@ -1540,20 +1540,20 @@ extern "C" { \brief Create a context using the given configuration. This function is similar to #Z3_mk_context. However, in the context returned by this function, the user - is responsible for managing Z3_ast reference counters. + is responsible for managing \c Z3_ast reference counters. Managing reference counters is a burden and error-prone, but allows the user to use the memory more efficiently. - The user must invoke #Z3_inc_ref for any Z3_ast returned - by Z3, and #Z3_dec_ref whenever the Z3_ast is not needed + The user must invoke #Z3_inc_ref for any \c Z3_ast returned + by Z3, and #Z3_dec_ref whenever the \c Z3_ast is not needed anymore. This idiom is similar to the one used in BDD (binary decision diagrams) packages such as CUDD. Remarks: - - Z3_sort, Z3_func_decl, Z3_app, Z3_pattern are Z3_ast's. + - \c Z3_sort, \c Z3_func_decl, \c Z3_app, \c Z3_pattern are \c Z3_ast's. - After a context is created, the configuration cannot be changed. - All main interaction with Z3 happens in the context of a \c Z3_context. - - Z3 uses hash-consing, i.e., when the same Z3_ast is created twice, + - Z3 uses hash-consing, i.e., when the same \c Z3_ast is created twice, Z3 will return the same pointer twice. def_API('Z3_mk_context_rc', CONTEXT, (_in(CONFIG),)) @@ -1615,7 +1615,7 @@ extern "C" { Starting at Z3 4.0, parameter sets are used to configure many components such as: simplifiers, tactics, solvers, etc. - \remark Reference counting must be used to manage parameter sets, even when the Z3_context was + \remark Reference counting must be used to manage parameter sets, even when the \c Z3_context was created using #Z3_mk_context instead of #Z3_mk_context_rc. def_API('Z3_mk_params', PARAMS, (_in(CONTEXT),)) @@ -1641,7 +1641,7 @@ extern "C" { def_API('Z3_params_set_bool', VOID, (_in(CONTEXT), _in(PARAMS), _in(SYMBOL), _in(BOOL))) */ - void Z3_API Z3_params_set_bool(Z3_context c, Z3_params p, Z3_symbol k, Z3_bool v); + void Z3_API Z3_params_set_bool(Z3_context c, Z3_params p, Z3_symbol k, bool v); /** \brief Add a unsigned parameter \c k with value \c v to the parameter set \c p. @@ -1715,7 +1715,7 @@ extern "C" { unsigned Z3_API Z3_param_descrs_size(Z3_context c, Z3_param_descrs p); /** - \brief Return the number of parameters in the given parameter description set. + \brief Return the name of the parameter at given index \c i. \pre i < Z3_param_descrs_size(c, p) @@ -1751,6 +1751,7 @@ extern "C" { NB. Not all integers can be passed to this function. The legal range of unsigned integers is 0 to 2^30-1. + \sa Z3_get_symbol_int \sa Z3_mk_string_symbol def_API('Z3_mk_int_symbol', SYMBOL, (_in(CONTEXT), _in(INT))) @@ -1762,6 +1763,7 @@ extern "C" { Symbols are used to name several term and type constructors. + \sa Z3_get_symbol_string \sa Z3_mk_int_symbol def_API('Z3_mk_string_symbol', SYMBOL, (_in(CONTEXT), _in(STRING))) @@ -2081,6 +2083,7 @@ extern "C" { Z3_sort range); + /** \brief Create a constant or function application. @@ -2140,6 +2143,48 @@ extern "C" { def_API('Z3_mk_fresh_const', AST, (_in(CONTEXT), _in(STRING), _in(SORT))) */ Z3_ast Z3_API Z3_mk_fresh_const(Z3_context c, Z3_string prefix, Z3_sort ty); + + + /** + \brief Declare a recursive function + + \param c logical context. + \param s name of the function. + \param domain_size number of arguments. It should be greater than 0. + \param domain array containing the sort of each argument. The array must contain domain_size elements. + \param range sort of the constant or the return sort of the function. + + After declaring recursive function, it should be associated with a recursive definition #Z3_add_rec_def. + The function #Z3_mk_app can be used to create a constant or function + application. + + \sa Z3_mk_app + \sa Z3_add_rec_def + + def_API('Z3_mk_rec_func_decl', FUNC_DECL, (_in(CONTEXT), _in(SYMBOL), _in(UINT), _in_array(2, SORT), _in(SORT))) + */ + Z3_func_decl Z3_API Z3_mk_rec_func_decl(Z3_context c, Z3_symbol s, + unsigned domain_size, Z3_sort const domain[], + Z3_sort range); + + /** + \brief Define the body of a recursive function. + + \param c logical context. + \param f function declaration. + \param n number of arguments to the function + \param args constants that are used as arguments to the recursive function in the definition. + \param body body of the recursive function + + After declaring a recursive function or a collection of mutually recursive functions, use + this function to provide the definition for the recursive function. + + \sa Z3_mk_rec_func_decl + + def_API('Z3_add_rec_def', VOID, (_in(CONTEXT), _in(FUNC_DECL), _in(UINT), _in_array(2, AST), _in(AST))) + */ + void Z3_API Z3_add_rec_def(Z3_context c, Z3_func_decl f, unsigned n, Z3_ast args[], Z3_ast body); + /*@}*/ /** @name Propositional Logic and Equality */ @@ -2850,7 +2895,7 @@ extern "C" { def_API('Z3_mk_bv2int', AST, (_in(CONTEXT), _in(AST), _in(BOOL))) */ - Z3_ast Z3_API Z3_mk_bv2int(Z3_context c,Z3_ast t1, Z3_bool is_signed); + Z3_ast Z3_API Z3_mk_bv2int(Z3_context c,Z3_ast t1, bool is_signed); /** \brief Create a predicate that checks that the bit-wise addition @@ -2860,7 +2905,7 @@ extern "C" { def_API('Z3_mk_bvadd_no_overflow', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(BOOL))) */ - Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_bool is_signed); + Z3_ast Z3_API Z3_mk_bvadd_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed); /** \brief Create a predicate that checks that the bit-wise signed addition @@ -2890,7 +2935,7 @@ extern "C" { def_API('Z3_mk_bvsub_no_underflow', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(BOOL))) */ - Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_bool is_signed); + Z3_ast Z3_API Z3_mk_bvsub_no_underflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed); /** \brief Create a predicate that checks that the bit-wise signed division @@ -2920,7 +2965,7 @@ extern "C" { def_API('Z3_mk_bvmul_no_overflow', AST, (_in(CONTEXT), _in(AST), _in(AST), _in(BOOL))) */ - Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, Z3_bool is_signed); + Z3_ast Z3_API Z3_mk_bvmul_no_overflow(Z3_context c, Z3_ast t1, Z3_ast t2, bool is_signed); /** \brief Create a predicate that checks that the bit-wise signed multiplication @@ -3224,7 +3269,7 @@ extern "C" { \sa Z3_mk_numeral def_API('Z3_mk_bv_numeral', AST, (_in(CONTEXT), _in(UINT), _in_array(1, BOOL))) */ - Z3_ast Z3_API Z3_mk_bv_numeral(Z3_context c, unsigned sz, Z3_bool const* bits); + Z3_ast Z3_API Z3_mk_bv_numeral(Z3_context c, unsigned sz, bool const* bits); /*@}*/ @@ -3243,7 +3288,7 @@ extern "C" { def_API('Z3_is_seq_sort', BOOL, (_in(CONTEXT), _in(SORT))) */ - Z3_bool Z3_API Z3_is_seq_sort(Z3_context c, Z3_sort s); + bool Z3_API Z3_is_seq_sort(Z3_context c, Z3_sort s); /** \brief Create a regular expression sort out of a sequence sort. @@ -3257,7 +3302,7 @@ extern "C" { def_API('Z3_is_re_sort', BOOL, (_in(CONTEXT), _in(SORT))) */ - Z3_bool Z3_API Z3_is_re_sort(Z3_context c, Z3_sort s); + bool Z3_API Z3_is_re_sort(Z3_context c, Z3_sort s); /** \brief Create a sort for 8 bit strings. @@ -3274,7 +3319,7 @@ extern "C" { def_API('Z3_is_string_sort', BOOL, (_in(CONTEXT), _in(SORT))) */ - Z3_bool Z3_API Z3_is_string_sort(Z3_context c, Z3_sort s); + bool Z3_API Z3_is_string_sort(Z3_context c, Z3_sort s); /** \brief Create a string constant out of the string that is passed in @@ -3287,7 +3332,7 @@ extern "C" { def_API('Z3_is_string', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_is_string(Z3_context c, Z3_ast s); + bool Z3_API Z3_is_string(Z3_context c, Z3_ast s); /** \brief Retrieve the string constant stored in \c s. @@ -3636,7 +3681,7 @@ extern "C" { */ Z3_ast Z3_API Z3_mk_quantifier( Z3_context c, - Z3_bool is_forall, + bool is_forall, unsigned weight, unsigned num_patterns, Z3_pattern const patterns[], unsigned num_decls, Z3_sort const sorts[], @@ -3670,7 +3715,7 @@ extern "C" { */ Z3_ast Z3_API Z3_mk_quantifier_ex( Z3_context c, - Z3_bool is_forall, + bool is_forall, unsigned weight, Z3_symbol quantifier_id, Z3_symbol skolem_id, @@ -3746,7 +3791,7 @@ extern "C" { */ Z3_ast Z3_API Z3_mk_quantifier_const( Z3_context c, - Z3_bool is_forall, + bool is_forall, unsigned weight, unsigned num_bound, Z3_app const bound[], unsigned num_patterns, Z3_pattern const patterns[], @@ -3761,7 +3806,7 @@ extern "C" { */ Z3_ast Z3_API Z3_mk_quantifier_const_ex( Z3_context c, - Z3_bool is_forall, + bool is_forall, unsigned weight, Z3_symbol quantifier_id, Z3_symbol skolem_id, @@ -3772,7 +3817,7 @@ extern "C" { ); /** - \brief Create a lambda expression. It taks an expression \c body that contains bound variables + \brief Create a lambda expression. It takes an expression \c body that contains bound variables of the same sorts as the sorts listed in the array \c sorts. The bound variables are de-Bruijn indices created using #Z3_mk_bound. The array \c decl_names contains the names that the quantified formula uses for the bound variables. Z3 applies the convention that the last element in the \c decl_names and \c sorts array @@ -3846,7 +3891,7 @@ extern "C" { /** \brief Return the symbol name. - \pre Z3_get_symbol_string(s) == Z3_STRING_SYMBOL + \pre Z3_get_symbol_kind(s) == Z3_STRING_SYMBOL \warning The returned buffer is statically allocated by Z3. It will be automatically deallocated when #Z3_del_context is invoked. @@ -3884,7 +3929,7 @@ extern "C" { def_API('Z3_is_eq_sort', BOOL, (_in(CONTEXT), _in(SORT), _in(SORT))) */ - Z3_bool Z3_API Z3_is_eq_sort(Z3_context c, Z3_sort s1, Z3_sort s2); + bool Z3_API Z3_is_eq_sort(Z3_context c, Z3_sort s1, Z3_sort s2); /** \brief Return the sort kind (e.g., array, tuple, int, bool, etc). @@ -3908,7 +3953,7 @@ extern "C" { unsigned Z3_API Z3_get_bv_sort_size(Z3_context c, Z3_sort t); /** - \brief Store the size of the sort in \c r. Return Z3_FALSE if the call failed. + \brief Store the size of the sort in \c r. Return \c false if the call failed. That is, Z3_get_sort_kind(s) == Z3_FINITE_DOMAIN_SORT def_API('Z3_get_finite_domain_sort_size', BOOL, (_in(CONTEXT), _in(SORT), _out(UINT64))) @@ -4049,7 +4094,7 @@ extern "C" { The remaining fields are left unchanged. It is the record equivalent of an array store (see \sa Z3_mk_store). If the datatype has more than one constructor, then the update function - behaves as identity if there is a miss-match between the accessor and + behaves as identity if there is a mismatch between the accessor and constructor. For example ((_ update-field car) nil 1) is nil, while ((_ update-field car) (cons 2 nil) 1) is (cons 1 nil). @@ -4151,7 +4196,7 @@ extern "C" { def_API('Z3_is_eq_func_decl', BOOL, (_in(CONTEXT), _in(FUNC_DECL), _in(FUNC_DECL))) */ - Z3_bool Z3_API Z3_is_eq_func_decl(Z3_context c, Z3_func_decl f1, Z3_func_decl f2); + bool Z3_API Z3_is_eq_func_decl(Z3_context c, Z3_func_decl f1, Z3_func_decl f2); /** \brief Return a unique identifier for \c f. @@ -4330,7 +4375,7 @@ extern "C" { def_API('Z3_is_eq_ast', BOOL, (_in(CONTEXT), _in(AST), _in(AST))) */ - Z3_bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast t1, Z3_ast t2); + bool Z3_API Z3_is_eq_ast(Z3_context c, Z3_ast t1, Z3_ast t2); /** \brief Return a unique identifier for \c t. @@ -4368,10 +4413,10 @@ extern "C" { def_API('Z3_is_well_sorted', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_is_well_sorted(Z3_context c, Z3_ast t); + bool Z3_API Z3_is_well_sorted(Z3_context c, Z3_ast t); /** - \brief Return Z3_L_TRUE if \c a is true, Z3_L_FALSE if it is false, and Z3_L_UNDEF otherwise. + \brief Return \c Z3_L_TRUE if \c a is true, \c Z3_L_FALSE if it is false, and \c Z3_L_UNDEF otherwise. def_API('Z3_get_bool_value', INT, (_in(CONTEXT), _in(AST))) */ @@ -4387,19 +4432,19 @@ extern "C" { /** def_API('Z3_is_app', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_is_app(Z3_context c, Z3_ast a); + bool Z3_API Z3_is_app(Z3_context c, Z3_ast a); /** def_API('Z3_is_numeral_ast', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a); + bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a); /** \brief Return true if the given AST is a real algebraic number. def_API('Z3_is_algebraic_number', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a); + bool Z3_API Z3_is_algebraic_number(Z3_context c, Z3_ast a); /** \brief Convert an \c ast into an \c APP_AST. This is just type casting. @@ -4438,6 +4483,15 @@ extern "C" { */ Z3_string Z3_API Z3_get_numeral_decimal_string(Z3_context c, Z3_ast a, unsigned precision); + /** + \brief Return numeral as a double. + + \pre Z3_get_ast_kind(c, a) == Z3_NUMERAL_AST || Z3_is_algebraic_number(c, a) + + def_API('Z3_get_numeral_double', DOUBLE, (_in(CONTEXT), _in(AST))) + */ + double Z3_API Z3_get_numeral_double(Z3_context c, Z3_ast a); + /** \brief Return the numerator (as a numeral AST) of a numeral AST of sort Real. @@ -4464,17 +4518,17 @@ extern "C" { \param num numerator. \param den denominator. - Return \c Z3_TRUE if the numeral value fits in 64 bit numerals, \c Z3_FALSE otherwise. + Return \c true if the numeral value fits in 64 bit numerals, \c false otherwise. \pre Z3_get_ast_kind(a) == Z3_NUMERAL_AST def_API('Z3_get_numeral_small', BOOL, (_in(CONTEXT), _in(AST), _out(INT64), _out(INT64))) */ - Z3_bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, int64_t* num, int64_t* den); + bool Z3_API Z3_get_numeral_small(Z3_context c, Z3_ast a, int64_t* num, int64_t* den); /** \brief Similar to #Z3_get_numeral_string, but only succeeds if - the value can fit in a machine int. Return Z3_TRUE if the call succeeded. + the value can fit in a machine int. Return \c true if the call succeeded. \pre Z3_get_ast_kind(c, v) == Z3_NUMERAL_AST @@ -4482,11 +4536,11 @@ extern "C" { def_API('Z3_get_numeral_int', BOOL, (_in(CONTEXT), _in(AST), _out(INT))) */ - Z3_bool Z3_API Z3_get_numeral_int(Z3_context c, Z3_ast v, int* i); + bool Z3_API Z3_get_numeral_int(Z3_context c, Z3_ast v, int* i); /** \brief Similar to #Z3_get_numeral_string, but only succeeds if - the value can fit in a machine unsigned int. Return Z3_TRUE if the call succeeded. + the value can fit in a machine unsigned int. Return \c true if the call succeeded. \pre Z3_get_ast_kind(c, v) == Z3_NUMERAL_AST @@ -4494,11 +4548,11 @@ extern "C" { def_API('Z3_get_numeral_uint', BOOL, (_in(CONTEXT), _in(AST), _out(UINT))) */ - Z3_bool Z3_API Z3_get_numeral_uint(Z3_context c, Z3_ast v, unsigned* u); + bool Z3_API Z3_get_numeral_uint(Z3_context c, Z3_ast v, unsigned* u); /** \brief Similar to #Z3_get_numeral_string, but only succeeds if - the value can fit in a machine \c uint64_t int. Return Z3_TRUE if the call succeeded. + the value can fit in a machine \c uint64_t int. Return \c true if the call succeeded. \pre Z3_get_ast_kind(c, v) == Z3_NUMERAL_AST @@ -4506,11 +4560,11 @@ extern "C" { def_API('Z3_get_numeral_uint64', BOOL, (_in(CONTEXT), _in(AST), _out(UINT64))) */ - Z3_bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, uint64_t* u); + bool Z3_API Z3_get_numeral_uint64(Z3_context c, Z3_ast v, uint64_t* u); /** \brief Similar to #Z3_get_numeral_string, but only succeeds if - the value can fit in a machine \c int64_t int. Return Z3_TRUE if the call succeeded. + the value can fit in a machine \c int64_t int. Return \c true if the call succeeded. \pre Z3_get_ast_kind(c, v) == Z3_NUMERAL_AST @@ -4518,11 +4572,11 @@ extern "C" { def_API('Z3_get_numeral_int64', BOOL, (_in(CONTEXT), _in(AST), _out(INT64))) */ - Z3_bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, int64_t* i); + bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, int64_t* i); /** \brief Similar to #Z3_get_numeral_string, but only succeeds if - the value can fit as a rational number as machine \c int64_t int. Return Z3_TRUE if the call succeeded. + the value can fit as a rational number as machine \c int64_t int. Return \c true if the call succeeded. \pre Z3_get_ast_kind(c, v) == Z3_NUMERAL_AST @@ -4530,7 +4584,7 @@ extern "C" { def_API('Z3_get_numeral_rational_int64', BOOL, (_in(CONTEXT), _in(AST), _out(INT64), _out(INT64))) */ - Z3_bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, int64_t* num, int64_t* den); + bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, int64_t* num, int64_t* den); /** \brief Return a lower bound for the given real algebraic number. @@ -4589,7 +4643,7 @@ extern "C" { def_API('Z3_is_quantifier_forall', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a); + bool Z3_API Z3_is_quantifier_forall(Z3_context c, Z3_ast a); /** \brief Determine if ast is an existential quantifier. @@ -4597,16 +4651,16 @@ extern "C" { def_API('Z3_is_quantifier_exists', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a); + bool Z3_API Z3_is_quantifier_exists(Z3_context c, Z3_ast a); /** - \brief Determine if ast is a lambda expresion. + \brief Determine if ast is a lambda expression. \pre Z3_get_ast_kind(a) == Z3_QUANTIFIER_AST def_API('Z3_is_lambda', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_is_lambda(Z3_context c, Z3_ast a); + bool Z3_API Z3_is_lambda(Z3_context c, Z3_ast a); /** \brief Obtain weight of quantifier. @@ -4697,6 +4751,8 @@ extern "C" { The returned AST is simplified using algebraic simplification rules, such as constant propagation (propagating true/false over logical connectives). + \sa Z3_simplify_ex + def_API('Z3_simplify', AST, (_in(CONTEXT), _in(AST))) */ Z3_ast Z3_API Z3_simplify(Z3_context c, Z3_ast a); @@ -4708,6 +4764,10 @@ extern "C" { This procedure is similar to #Z3_simplify, but the behavior of the simplifier can be configured using the given parameter set. + \sa Z3_simplify + \sa Z3_simplify_get_help + \sa Z3_simplify_get_param_descrs + def_API('Z3_simplify_ex', AST, (_in(CONTEXT), _in(AST), _in(PARAMS))) */ Z3_ast Z3_API Z3_simplify_ex(Z3_context c, Z3_ast a, Z3_params p); @@ -4715,6 +4775,9 @@ extern "C" { /** \brief Return a string describing all available parameters. + \sa Z3_simplify_ex + \sa Z3_simplify_get_param_descrs + def_API('Z3_simplify_get_help', STRING, (_in(CONTEXT),)) */ Z3_string Z3_API Z3_simplify_get_help(Z3_context c); @@ -4722,6 +4785,9 @@ extern "C" { /** \brief Return the parameter description set for the simplify procedure. + \sa Z3_simplify_ex + \sa Z3_simplify_get_help + def_API('Z3_simplify_get_param_descrs', PARAM_DESCRS, (_in(CONTEXT),)) */ Z3_param_descrs Z3_API Z3_simplify_get_param_descrs(Z3_context c); @@ -4799,12 +4865,12 @@ extern "C" { /** \brief Evaluate the AST node \c t in the given model. - Return \c Z3_TRUE if succeeded, and store the result in \c v. + Return \c true if succeeded, and store the result in \c v. - If \c model_completion is Z3_TRUE, then Z3 will assign an interpretation for any constant or function that does + If \c model_completion is \c true, then Z3 will assign an interpretation for any constant or function that does not have an interpretation in \c m. These constants and functions were essentially don't cares. - If \c model_completion is Z3_FALSE, then Z3 will not assign interpretations to constants for functions that do + If \c model_completion is \c false, then Z3 will not assign interpretations to constants for functions that do not have interpretations in \c m. Evaluation behaves as the identify function in this case. The evaluation may fail for the following reasons: @@ -4820,7 +4886,7 @@ extern "C" { def_API('Z3_model_eval', BOOL, (_in(CONTEXT), _in(MODEL), _in(AST), _in(BOOL), _out(AST))) */ - Z3_bool_opt Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, Z3_bool model_completion, Z3_ast * v); + Z3_bool_opt Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, bool model_completion, Z3_ast * v); /** \brief Return the interpretation (i.e., assignment) of constant \c a in the model \c m. @@ -4838,7 +4904,7 @@ extern "C" { def_API('Z3_model_has_interp', BOOL, (_in(CONTEXT), _in(MODEL), _in(FUNC_DECL))) */ - Z3_bool Z3_API Z3_model_has_interp(Z3_context c, Z3_model m, Z3_func_decl a); + bool Z3_API Z3_model_has_interp(Z3_context c, Z3_model m, Z3_func_decl a); /** \brief Return the interpretation of the function \c f in the model \c m. @@ -4932,7 +4998,7 @@ extern "C" { Z3_ast_vector Z3_API Z3_model_get_sort_universe(Z3_context c, Z3_model m, Z3_sort s); /** - \brief translate model from context c to context \c dst. + \brief translate model from context \c c to context \c dst. def_API('Z3_model_translate', MODEL, (_in(CONTEXT), _in(MODEL), _in(CONTEXT))) */ @@ -4941,7 +5007,7 @@ extern "C" { /** \brief The \ccode{(_ as-array f)} AST node is a construct for assigning interpretations for arrays in Z3. It is the array such that forall indices \c i we have that \ccode{(select (_ as-array f) i)} is equal to \ccode{(f i)}. - This procedure returns Z3_TRUE if the \c a is an \c as-array AST node. + This procedure returns \c true if the \c a is an \c as-array AST node. Z3 current solvers have minimal support for \c as_array nodes. @@ -4949,7 +5015,7 @@ extern "C" { def_API('Z3_is_as_array', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a); + bool Z3_API Z3_is_as_array(Z3_context c, Z3_ast a); /** \brief Return the function declaration \c f associated with a \ccode{(_ as_array f)} node. @@ -5114,7 +5180,7 @@ extern "C" { extra_API('Z3_open_log', INT, (_in(STRING),)) */ - Z3_bool Z3_API Z3_open_log(Z3_string filename); + bool Z3_API Z3_open_log(Z3_string filename); /** \brief Append user-defined string to interaction log. @@ -5142,7 +5208,7 @@ extern "C" { def_API('Z3_toggle_warning_messages', VOID, (_in(BOOL),)) */ - void Z3_API Z3_toggle_warning_messages(Z3_bool enabled); + void Z3_API Z3_toggle_warning_messages(bool enabled); /*@}*/ /** @name String conversion */ @@ -5403,7 +5469,7 @@ extern "C" { def_API('Z3_mk_goal', GOAL, (_in(CONTEXT), _in(BOOL), _in(BOOL), _in(BOOL))) */ - Z3_goal Z3_API Z3_mk_goal(Z3_context c, Z3_bool models, Z3_bool unsat_cores, Z3_bool proofs); + Z3_goal Z3_API Z3_mk_goal(Z3_context c, bool models, bool unsat_cores, bool proofs); /** \brief Increment the reference counter of the given goal. @@ -5447,7 +5513,7 @@ extern "C" { def_API('Z3_goal_inconsistent', BOOL, (_in(CONTEXT), _in(GOAL))) */ - Z3_bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g); + bool Z3_API Z3_goal_inconsistent(Z3_context c, Z3_goal g); /** \brief Return the depth of the given goal. It tracks how many transformations were applied to it. @@ -5491,14 +5557,14 @@ extern "C" { def_API('Z3_goal_is_decided_sat', BOOL, (_in(CONTEXT), _in(GOAL))) */ - Z3_bool Z3_API Z3_goal_is_decided_sat(Z3_context c, Z3_goal g); + bool Z3_API Z3_goal_is_decided_sat(Z3_context c, Z3_goal g); /** \brief Return true if the goal contains false, and it is precise or the product of an over approximation. def_API('Z3_goal_is_decided_unsat', BOOL, (_in(CONTEXT), _in(GOAL))) */ - Z3_bool Z3_API Z3_goal_is_decided_unsat(Z3_context c, Z3_goal g); + bool Z3_API Z3_goal_is_decided_unsat(Z3_context c, Z3_goal g); /** \brief Copy a goal \c g from the context \c source to the context \c target. @@ -5527,7 +5593,7 @@ extern "C" { \brief Convert a goal into a DIMACS formatted string. The goal must be in CNF. You can convert a goal to CNF by applying the tseitin-cnf tactic. Bit-vectors are not automatically - converted to Booleans either, so the caller intends to + converted to Booleans either, so if the caller intends to preserve satisfiability, it should apply bit-blasting tactics. Quantifiers and theory atoms will not be encoded. @@ -5898,9 +5964,9 @@ extern "C" { on how it is used and how its parameters are set. If the solver is used in a non incremental way (i.e. no calls to - `Z3_solver_push()` or `Z3_solver_pop()`, and no calls to - `Z3_solver_assert()` or `Z3_solver_assert_and_track()` after checking - satisfiability without an intervening `Z3_solver_reset()`) then solver1 + #Z3_solver_push() or #Z3_solver_pop(), and no calls to + #Z3_solver_assert() or #Z3_solver_assert_and_track() after checking + satisfiability without an intervening #Z3_solver_reset()) then solver1 will be used. This solver will apply Z3's "default" tactic. The "default" tactic will attempt to probe the logic used by the @@ -5934,13 +6000,13 @@ extern "C" { This is equivalent to applying the "smt" tactic. - Unlike `Z3_mk_solver()` this solver + Unlike #Z3_mk_solver() this solver - Does not attempt to apply any logic specific tactics. - Does not change its behaviour based on whether it used incrementally/non-incrementally. Note that these differences can result in very different performance - compared to `Z3_mk_solver()`. + compared to #Z3_mk_solver(). The function #Z3_solver_get_model retrieves a model if the assertions is satisfiable (i.e., the result is \c @@ -5987,7 +6053,7 @@ extern "C" { Z3_solver Z3_API Z3_solver_translate(Z3_context source, Z3_solver s, Z3_context target); /** - \brief Ad-hoc method for importing model convertion from solver. + \brief Ad-hoc method for importing model conversion from solver. def_API('Z3_solver_import_model_converter', VOID, (_in(CONTEXT), _in(SOLVER), _in(SOLVER))) */ @@ -5996,6 +6062,9 @@ extern "C" { /** \brief Return a string describing all solver available parameters. + \sa Z3_solver_get_param_descrs + \sa Z3_solver_set_params + def_API('Z3_solver_get_help', STRING, (_in(CONTEXT), _in(SOLVER))) */ Z3_string Z3_API Z3_solver_get_help(Z3_context c, Z3_solver s); @@ -6003,6 +6072,9 @@ extern "C" { /** \brief Return the parameter description set for the given solver object. + \sa Z3_solver_get_help + \sa Z3_solver_set_params + def_API('Z3_solver_get_param_descrs', PARAM_DESCRS, (_in(CONTEXT), _in(SOLVER))) */ Z3_param_descrs Z3_API Z3_solver_get_param_descrs(Z3_context c, Z3_solver s); @@ -6010,6 +6082,9 @@ extern "C" { /** \brief Set the given solver using the given parameters. + \sa Z3_solver_get_help + \sa Z3_solver_get_param_descrs + def_API('Z3_solver_set_params', VOID, (_in(CONTEXT), _in(SOLVER), _in(PARAMS))) */ void Z3_API Z3_solver_set_params(Z3_context c, Z3_solver s, Z3_params p); @@ -6033,6 +6108,7 @@ extern "C" { The solver contains a stack of assertions. + \sa Z3_solver_get_num_scopes \sa Z3_solver_pop def_API('Z3_solver_push', VOID, (_in(CONTEXT), _in(SOLVER))) @@ -6042,6 +6118,7 @@ extern "C" { /** \brief Backtrack \c n backtracking points. + \sa Z3_solver_get_num_scopes \sa Z3_solver_push \pre n <= Z3_solver_get_num_scopes(c, s) @@ -6053,6 +6130,9 @@ extern "C" { /** \brief Remove all assertions from the solver. + \sa Z3_solver_assert + \sa Z3_solver_assert_and_track + def_API('Z3_solver_reset', VOID, (_in(CONTEXT), _in(SOLVER))) */ void Z3_API Z3_solver_reset(Z3_context c, Z3_solver s); @@ -6073,6 +6153,9 @@ extern "C" { The functions #Z3_solver_check and #Z3_solver_check_assumptions should be used to check whether the logical context is consistent or not. + \sa Z3_solver_assert_and_track + \sa Z3_solver_reset + def_API('Z3_solver_assert', VOID, (_in(CONTEXT), _in(SOLVER), _in(AST))) */ void Z3_API Z3_solver_assert(Z3_context c, Z3_solver s, Z3_ast a); @@ -6089,6 +6172,9 @@ extern "C" { \pre \c a must be a Boolean expression \pre \c p must be a Boolean constant (aka variable). + \sa Z3_solver_assert + \sa Z3_solver_reset + def_API('Z3_solver_assert_and_track', VOID, (_in(CONTEXT), _in(SOLVER), _in(AST), _in(AST))) */ void Z3_API Z3_solver_assert_and_track(Z3_context c, Z3_solver s, Z3_ast a, Z3_ast p); @@ -6096,6 +6182,9 @@ extern "C" { /** \brief load solver assertions from a file. + \sa Z3_solver_from_string + \sa Z3_solver_to_string + def_API('Z3_solver_from_file', VOID, (_in(CONTEXT), _in(SOLVER), _in(STRING))) */ void Z3_API Z3_solver_from_file(Z3_context c, Z3_solver s, Z3_string file_name); @@ -6103,6 +6192,9 @@ extern "C" { /** \brief load solver assertions from a string. + \sa Z3_solver_from_file + \sa Z3_solver_to_string + def_API('Z3_solver_from_string', VOID, (_in(CONTEXT), _in(SOLVER), _in(STRING))) */ void Z3_API Z3_solver_from_string(Z3_context c, Z3_solver s, Z3_string file_name); @@ -6121,13 +6213,21 @@ extern "C" { */ Z3_ast_vector Z3_API Z3_solver_get_units(Z3_context c, Z3_solver s); + + /** + \brief Return the set of non units in the solver state. + + def_API('Z3_solver_get_non_units', AST_VECTOR, (_in(CONTEXT), _in(SOLVER))) + */ + Z3_ast_vector Z3_API Z3_solver_get_non_units(Z3_context c, Z3_solver s); + /** \brief Check whether the assertions in a given solver are consistent or not. The function #Z3_solver_get_model retrieves a model if the assertions is satisfiable (i.e., the result is \c Z3_L_TRUE) and model construction is enabled. - Note that if the call returns Z3_L_UNDEF, Z3 does not + Note that if the call returns \c Z3_L_UNDEF, Z3 does not ensure that calls to #Z3_solver_get_model succeed and any models produced in this case are not guaranteed to satisfy the assertions. @@ -6135,6 +6235,8 @@ extern "C" { generation was enabled when the context was created, and the assertions are unsatisfiable (i.e., the result is \c Z3_L_FALSE). + \sa Z3_solver_check_assumptions + def_API('Z3_solver_check', INT, (_in(CONTEXT), _in(SOLVER))) */ Z3_lbool Z3_API Z3_solver_check(Z3_context c, Z3_solver s); @@ -6167,7 +6269,7 @@ extern "C" { the current context implies that they are equal. A side-effect of the function is a satisfiability check on the assertions on the solver that is passed in. - The function return Z3_L_FALSE if the current assertions are not satisfiable. + The function return \c Z3_L_FALSE if the current assertions are not satisfiable. def_API('Z3_get_implied_equalities', INT, (_in(CONTEXT), _in(SOLVER), _in(UINT), _in_array(2, AST), _out_array(2, UINT))) */ @@ -6198,7 +6300,7 @@ extern "C" { The third argument is a vector of variables that may be used for cubing. The contents of the vector is only used in the first call. The initial list of variables is used in subsequent calls until it returns the unsatisfiable cube. - The vector is modified to contain a set of Autarky variables that occor in clauses that + The vector is modified to contain a set of Autarky variables that occur in clauses that are affected by the (last literal in the) cube. These variables could be used by a different cuber (on a different solver object) for further recursive cubing. @@ -6240,7 +6342,7 @@ extern "C" { Z3_ast_vector Z3_API Z3_solver_get_unsat_core(Z3_context c, Z3_solver s); /** - \brief Return a brief justification for an "unknown" result (i.e., Z3_L_UNDEF) for + \brief Return a brief justification for an "unknown" result (i.e., \c Z3_L_UNDEF) for the commands #Z3_solver_check and #Z3_solver_check_assumptions def_API('Z3_solver_get_reason_unknown', STRING, (_in(CONTEXT), _in(SOLVER))) @@ -6259,6 +6361,9 @@ extern "C" { /** \brief Convert a solver into a string. + \sa Z3_solver_from_file + \sa Z3_solver_from_string + def_API('Z3_solver_to_string', STRING, (_in(CONTEXT), _in(SOLVER))) */ Z3_string Z3_API Z3_solver_to_string(Z3_context c, Z3_solver s); @@ -6306,22 +6411,22 @@ extern "C" { Z3_string Z3_API Z3_stats_get_key(Z3_context c, Z3_stats s, unsigned idx); /** - \brief Return Z3_TRUE if the given statistical data is a unsigned integer. + \brief Return \c true if the given statistical data is a unsigned integer. \pre idx < Z3_stats_size(c, s) def_API('Z3_stats_is_uint', BOOL, (_in(CONTEXT), _in(STATS), _in(UINT))) */ - Z3_bool Z3_API Z3_stats_is_uint(Z3_context c, Z3_stats s, unsigned idx); + bool Z3_API Z3_stats_is_uint(Z3_context c, Z3_stats s, unsigned idx); /** - \brief Return Z3_TRUE if the given statistical data is a double. + \brief Return \c true if the given statistical data is a double. \pre idx < Z3_stats_size(c, s) def_API('Z3_stats_is_double', BOOL, (_in(CONTEXT), _in(STATS), _in(UINT))) */ - Z3_bool Z3_API Z3_stats_is_double(Z3_context c, Z3_stats s, unsigned idx); + bool Z3_API Z3_stats_is_double(Z3_context c, Z3_stats s, unsigned idx); /** \brief Return the unsigned value of the given statistical data. diff --git a/src/api/z3_ast_containers.h b/src/api/z3_ast_containers.h index c423a3286..c8438a2ad 100644 --- a/src/api/z3_ast_containers.h +++ b/src/api/z3_ast_containers.h @@ -138,7 +138,7 @@ extern "C" { def_API('Z3_ast_map_contains', BOOL, (_in(CONTEXT), _in(AST_MAP), _in(AST))) */ - Z3_bool Z3_API Z3_ast_map_contains(Z3_context c, Z3_ast_map m, Z3_ast k); + bool Z3_API Z3_ast_map_contains(Z3_context c, Z3_ast_map m, Z3_ast k); /** \brief Return the value associated with the key \c k. diff --git a/src/api/z3_fixedpoint.h b/src/api/z3_fixedpoint.h index b4c3eee49..54a42e9bf 100644 --- a/src/api/z3_fixedpoint.h +++ b/src/api/z3_fixedpoint.h @@ -106,9 +106,9 @@ extern "C" { \endcode query returns - - Z3_L_FALSE if the query is unsatisfiable. - - Z3_L_TRUE if the query is satisfiable. Obtain the answer by calling #Z3_fixedpoint_get_answer. - - Z3_L_UNDEF if the query was interrupted, timed out or otherwise failed. + - \c Z3_L_FALSE if the query is unsatisfiable. + - \c Z3_L_TRUE if the query is satisfiable. Obtain the answer by calling #Z3_fixedpoint_get_answer. + - \c Z3_L_UNDEF if the query was interrupted, timed out or otherwise failed. def_API('Z3_fixedpoint_query', INT, (_in(CONTEXT), _in(FIXEDPOINT), _in(AST))) */ @@ -120,9 +120,9 @@ extern "C" { The queries are encoded as relations (function declarations). query returns - - Z3_L_FALSE if the query is unsatisfiable. - - Z3_L_TRUE if the query is satisfiable. Obtain the answer by calling #Z3_fixedpoint_get_answer. - - Z3_L_UNDEF if the query was interrupted, timed out or otherwise failed. + - \c Z3_L_FALSE if the query is unsatisfiable. + - \c Z3_L_TRUE if the query is satisfiable. Obtain the answer by calling #Z3_fixedpoint_get_answer. + - \c Z3_L_UNDEF if the query was interrupted, timed out or otherwise failed. def_API('Z3_fixedpoint_query_relations', INT, (_in(CONTEXT), _in(FIXEDPOINT), _in(UINT), _in_array(2, FUNC_DECL))) */ @@ -138,8 +138,8 @@ extern "C" { Each conjunct encodes values of the bound variables of the query that are satisfied. In PDR mode, the returned answer is a single conjunction. - When used in Datalog mode the previous call to Z3_fixedpoint_query must have returned Z3_L_TRUE. - When used with the PDR engine, the previous call must have been either Z3_L_TRUE or Z3_L_FALSE. + When used in Datalog mode the previous call to #Z3_fixedpoint_query must have returned \c Z3_L_TRUE. + When used with the PDR engine, the previous call must have been either \c Z3_L_TRUE or \c Z3_L_FALSE. def_API('Z3_fixedpoint_get_answer', AST, (_in(CONTEXT), _in(FIXEDPOINT))) */ @@ -148,7 +148,7 @@ extern "C" { /** \brief Retrieve a string that describes the last status returned by #Z3_fixedpoint_query. - Use this method when #Z3_fixedpoint_query returns Z3_L_UNDEF. + Use this method when #Z3_fixedpoint_query returns \c Z3_L_UNDEF. def_API('Z3_fixedpoint_get_reason_unknown', STRING, (_in(CONTEXT), _in(FIXEDPOINT) )) */ @@ -253,6 +253,9 @@ extern "C" { /** \brief Set parameters on fixedpoint context. + \sa Z3_fixedpoint_get_help + \sa Z3_fixedpoint_get_param_descrs + def_API('Z3_fixedpoint_set_params', VOID, (_in(CONTEXT), _in(FIXEDPOINT), _in(PARAMS))) */ void Z3_API Z3_fixedpoint_set_params(Z3_context c, Z3_fixedpoint f, Z3_params p); @@ -260,6 +263,9 @@ extern "C" { /** \brief Return a string describing all fixedpoint available parameters. + \sa Z3_fixedpoint_get_param_descrs + \sa Z3_fixedpoint_set_params + def_API('Z3_fixedpoint_get_help', STRING, (_in(CONTEXT), _in(FIXEDPOINT))) */ Z3_string Z3_API Z3_fixedpoint_get_help(Z3_context c, Z3_fixedpoint f); @@ -267,6 +273,9 @@ extern "C" { /** \brief Return the parameter description set for the given fixedpoint object. + \sa Z3_fixedpoint_get_help + \sa Z3_fixedpoint_set_params + def_API('Z3_fixedpoint_get_param_descrs', PARAM_DESCRS, (_in(CONTEXT), _in(FIXEDPOINT))) */ Z3_param_descrs Z3_API Z3_fixedpoint_get_param_descrs(Z3_context c, Z3_fixedpoint f); @@ -278,6 +287,9 @@ extern "C" { \param num_queries - number of additional queries to print. \param queries - additional queries. + \sa Z3_fixedpoint_from_file + \sa Z3_fixedpoint_from_string + def_API('Z3_fixedpoint_to_string', STRING, (_in(CONTEXT), _in(FIXEDPOINT), _in(UINT), _in_array(2, AST))) */ Z3_string Z3_API Z3_fixedpoint_to_string( @@ -295,6 +307,9 @@ extern "C" { \param f - fixedpoint context. \param s - string containing SMT2 specification. + \sa Z3_fixedpoint_from_file + \sa Z3_fixedpoint_to_string + def_API('Z3_fixedpoint_from_string', AST_VECTOR, (_in(CONTEXT), _in(FIXEDPOINT), _in(STRING))) */ Z3_ast_vector Z3_API Z3_fixedpoint_from_string(Z3_context c, @@ -308,7 +323,10 @@ extern "C" { \param c - context. \param f - fixedpoint context. - \param s - string containing SMT2 specification. + \param s - path to file containing SMT2 specification. + + \sa Z3_fixedpoint_from_string + \sa Z3_fixedpoint_to_string def_API('Z3_fixedpoint_from_file', AST_VECTOR, (_in(CONTEXT), _in(FIXEDPOINT), _in(STRING))) */ @@ -377,7 +395,7 @@ extern "C" { Z3_fixedpoint_predecessor_eh predecessor_eh, Z3_fixedpoint_unfold_eh unfold_eh); - void Z3_fixedpoint_add_constraint (Z3_context c, Z3_fixedpoint d, Z3_ast e, unsigned lvl); + void Z3_API Z3_fixedpoint_add_constraint (Z3_context c, Z3_fixedpoint d, Z3_ast e, unsigned lvl); /*@}*/ /*@}*/ diff --git a/src/api/z3_fpa.h b/src/api/z3_fpa.h index f6001e87d..1eaa1f64e 100644 --- a/src/api/z3_fpa.h +++ b/src/api/z3_fpa.h @@ -134,7 +134,7 @@ extern "C" { \param ebits number of exponent bits \param sbits number of significand bits - \remark ebits must be larger than 1 and sbits must be larger than 2. + \remark \c ebits must be larger than 1 and \c sbits must be larger than 2. def_API('Z3_mk_fpa_sort', SORT, (_in(CONTEXT), _in(UINT), _in(UINT))) */ @@ -213,7 +213,7 @@ extern "C" { Z3_sort Z3_API Z3_mk_fpa_sort_128(Z3_context c); /** - \brief Create a floating-point NaN of sort s. + \brief Create a floating-point NaN of sort \c s. \param c logical context \param s target sort @@ -223,36 +223,36 @@ extern "C" { Z3_ast Z3_API Z3_mk_fpa_nan(Z3_context c, Z3_sort s); /** - \brief Create a floating-point infinity of sort s. + \brief Create a floating-point infinity of sort \c s. \param c logical context \param s target sort \param negative indicates whether the result should be negative - When \c negative is true, -oo will be generated instead of +oo. + When \c negative is \c true, -oo will be generated instead of +oo. def_API('Z3_mk_fpa_inf', AST, (_in(CONTEXT),_in(SORT),_in(BOOL))) */ - Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, Z3_bool negative); + Z3_ast Z3_API Z3_mk_fpa_inf(Z3_context c, Z3_sort s, bool negative); /** - \brief Create a floating-point zero of sort s. + \brief Create a floating-point zero of sort \c s. \param c logical context \param s target sort \param negative indicates whether the result should be negative - When \c negative is true, -zero will be generated instead of +zero. + When \c negative is \c true, -zero will be generated instead of +zero. def_API('Z3_mk_fpa_zero', AST, (_in(CONTEXT),_in(SORT),_in(BOOL))) */ - Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, Z3_bool negative); + Z3_ast Z3_API Z3_mk_fpa_zero(Z3_context c, Z3_sort s, bool negative); /** \brief Create an expression of FloatingPoint sort from three bit-vector expressions. This is the operator named `fp' in the SMT FP theory definition. - Note that \c sign is required to be a bit-vector of size 1. Significand and exponent + Note that \c sgn is required to be a bit-vector of size 1. Significand and exponent are required to be longer than 1 and 2 respectively. The FloatingPoint sort of the resulting expression is automatically determined from the bit-vector sizes of the arguments. The exponent is assumed to be in IEEE-754 biased representation. @@ -276,7 +276,7 @@ extern "C" { \param v value \param ty sort - ty must be a FloatingPoint sort + \c ty must be a FloatingPoint sort \sa Z3_mk_numeral @@ -294,7 +294,7 @@ extern "C" { \param v value \param ty sort - ty must be a FloatingPoint sort + \c ty must be a FloatingPoint sort \sa Z3_mk_numeral @@ -309,7 +309,7 @@ extern "C" { \param v value \param ty result sort - ty must be a FloatingPoint sort + \c ty must be a FloatingPoint sort \sa Z3_mk_numeral @@ -326,13 +326,13 @@ extern "C" { \param exp exponent \param ty result sort - ty must be a FloatingPoint sort + \c ty must be a FloatingPoint sort \sa Z3_mk_numeral def_API('Z3_mk_fpa_numeral_int_uint', AST, (_in(CONTEXT), _in(BOOL), _in(INT), _in(UINT), _in(SORT))) */ - Z3_ast Z3_API Z3_mk_fpa_numeral_int_uint(Z3_context c, Z3_bool sgn, signed exp, unsigned sig, Z3_sort ty); + Z3_ast Z3_API Z3_mk_fpa_numeral_int_uint(Z3_context c, bool sgn, signed exp, unsigned sig, Z3_sort ty); /** \brief Create a numeral of FloatingPoint sort from a sign bit and two 64-bit integers. @@ -343,13 +343,13 @@ extern "C" { \param exp exponent \param ty result sort - ty must be a FloatingPoint sort + \c ty must be a FloatingPoint sort \sa Z3_mk_numeral def_API('Z3_mk_fpa_numeral_int64_uint64', AST, (_in(CONTEXT), _in(BOOL), _in(INT64), _in(UINT64), _in(SORT))) */ - Z3_ast Z3_API Z3_mk_fpa_numeral_int64_uint64(Z3_context c, Z3_bool sgn, int64_t exp, uint64_t sig, Z3_sort ty); + Z3_ast Z3_API Z3_mk_fpa_numeral_int64_uint64(Z3_context c, bool sgn, int64_t exp, uint64_t sig, Z3_sort ty); /** \brief Floating-point absolute value @@ -379,7 +379,7 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - rm must be of RoundingMode sort, t1 and t2 must have the same FloatingPoint sort. + \c rm must be of RoundingMode sort, \c t1 and \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_add', AST, (_in(CONTEXT),_in(AST),_in(AST),_in(AST))) */ @@ -393,7 +393,7 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - rm must be of RoundingMode sort, t1 and t2 must have the same FloatingPoint sort. + \c rm must be of RoundingMode sort, \c t1 and \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_sub', AST, (_in(CONTEXT),_in(AST),_in(AST),_in(AST))) */ @@ -407,7 +407,7 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - rm must be of RoundingMode sort, t1 and t2 must have the same FloatingPoint sort. + \c rm must be of RoundingMode sort, \c t1 and \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_mul', AST, (_in(CONTEXT),_in(AST),_in(AST),_in(AST))) */ @@ -421,7 +421,7 @@ extern "C" { \param t1 term of FloatingPoint sort. \param t2 term of FloatingPoint sort - The nodes rm must be of RoundingMode sort t1 and t2 must have the same FloatingPoint sort. + The nodes \c rm must be of RoundingMode sort, \c t1 and \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_div', AST, (_in(CONTEXT),_in(AST),_in(AST),_in(AST))) */ @@ -436,9 +436,9 @@ extern "C" { \param t2 term of FloatingPoint sort \param t3 term of FloatingPoint sort - The result is round((t1 * t2) + t3) + The result is \ccode{round((t1 * t2) + t3)}. - rm must be of RoundingMode sort, t1, t2, and t3 must have the same FloatingPoint sort. + \c rm must be of RoundingMode sort, \c t1, \c t2, and \c t3 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_fma', AST, (_in(CONTEXT),_in(AST),_in(AST),_in(AST),_in(AST))) */ @@ -451,7 +451,7 @@ extern "C" { \param rm term of RoundingMode sort \param t term of FloatingPoint sort - rm must be of RoundingMode sort, t must have FloatingPoint sort. + \c rm must be of RoundingMode sort, \c t must have FloatingPoint sort. def_API('Z3_mk_fpa_sqrt', AST, (_in(CONTEXT),_in(AST),_in(AST))) */ @@ -464,7 +464,7 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - t1 and t2 must have the same FloatingPoint sort. + \c t1 and \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_rem', AST, (_in(CONTEXT),_in(AST),_in(AST))) */ @@ -478,7 +478,7 @@ extern "C" { \param rm term of RoundingMode sort \param t term of FloatingPoint sort - t must be of FloatingPoint sort. + \c t must be of FloatingPoint sort. def_API('Z3_mk_fpa_round_to_integral', AST, (_in(CONTEXT),_in(AST),_in(AST))) */ @@ -491,7 +491,7 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - t1, t2 must have the same FloatingPoint sort. + \c t1, \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_min', AST, (_in(CONTEXT),_in(AST),_in(AST))) */ @@ -504,7 +504,7 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - t1, t2 must have the same FloatingPoint sort. + \c t1, \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_max', AST, (_in(CONTEXT),_in(AST),_in(AST))) */ @@ -517,7 +517,7 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - t1 and t2 must have the same FloatingPoint sort. + \c t1 and \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_leq', AST, (_in(CONTEXT),_in(AST),_in(AST))) */ @@ -530,7 +530,7 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - t1 and t2 must have the same FloatingPoint sort. + \c t1 and \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_lt', AST, (_in(CONTEXT),_in(AST),_in(AST))) */ @@ -543,7 +543,7 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - t1 and t2 must have the same FloatingPoint sort. + \c t1 and \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_geq', AST, (_in(CONTEXT),_in(AST),_in(AST))) */ @@ -556,7 +556,7 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - t1 and t2 must have the same FloatingPoint sort. + \c t1 and \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_gt', AST, (_in(CONTEXT),_in(AST),_in(AST))) */ @@ -569,93 +569,93 @@ extern "C" { \param t1 term of FloatingPoint sort \param t2 term of FloatingPoint sort - Note that this is IEEE 754 equality (as opposed to SMT-LIB =). + Note that this is IEEE 754 equality (as opposed to SMT-LIB \ccode{=}). - t1 and t2 must have the same FloatingPoint sort. + \c t1 and \c t2 must have the same FloatingPoint sort. def_API('Z3_mk_fpa_eq', AST, (_in(CONTEXT),_in(AST),_in(AST))) */ Z3_ast Z3_API Z3_mk_fpa_eq(Z3_context c, Z3_ast t1, Z3_ast t2); /** - \brief Predicate indicating whether t is a normal floating-point number. + \brief Predicate indicating whether \c t is a normal floating-point number. \param c logical context \param t term of FloatingPoint sort - t must have FloatingPoint sort. + \c t must have FloatingPoint sort. def_API('Z3_mk_fpa_is_normal', AST, (_in(CONTEXT),_in(AST))) */ Z3_ast Z3_API Z3_mk_fpa_is_normal(Z3_context c, Z3_ast t); /** - \brief Predicate indicating whether t is a subnormal floating-point number. + \brief Predicate indicating whether \c t is a subnormal floating-point number. \param c logical context \param t term of FloatingPoint sort - t must have FloatingPoint sort. + \c t must have FloatingPoint sort. def_API('Z3_mk_fpa_is_subnormal', AST, (_in(CONTEXT),_in(AST))) */ Z3_ast Z3_API Z3_mk_fpa_is_subnormal(Z3_context c, Z3_ast t); /** - \brief Predicate indicating whether t is a floating-point number with zero value, i.e., +zero or -zero. + \brief Predicate indicating whether \c t is a floating-point number with zero value, i.e., +zero or -zero. \param c logical context \param t term of FloatingPoint sort - t must have FloatingPoint sort. + \c t must have FloatingPoint sort. def_API('Z3_mk_fpa_is_zero', AST, (_in(CONTEXT),_in(AST))) */ Z3_ast Z3_API Z3_mk_fpa_is_zero(Z3_context c, Z3_ast t); /** - \brief Predicate indicating whether t is a floating-point number representing +oo or -oo. + \brief Predicate indicating whether \c t is a floating-point number representing +oo or -oo. \param c logical context \param t term of FloatingPoint sort - t must have FloatingPoint sort. + \c t must have FloatingPoint sort. def_API('Z3_mk_fpa_is_infinite', AST, (_in(CONTEXT),_in(AST))) */ Z3_ast Z3_API Z3_mk_fpa_is_infinite(Z3_context c, Z3_ast t); /** - \brief Predicate indicating whether t is a NaN. + \brief Predicate indicating whether \c t is a NaN. \param c logical context \param t term of FloatingPoint sort - t must have FloatingPoint sort. + \c t must have FloatingPoint sort. def_API('Z3_mk_fpa_is_nan', AST, (_in(CONTEXT),_in(AST))) */ Z3_ast Z3_API Z3_mk_fpa_is_nan(Z3_context c, Z3_ast t); /** - \brief Predicate indicating whether t is a negative floating-point number. + \brief Predicate indicating whether \c t is a negative floating-point number. \param c logical context \param t term of FloatingPoint sort - t must have FloatingPoint sort. + \c t must have FloatingPoint sort. def_API('Z3_mk_fpa_is_negative', AST, (_in(CONTEXT),_in(AST))) */ Z3_ast Z3_API Z3_mk_fpa_is_negative(Z3_context c, Z3_ast t); /** - \brief Predicate indicating whether t is a positive floating-point number. + \brief Predicate indicating whether \c t is a positive floating-point number. \param c logical context \param t term of FloatingPoint sort - t must have FloatingPoint sort. + \c t must have FloatingPoint sort. def_API('Z3_mk_fpa_is_positive', AST, (_in(CONTEXT),_in(AST))) */ @@ -664,15 +664,15 @@ extern "C" { /** \brief Conversion of a single IEEE 754-2008 bit-vector into a floating-point number. - Produces a term that represents the conversion of a bit-vector term bv to a - floating-point term of sort s. + Produces a term that represents the conversion of a bit-vector term \c bv to a + floating-point term of sort \c s. \param c logical context \param bv a bit-vector term \param s floating-point sort - s must be a FloatingPoint sort, t must be of bit-vector sort, and the bit-vector - size of bv must be equal to ebits+sbits of s. The format of the bit-vector is + \c s must be a FloatingPoint sort, \c t must be of bit-vector sort, and the bit-vector + size of \c bv must be equal to \ccode{ebits+sbits} of \c s. The format of the bit-vector is as defined by the IEEE 754-2008 interchange format. def_API('Z3_mk_fpa_to_fp_bv', AST, (_in(CONTEXT),_in(AST),_in(SORT))) @@ -682,16 +682,16 @@ extern "C" { /** \brief Conversion of a FloatingPoint term into another term of different FloatingPoint sort. - Produces a term that represents the conversion of a floating-point term t to a - floating-point term of sort s. If necessary, the result will be rounded according - to rounding mode rm. + Produces a term that represents the conversion of a floating-point term \c t to a + floating-point term of sort \c s. If necessary, the result will be rounded according + to rounding mode \c rm. \param c logical context \param rm term of RoundingMode sort \param t term of FloatingPoint sort \param s floating-point sort - s must be a FloatingPoint sort, rm must be of RoundingMode sort, t must be of floating-point sort. + \c s must be a FloatingPoint sort, \c rm must be of RoundingMode sort, \c t must be of floating-point sort. def_API('Z3_mk_fpa_to_fp_float', AST, (_in(CONTEXT),_in(AST),_in(AST),_in(SORT))) */ @@ -700,16 +700,16 @@ extern "C" { /** \brief Conversion of a term of real sort into a term of FloatingPoint sort. - Produces a term that represents the conversion of term t of real sort into a - floating-point term of sort s. If necessary, the result will be rounded according - to rounding mode rm. + Produces a term that represents the conversion of term \c t of real sort into a + floating-point term of sort \c s. If necessary, the result will be rounded according + to rounding mode \c rm. \param c logical context \param rm term of RoundingMode sort \param t term of Real sort \param s floating-point sort - s must be a FloatingPoint sort, rm must be of RoundingMode sort, t must be of real sort. + \c s must be a FloatingPoint sort, \c rm must be of RoundingMode sort, \c t must be of real sort. def_API('Z3_mk_fpa_to_fp_real', AST, (_in(CONTEXT),_in(AST),_in(AST),_in(SORT))) */ @@ -718,17 +718,17 @@ extern "C" { /** \brief Conversion of a 2's complement signed bit-vector term into a term of FloatingPoint sort. - Produces a term that represents the conversion of the bit-vector term t into a - floating-point term of sort s. The bit-vector t is taken to be in signed + Produces a term that represents the conversion of the bit-vector term \c t into a + floating-point term of sort \c s. The bit-vector \c t is taken to be in signed 2's complement format. If necessary, the result will be rounded according - to rounding mode rm. + to rounding mode \c rm. \param c logical context \param rm term of RoundingMode sort \param t term of bit-vector sort \param s floating-point sort - s must be a FloatingPoint sort, rm must be of RoundingMode sort, t must be of bit-vector sort. + \c s must be a FloatingPoint sort, \c rm must be of RoundingMode sort, \c t must be of bit-vector sort. def_API('Z3_mk_fpa_to_fp_signed', AST, (_in(CONTEXT),_in(AST),_in(AST),_in(SORT))) */ @@ -737,17 +737,17 @@ extern "C" { /** \brief Conversion of a 2's complement unsigned bit-vector term into a term of FloatingPoint sort. - Produces a term that represents the conversion of the bit-vector term t into a - floating-point term of sort s. The bit-vector t is taken to be in unsigned + Produces a term that represents the conversion of the bit-vector term \c t into a + floating-point term of sort \c s. The bit-vector \c t is taken to be in unsigned 2's complement format. If necessary, the result will be rounded according - to rounding mode rm. + to rounding mode \c rm. \param c logical context \param rm term of RoundingMode sort \param t term of bit-vector sort \param s floating-point sort - s must be a FloatingPoint sort, rm must be of RoundingMode sort, t must be of bit-vector sort. + \c s must be a FloatingPoint sort, \c rm must be of RoundingMode sort, \c t must be of bit-vector sort. def_API('Z3_mk_fpa_to_fp_unsigned', AST, (_in(CONTEXT),_in(AST),_in(AST),_in(SORT))) */ @@ -756,9 +756,9 @@ extern "C" { /** \brief Conversion of a floating-point term into an unsigned bit-vector. - Produces a term that represents the conversion of the floating-point term t into a - bit-vector term of size sz in unsigned 2's complement format. If necessary, the result - will be rounded according to rounding mode rm. + Produces a term that represents the conversion of the floating-point term \c t into a + bit-vector term of size \c sz in unsigned 2's complement format. If necessary, the result + will be rounded according to rounding mode \c rm. \param c logical context \param rm term of RoundingMode sort @@ -772,9 +772,9 @@ extern "C" { /** \brief Conversion of a floating-point term into a signed bit-vector. - Produces a term that represents the conversion of the floating-point term t into a - bit-vector term of size sz in signed 2's complement format. If necessary, the result - will be rounded according to rounding mode rm. + Produces a term that represents the conversion of the floating-point term \c t into a + bit-vector term of size \c sz in signed 2's complement format. If necessary, the result + will be rounded according to rounding mode \c rm. \param c logical context \param rm term of RoundingMode sort @@ -788,7 +788,7 @@ extern "C" { /** \brief Conversion of a floating-point term into a real-numbered term. - Produces a term that represents the conversion of the floating-point term t into a + Produces a term that represents the conversion of the floating-point term \c t into a real number. Note that this type of conversion will often result in non-linear constraints over real terms. @@ -830,7 +830,7 @@ extern "C" { def_API('Z3_fpa_is_numeral_nan', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_fpa_is_numeral_nan(Z3_context c, Z3_ast t); + bool Z3_API Z3_fpa_is_numeral_nan(Z3_context c, Z3_ast t); /** \brief Checks whether a given floating-point numeral is a +oo or -oo. @@ -840,7 +840,7 @@ extern "C" { def_API('Z3_fpa_is_numeral_inf', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_fpa_is_numeral_inf(Z3_context c, Z3_ast t); + bool Z3_API Z3_fpa_is_numeral_inf(Z3_context c, Z3_ast t); /** \brief Checks whether a given floating-point numeral is +zero or -zero. @@ -850,7 +850,7 @@ extern "C" { def_API('Z3_fpa_is_numeral_zero', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_fpa_is_numeral_zero(Z3_context c, Z3_ast t); + bool Z3_API Z3_fpa_is_numeral_zero(Z3_context c, Z3_ast t); /** \brief Checks whether a given floating-point numeral is normal. @@ -860,7 +860,7 @@ extern "C" { def_API('Z3_fpa_is_numeral_normal', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_fpa_is_numeral_normal(Z3_context c, Z3_ast t); + bool Z3_API Z3_fpa_is_numeral_normal(Z3_context c, Z3_ast t); /** \brief Checks whether a given floating-point numeral is subnormal. @@ -870,7 +870,7 @@ extern "C" { def_API('Z3_fpa_is_numeral_subnormal', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_fpa_is_numeral_subnormal(Z3_context c, Z3_ast t); + bool Z3_API Z3_fpa_is_numeral_subnormal(Z3_context c, Z3_ast t); /** \brief Checks whether a given floating-point numeral is positive. @@ -880,7 +880,7 @@ extern "C" { def_API('Z3_fpa_is_numeral_positive', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_fpa_is_numeral_positive(Z3_context c, Z3_ast t); + bool Z3_API Z3_fpa_is_numeral_positive(Z3_context c, Z3_ast t); /** \brief Checks whether a given floating-point numeral is negative. @@ -890,7 +890,7 @@ extern "C" { def_API('Z3_fpa_is_numeral_negative', BOOL, (_in(CONTEXT), _in(AST))) */ - Z3_bool Z3_API Z3_fpa_is_numeral_negative(Z3_context c, Z3_ast t); + bool Z3_API Z3_fpa_is_numeral_negative(Z3_context c, Z3_ast t); /** \brief Retrieves the sign of a floating-point literal as a bit-vector expression. @@ -928,7 +928,7 @@ extern "C" { def_API('Z3_fpa_get_numeral_sign', BOOL, (_in(CONTEXT), _in(AST), _out(INT))) */ - Z3_bool Z3_API Z3_fpa_get_numeral_sign(Z3_context c, Z3_ast t, int * sgn); + bool Z3_API Z3_fpa_get_numeral_sign(Z3_context c, Z3_ast t, int * sgn); /** \brief Return the significand value of a floating-point numeral as a string. @@ -936,7 +936,7 @@ extern "C" { \param c logical context \param t a floating-point numeral - Remarks: The significand s is always 0.0 <= s < 2.0; the resulting string is long + Remarks: The significand \c s is always \ccode{0.0 <= s < 2.0}; the resulting string is long enough to represent the real significand precisely. def_API('Z3_fpa_get_numeral_significand_string', STRING, (_in(CONTEXT), _in(AST))) @@ -951,12 +951,12 @@ extern "C" { \param n pointer to output uint64 Remarks: This function extracts the significand bits in `t`, without the - hidden bit or normalization. Sets the Z3_INVALID_ARG error code if the - significand does not fit into a uint64. NaN is an invalid argument. + hidden bit or normalization. Sets the \c Z3_INVALID_ARG error code if the + significand does not fit into a \c uint64. NaN is an invalid argument. def_API('Z3_fpa_get_numeral_significand_uint64', BOOL, (_in(CONTEXT), _in(AST), _out(UINT64))) */ - Z3_bool Z3_API Z3_fpa_get_numeral_significand_uint64(Z3_context c, Z3_ast t, uint64_t * n); + bool Z3_API Z3_fpa_get_numeral_significand_uint64(Z3_context c, Z3_ast t, uint64_t * n); /** \brief Return the exponent value of a floating-point numeral as a string. @@ -970,7 +970,7 @@ extern "C" { def_API('Z3_fpa_get_numeral_exponent_string', STRING, (_in(CONTEXT), _in(AST), _in(BOOL))) */ - Z3_string Z3_API Z3_fpa_get_numeral_exponent_string(Z3_context c, Z3_ast t, Z3_bool biased); + Z3_string Z3_API Z3_fpa_get_numeral_exponent_string(Z3_context c, Z3_ast t, bool biased); /** \brief Return the exponent value of a floating-point numeral as a signed 64-bit integer @@ -985,7 +985,7 @@ extern "C" { def_API('Z3_fpa_get_numeral_exponent_int64', BOOL, (_in(CONTEXT), _in(AST), _out(INT64), _in(BOOL))) */ - Z3_bool Z3_API Z3_fpa_get_numeral_exponent_int64(Z3_context c, Z3_ast t, int64_t * n, Z3_bool biased); + bool Z3_API Z3_fpa_get_numeral_exponent_int64(Z3_context c, Z3_ast t, int64_t * n, bool biased); /** \brief Retrieves the exponent of a floating-point literal as a bit-vector expression. @@ -999,7 +999,7 @@ extern "C" { def_API('Z3_fpa_get_numeral_exponent_bv', AST, (_in(CONTEXT), _in(AST), _in(BOOL))) */ - Z3_ast Z3_API Z3_fpa_get_numeral_exponent_bv(Z3_context c, Z3_ast t, Z3_bool biased); + Z3_ast Z3_API Z3_fpa_get_numeral_exponent_bv(Z3_context c, Z3_ast t, bool biased); /** \brief Conversion of a floating-point term into a bit-vector term in IEEE 754-2008 format. @@ -1007,7 +1007,7 @@ extern "C" { \param c logical context \param t term of FloatingPoint sort - t must have FloatingPoint sort. The size of the resulting bit-vector is automatically + \c t must have FloatingPoint sort. The size of the resulting bit-vector is automatically determined. Note that IEEE 754-2008 allows multiple different representations of NaN. This conversion @@ -1021,9 +1021,9 @@ extern "C" { /** \brief Conversion of a real-sorted significand and an integer-sorted exponent into a term of FloatingPoint sort. - Produces a term that represents the conversion of sig * 2^exp into a - floating-point term of sort s. If necessary, the result will be rounded - according to rounding mode rm. + Produces a term that represents the conversion of \ccode{sig * 2^exp} into a + floating-point term of sort \c s. If necessary, the result will be rounded + according to rounding mode \c rm. \param c logical context \param rm term of RoundingMode sort @@ -1031,7 +1031,7 @@ extern "C" { \param sig significand term of Real sort \param s FloatingPoint sort - s must be a FloatingPoint sort, rm must be of RoundingMode sort, exp must be of int sort, sig must be of real sort. + \c s must be a FloatingPoint sort, \c rm must be of RoundingMode sort, \c exp must be of int sort, \c sig must be of real sort. def_API('Z3_mk_fpa_to_fp_int_real', AST, (_in(CONTEXT),_in(AST),_in(AST),_in(AST),_in(SORT))) */ diff --git a/src/api/z3_macros.h b/src/api/z3_macros.h index c74144e90..d1ac18804 100644 --- a/src/api/z3_macros.h +++ b/src/api/z3_macros.h @@ -19,7 +19,3 @@ Copyright (c) 2015 Microsoft Corporation #ifndef DEFINE_TYPE #define DEFINE_TYPE(T) typedef struct _ ## T *T #endif - -#ifndef DEFINE_VOID -#define DEFINE_VOID(T) typedef void* T -#endif diff --git a/src/api/z3_optimization.h b/src/api/z3_optimization.h index f49e1b9ce..a8ffd45ab 100644 --- a/src/api/z3_optimization.h +++ b/src/api/z3_optimization.h @@ -55,6 +55,8 @@ extern "C" { /** \brief Assert hard constraint to the optimization context. + \sa Z3_optimize_assert_soft + def_API('Z3_optimize_assert', VOID, (_in(CONTEXT), _in(OPTIMIZE), _in(AST))) */ void Z3_API Z3_optimize_assert(Z3_context c, Z3_optimize o, Z3_ast a); @@ -67,6 +69,8 @@ extern "C" { \param weight - a positive weight, penalty for violating soft constraint \param id - optional identifier to group soft constraints + \sa Z3_optimize_assert + def_API('Z3_optimize_assert_soft', UINT, (_in(CONTEXT), _in(OPTIMIZE), _in(AST), _in(STRING), _in(SYMBOL))) */ unsigned Z3_API Z3_optimize_assert_soft(Z3_context c, Z3_optimize o, Z3_ast a, Z3_string weight, Z3_symbol id); @@ -76,6 +80,9 @@ extern "C" { \param c - context \param o - optimization context \param t - arithmetical term + + \sa Z3_optimize_minimize + def_API('Z3_optimize_maximize', UINT, (_in(CONTEXT), _in(OPTIMIZE), _in(AST))) */ unsigned Z3_API Z3_optimize_maximize(Z3_context c, Z3_optimize o, Z3_ast t); @@ -86,6 +93,8 @@ extern "C" { \param o - optimization context \param t - arithmetical term + \sa Z3_optimize_maximize + def_API('Z3_optimize_minimize', UINT, (_in(CONTEXT), _in(OPTIMIZE), _in(AST))) */ unsigned Z3_API Z3_optimize_minimize(Z3_context c, Z3_optimize o, Z3_ast t); @@ -117,16 +126,23 @@ extern "C" { \brief Check consistency and produce optimal values. \param c - context \param o - optimization context + \param num_assumptions - number of additional assumptions + \param assumptions - the additional assumptions - def_API('Z3_optimize_check', INT, (_in(CONTEXT), _in(OPTIMIZE))) + \sa Z3_optimize_get_reason_unknown + \sa Z3_optimize_get_model + \sa Z3_optimize_get_statistics + \sa Z3_optimize_get_unsat_core + + def_API('Z3_optimize_check', INT, (_in(CONTEXT), _in(OPTIMIZE), _in(UINT), _in_array(2, AST))) */ - Z3_lbool Z3_API Z3_optimize_check(Z3_context c, Z3_optimize o); + Z3_lbool Z3_API Z3_optimize_check(Z3_context c, Z3_optimize o, unsigned num_assumptions, Z3_ast const assumptions[]); /** \brief Retrieve a string that describes the last status returned by #Z3_optimize_check. - Use this method when #Z3_optimize_check returns Z3_L_UNDEF. + Use this method when #Z3_optimize_check returns \c Z3_L_UNDEF. def_API('Z3_optimize_get_reason_unknown', STRING, (_in(CONTEXT), _in(OPTIMIZE) )) */ @@ -143,6 +159,14 @@ extern "C" { */ Z3_model Z3_API Z3_optimize_get_model(Z3_context c, Z3_optimize o); + /** + \brief Retrieve the unsat core for the last #Z3_optimize_check + The unsat core is a subset of the assumptions \c a. + + def_API('Z3_optimize_get_unsat_core', AST_VECTOR, (_in(CONTEXT), _in(OPTIMIZE))) + */ + Z3_ast_vector Z3_API Z3_optimize_get_unsat_core(Z3_context c, Z3_optimize o); + /** \brief Set parameters on optimization context. @@ -150,6 +174,9 @@ extern "C" { \param o - optimization context \param p - parameters + \sa Z3_optimize_get_help + \sa Z3_optimize_get_param_descrs + def_API('Z3_optimize_set_params', VOID, (_in(CONTEXT), _in(OPTIMIZE), _in(PARAMS))) */ void Z3_API Z3_optimize_set_params(Z3_context c, Z3_optimize o, Z3_params p); @@ -160,6 +187,9 @@ extern "C" { \param c - context \param o - optimization context + \sa Z3_optimize_get_help + \sa Z3_optimize_set_params + def_API('Z3_optimize_get_param_descrs', PARAM_DESCRS, (_in(CONTEXT), _in(OPTIMIZE))) */ Z3_param_descrs Z3_API Z3_optimize_get_param_descrs(Z3_context c, Z3_optimize o); @@ -171,6 +201,10 @@ extern "C" { \param o - optimization context \param idx - index of optimization objective + \sa Z3_optimize_get_upper + \sa Z3_optimize_get_lower_as_vector + \sa Z3_optimize_get_upper_as_vector + def_API('Z3_optimize_get_lower', AST, (_in(CONTEXT), _in(OPTIMIZE), _in(UINT))) */ Z3_ast Z3_API Z3_optimize_get_lower(Z3_context c, Z3_optimize o, unsigned idx); @@ -182,6 +216,10 @@ extern "C" { \param o - optimization context \param idx - index of optimization objective + \sa Z3_optimize_get_lower + \sa Z3_optimize_get_lower_as_vector + \sa Z3_optimize_get_upper_as_vector + def_API('Z3_optimize_get_upper', AST, (_in(CONTEXT), _in(OPTIMIZE), _in(UINT))) */ Z3_ast Z3_API Z3_optimize_get_upper(Z3_context c, Z3_optimize o, unsigned idx); @@ -190,13 +228,17 @@ extern "C" { /** \brief Retrieve lower bound value or approximation for the i'th optimization objective. The returned vector is of length 3. It always contains numerals. - The three numerals are coefficients a, b, c and encode the result of \c Z3_optimize_get_lower - a * infinity + b + c * epsilon. + The three numerals are coefficients \c a, \c b, \c c and encode the result of + #Z3_optimize_get_lower \ccode{a * infinity + b + c * epsilon}. \param c - context \param o - optimization context \param idx - index of optimization objective + \sa Z3_optimize_get_lower + \sa Z3_optimize_get_upper + \sa Z3_optimize_get_upper_as_vector + def_API('Z3_optimize_get_lower_as_vector', AST_VECTOR, (_in(CONTEXT), _in(OPTIMIZE), _in(UINT))) */ Z3_ast_vector Z3_API Z3_optimize_get_lower_as_vector(Z3_context c, Z3_optimize o, unsigned idx); @@ -208,6 +250,10 @@ extern "C" { \param o - optimization context \param idx - index of optimization objective + \sa Z3_optimize_get_lower + \sa Z3_optimize_get_upper + \sa Z3_optimize_get_lower_as_vector + def_API('Z3_optimize_get_upper_as_vector', AST_VECTOR, (_in(CONTEXT), _in(OPTIMIZE), _in(UINT))) */ Z3_ast_vector Z3_API Z3_optimize_get_upper_as_vector(Z3_context c, Z3_optimize o, unsigned idx); @@ -218,6 +264,9 @@ extern "C" { \param c - context. \param o - optimization context. + \sa Z3_optimize_from_file + \sa Z3_optimize_from_string + def_API('Z3_optimize_to_string', STRING, (_in(CONTEXT), _in(OPTIMIZE))) */ Z3_string Z3_API Z3_optimize_to_string(Z3_context c, Z3_optimize o); @@ -231,6 +280,9 @@ extern "C" { \param o - optimize context. \param s - string containing SMT2 specification. + \sa Z3_optimize_from_file + \sa Z3_optimize_to_string + def_API('Z3_optimize_from_string', VOID, (_in(CONTEXT), _in(OPTIMIZE), _in(STRING))) */ void Z3_API Z3_optimize_from_string(Z3_context c, Z3_optimize o, Z3_string s); @@ -242,7 +294,10 @@ extern "C" { \param c - context. \param o - optimize context. - \param s - string containing SMT2 specification. + \param s - path to file containing SMT2 specification. + + \sa Z3_optimize_from_string + \sa Z3_optimize_to_string def_API('Z3_optimize_from_file', VOID, (_in(CONTEXT), _in(OPTIMIZE), _in(STRING))) */ @@ -251,6 +306,9 @@ extern "C" { /** \brief Return a string containing a description of parameters accepted by optimize. + \sa Z3_optimize_get_param_descrs + \sa Z3_optimize_set_params + def_API('Z3_optimize_get_help', STRING, (_in(CONTEXT), _in(OPTIMIZE))) */ Z3_string Z3_API Z3_optimize_get_help(Z3_context c, Z3_optimize t); @@ -272,7 +330,7 @@ extern "C" { /** \brief Return objectives on the optimization context. If the objective function is a max-sat objective it is returned - as a Pseudo-Boolean (minimization) sum of the form (+ (if f1 w1 0) (if f2 w2 0) ...) + as a Pseudo-Boolean (minimization) sum of the form \ccode{(+ (if f1 w1 0) (if f2 w2 0) ...)} If the objective function is entered as a maximization objective, then return the corresponding minimization objective. In this way the resulting objective function is always returned as a minimization objective. diff --git a/src/api/z3_polynomial.h b/src/api/z3_polynomial.h index 0561bfd9c..5f4815d02 100644 --- a/src/api/z3_polynomial.h +++ b/src/api/z3_polynomial.h @@ -36,9 +36,8 @@ extern "C" { \pre \c p, \c q and \c x are Z3 expressions where \c p and \c q are arithmetic terms. Note that, any subterm that cannot be viewed as a polynomial is assumed to be a variable. - Example: f(a) is a considered to be a variable in the polynomial - - f(a)*f(a) + 2*f(a) + 1 + Example: \ccode{f(a)} is a considered to be a variable in the polynomial \ccode{ + f(a)*f(a) + 2*f(a) + 1} def_API('Z3_polynomial_subresultants', AST_VECTOR, (_in(CONTEXT), _in(AST), _in(AST), _in(AST))) */ diff --git a/src/api/z3_private.h b/src/api/z3_private.h index 7b60a6ab9..4d5e2d3bd 100644 --- a/src/api/z3_private.h +++ b/src/api/z3_private.h @@ -29,7 +29,7 @@ Notes: extern "C" { #endif // __cplusplus - Z3_bool Z3_API Z3_get_numeral_rational(Z3_context c, Z3_ast a, rational& r); + bool Z3_API Z3_get_numeral_rational(Z3_context c, Z3_ast a, rational& r); #ifdef __cplusplus }; diff --git a/src/api/z3_rcf.h b/src/api/z3_rcf.h index 779c3ff88..4e4ecbd15 100644 --- a/src/api/z3_rcf.h +++ b/src/api/z3_rcf.h @@ -74,7 +74,7 @@ extern "C" { Z3_rcf_num Z3_API Z3_rcf_mk_infinitesimal(Z3_context c); /** - \brief Store in roots the roots of the polynomial a[n-1]*x^{n-1} + ... + a[0]. + \brief Store in roots the roots of the polynomial \ccode{a[n-1]*x^{n-1} + ... + a[0]}. The output vector \c roots must have size \c n. It returns the number of roots of the polynomial. @@ -85,102 +85,102 @@ extern "C" { unsigned Z3_API Z3_rcf_mk_roots(Z3_context c, unsigned n, Z3_rcf_num const a[], Z3_rcf_num roots[]); /** - \brief Return the value a + b. + \brief Return the value \ccode{a + b}. def_API('Z3_rcf_add', RCF_NUM, (_in(CONTEXT), _in(RCF_NUM), _in(RCF_NUM))) */ Z3_rcf_num Z3_API Z3_rcf_add(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); /** - \brief Return the value a - b. + \brief Return the value \ccode{a - b}. def_API('Z3_rcf_sub', RCF_NUM, (_in(CONTEXT), _in(RCF_NUM), _in(RCF_NUM))) */ Z3_rcf_num Z3_API Z3_rcf_sub(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); /** - \brief Return the value a * b. + \brief Return the value \ccode{a * b}. def_API('Z3_rcf_mul', RCF_NUM, (_in(CONTEXT), _in(RCF_NUM), _in(RCF_NUM))) */ Z3_rcf_num Z3_API Z3_rcf_mul(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); /** - \brief Return the value a / b. + \brief Return the value \ccode{a / b}. def_API('Z3_rcf_div', RCF_NUM, (_in(CONTEXT), _in(RCF_NUM), _in(RCF_NUM))) */ Z3_rcf_num Z3_API Z3_rcf_div(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); /** - \brief Return the value -a + \brief Return the value \ccode{-a}. def_API('Z3_rcf_neg', RCF_NUM, (_in(CONTEXT), _in(RCF_NUM))) */ Z3_rcf_num Z3_API Z3_rcf_neg(Z3_context c, Z3_rcf_num a); /** - \brief Return the value 1/a + \brief Return the value \ccode{1/a}. def_API('Z3_rcf_inv', RCF_NUM, (_in(CONTEXT), _in(RCF_NUM))) */ Z3_rcf_num Z3_API Z3_rcf_inv(Z3_context c, Z3_rcf_num a); /** - \brief Return the value a^k + \brief Return the value \ccode{a^k}. def_API('Z3_rcf_power', RCF_NUM, (_in(CONTEXT), _in(RCF_NUM), _in(UINT))) */ Z3_rcf_num Z3_API Z3_rcf_power(Z3_context c, Z3_rcf_num a, unsigned k); /** - \brief Return Z3_TRUE if a < b + \brief Return \c true if \ccode{a < b}. def_API('Z3_rcf_lt', BOOL, (_in(CONTEXT), _in(RCF_NUM), _in(RCF_NUM))) */ - Z3_bool Z3_API Z3_rcf_lt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); + bool Z3_API Z3_rcf_lt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); /** - \brief Return Z3_TRUE if a > b + \brief Return \c true if \ccode{a > b}. def_API('Z3_rcf_gt', BOOL, (_in(CONTEXT), _in(RCF_NUM), _in(RCF_NUM))) */ - Z3_bool Z3_API Z3_rcf_gt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); + bool Z3_API Z3_rcf_gt(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); /** - \brief Return Z3_TRUE if a <= b + \brief Return \c true if \ccode{a <= b}. def_API('Z3_rcf_le', BOOL, (_in(CONTEXT), _in(RCF_NUM), _in(RCF_NUM))) */ - Z3_bool Z3_API Z3_rcf_le(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); + bool Z3_API Z3_rcf_le(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); /** - \brief Return Z3_TRUE if a >= b + \brief Return \c true if \ccode{a >= b}. def_API('Z3_rcf_ge', BOOL, (_in(CONTEXT), _in(RCF_NUM), _in(RCF_NUM))) */ - Z3_bool Z3_API Z3_rcf_ge(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); + bool Z3_API Z3_rcf_ge(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); /** - \brief Return Z3_TRUE if a == b + \brief Return \c true if \ccode{a == b}. def_API('Z3_rcf_eq', BOOL, (_in(CONTEXT), _in(RCF_NUM), _in(RCF_NUM))) */ - Z3_bool Z3_API Z3_rcf_eq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); + bool Z3_API Z3_rcf_eq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); /** - \brief Return Z3_TRUE if a != b + \brief Return \c true if \ccode{a != b}. def_API('Z3_rcf_neq', BOOL, (_in(CONTEXT), _in(RCF_NUM), _in(RCF_NUM))) */ - Z3_bool Z3_API Z3_rcf_neq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); + bool Z3_API Z3_rcf_neq(Z3_context c, Z3_rcf_num a, Z3_rcf_num b); /** \brief Convert the RCF numeral into a string. def_API('Z3_rcf_num_to_string', STRING, (_in(CONTEXT), _in(RCF_NUM), _in(BOOL), _in(BOOL))) */ - Z3_string Z3_API Z3_rcf_num_to_string(Z3_context c, Z3_rcf_num a, Z3_bool compact, Z3_bool html); + Z3_string Z3_API Z3_rcf_num_to_string(Z3_context c, Z3_rcf_num a, bool compact, bool html); /** \brief Convert the RCF numeral into a string in decimal notation. @@ -191,7 +191,7 @@ extern "C" { /** \brief Extract the "numerator" and "denominator" of the given RCF numeral. - We have that a = n/d, moreover n and d are not represented using rational functions. + We have that \ccode{a = n/d}, moreover \c n and \c d are not represented using rational functions. def_API('Z3_rcf_get_numerator_denominator', VOID, (_in(CONTEXT), _in(RCF_NUM), _out(RCF_NUM), _out(RCF_NUM))) */ diff --git a/src/api/z3_replayer.cpp b/src/api/z3_replayer.cpp index 8ebac8068..97b88c9d7 100644 --- a/src/api/z3_replayer.cpp +++ b/src/api/z3_replayer.cpp @@ -401,6 +401,7 @@ struct z3_replayer::imp { #define TICK_FREQUENCY 100000 void parse() { + memory::exit_when_out_of_memory(false, nullptr); uint64_t counter = 0; unsigned tick = 0; while (true) { diff --git a/src/api/z3_spacer.h b/src/api/z3_spacer.h index 88129d095..09cbe6a51 100644 --- a/src/api/z3_spacer.h +++ b/src/api/z3_spacer.h @@ -37,9 +37,9 @@ extern "C" { \endcode query returns - - Z3_L_FALSE if the query is unsatisfiable. - - Z3_L_TRUE if the query is satisfiable. Obtain the answer by calling #Z3_fixedpoint_get_answer. - - Z3_L_UNDEF if the query was interrupted, timed out or otherwise failed. + - \c Z3_L_FALSE if the query is unsatisfiable. + - \c Z3_L_TRUE if the query is satisfiable. Obtain the answer by calling #Z3_fixedpoint_get_answer. + - \c Z3_L_UNDEF if the query was interrupted, timed out or otherwise failed. def_API('Z3_fixedpoint_query_from_lvl', INT, (_in(CONTEXT), _in(FIXEDPOINT), _in(AST), _in(UINT))) */ @@ -48,7 +48,7 @@ extern "C" { /** \brief Retrieve a bottom-up (from query) sequence of ground facts - The previous call to Z3_fixedpoint_query must have returned Z3_L_TRUE. + The previous call to #Z3_fixedpoint_query must have returned \c Z3_L_TRUE. def_API('Z3_fixedpoint_get_ground_sat_answer', AST, (_in(CONTEXT), _in(FIXEDPOINT))) */ diff --git a/src/ast/CMakeLists.txt b/src/ast/CMakeLists.txt index 80543bb05..ce2817b58 100644 --- a/src/ast/CMakeLists.txt +++ b/src/ast/CMakeLists.txt @@ -14,6 +14,7 @@ z3_add_component(ast ast_translation.cpp ast_util.cpp bv_decl_plugin.cpp + csp_decl_plugin.cpp datatype_decl_plugin.cpp decl_collector.cpp dl_decl_plugin.cpp @@ -35,6 +36,7 @@ z3_add_component(ast occurs.cpp pb_decl_plugin.cpp pp.cpp + recfun_decl_plugin.cpp reg_decl_plugins.cpp seq_decl_plugin.cpp shared_occs.cpp diff --git a/src/ast/arith_decl_plugin.h b/src/ast/arith_decl_plugin.h index 09f082522..00c7e694f 100644 --- a/src/ast/arith_decl_plugin.h +++ b/src/ast/arith_decl_plugin.h @@ -231,6 +231,11 @@ public: bool is_arith_expr(expr const * n) const { return is_app(n) && to_app(n)->get_family_id() == m_afid; } bool is_irrational_algebraic_numeral(expr const * n) const; + bool is_unsigned(expr const * n, unsigned& u) const { + rational val; + bool is_int = true; + return is_numeral(n, val, is_int) && is_int && val.is_unsigned(), u = val.get_unsigned(), true; + } bool is_numeral(expr const * n, rational & val, bool & is_int) const; bool is_numeral(expr const * n, rational & val) const { bool is_int; return is_numeral(n, val, is_int); } bool is_numeral(expr const * n) const { return is_app_of(n, m_afid, OP_NUM); } @@ -361,6 +366,9 @@ public: app * mk_int(int i) { return mk_numeral(rational(i), true); } + app * mk_int(rational const& r) { + return mk_numeral(r, true); + } app * mk_real(int i) { return mk_numeral(rational(i), false); } diff --git a/src/ast/array_decl_plugin.cpp b/src/ast/array_decl_plugin.cpp index af451f9c5..fa17b591d 100644 --- a/src/ast/array_decl_plugin.cpp +++ b/src/ast/array_decl_plugin.cpp @@ -253,7 +253,10 @@ func_decl* array_decl_plugin::mk_select(unsigned arity, sort * const * domain) { if (!parameters[i].is_ast() || !is_sort(parameters[i].get_ast()) || !m_manager->compatible_sorts(domain[i+1], to_sort(parameters[i].get_ast()))) { - m_manager->raise_exception("domain sort and parameter do not match"); + std::stringstream strm; + strm << "domain sort " << sort_ref(domain[i+1], *m_manager) << " and parameter "; + strm << parameter_pp(parameters[i], *m_manager) << " do not match"; + m_manager->raise_exception(strm.str().c_str()); UNREACHABLE(); return nullptr; } @@ -292,8 +295,12 @@ func_decl * array_decl_plugin::mk_store(unsigned arity, sort * const * domain) { m_manager->raise_exception("expecting sort parameter"); return nullptr; } - if (!m_manager->compatible_sorts(to_sort(parameters[i].get_ast()), domain[i+1])) { - m_manager->raise_exception("domain sort and parameter do not match"); + sort* srt1 = to_sort(parameters[i].get_ast()); + sort* srt2 = domain[i+1]; + if (!m_manager->compatible_sorts(srt1, srt2)) { + std::stringstream strm; + strm << "domain sort " << sort_ref(srt2, *m_manager) << " and parameter sort " << sort_ref(srt2, *m_manager) << " do not match"; + m_manager->raise_exception(strm.str()); UNREACHABLE(); return nullptr; } @@ -326,13 +333,13 @@ bool array_decl_plugin::check_set_arguments(unsigned arity, sort * const * domai if (domain[i] != domain[0]) { std::ostringstream buffer; buffer << "arguments " << 1 << " and " << (i+1) << " have different sorts"; - m_manager->raise_exception(buffer.str().c_str()); + m_manager->raise_exception(buffer.str()); return false; } if (domain[i]->get_family_id() != m_family_id) { std::ostringstream buffer; buffer << "argument " << (i+1) << " is not of array sort"; - m_manager->raise_exception(buffer.str().c_str()); + m_manager->raise_exception(buffer.str()); return false; } } @@ -517,6 +524,7 @@ func_decl * array_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters void array_decl_plugin::get_sort_names(svector& sort_names, symbol const & logic) { sort_names.push_back(builtin_name(ARRAY_SORT_STR, ARRAY_SORT)); + sort_names.push_back(builtin_name("=>", ARRAY_SORT)); // TBD: this could easily break users even though it is already used in CVC4: // sort_names.push_back(builtin_name("Set", _SET_SORT)); } diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp index 11a15492c..1f2f40941 100644 --- a/src/ast/ast.cpp +++ b/src/ast/ast.cpp @@ -16,8 +16,8 @@ Author: Revision History: --*/ -#include -#include +#include +#include #include "ast/ast.h" #include "ast/ast_pp.h" #include "ast/ast_ll_pp.h" @@ -424,7 +424,7 @@ sort * get_sort(expr const * n) { return to_quantifier(n)->get_sort(); default: UNREACHABLE(); - return 0; + return nullptr; } } @@ -595,8 +595,7 @@ unsigned get_node_hash(ast const * n) { return 0; } -void ast_table::erase(ast * n) { - // Customized erase method +void ast_table::push_erase(ast * n) { // It uses two important properties: // 1. n is known to be in the table. // 2. operator== can be used instead of compare_nodes (big savings) @@ -604,36 +603,59 @@ void ast_table::erase(ast * n) { unsigned h = n->hash(); unsigned idx = h & mask; cell * c = m_table + idx; - SASSERT(!c->is_free()); cell * prev = nullptr; while (true) { + SASSERT(!c->is_free()); + cell * next = c->m_next; if (c->m_data == n) { m_size--; if (prev == nullptr) { - cell * next = c->m_next; if (next == nullptr) { m_used_slots--; + push_recycle_cell(c); c->mark_free(); SASSERT(c->is_free()); } else { *c = *next; - recycle_cell(next); + next->m_data = n; + push_recycle_cell(next); } } else { - prev->m_next = c->m_next; - recycle_cell(c); + prev->m_next = next; + push_recycle_cell(c); } return; } CHS_CODE(m_collisions++;); prev = c; - c = c->m_next; + c = next; SASSERT(c); } } +ast* ast_table::pop_erase() { + cell* c = m_tofree_cell; + if (c == nullptr) { + return nullptr; + } + if (c->is_free()) { + // cell was marked free, should not be recycled. + c->unmark_free(); + m_tofree_cell = c->m_next; + c->mark_free(); + } + else { + // cell should be recycled with m_free_cell + m_tofree_cell = c->m_next; + recycle_cell(c); + } + return c->m_data; +} + + + // ----------------------------------- // // decl_plugin @@ -1360,11 +1382,13 @@ ast_manager::ast_manager(ast_manager const & src, bool disable_proofs): m_proof_mode(disable_proofs ? PGM_DISABLED : src.m_proof_mode), m_trace_stream(src.m_trace_stream), m_trace_stream_owner(false), - m_rec_fun(":rec-fun") { + m_rec_fun(":rec-fun"), + m_lambda_def(":lambda-def") { SASSERT(!src.is_format_manager()); m_format_manager = alloc(ast_manager, PGM_DISABLED, m_trace_stream, true); init(); copy_families_plugins(src); + update_fresh_id(src); } void ast_manager::update_fresh_id(ast_manager const& m) { @@ -1541,6 +1565,20 @@ void ast_manager::raise_exception(char const * msg) { throw ast_exception(msg); } +void ast_manager::raise_exception(std::string const& msg) { + throw ast_exception(msg.c_str()); +} + + +std::ostream& ast_manager::display(std::ostream& out, parameter const& p) { + switch (p.get_kind()) { + case parameter::PARAM_AST: + return out << mk_pp(p.get_ast(), *this); + default: + return p.display(out); + } + return out; +} void ast_manager::copy_families_plugins(ast_manager const & from) { TRACE("copy_families_plugins", @@ -1656,6 +1694,12 @@ bool ast_manager::are_distinct(expr* a, expr* b) const { return false; } +func_decl* ast_manager::get_rec_fun_decl(quantifier* q) const { + SASSERT(is_rec_fun_def(q)); + return to_app(to_app(q->get_pattern(0))->get_arg(0))->get_decl(); +} + + void ast_manager::register_plugin(family_id id, decl_plugin * plugin) { SASSERT(m_plugins.get(id, 0) == 0); m_plugins.setx(id, plugin, 0); @@ -1806,21 +1850,17 @@ ast * ast_manager::register_node_core(ast * n) { void ast_manager::delete_node(ast * n) { TRACE("delete_node_bug", tout << mk_ll_pp(n, *this) << "\n";); - ptr_buffer worklist; - worklist.push_back(n); - while (!worklist.empty()) { - n = worklist.back(); - worklist.pop_back(); + SASSERT(m_ast_table.contains(n)); + m_ast_table.push_erase(n); + + while ((n = m_ast_table.pop_erase())) { TRACE("ast", tout << "Deleting object " << n->m_id << " " << n << "\n";); CTRACE("del_quantifier", is_quantifier(n), tout << "deleting quantifier " << n->m_id << " " << n << "\n";); TRACE("mk_var_bug", tout << "del_ast: " << n->m_id << "\n";); TRACE("ast_delete_node", tout << mk_bounded_pp(n, *this) << "\n";); - SASSERT(m_ast_table.contains(n)); - m_ast_table.erase(n); - SASSERT(!m_ast_table.contains(n)); SASSERT(!m_debug_ref_count || !m_debug_free_indices.contains(n->m_id)); #ifdef RECYCLE_FREE_AST_INDICES @@ -1839,29 +1879,35 @@ void ast_manager::delete_node(ast * n) { dealloc(info); } break; - case AST_FUNC_DECL: - if (to_func_decl(n)->m_info != nullptr && !m_debug_ref_count) { - func_decl_info * info = to_func_decl(n)->get_info(); + case AST_FUNC_DECL: { + func_decl* f = to_func_decl(n); + if (f->m_info != nullptr && !m_debug_ref_count) { + func_decl_info * info = f->get_info(); info->del_eh(*this); dealloc(info); } - dec_array_ref(worklist, to_func_decl(n)->get_arity(), to_func_decl(n)->get_domain()); - dec_ref(worklist, to_func_decl(n)->get_range()); + push_dec_array_ref(f->get_arity(), f->get_domain()); + push_dec_ref(f->get_range()); break; - case AST_APP: - dec_ref(worklist, to_app(n)->get_decl()); - dec_array_ref(worklist, to_app(n)->get_num_args(), to_app(n)->get_args()); + } + case AST_APP: { + app* a = to_app(n); + push_dec_ref(a->get_decl()); + push_dec_array_ref(a->get_num_args(), a->get_args()); break; + } case AST_VAR: - dec_ref(worklist, to_var(n)->get_sort()); + push_dec_ref(to_var(n)->get_sort()); break; - case AST_QUANTIFIER: - dec_array_ref(worklist, to_quantifier(n)->get_num_decls(), to_quantifier(n)->get_decl_sorts()); - dec_ref(worklist, to_quantifier(n)->get_expr()); - dec_ref(worklist, to_quantifier(n)->get_sort()); - dec_array_ref(worklist, to_quantifier(n)->get_num_patterns(), to_quantifier(n)->get_patterns()); - dec_array_ref(worklist, to_quantifier(n)->get_num_no_patterns(), to_quantifier(n)->get_no_patterns()); + case AST_QUANTIFIER: { + quantifier* q = to_quantifier(n); + push_dec_array_ref(q->get_num_decls(), q->get_decl_sorts()); + push_dec_ref(q->get_expr()); + push_dec_ref(q->get_sort()); + push_dec_array_ref(q->get_num_patterns(), q->get_patterns()); + push_dec_array_ref(q->get_num_no_patterns(), q->get_no_patterns()); break; + } default: break; } diff --git a/src/ast/ast.h b/src/ast/ast.h index 89df04961..b81db5196 100644 --- a/src/ast/ast.h +++ b/src/ast/ast.h @@ -707,6 +707,10 @@ public: func_decl * get_decl() const { return m_decl; } family_id get_family_id() const { return get_decl()->get_family_id(); } decl_kind get_decl_kind() const { return get_decl()->get_decl_kind(); } + symbol const& get_name() const { return get_decl()->get_name(); } + unsigned get_num_parameters() const { return get_decl()->get_num_parameters(); } + parameter const& get_parameter(unsigned idx) const { return get_decl()->get_parameter(idx); } + parameter const* get_parameters() const { return get_decl()->get_parameters(); } bool is_app_of(family_id fid, decl_kind k) const { return get_family_id() == fid && get_decl_kind() == k; } unsigned get_num_args() const { return m_num_args; } expr * get_arg(unsigned idx) const { SASSERT(idx < m_num_args); return m_args[idx]; } @@ -958,7 +962,8 @@ class ast_translation; class ast_table : public chashtable, ast_eq_proc> { public: - void erase(ast * n); + void push_erase(ast * n); + ast* pop_erase(); }; // ----------------------------------- @@ -1558,6 +1563,9 @@ public: // Equivalent to throw ast_exception(msg) Z3_NORETURN void raise_exception(char const * msg); + Z3_NORETURN void raise_exception(std::string const& s); + + std::ostream& display(std::ostream& out, parameter const& p); bool is_format_manager() const { return m_format_manager == nullptr; } @@ -1629,9 +1637,10 @@ public: bool are_distinct(expr * a, expr * b) const; bool contains(ast * a) const { return m_ast_table.contains(a); } - + bool is_rec_fun_def(quantifier* q) const { return q->get_qid() == m_rec_fun; } bool is_lambda_def(quantifier* q) const { return q->get_qid() == m_lambda_def; } + func_decl* get_rec_fun_decl(quantifier* q) const; symbol const& rec_fun_qid() const { return m_rec_fun; } @@ -2289,17 +2298,17 @@ protected: bool check_nnf_proof_parents(unsigned num_proofs, proof * const * proofs) const; private: - void dec_ref(ptr_buffer & worklist, ast * n) { + void push_dec_ref(ast * n) { n->dec_ref(); if (n->get_ref_count() == 0) { - worklist.push_back(n); + m_ast_table.push_erase(n); } } template - void dec_array_ref(ptr_buffer & worklist, unsigned sz, T * const * a) { + void push_dec_array_ref(unsigned sz, T * const * a) { for(unsigned i = 0; i < sz; i++) { - dec_ref(worklist, a[i]); + push_dec_ref(a[i]); } } }; @@ -2493,6 +2502,7 @@ public: void mark(ast * n, bool flag) { if (flag) mark(n); else reset_mark(n); } }; + typedef ast_ref_fast_mark<1> ast_ref_fast_mark1; typedef ast_ref_fast_mark<2> ast_ref_fast_mark2; typedef ast_ref_fast_mark1 expr_ref_fast_mark1; @@ -2568,6 +2578,16 @@ public: void operator()(AST * n) { m_manager.inc_ref(n); } }; +struct parameter_pp { + parameter const& p; + ast_manager& m; + parameter_pp(parameter const& p, ast_manager& m): p(p), m(m) {} +}; + +inline std::ostream& operator<<(std::ostream& out, parameter_pp const& pp) { + return pp.m.display(out, pp.p); +} + #endif /* AST_H_ */ diff --git a/src/ast/ast_pp.h b/src/ast/ast_pp.h index 5629f847a..bfb92c920 100644 --- a/src/ast/ast_pp.h +++ b/src/ast/ast_pp.h @@ -32,5 +32,27 @@ struct mk_pp : public mk_ismt2_pp { } }; +//> recfuns; + recfun::util u(m); + func_decl_ref_vector funs = u.get_rec_funs(); + if (funs.empty()) return; + for (func_decl * f : funs) { + recfuns.push_back(std::make_pair(f, u.get_def(f).get_rhs())); + } + ast_smt2_pp_recdefs(out, recfuns, m_env); } void ast_pp_util::remove_decl(func_decl* f) { diff --git a/src/ast/ast_pp_util.h b/src/ast/ast_pp_util.h index c3b8aa601..e70880672 100644 --- a/src/ast/ast_pp_util.h +++ b/src/ast/ast_pp_util.h @@ -31,7 +31,7 @@ class ast_pp_util { decl_collector coll; - ast_pp_util(ast_manager& m): m(m), m_env(m), coll(m, false) {} + ast_pp_util(ast_manager& m): m(m), m_env(m), coll(m) {} void collect(expr* e); diff --git a/src/ast/ast_smt2_pp.cpp b/src/ast/ast_smt2_pp.cpp index 3a55bbb0b..ceeab30ff 100644 --- a/src/ast/ast_smt2_pp.cpp +++ b/src/ast/ast_smt2_pp.cpp @@ -238,7 +238,7 @@ format * smt2_pp_environment::pp_float_literal(app * t, bool use_bv_lits, bool u string_buffer<> buf; VERIFY(get_futil().is_numeral(t, v)); if (fm.is_nan(v)) { - buf << "(_ NaN " << v.get().get_ebits() << " " << v.get().get_sbits() << ")"; + buf << "(_ NaN " << v.get().get_ebits() << " " << v.get().get_sbits() << ")"; return mk_string(m, buf.c_str()); } else if (fm.is_pinf(v)) { @@ -1163,6 +1163,33 @@ public: unregister_var_names(f->get_arity()); } + // format set of mutually recursive definitions + void operator()(vector> const& funs, format_ref & r) { + format_ref_vector decls(m()), bodies(m()); + format_ref r1(m()), r2(m()); + + for (auto const& p : funs) { + unsigned len; + func_decl* f = p.first; + expr* e = p.second; + format * fname = m_env.pp_fdecl_name(f, len); + register_var_names(f->get_arity()); + format * args[3]; + args[0] = fname; + args[1] = pp_var_args(f->get_arity(), f->get_domain()); + args[2] = m_env.pp_sort(f->get_range()); + decls.push_back(mk_seq1(m(), args, args+3, f2f(), "")); + process(e, r); + bodies.push_back(r); + unregister_var_names(f->get_arity()); + } + r1 = mk_seq1(m(), decls.begin(), decls.end(), f2f(), ""); + r2 = mk_seq1(m(), bodies.begin(), bodies.end(), f2f(), ""); + format * args[2]; + args[0] = r1; + args[1] = r2; + r = mk_seq1(m(), args, args+2, f2f(), "define-rec-funs"); + } }; @@ -1275,6 +1302,16 @@ std::ostream & ast_smt2_pp(std::ostream & out, symbol const& s, bool is_skolem, return out; } +std::ostream & ast_smt2_pp_recdefs(std::ostream & out, vector> const& funs, smt2_pp_environment & env, params_ref const & p) { + ast_manager & m = env.get_manager(); + format_ref r(fm(m)); + smt2_printer pr(env, p); + pr(funs, r); + pp(out, r.get(), m, p); + return out; +} + + mk_ismt2_pp::mk_ismt2_pp(ast * t, ast_manager & m, params_ref const & p, unsigned indent, unsigned num_vars, char const * var_prefix): m_ast(t), m_manager(m), diff --git a/src/ast/ast_smt2_pp.h b/src/ast/ast_smt2_pp.h index 13093f138..dc306c6df 100644 --- a/src/ast/ast_smt2_pp.h +++ b/src/ast/ast_smt2_pp.h @@ -105,6 +105,8 @@ std::ostream & ast_smt2_pp(std::ostream & out, sort * s, smt2_pp_environment & e std::ostream & ast_smt2_pp(std::ostream & out, func_decl * f, smt2_pp_environment & env, params_ref const & p = params_ref(), unsigned indent = 0, char const* cmd = "declare-fun"); std::ostream & ast_smt2_pp(std::ostream & out, func_decl * f, expr* e, smt2_pp_environment & env, params_ref const & p = params_ref(), unsigned indent = 0, char const* cmd = "define-fun"); std::ostream & ast_smt2_pp(std::ostream & out, symbol const& s, bool is_skolem, smt2_pp_environment & env, params_ref const& p = params_ref()); +std::ostream & ast_smt2_pp_recdefs(std::ostream & out, vector> const& funs, smt2_pp_environment & env, params_ref const & p = params_ref()); + /** \brief Internal wrapper (for debugging purposes only) diff --git a/src/ast/ast_smt_pp.cpp b/src/ast/ast_smt_pp.cpp index 5e2828adf..2490e0314 100644 --- a/src/ast/ast_smt_pp.cpp +++ b/src/ast/ast_smt_pp.cpp @@ -399,12 +399,12 @@ class smt_printer { pp_marked_expr(n->get_arg(0)); m_out << ") (_ bv1 1))"; } - else if (m_manager.is_label(n, pos, names) && names.size() >= 1) { + else if (m_manager.is_label(n, pos, names) && !names.empty()) { m_out << "(! "; pp_marked_expr(n->get_arg(0)); m_out << (pos?":lblpos":":lblneg") << " " << m_renaming.get_symbol(names[0], false) << ")"; } - else if (m_manager.is_label_lit(n, names) && names.size() >= 1) { + else if (m_manager.is_label_lit(n, names) && !names.empty()) { m_out << "(! true :lblpos " << m_renaming.get_symbol(names[0], false) << ")"; } else if (num_args == 0) { @@ -811,8 +811,6 @@ public: m_out << ")"; } m_out << "("; - m_out << m_renaming.get_symbol(d->name(), false); - m_out << " "; bool first_constr = true; for (datatype::constructor* f : *d) { if (!first_constr) m_out << " "; else first_constr = false; @@ -954,7 +952,7 @@ void ast_smt_pp::display_smt2(std::ostream& strm, expr* n) { if (m_logic != symbol::null && m_logic != symbol("")) { strm << "(set-logic " << m_logic << ")\n"; } - if (m_attributes.size() > 0) { + if (!m_attributes.empty()) { strm << "; " << m_attributes.c_str(); } @@ -980,14 +978,6 @@ void ast_smt_pp::display_smt2(std::ostream& strm, expr* n) { } } - for (unsigned i = 0; i < decls.get_num_preds(); ++i) { - func_decl* d = decls.get_pred_decls()[i]; - if (!(*m_is_declared)(d)) { - smt_printer p(strm, m, ql, rn, m_logic, true, true, m_simplify_implies, 0); - p(d); - strm << "\n"; - } - } #endif for (expr* a : m_assumptions) { diff --git a/src/ast/ast_util.h b/src/ast/ast_util.h index 23c2205bb..a45c65d82 100644 --- a/src/ast/ast_util.h +++ b/src/ast/ast_util.h @@ -123,7 +123,7 @@ inline expr_ref mk_or(expr_ref_vector const& args) { return expr_ref(mk_or(args. /** Return a if arg = (not a) - Retur (not arg) otherwise + Return (not arg) otherwise */ expr * mk_not(ast_manager & m, expr * arg); diff --git a/src/ast/csp_decl_plugin.cpp b/src/ast/csp_decl_plugin.cpp new file mode 100644 index 000000000..154bbfbc3 --- /dev/null +++ b/src/ast/csp_decl_plugin.cpp @@ -0,0 +1,374 @@ +/*++ +Copyright (c) 2018 Microsoft Corporation + +Module Name: + + csp_decl_plugin.h + +Abstract: + + Declarations used for a job-shop scheduling domain. + +Author: + + Nikolaj Bjorner (nbjorner) 2018-8-9 + +Revision History: + + +--*/ +#include "ast/csp_decl_plugin.h" +#include "ast/arith_decl_plugin.h" + +void csp_decl_plugin::set_manager(ast_manager* m, family_id fid) { + decl_plugin::set_manager(m, fid); + m_int_sort = m_manager->mk_sort(m_manager->mk_family_id("arith"), INT_SORT); + m_alist_sort = m_manager->mk_sort(symbol("AList"), sort_info(m_family_id, ALIST_SORT)); + m_job_sort = m_manager->mk_sort(symbol("Job"), sort_info(m_family_id, JOB_SORT)); + m_resource_sort = m_manager->mk_sort(symbol("Resource"), sort_info(m_family_id, RESOURCE_SORT)); + m_manager->inc_ref(m_int_sort); + m_manager->inc_ref(m_resource_sort); + m_manager->inc_ref(m_job_sort); + m_manager->inc_ref(m_alist_sort); +} + +void csp_decl_plugin::finalize() { + m_manager->dec_ref(m_alist_sort); + m_manager->dec_ref(m_job_sort); + m_manager->dec_ref(m_resource_sort); + m_manager->dec_ref(m_int_sort); +} + +sort * csp_decl_plugin::mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) { + if (num_parameters != 0) { + m_manager->raise_exception("no parameters expected with job-shop sort"); + } + switch (static_cast(k)) { + case JOB_SORT: return m_job_sort; + case RESOURCE_SORT: return m_resource_sort; + case ALIST_SORT: return m_alist_sort; + default: UNREACHABLE(); return nullptr; + } +} + +func_decl * csp_decl_plugin::mk_func_decl( + decl_kind k, unsigned num_parameters, parameter const * parameters, unsigned arity, sort * const * domain, sort *) { + symbol name; + sort* rng = nullptr; + switch (static_cast(k)) { + case OP_JS_JOB: + check_arity(arity); + check_index1(num_parameters, parameters); + name = symbol("job"); + rng = m_job_sort; + break; + case OP_JS_RESOURCE: + check_arity(arity); + check_index1(num_parameters, parameters); + name = symbol("resource"); + rng = m_resource_sort; + break; + case OP_JS_RESOURCE_MAKESPAN: + if (arity != 1 || domain[0] != m_resource_sort) m_manager->raise_exception("makespan expects a resource argument"); + name = symbol("makespan"); + rng = m_int_sort; + break; + case OP_JS_START: + if (arity != 1 || domain[0] != m_job_sort) m_manager->raise_exception("start expects a job argument"); + if (num_parameters > 0) m_manager->raise_exception("no parameters"); + name = symbol("job-start"); + rng = m_int_sort; + break; + case OP_JS_END: + if (arity != 1 || domain[0] != m_job_sort) m_manager->raise_exception("resource expects a job argument"); + if (num_parameters > 0) m_manager->raise_exception("no parameters"); + name = symbol("job-end"); + rng = m_int_sort; + break; + case OP_JS_JOB2RESOURCE: + if (arity != 1 || domain[0] != m_job_sort) m_manager->raise_exception("job2resource expects a job argument"); + if (num_parameters > 0) m_manager->raise_exception("no parameters"); + name = symbol("job2resource"); + rng = m_resource_sort; + break; + case OP_JS_MODEL: + // has no parameters + // all arguments are of sort alist + name = symbol("js-model"); + rng = m_manager->mk_bool_sort(); + break; + case OP_JS_JOB_RESOURCE: + if (arity != 6) m_manager->raise_exception("add-job-resource expects 6 arguments"); + if (domain[0] != m_job_sort) m_manager->raise_exception("first argument of add-job-resource expects should be a job"); + if (domain[1] != m_resource_sort) m_manager->raise_exception("second argument of add-job-resource expects should be a resource"); + if (domain[2] != m_int_sort) m_manager->raise_exception("3rd argument of add-job-resource expects should be an integer"); + if (domain[3] != m_int_sort) m_manager->raise_exception("4th argument of add-job-resource expects should be an integer"); + if (domain[4] != m_int_sort) m_manager->raise_exception("5th argument of add-job-resource expects should be an integer"); + if (domain[5] != m_alist_sort) m_manager->raise_exception("6th argument of add-job-resource should be a list of properties"); + name = symbol("add-job-resource"); + rng = m_alist_sort; + break; + case OP_JS_RESOURCE_AVAILABLE: + if (arity != 6) m_manager->raise_exception("add-resource-available expects 6 arguments"); + if (domain[0] != m_resource_sort) m_manager->raise_exception("first argument of add-resource-available expects should be a resource"); + if (domain[2] != m_int_sort) m_manager->raise_exception("2nd argument of add-resource-available expects should be an integer"); + if (domain[2] != m_int_sort) m_manager->raise_exception("3rd argument of add-resource-available expects should be an integer"); + if (domain[3] != m_int_sort) m_manager->raise_exception("4th argument of add-resource-available expects should be an integer"); + if (domain[4] != m_int_sort) m_manager->raise_exception("5th argument of add-resource-available expects should be an integer"); + if (domain[5] != m_alist_sort) m_manager->raise_exception("6th argument of add-resource-available should be a list of properties"); + name = symbol("add-resource-available"); + rng = m_alist_sort; + break; + case OP_JS_JOB_PREEMPTABLE: + if (arity != 1 || domain[0] != m_job_sort) + m_manager->raise_exception("set-preemptable expects one argument, which is a job"); + name = symbol("set-preemptable"); + rng = m_alist_sort; + break; + case OP_JS_PROPERTIES: + if (arity != 0) m_manager->raise_exception("js-properties takes no arguments"); + for (unsigned i = 0; i < num_parameters; ++i) { + if (!parameters[i].is_symbol()) m_manager->raise_exception("js-properties expects a list of keyword parameters"); + } + name = symbol("js-properties"); + rng = m_alist_sort; + break; + case OP_JS_JOB_GOAL: + if (arity != 1 || domain[0] != m_job_sort) + m_manager->raise_exception("add-job-goal expects one argument, which is a job"); + if (num_parameters != 2 || !parameters[0].is_symbol() || !parameters[1].is_int()) + m_manager->raise_exception("add-job-goal expects one symbol and one integer parameter"); + name = symbol("add-job-goal"); + rng = m_alist_sort; + break; + case OP_JS_OBJECTIVE: + if (arity != 0) + m_manager->raise_exception("add-optimization-objective expects no arguments"); + if (num_parameters != 1 || !parameters[0].is_symbol()) + m_manager->raise_exception("add-optimization-objective expects one symbol parameter"); + name = symbol("add-optimization-objective"); + rng = m_alist_sort; + break; + default: + UNREACHABLE(); + return nullptr; + } + return m_manager->mk_func_decl(name, arity, domain, rng, func_decl_info(m_family_id, k, num_parameters, parameters)); + +} + +void csp_decl_plugin::check_arity(unsigned arity) { + if (arity > 0) + m_manager->raise_exception("csp variables use parameters only and take no arguments"); +} + +void csp_decl_plugin::check_index1(unsigned num_parameters, parameter const* ps) { + if (num_parameters != 1 || !ps[0].is_int()) + m_manager->raise_exception("csp variable expects a single integer parameter"); +} + +void csp_decl_plugin::check_index2(unsigned num_parameters, parameter const* ps) { + if (num_parameters != 2 || !ps[0].is_int() || !ps[1].is_int()) + m_manager->raise_exception("csp variable expects two integer parameters"); +} + + +bool csp_decl_plugin::is_value(app * e) const { + return is_app_of(e, m_family_id, OP_JS_JOB) || is_app_of(e, m_family_id, OP_JS_RESOURCE); +} + +void csp_decl_plugin::get_op_names(svector & op_names, symbol const & logic) { + if (logic == symbol("CSP")) { + op_names.push_back(builtin_name("job", OP_JS_JOB)); + op_names.push_back(builtin_name("resource", OP_JS_RESOURCE)); + op_names.push_back(builtin_name("makespan", OP_JS_RESOURCE_MAKESPAN)); + op_names.push_back(builtin_name("job-start", OP_JS_START)); + op_names.push_back(builtin_name("job-end", OP_JS_END)); + op_names.push_back(builtin_name("job2resource", OP_JS_JOB2RESOURCE)); + op_names.push_back(builtin_name("js-model", OP_JS_MODEL)); + op_names.push_back(builtin_name("add-job-resource", OP_JS_JOB_RESOURCE)); + op_names.push_back(builtin_name("add-resource-available", OP_JS_RESOURCE_AVAILABLE)); + op_names.push_back(builtin_name("set-preemptable", OP_JS_JOB_PREEMPTABLE)); + op_names.push_back(builtin_name("js-properties", OP_JS_PROPERTIES)); + op_names.push_back(builtin_name("add-job-goal", OP_JS_JOB_GOAL)); + op_names.push_back(builtin_name("add-optimization-objective", OP_JS_OBJECTIVE)); + } +} + +void csp_decl_plugin::get_sort_names(svector & sort_names, symbol const & logic) { + if (logic == symbol("CSP")) { + sort_names.push_back(builtin_name("Job", JOB_SORT)); + sort_names.push_back(builtin_name("Resource", RESOURCE_SORT)); + } +} + +expr * csp_decl_plugin::get_some_value(sort * s) { + parameter p(0); + if (is_sort_of(s, m_family_id, JOB_SORT)) + return m_manager->mk_const(mk_func_decl(OP_JS_JOB, 1, &p, 0, nullptr, nullptr)); + if (is_sort_of(s, m_family_id, RESOURCE_SORT)) + return m_manager->mk_const(mk_func_decl(OP_JS_RESOURCE, 1, &p, 0, nullptr, nullptr)); + UNREACHABLE(); + return nullptr; +} + + +csp_util::csp_util(ast_manager& m): m(m) { + m_fid = m.mk_family_id("csp"); + m_plugin = static_cast(m.get_plugin(m_fid)); +} + +sort* csp_util::mk_job_sort() { + return m_plugin->mk_job_sort(); +} + +sort* csp_util::mk_resource_sort() { + return m_plugin->mk_resource_sort(); +} + +app* csp_util::mk_job(unsigned j) { + parameter p(j); + return m.mk_const(m.mk_func_decl(m_fid, OP_JS_JOB, 1, &p, 0, (sort*const*)nullptr, nullptr)); +} + +unsigned csp_util::job2id(expr* j) { + if (is_app_of(j, m_fid, OP_JS_JOB)) { + return to_app(j)->get_decl()->get_parameter(0).get_int(); + } + SASSERT(is_app_of(j, m_fid, OP_JS_START) || + is_app_of(j, m_fid, OP_JS_END) || + is_app_of(j, m_fid, OP_JS_JOB2RESOURCE)); + return job2id(to_app(j)->get_arg(0)); +} + +app* csp_util::mk_resource(unsigned r) { + parameter p(r); + return m.mk_const(m.mk_func_decl(m_fid, OP_JS_RESOURCE, 1, &p, 0, (sort*const*)nullptr, nullptr)); +} + +unsigned csp_util::resource2id(expr* r) { + SASSERT(is_app_of(r, m_fid, OP_JS_RESOURCE)); + return to_app(r)->get_decl()->get_parameter(0).get_int(); +} + +app* csp_util::mk_start(unsigned j) { + app_ref job(mk_job(j), m); + sort* js = m.get_sort(job); + return m.mk_app(m.mk_func_decl(m_fid, OP_JS_START, 0, nullptr, 1, &js, nullptr), job); +} + +app* csp_util::mk_end(unsigned j) { + app_ref job(mk_job(j), m); + sort* js = m.get_sort(job); + return m.mk_app(m.mk_func_decl(m_fid, OP_JS_END, 0, nullptr, 1, &js, nullptr), job); +} + +app* csp_util::mk_job2resource(unsigned j) { + app_ref job(mk_job(j), m); + sort* js = m.get_sort(job); + return m.mk_app(m.mk_func_decl(m_fid, OP_JS_JOB2RESOURCE, 0, nullptr, 1, &js, nullptr), job); +} + +app* csp_util::mk_makespan(unsigned r) { + app_ref resource(mk_resource(r), m); + sort* rs = m.get_sort(resource); + return m.mk_app(m.mk_func_decl(m_fid, OP_JS_RESOURCE_MAKESPAN, 0, nullptr, 1, &rs, nullptr), resource); +} + +bool csp_util::is_resource(expr* e, unsigned& r) { + return is_app_of(e, m_fid, OP_JS_RESOURCE) && (r = resource2id(e), true); +} + +bool csp_util::is_makespan(expr * e, unsigned& r) { + return is_app_of(e, m_fid, OP_JS_RESOURCE_MAKESPAN) && is_resource(to_app(e)->get_arg(0), r); +} + +bool csp_util::is_job(expr* e, unsigned& j) { + return is_app_of(e, m_fid, OP_JS_JOB) && (j = job2id(e), true); +} + +bool csp_util::is_job2resource(expr* e, unsigned& j) { + return is_app_of(e, m_fid, OP_JS_JOB2RESOURCE) && (j = job2id(e), true); +} + +bool csp_util::is_add_resource_available(expr * e, expr *& res, unsigned& loadpct, unsigned& cap_time, uint64_t& start, uint64_t& end, svector& properties) { + if (!is_app_of(e, m_fid, OP_JS_RESOURCE_AVAILABLE)) return false; + res = to_app(e)->get_arg(0); + arith_util a(m); + rational r; + if (!a.is_numeral(to_app(e)->get_arg(1), r) || !r.is_unsigned()) return false; + loadpct = r.get_unsigned(); + if (!a.is_numeral(to_app(e)->get_arg(2), r) || !r.is_unsigned()) return false; + cap_time = r.get_unsigned(); + if (!a.is_numeral(to_app(e)->get_arg(3), r) || !r.is_uint64()) return false; + start = r.get_uint64(); + if (!a.is_numeral(to_app(e)->get_arg(4), r) || !r.is_uint64()) return false; + end = r.get_uint64(); + if (!is_js_properties(to_app(e)->get_arg(5), properties)) return false; + return true; +} + +bool csp_util::is_add_job_resource(expr * e, expr *& job, expr*& res, unsigned& loadpct, uint64_t& capacity, uint64_t& end, svector& properties) { + if (!is_app_of(e, m_fid, OP_JS_JOB_RESOURCE)) return false; + job = to_app(e)->get_arg(0); + res = to_app(e)->get_arg(1); + arith_util a(m); + rational r; + if (!a.is_numeral(to_app(e)->get_arg(2), r) || !r.is_unsigned()) return false; + loadpct = r.get_unsigned(); + if (!a.is_numeral(to_app(e)->get_arg(3), r) || !r.is_uint64()) return false; + capacity = r.get_uint64(); + if (!a.is_numeral(to_app(e)->get_arg(4), r) || !r.is_uint64()) return false; + end = r.get_uint64(); + if (!is_js_properties(to_app(e)->get_arg(5), properties)) return false; + return true; +} + +bool csp_util::is_set_preemptable(expr* e, expr *& job) { + if (!is_app_of(e, m_fid, OP_JS_JOB_PREEMPTABLE)) return false; + job = to_app(e)->get_arg(0); + return true; +} + +bool csp_util::is_js_properties(expr* e, svector& properties) { + if (!is_app_of(e, m_fid, OP_JS_PROPERTIES)) + return false; + unsigned sz = to_app(e)->get_decl()->get_num_parameters(); + for (unsigned i = 0; i < sz; ++i) { + properties.push_back(to_app(e)->get_decl()->get_parameter(i).get_symbol()); + } + return true; +} + +bool csp_util::is_job_goal(expr* e, js_job_goal& goal, unsigned& level, expr*& job) { + if (!is_app_of(e, m_fid, OP_JS_JOB_GOAL)) + return false; + SASSERT(2 == to_app(e)->get_decl()->get_num_parameters()); + SASSERT(1 == to_app(e)->get_num_args()); + symbol g = to_app(e)->get_decl()->get_parameter(0).get_symbol(); + level = to_app(e)->get_decl()->get_parameter(1).get_int(); + if (g == ":earliest-end-time" || g == "earliest-end-time") + goal = JS_JOB_GOAL_EARLIEST_END_TIME; + else if (g == ":latest-start-time" || g == "latest-start-time") + goal = JS_JOB_GOAL_LATEST_START_TIME; + else + return false; + job = to_app(e)->get_arg(0); + return true; +} + +bool csp_util::is_objective(expr* e, js_optimization_objective& objective) { + if (!is_app_of(e, m_fid, OP_JS_OBJECTIVE)) + return false; + SASSERT(1 == to_app(e)->get_decl()->get_num_parameters()); + symbol obj = to_app(e)->get_decl()->get_parameter(0).get_symbol(); + if (obj == ":duration" || obj == "duration") + objective = JS_OBJECTIVE_DURATION; + else if (obj == ":priority" || obj == "priority") + objective = JS_OBJECTIVE_PRIORITY; + else + return false; + return true; +} + + diff --git a/src/ast/csp_decl_plugin.h b/src/ast/csp_decl_plugin.h new file mode 100644 index 000000000..7c10bbfe9 --- /dev/null +++ b/src/ast/csp_decl_plugin.h @@ -0,0 +1,162 @@ +/*++ +Copyright (c) 2018 Microsoft Corporation + +Module Name: + + csp_decl_plugin.h + +Abstract: + + Declarations used for a job-shop scheduling domain. + + The job-shop domain comprises of constants job(j), resource(r) + + It finds values to variables: + - start(j), end(j), job2resource(j) + + It assumes a background of: + - resources : Job -> Resource -> Int * LoadPct - time to run job j on resource r assuming LoadPct + - runtime : Job -> Int - time to run job j if not associated with any resource + - capacity : Resource -> Int -> LoadPct - capacity of resource r at time t, given as sequence of time intervals + // assume each job has at least one resource associated with it. + // introduce a dummy resource if needed. + + // Theory: + end(j) - start(j) = time-to-execute(j) + time-to-execute(j) := time-to-execute(j, resource(j)) otherwise + + time-to-execute(j, r) := (T - start(j)) + where capacity(j,r) = sum_{t = start(j)}^{T} load(loadpct(j,r), r, t) + + capacity(j, r) := cap where (cap, loadpct) = resources j r + loadpct(j, r) := loadpct where (cap, loadpct) = resources j r + + load(loadpct, r, t) := min(capacity r t, loadpct) / loadpct + + capacity(r, t) >= sum_{j | job-on-resource(j, r, t) } min(capacity r t, loadpct(j, r)) + + // Macros: + job-on-resource(j, r) := r = resource(j); + job-on-resource(j, r, t) := (job-on-resource(j, r) & start(j) <= t <= end(j)); + start_min(j, t) := start(j) >= t; + end_max(j, t) := end(j) <= t; + job_link(j1, j2, startstart, hard) := start(j1) = start(j2); + job_link(j1, j2, startstart, soft) := start(j1) <= start(j2); + job_link(j1, j2, endend, hard) := end(j1) = end(j2); + job_link(j1, j2, endend, soft) := end(j2) <= end(j1); + job_link(j1, j2, endstart, hard) := end(j1) = start(j2); + job_link(j1, j2, endstart, soft) := end(j2) <= start(j1); + job_link(j1, j2, startend, hard) := end(j2) = start(j1); + job_link(j1, j2, startend, soft) := end(j1) <= start(j2); + job_delay(j1, j2, t) := end(j1) + t <= end(j2); + job_on_same_resource(j1, j2) := resource(j1) = resource(j2); + job_not_on_same_resource(j1, j2) := resource(j1) != resource(j2); + job_time_intersect(j1, j2) := start(j1) <= end(j2) <= end(j1) || start(j2) <= end(j1) <= end(j2); + + job-on-resource(j, r, t) => job-property(j) = null or job_property(j) in working_time_property(r, t); + +Author: + + Nikolaj Bjorner (nbjorner) 2018-8-9 + +Revision History: + + +--*/ +#pragma once +#include "ast/ast.h" + +enum js_sort_kind { + JOB_SORT, + RESOURCE_SORT, + ALIST_SORT +}; + +enum js_op_kind { + OP_JS_JOB, // value of type job + OP_JS_RESOURCE, // value of type resource + OP_JS_RESOURCE_MAKESPAN, // makespan of resource: the minimal resource time required for assigned jobs. + OP_JS_START, // start time of a job + OP_JS_END, // end time of a job + OP_JS_JOB2RESOURCE, // resource associated with job + OP_JS_MODEL, // jobscheduler model + OP_JS_JOB_RESOURCE, // model declaration for job assignment to resource + OP_JS_JOB_PREEMPTABLE, // model declaration for whether job is pre-emptable + OP_JS_RESOURCE_AVAILABLE, // model declaration for availability intervals of resource + OP_JS_PROPERTIES, // model declaration of a set of properties. Each property is a keyword. + OP_JS_JOB_GOAL, // job goal objective :earliest-end-time or :latest-start-time + OP_JS_OBJECTIVE // duration or completion-time +}; + +enum js_job_goal { + JS_JOB_GOAL_EARLIEST_END_TIME, + JS_JOB_GOAL_LATEST_START_TIME +}; + +enum js_optimization_objective { + JS_OBJECTIVE_DURATION, + JS_OBJECTIVE_PRIORITY +}; + +class csp_decl_plugin : public decl_plugin { +public: + csp_decl_plugin() {} + ~csp_decl_plugin() override {} + void finalize() override; + void set_manager(ast_manager* m, family_id fid) override; + decl_plugin * mk_fresh() override { return alloc(csp_decl_plugin); } + sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override; + func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters, + unsigned arity, sort * const * domain, sort * range) override; + bool is_value(app * e) const override; + bool is_unique_value(app * e) const override { return is_value(e); } + void get_op_names(svector & op_names, symbol const & logic) override; + void get_sort_names(svector & sort_names, symbol const & logic) override; + expr * get_some_value(sort * s) override; + sort * mk_job_sort() const { return m_job_sort; } + sort * mk_resource_sort() const { return m_resource_sort; } + sort * mk_alist_sort() const { return m_alist_sort; } +private: + sort* m_job_sort; + sort* m_resource_sort; + sort* m_alist_sort; + sort* m_int_sort; + + void check_arity(unsigned arity); + void check_index1(unsigned n, parameter const* ps); + void check_index2(unsigned n, parameter const* ps); +}; + +class csp_util { + ast_manager& m; + family_id m_fid; + csp_decl_plugin* m_plugin; +public: + csp_util(ast_manager& m); + sort* mk_job_sort(); + sort* mk_resource_sort(); + + app* mk_job(unsigned j); + app* mk_resource(unsigned r); + app* mk_start(unsigned j); + app* mk_end(unsigned j); + app* mk_job2resource(unsigned j); + app* mk_makespan(unsigned r); + + bool is_job(expr* e, unsigned& j); + bool is_job2resource(expr* e, unsigned& j); + bool is_resource(expr* e, unsigned& r); + bool is_makespan(expr* e, unsigned& r); + bool is_add_resource_available(expr * e, expr *& res, unsigned& loadpct, unsigned& cap_time, uint64_t& start, uint64_t& end, svector& properites); + bool is_add_job_resource(expr * e, expr *& job, expr*& res, unsigned& loadpct, uint64_t& capacity, uint64_t& end, svector& properites); + bool is_set_preemptable(expr* e, expr *& job); + bool is_model(expr* e) const { return is_app_of(e, m_fid, OP_JS_MODEL); } + bool is_js_properties(expr* e, svector& properties); + bool is_job_goal(expr* e, js_job_goal& goal, unsigned& level, expr*& job); + bool is_objective(expr* e, js_optimization_objective& objective); + +private: + unsigned job2id(expr* j); + unsigned resource2id(expr* r); + +}; diff --git a/src/ast/datatype_decl_plugin.cpp b/src/ast/datatype_decl_plugin.cpp index 284c4df93..0271d8311 100644 --- a/src/ast/datatype_decl_plugin.cpp +++ b/src/ast/datatype_decl_plugin.cpp @@ -231,7 +231,7 @@ namespace datatype { } return s; } - catch (invalid_datatype) { + catch (const invalid_datatype &) { m_manager->raise_exception("invalid datatype"); return nullptr; } @@ -682,7 +682,7 @@ namespace datatype { /** \brief Return true if the inductive datatype is well-founded. - Pre-condition: The given argument constains the parameters of an inductive datatype. + Pre-condition: The given argument constrains the parameters of an inductive datatype. */ bool util::is_well_founded(unsigned num_types, sort* const* sorts) { buffer well_founded(num_types, false); diff --git a/src/ast/decl_collector.cpp b/src/ast/decl_collector.cpp index bec60e61c..bc415c461 100644 --- a/src/ast/decl_collector.cpp +++ b/src/ast/decl_collector.cpp @@ -50,18 +50,14 @@ void decl_collector::visit_func(func_decl * n) { if (!m_visited.is_marked(n)) { family_id fid = n->get_family_id(); if (fid == null_family_id) { - if (m_sep_preds && is_bool(n->get_range())) - m_preds.push_back(n); - else - m_decls.push_back(n); + m_decls.push_back(n); } m_visited.mark(n, true); } } -decl_collector::decl_collector(ast_manager & m, bool preds): +decl_collector::decl_collector(ast_manager & m): m_manager(m), - m_sep_preds(preds), m_dt_util(m) { m_basic_fid = m_manager.get_basic_family_id(); m_dt_fid = m_dt_util.get_family_id(); diff --git a/src/ast/decl_collector.h b/src/ast/decl_collector.h index 07539dbd8..8945c0bec 100644 --- a/src/ast/decl_collector.h +++ b/src/ast/decl_collector.h @@ -26,10 +26,8 @@ Revision History: class decl_collector { ast_manager & m_manager; - bool m_sep_preds; ptr_vector m_sorts; ptr_vector m_decls; - ptr_vector m_preds; ast_mark m_visited; family_id m_basic_fid; family_id m_dt_fid; @@ -46,8 +44,7 @@ class decl_collector { public: - // if preds == true, then predicates are stored in a separate collection. - decl_collector(ast_manager & m, bool preds = true); + decl_collector(ast_manager & m); ast_manager & m() { return m_manager; } void visit_func(func_decl* n); @@ -59,11 +56,9 @@ public: unsigned get_num_sorts() const { return m_sorts.size(); } unsigned get_num_decls() const { return m_decls.size(); } - unsigned get_num_preds() const { return m_preds.size(); } sort * const * get_sorts() const { return m_sorts.c_ptr(); } func_decl * const * get_func_decls() const { return m_decls.c_ptr(); } - func_decl * const * get_pred_decls() const { return m_preds.c_ptr(); } }; #endif diff --git a/src/ast/dl_decl_plugin.cpp b/src/ast/dl_decl_plugin.cpp index f4a538abd..01b06518e 100644 --- a/src/ast/dl_decl_plugin.cpp +++ b/src/ast/dl_decl_plugin.cpp @@ -147,7 +147,7 @@ namespace datalog { for (unsigned i = 0; i < n; ++i) { parameter const& p = r->get_parameter(i); if (!p.is_ast() || !is_sort(p.get_ast())) { - m_manager->raise_exception("exptected sort parameter"); + m_manager->raise_exception("expected sort parameter"); return false; } sorts.push_back(to_sort(p.get_ast())); @@ -185,7 +185,7 @@ namespace datalog { verbose_stream() << "Domain: " << mk_pp(domain[0], m) << "\n" << mk_pp(sorts[i], m) << "\n" << mk_pp(domain[i+1], m) << "\n";); - m_manager->raise_exception("sort miss-match for relational access"); + m_manager->raise_exception("sort mismatch for relational access"); return nullptr; } } @@ -252,7 +252,7 @@ namespace datalog { func_decl * dl_decl_plugin::mk_unionw(decl_kind k, sort* s1, sort* s2) { ast_manager& m = *m_manager; if (s1 != s2) { - m_manager->raise_exception("sort miss-match for arguments to union"); + m_manager->raise_exception("sort mismatch for arguments to union"); return nullptr; } if (!is_rel_sort(s1)) { @@ -298,7 +298,7 @@ namespace datalog { return nullptr; } if (sorts[idx] != m.get_sort(e)) { - m_manager->raise_exception("sort miss-match in filter"); + m_manager->raise_exception("sort mismatch in filter"); return nullptr; } break; @@ -391,7 +391,7 @@ namespace datalog { return nullptr; } if (sorts1[i1] != sorts2[i2]) { - m_manager->raise_exception("sort miss-match in join"); + m_manager->raise_exception("sort mismatch in join"); return nullptr; } } @@ -435,7 +435,7 @@ namespace datalog { return nullptr; } if (sorts1[i1] != sorts2[i2]) { - m_manager->raise_exception("sort miss-match in join"); + m_manager->raise_exception("sort mismatch in join"); return nullptr; } } diff --git a/src/ast/expr2polynomial.cpp b/src/ast/expr2polynomial.cpp index 280d7487a..82bace428 100644 --- a/src/ast/expr2polynomial.cpp +++ b/src/ast/expr2polynomial.cpp @@ -436,7 +436,7 @@ struct expr2polynomial::imp { margs.push_back(t); } } - if (margs.size() == 0) { + if (margs.empty()) { args.push_back(m_autil.mk_numeral(rational(1), is_int)); } else if (margs.size() == 1) { @@ -447,7 +447,7 @@ struct expr2polynomial::imp { } } - if (args.size() == 0) { + if (args.empty()) { r = m_autil.mk_numeral(rational(0), is_int); } else if (args.size() == 1) { diff --git a/src/ast/expr_functors.cpp b/src/ast/expr_functors.cpp index cada71ac9..6a2138106 100644 --- a/src/ast/expr_functors.cpp +++ b/src/ast/expr_functors.cpp @@ -69,7 +69,11 @@ void check_pred::visit(expr* e) { case AST_QUANTIFIER: { quantifier* q = to_quantifier(e); expr* arg = q->get_expr(); - if (m_visited.is_marked(arg)) { + if (!m_check_quantifiers) { + todo.pop_back(); + m_visited.mark(e, true); + } + else if (m_visited.is_marked(arg)) { todo.pop_back(); if (m_pred_holds.is_marked(arg)) { m_pred_holds.mark(e, true); diff --git a/src/ast/expr_functors.h b/src/ast/expr_functors.h index 5a4cac477..5825bea73 100644 --- a/src/ast/expr_functors.h +++ b/src/ast/expr_functors.h @@ -53,8 +53,10 @@ class check_pred { ast_mark m_pred_holds; ast_mark m_visited; expr_ref_vector m_refs; + bool m_check_quantifiers; public: - check_pred(i_expr_pred& p, ast_manager& m) : m_pred(p), m_refs(m) {} + check_pred(i_expr_pred& p, ast_manager& m, bool check_quantifiers = true) : + m_pred(p), m_refs(m), m_check_quantifiers(check_quantifiers) {} bool operator()(expr* e); diff --git a/src/ast/for_each_expr.cpp b/src/ast/for_each_expr.cpp index d46388801..311133e05 100644 --- a/src/ast/for_each_expr.cpp +++ b/src/ast/for_each_expr.cpp @@ -58,7 +58,7 @@ bool has_skolem_functions(expr * n) { try { for_each_expr(p, n); } - catch (has_skolem_functions_ns::found) { + catch (const has_skolem_functions_ns::found &) { return true; } return false; diff --git a/src/ast/fpa/fpa2bv_converter.cpp b/src/ast/fpa/fpa2bv_converter.cpp index dd3f35a2a..1dc13ff9e 100644 --- a/src/ast/fpa/fpa2bv_converter.cpp +++ b/src/ast/fpa/fpa2bv_converter.cpp @@ -21,6 +21,8 @@ Notes: #include "ast/ast_smt2_pp.h" #include "ast/well_sorted.h" #include "ast/rewriter/th_rewriter.h" +#include "ast/used_vars.h" +#include "ast/rewriter/var_subst.h" #include "ast/fpa/fpa2bv_converter.h" #include "ast/rewriter/fpa_rewriter.h" @@ -230,6 +232,42 @@ void fpa2bv_converter::mk_var(unsigned base_inx, sort * srt, expr_ref & result) result = m_util.mk_fp(sgn, e, s); } +expr_ref fpa2bv_converter::extra_quantify(expr * e) +{ + used_vars uv; + unsigned nv; + + ptr_buffer new_decl_sorts; + sbuffer new_decl_names; + expr_ref_buffer subst_map(m); + + uv(e); + nv = uv.get_num_vars(); + subst_map.resize(uv.get_max_found_var_idx_plus_1()); + + if (nv == 0) + return expr_ref(e, m); + + for (unsigned i = 0; i < nv; i++) + { + if (uv.contains(i)) { + TRACE("fpa2bv", tout << "uv[" << i << "] = " << mk_ismt2_pp(uv.get(i), m) << std::endl; ); + sort * s = uv.get(i); + var * v = m.mk_var(i, s); + new_decl_sorts.push_back(s); + new_decl_names.push_back(symbol(i)); + subst_map.set(i, v); + } + } + + expr_ref res(m); + var_subst vsubst(m); + res = vsubst.operator()(e, nv, subst_map.c_ptr()); + TRACE("fpa2bv", tout << "subst'd = " << mk_ismt2_pp(res, m) << std::endl; ); + res = m.mk_forall(nv, new_decl_sorts.c_ptr(), new_decl_names.c_ptr(), res); + return res; +} + void fpa2bv_converter::mk_uf(func_decl * f, unsigned num, expr * const * args, expr_ref & result) { TRACE("fpa2bv", tout << "UF: " << mk_ismt2_pp(f, m) << std::endl; ); @@ -252,7 +290,7 @@ void fpa2bv_converter::mk_uf(func_decl * f, unsigned num, expr * const * args, e m_bv_util.mk_extract(sbits+ebits-2, sbits-1, bv_app), m_bv_util.mk_extract(sbits-2, 0, bv_app)); new_eq = m.mk_eq(fapp, flt_app); - m_extra_assertions.push_back(new_eq); + m_extra_assertions.push_back(extra_quantify(new_eq)); result = flt_app; } else if (m_util.is_rm(rng)) { @@ -263,7 +301,7 @@ void fpa2bv_converter::mk_uf(func_decl * f, unsigned num, expr * const * args, e bv_app = m.mk_app(bv_f, num, args); flt_app = m_util.mk_bv2rm(bv_app); new_eq = m.mk_eq(fapp, flt_app); - m_extra_assertions.push_back(new_eq); + m_extra_assertions.push_back(extra_quantify(new_eq)); result = flt_app; } else diff --git a/src/ast/fpa/fpa2bv_converter.h b/src/ast/fpa/fpa2bv_converter.h index 7637317b0..812c24155 100644 --- a/src/ast/fpa/fpa2bv_converter.h +++ b/src/ast/fpa/fpa2bv_converter.h @@ -220,6 +220,8 @@ private: func_decl * mk_bv_uf(func_decl * f, sort * const * domain, sort * range); expr_ref nan_wrap(expr * n); + + expr_ref extra_quantify(expr * e); }; #endif diff --git a/src/ast/fpa/fpa2bv_rewriter.cpp b/src/ast/fpa/fpa2bv_rewriter.cpp index cc25905f0..7195f7179 100644 --- a/src/ast/fpa/fpa2bv_rewriter.cpp +++ b/src/ast/fpa/fpa2bv_rewriter.cpp @@ -31,7 +31,7 @@ fpa2bv_rewriter_cfg::fpa2bv_rewriter_cfg(ast_manager & m, fpa2bv_converter & c, m_bindings(m) { updt_params(p); - // We need to make sure that the mananger has the BV plugin loaded. + // We need to make sure that the manager has the BV plugin loaded. symbol s_bv("bv"); if (!m_manager.has_plugin(s_bv)) m_manager.register_plugin(s_bv, alloc(bv_decl_plugin)); @@ -215,6 +215,12 @@ bool fpa2bv_rewriter_cfg::reduce_quantifier(quantifier * old_q, new_decl_names.push_back(symbol(name_buffer.c_str())); new_decl_sorts.push_back(m_conv.bu().mk_sort(sbits+ebits)); } + else if (m_conv.is_rm(s)) { + name_buffer.reset(); + name_buffer << n << ".bv"; + new_decl_names.push_back(symbol(name_buffer.c_str())); + new_decl_sorts.push_back(m_conv.bu().mk_sort(3)); + } else { new_decl_sorts.push_back(s); new_decl_names.push_back(n); @@ -248,6 +254,11 @@ bool fpa2bv_rewriter_cfg::reduce_var(var * t, expr_ref & result, proof_ref & res m_conv.bu().mk_extract(ebits - 1, 0, new_var), m_conv.bu().mk_extract(sbits+ebits-2, ebits, new_var)); } + else if (m_conv.is_rm(s)) { + expr_ref new_var(m()); + new_var = m().mk_var(t->get_idx(), m_conv.bu().mk_sort(3)); + new_exp = m_conv.fu().mk_bv2rm(new_var); + } else new_exp = m().mk_var(t->get_idx(), s); diff --git a/src/ast/func_decl_dependencies.h b/src/ast/func_decl_dependencies.h index b813dc31f..9bc0be22d 100644 --- a/src/ast/func_decl_dependencies.h +++ b/src/ast/func_decl_dependencies.h @@ -58,7 +58,7 @@ public: void reset(); /** - \brief Create a dependecy set. + \brief Create a dependency set. This set should be populated using #collect_func_decls. After populating the set, it must be used as an argument for the #insert method. diff --git a/src/ast/macros/quasi_macros.cpp b/src/ast/macros/quasi_macros.cpp index ee1b77545..c91f19df8 100644 --- a/src/ast/macros/quasi_macros.cpp +++ b/src/ast/macros/quasi_macros.cpp @@ -263,7 +263,7 @@ bool quasi_macros::find_macros(unsigned n, expr * const * exprs) { m_occurrences.reset(); - // Find out how many non-ground appearences for each uninterpreted function there are + // Find out how many non-ground appearances for each uninterpreted function there are for (unsigned i = 0 ; i < n ; i++) find_occurrences(exprs[i]); @@ -301,7 +301,7 @@ bool quasi_macros::find_macros(unsigned n, justified_expr const * exprs) { m_occurrences.reset(); - // Find out how many non-ground appearences for each uninterpreted function there are + // Find out how many non-ground appearances for each uninterpreted function there are for ( unsigned i = 0 ; i < n ; i++ ) find_occurrences(exprs[i].get_fml()); diff --git a/src/ast/normal_forms/defined_names.cpp b/src/ast/normal_forms/defined_names.cpp index b63c947a9..88ded842f 100644 --- a/src/ast/normal_forms/defined_names.cpp +++ b/src/ast/normal_forms/defined_names.cpp @@ -221,7 +221,7 @@ void defined_names::impl::mk_definition(expr * e, app * n, sort_ref_buffer & var args.push_back(m.mk_var(q->get_num_decls() - i - 1, q->get_decl_sort(i))); } array_util autil(m); - func_decl * f = 0; + func_decl * f = nullptr; if (autil.is_as_array(n2, f)) { n3 = m.mk_app(f, args.size()-1, args.c_ptr() + 1); } diff --git a/src/ast/normal_forms/name_exprs.cpp b/src/ast/normal_forms/name_exprs.cpp index 5e9af1c2d..bb2543b3e 100644 --- a/src/ast/normal_forms/name_exprs.cpp +++ b/src/ast/normal_forms/name_exprs.cpp @@ -127,7 +127,7 @@ class name_nested_formulas : public name_exprs_core { ast_manager & m; expr * m_root; - pred(ast_manager & m):m(m), m_root(0) {} + pred(ast_manager & m):m(m), m_root(nullptr) {} bool operator()(expr * t) override { TRACE("name_exprs", tout << "name_nested_formulas::pred:\n" << mk_ismt2_pp(t, m) << "\n";); diff --git a/src/ast/normal_forms/nnf.cpp b/src/ast/normal_forms/nnf.cpp index 7786def0b..c03ff1d0f 100644 --- a/src/ast/normal_forms/nnf.cpp +++ b/src/ast/normal_forms/nnf.cpp @@ -258,7 +258,6 @@ struct nnf::imp { // configuration ---------------- nnf_mode m_mode; bool m_ignore_labels; - bool m_skolemize; // ------------------------------ name_exprs * m_name_nested_formulas; @@ -312,7 +311,6 @@ struct nnf::imp { TRACE("nnf", tout << "nnf-mode: " << m_mode << " " << mode_sym << "\n" << _p << "\n";); m_ignore_labels = p.ignore_labels(); - m_skolemize = p.skolemize(); m_max_memory = megabytes_to_bytes(p.max_memory()); m_skolemizer.set_sk_hack(p.sk_hack()); } @@ -759,7 +757,7 @@ struct nnf::imp { if (!visit(q->get_expr(), fr.m_pol, true)) return false; } - else if (is_forall(q) == fr.m_pol || !m_skolemize) { + else if (is_forall(q) == fr.m_pol) { if (!visit(q->get_expr(), fr.m_pol, true)) return false; } @@ -788,7 +786,7 @@ struct nnf::imp { } return true; } - else if (is_forall(q) == fr.m_pol || !m_skolemize) { + else if (is_forall(q) == fr.m_pol) { expr * new_expr = m_result_stack.back(); proof * new_expr_pr = proofs_enabled() ? m_result_pr_stack.back() : nullptr; diff --git a/src/ast/normal_forms/nnf_params.pyg b/src/ast/normal_forms/nnf_params.pyg index aac8fbb86..999465efc 100644 --- a/src/ast/normal_forms/nnf_params.pyg +++ b/src/ast/normal_forms/nnf_params.pyg @@ -5,5 +5,4 @@ def_module_params('nnf', ('sk_hack', BOOL, False, 'hack for VCC'), ('mode', SYMBOL, 'skolem', 'NNF translation mode: skolem (skolem normal form), quantifiers (skolem normal form + quantifiers in NNF), full'), - ('ignore_labels', BOOL, False, 'remove/ignore labels in the input formula, this option is ignored if proofs are enabled'), - ('skolemize', BOOL, True, 'skolemize (existential force) quantifiers'))) + ('ignore_labels', BOOL, False, 'remove/ignore labels in the input formula, this option is ignored if proofs are enabled'))) diff --git a/src/ast/normal_forms/pull_quant.cpp b/src/ast/normal_forms/pull_quant.cpp index 9ff75ca25..441db5234 100644 --- a/src/ast/normal_forms/pull_quant.cpp +++ b/src/ast/normal_forms/pull_quant.cpp @@ -24,11 +24,11 @@ Notes: struct pull_quant::imp { struct rw_cfg : public default_rewriter_cfg { - ast_manager & m_manager; + ast_manager & m; shift_vars m_shift; rw_cfg(ast_manager & m): - m_manager(m), + m(m), m_shift(m) { } @@ -43,14 +43,14 @@ struct pull_quant::imp { // Remark: (AND a1 ...) may be represented (NOT (OR (NOT a1) ...))) // So, when pulling a quantifier over a NOT, it becomes an exists. - if (m_manager.is_not(d)) { + if (m.is_not(d)) { SASSERT(num_children == 1); expr * child = children[0]; if (is_quantifier(child)) { quantifier * q = to_quantifier(child); expr * body = q->get_expr(); quantifier_kind k = q->get_kind() == forall_k ? exists_k : forall_k; - result = m_manager.update_quantifier(q, k, m_manager.mk_not(body)); + result = m.update_quantifier(q, k, m.mk_not(body)); return true; } else { @@ -86,7 +86,7 @@ struct pull_quant::imp { var_sorts.push_back(nested_q->get_decl_sort(j)); symbol s = nested_q->get_decl_name(j); if (std::find(var_names.begin(), var_names.end(), s) != var_names.end()) - var_names.push_back(m_manager.mk_fresh_var_name(s.is_numerical() ? nullptr : s.bare_str())); + var_names.push_back(m.mk_fresh_var_name(s.is_numerical() ? nullptr : s.bare_str())); else var_names.push_back(s); } @@ -96,8 +96,8 @@ struct pull_quant::imp { if (!var_sorts.empty()) { SASSERT(found_quantifier); // adjust the variable ids in formulas in new_children - expr_ref_buffer new_adjusted_children(m_manager); - expr_ref adjusted_child(m_manager); + expr_ref_buffer new_adjusted_children(m); + expr_ref adjusted_child(m); unsigned num_decls = var_sorts.size(); unsigned shift_amount = 0; TRACE("pull_quant", tout << "Result num decls:" << num_decls << "\n";); @@ -108,7 +108,7 @@ struct pull_quant::imp { // child will be in the scope of num_decls bound variables. m_shift(child, num_decls, adjusted_child); TRACE("pull_quant", tout << "shifted by: " << num_decls << "\n" << - mk_pp(child, m_manager) << "\n---->\n" << mk_pp(adjusted_child, m_manager) << "\n";); + mk_pp(child, m) << "\n---->\n" << mk_pp(adjusted_child, m) << "\n";); } else { quantifier * nested_q = to_quantifier(child); @@ -130,8 +130,8 @@ struct pull_quant::imp { shift_amount, // shift2 (shift by this amount if var idx < bound) adjusted_child); TRACE("pull_quant", tout << "shifted bound: " << nested_q->get_num_decls() << " shift1: " << shift_amount << - " shift2: " << (num_decls - nested_q->get_num_decls()) << "\n" << mk_pp(nested_q->get_expr(), m_manager) << - "\n---->\n" << mk_pp(adjusted_child, m_manager) << "\n";); + " shift2: " << (num_decls - nested_q->get_num_decls()) << "\n" << mk_pp(nested_q->get_expr(), m) << + "\n---->\n" << mk_pp(adjusted_child, m) << "\n";); shift_amount += nested_q->get_num_decls(); } new_adjusted_children.push_back(adjusted_child); @@ -150,11 +150,11 @@ struct pull_quant::imp { // 3) MBQI std::reverse(var_sorts.begin(), var_sorts.end()); std::reverse(var_names.begin(), var_names.end()); - result = m_manager.mk_quantifier(forall_children ? forall_k : exists_k, + result = m.mk_quantifier(forall_children ? forall_k : exists_k, var_sorts.size(), var_sorts.c_ptr(), var_names.c_ptr(), - m_manager.mk_app(d, new_adjusted_children.size(), new_adjusted_children.c_ptr()), + m.mk_app(d, new_adjusted_children.size(), new_adjusted_children.c_ptr()), w, qid); return true; @@ -167,7 +167,7 @@ struct pull_quant::imp { void pull_quant1(func_decl * d, unsigned num_children, expr * const * children, expr_ref & result) { if (!pull_quant1_core(d, num_children, children, result)) { - result = m_manager.mk_app(d, num_children, children); + result = m.mk_app(d, num_children, children); } } @@ -185,7 +185,7 @@ struct pull_quant::imp { var_names.append(nested_q->get_num_decls(), const_cast(nested_q->get_decl_names())); // Remark: patterns are ignored. // See comment in reduce1_app - result = m_manager.mk_forall(var_sorts.size(), + result = m.mk_forall(var_sorts.size(), var_sorts.c_ptr(), var_names.c_ptr(), nested_q->get_expr(), @@ -201,7 +201,7 @@ struct pull_quant::imp { } else { SASSERT(!is_quantifier(new_expr)); - result = m_manager.update_quantifier(q, new_expr); + result = m.update_quantifier(q, new_expr); } } @@ -218,36 +218,36 @@ struct pull_quant::imp { void pull_quant2(expr * n, expr_ref & r, proof_ref & pr) { pr = nullptr; if (is_app(n)) { - expr_ref_buffer new_args(m_manager); - expr_ref new_arg(m_manager); + expr_ref_buffer new_args(m); + expr_ref new_arg(m); ptr_buffer proofs; for (expr * arg : *to_app(n)) { pull_quant1(arg , new_arg); new_args.push_back(new_arg); if (new_arg != arg) - proofs.push_back(m_manager.mk_pull_quant(arg, to_quantifier(new_arg))); + proofs.push_back(m.mk_pull_quant(arg, to_quantifier(new_arg))); } pull_quant1(to_app(n)->get_decl(), new_args.size(), new_args.c_ptr(), r); - if (m_manager.proofs_enabled()) { - app * r1 = m_manager.mk_app(to_app(n)->get_decl(), new_args.size(), new_args.c_ptr()); - proof * p1 = proofs.empty() ? nullptr : m_manager.mk_congruence(to_app(n), r1, proofs.size(), proofs.c_ptr()); - proof * p2 = r1 == r ? nullptr : m_manager.mk_pull_quant(r1, to_quantifier(r)); - pr = m_manager.mk_transitivity(p1, p2); + if (m.proofs_enabled()) { + app * r1 = m.mk_app(to_app(n)->get_decl(), new_args.size(), new_args.c_ptr()); + proof * p1 = proofs.empty() ? nullptr : m.mk_congruence(to_app(n), r1, proofs.size(), proofs.c_ptr()); + proof * p2 = r1 == r ? nullptr : m.mk_pull_quant(r1, to_quantifier(r)); + pr = m.mk_transitivity(p1, p2); } } else if (is_quantifier(n)) { - expr_ref new_expr(m_manager); + expr_ref new_expr(m); pull_quant1(to_quantifier(n)->get_expr(), new_expr); pull_quant1(to_quantifier(n), new_expr, r); - if (m_manager.proofs_enabled()) { - quantifier * q1 = m_manager.update_quantifier(to_quantifier(n), new_expr); + if (m.proofs_enabled()) { + quantifier * q1 = m.update_quantifier(to_quantifier(n), new_expr); proof * p1 = nullptr; if (n != q1) { - proof * p0 = m_manager.mk_pull_quant(n, to_quantifier(new_expr)); - p1 = m_manager.mk_quant_intro(to_quantifier(n), q1, p0); + proof * p0 = m.mk_pull_quant(n, to_quantifier(new_expr)); + p1 = m.mk_quant_intro(to_quantifier(n), q1, p0); } - proof * p2 = q1 == r ? nullptr : m_manager.mk_pull_quant(q1, to_quantifier(r)); - pr = m_manager.mk_transitivity(p1, p2); + proof * p2 = q1 == r ? nullptr : m.mk_pull_quant(q1, to_quantifier(r)); + pr = m.mk_transitivity(p1, p2); } } else { @@ -256,14 +256,14 @@ struct pull_quant::imp { } br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) { - if (!m_manager.is_or(f) && !m_manager.is_and(f) && !m_manager.is_not(f)) + if (!m.is_or(f) && !m.is_and(f) && !m.is_not(f)) return BR_FAILED; if (!pull_quant1_core(f, num, args, result)) return BR_FAILED; - if (m_manager.proofs_enabled()) { - result_pr = m_manager.mk_pull_quant(m_manager.mk_app(f, num, args), + if (m.proofs_enabled()) { + result_pr = m.mk_pull_quant(m.mk_app(f, num, args), to_quantifier(result.get())); } return BR_DONE; @@ -277,8 +277,11 @@ struct pull_quant::imp { proof_ref & result_pr) { if (is_exists(old_q)) { - UNREACHABLE(); - return false; + result = m.mk_not(new_body); + result = m.mk_not(m.update_quantifier(old_q, exists_k, result)); + if (m.proofs_enabled()) + m.mk_rewrite(old_q, result); + return true; } if (is_lambda(old_q)) { return false; @@ -288,8 +291,8 @@ struct pull_quant::imp { return false; pull_quant1_core(old_q, new_body, result); - if (m_manager.proofs_enabled()) - result_pr = m_manager.mk_pull_quant(old_q, to_quantifier(result.get())); + if (m.proofs_enabled()) + result_pr = m.mk_pull_quant(old_q, to_quantifier(result.get())); return true; } }; diff --git a/src/ast/occurs.cpp b/src/ast/occurs.cpp index c76e73748..9ddb2fa56 100644 --- a/src/ast/occurs.cpp +++ b/src/ast/occurs.cpp @@ -58,7 +58,7 @@ bool occurs(expr * n1, expr * n2) { try { quick_for_each_expr(p, n2); } - catch (occurs_namespace::found) { + catch (const occurs_namespace::found &) { return true; } return false; @@ -69,7 +69,7 @@ bool occurs(func_decl * d, expr * n) { try { quick_for_each_expr(p, n); } - catch (occurs_namespace::found) { + catch (const occurs_namespace::found &) { return true; } return false; diff --git a/src/ast/pattern/expr_pattern_match.cpp b/src/ast/pattern/expr_pattern_match.cpp index 47b3e9203..5cd3542df 100644 --- a/src/ast/pattern/expr_pattern_match.cpp +++ b/src/ast/pattern/expr_pattern_match.cpp @@ -393,10 +393,8 @@ expr_pattern_match::initialize(char const * spec_string) { VERIFY(parse_smt2_commands(ctx, is)); ctx.set_print_success(ps); - ptr_vector::const_iterator it = ctx.begin_assertions(); - ptr_vector::const_iterator end = ctx.end_assertions(); - for (; it != end; ++it) { - compile(*it); + for (expr * e : ctx.assertions()) { + compile(e); } TRACE("expr_pattern_match", display(tout); ); } diff --git a/src/ast/pattern/pattern_inference.cpp b/src/ast/pattern/pattern_inference.cpp index f6c8788d0..93b269f87 100644 --- a/src/ast/pattern/pattern_inference.cpp +++ b/src/ast/pattern/pattern_inference.cpp @@ -594,7 +594,6 @@ bool pattern_inference_cfg::reduce_quantifier( unsigned new_weight; if (m_database.match_quantifier(q, new_patterns, new_weight)) { DEBUG_CODE(for (unsigned i = 0; i < new_patterns.size(); i++) { SASSERT(is_well_sorted(m, new_patterns.get(i))); }); - quantifier_ref new_q(m); if (q->get_num_patterns() > 0) { // just update the weight... TRACE("pattern_inference", tout << "updating weight to: " << new_weight << "\n" << mk_pp(q, m) << "\n";); @@ -604,10 +603,10 @@ bool pattern_inference_cfg::reduce_quantifier( quantifier_ref tmp(m); tmp = m.update_quantifier(q, new_patterns.size(), (expr**) new_patterns.c_ptr(), q->get_expr()); result = m.update_quantifier_weight(tmp, new_weight); - TRACE("pattern_inference", tout << "found patterns in database, weight: " << new_weight << "\n" << mk_pp(new_q, m) << "\n";); + TRACE("pattern_inference", tout << "found patterns in database, weight: " << new_weight << "\n" << mk_pp(result, m) << "\n";); } if (m.proofs_enabled()) - result_pr = m.mk_rewrite(q, new_q); + result_pr = m.mk_rewrite(q, result); return true; } } @@ -687,7 +686,7 @@ bool pattern_inference_cfg::reduce_quantifier( mk_patterns(result2->get_num_decls(), result2->get_expr(), 0, nullptr, new_patterns); if (!new_patterns.empty()) { if (m_params.m_pi_warnings) { - warning_msg("pulled nested quantifier to be able to find an useable pattern (quantifier id: %s)", q->get_qid().str().c_str()); + warning_msg("pulled nested quantifier to be able to find an usable pattern (quantifier id: %s)", q->get_qid().str().c_str()); } new_q = m.update_quantifier(result2, new_patterns.size(), (expr**) new_patterns.c_ptr(), result2->get_expr()); if (m.proofs_enabled()) { diff --git a/src/ast/proofs/proof_utils.cpp b/src/ast/proofs/proof_utils.cpp index 5483a9ea0..5c37c3794 100644 --- a/src/ast/proofs/proof_utils.cpp +++ b/src/ast/proofs/proof_utils.cpp @@ -238,7 +238,7 @@ class reduce_hypotheses { { args.push_back(fact); } - if (args.size() == 0) { return pf; } + if (args.empty()) { return pf; } else if (args.size() == 1) { lemma = args.get(0); } else { diff --git a/src/ast/recfun_decl_plugin.cpp b/src/ast/recfun_decl_plugin.cpp new file mode 100644 index 000000000..ebdf86ca5 --- /dev/null +++ b/src/ast/recfun_decl_plugin.cpp @@ -0,0 +1,420 @@ +/*++ +Copyright (c) 2017 Microsoft Corporation, Simon Cruanes + +Module Name: + + recfun_decl_plugin.cpp + +Abstract: + + Declaration and definition of (potentially recursive) functions + +Author: + + Simon Cruanes 2017-11 + +Revision History: + +--*/ + + +#include +#include +#include "ast/expr_functors.h" +#include "ast/recfun_decl_plugin.h" +#include "ast/ast_pp.h" +#include "util/scoped_ptr_vector.h" + +#define TRACEFN(x) TRACE("recfun", tout << x << '\n';) +#define VALIDATE_PARAM(m, _pred_) if (!(_pred_)) m.raise_exception("invalid parameter to recfun " #_pred_); + +namespace recfun { + + + case_def::case_def( + ast_manager &m, + family_id fid, + def * d, + std::string & name, + unsigned case_index, + sort_ref_vector const & arg_sorts, + expr_ref_vector const& guards, + expr* rhs) + : m_pred(m), + m_guards(guards), + m_rhs(expr_ref(rhs,m)), + m_def(d) { + parameter p(case_index); + func_decl_info info(fid, OP_FUN_CASE_PRED, 1, &p); + m_pred = m.mk_func_decl(symbol(name.c_str()), arg_sorts.size(), arg_sorts.c_ptr(), m.mk_bool_sort(), info); + } + + def::def(ast_manager &m, family_id fid, symbol const & s, + unsigned arity, sort* const * domain, sort* range) + : m(m), m_name(s), + m_domain(m, arity, domain), + m_range(range, m), m_vars(m), m_cases(), + m_decl(m), + m_rhs(m), + m_fid(fid) + { + SASSERT(arity == get_arity()); + func_decl_info info(fid, OP_FUN_DEFINED); + m_decl = m.mk_func_decl(s, arity, domain, range, info); + } + + // does `e` contain any `ite` construct? + bool def::contains_ite(expr * e) { + struct ite_find_p : public i_expr_pred { + ast_manager & m; + ite_find_p(ast_manager & m) : m(m) {} + bool operator()(expr * e) override { return m.is_ite(e); } + }; + // ignore ites under quantifiers. + // this is redundant as the code + // that unfolds ites uses quantifier-free portion. + ite_find_p p(m); + check_pred cp(p, m, false); + return cp(e); + } + + /* + * compilation of functions to a list of cases. + * + * We use a backtracking algorithm in a relatively functional style, + * where the multiple states (corresponding to alternatives) are stored in + * a region, and deallocated at the end + */ + + // immutable list of choices of `ite` terms (mapping each one's condition to true/false) + struct choice_lst { + app * ite; + bool sign; + choice_lst const * next; // or null for the last one + choice_lst(app * ite, bool sign, choice_lst const * next) : ite(ite), sign(sign), next(next) {} + }; + + struct ite_lst { + app * ite; // invariant: `is_ite(e)` + ite_lst const * next; + ite_lst(app * ite, ite_lst const * next) : ite(ite), next(next) {} + }; + + // immutable stack of expressions to unfold + struct unfold_lst { + expr * e; + unfold_lst const * next; // or null for last one + }; + + // main state for one branch of the search tree. + struct branch { + choice_lst const * path; // choices made so far + ite_lst const * to_split; // `ite` terms to make a choice on + unfold_lst const * to_unfold; // terms yet to unfold + + branch(unfold_lst const * to_unfold): + path(nullptr), to_split(nullptr), to_unfold(to_unfold) {} + branch(choice_lst const * path, ite_lst const * to_split, unfold_lst const * to_unfold) : + path(path), to_split(to_split), to_unfold(to_unfold) {} + branch(branch const & from) : + path(from.path), to_split(from.to_split), to_unfold(from.to_unfold) {} + }; + + // state for computing cases from the RHS of a functions' definition + class case_state { + region m_reg; + vector m_branches; + + public: + case_state() : m_reg(), m_branches() {} + + bool empty() const { return m_branches.empty(); } + + branch pop_branch() { + branch res = m_branches.back(); + m_branches.pop_back(); + return res; + } + + void push_branch(branch const & b) { m_branches.push_back(b); } + + unfold_lst const * cons_unfold(expr * e, unfold_lst const * next) { + return new (m_reg) unfold_lst{e, next}; + } + unfold_lst const * cons_unfold(expr * e1, expr * e2, unfold_lst const * next) { + return cons_unfold(e1, cons_unfold(e2, next)); + } + unfold_lst const * mk_unfold_lst(expr * e) { + return cons_unfold(e, nullptr); + } + + ite_lst const * cons_ite(app * ite, ite_lst const * next) { + return new (m_reg) ite_lst{ite, next}; + } + + choice_lst const * cons_choice(app * ite, bool sign, choice_lst const * next) { + return new (m_reg) choice_lst{ite, sign, next}; + } + }; + + //next) { + app * ite = choices->ite; + expr* c = nullptr, *th = nullptr, *el = nullptr; + VERIFY(m.is_ite(ite, c, th, el)); + + // condition to add to the guard + conditions.push_back(choices->sign ? c : m.mk_not(c)); + + // binding to add to the substitution + subst.insert(ite, choices->sign ? th : el); + } + } + + + void def::add_case(std::string & name, unsigned case_index, expr_ref_vector const& conditions, expr * rhs, bool is_imm) { + case_def c(m, m_fid, this, name, case_index, get_domain(), conditions, rhs); + c.set_is_immediate(is_imm); + TRACEFN("add_case " << name << " " << mk_pp(rhs, m) + << " :is_imm " << is_imm + << " :guards " << conditions); + m_cases.push_back(c); + } + + + // Compute a set of cases, given the RHS + void def::compute_cases(replace& subst, + is_immediate_pred & is_i, + unsigned n_vars, var *const * vars, expr* rhs) + { + VERIFY(m_cases.empty() && "cases cannot already be computed"); + SASSERT(n_vars == m_domain.size()); + + TRACEFN("compute cases " << mk_pp(rhs, m)); + + unsigned case_idx = 0; + + std::string name("case-"); + name.append(m_name.bare_str()); + + m_vars.append(n_vars, vars); + m_rhs = rhs; + + expr_ref_vector conditions(m); + + // is the function a macro (unconditional body)? + if (n_vars == 0 || !contains_ite(rhs)) { + // constant function or trivial control flow, only one (dummy) case + add_case(name, 0, conditions, rhs); + return; + } + + // analyze control flow of `rhs`, accumulating guards and + // rebuilding a `ite`-free RHS on the fly for each path in `rhs`. + // Each such `ite`-free term is converted into a case_def and added to definition. + + case_state st; + + st.push_branch(branch(st.mk_unfold_lst(rhs))); + + while (! st.empty()) { + TRACEFN("main loop iter"); + + branch b = st.pop_branch(); + + // first: unfold expressions, stopping when we meet subterms that are `ite` + while (b.to_unfold != nullptr) { + + ptr_vector stack; + stack.push_back(b.to_unfold->e); + + b.to_unfold = b.to_unfold->next; + + while (! stack.empty()) { + expr * e = stack.back(); + stack.pop_back(); + + if (m.is_ite(e)) { + // need to do a case split on `e`, forking the search space + b.to_split = st.cons_ite(to_app(e), b.to_split); + } + else if (is_app(e)) { + // explore arguments + for (expr * arg : *to_app(e)) { + if (contains_ite(arg)) { + stack.push_back(arg); + } + } + } + } + } + + if (b.to_split != nullptr) { + // split one `ite`, which will lead to distinct (sets of) cases + app * ite = b.to_split->ite; + expr* c = nullptr, *th = nullptr, *el = nullptr; + VERIFY(m.is_ite(ite, c, th, el)); + + /* explore both positive choice and negative choice. + * each contains a longer path, with `ite` mapping to `true` (resp. `false), + * and must unfold the `then` (resp. `else`) branch. + * We must also unfold the test itself, for it could contain + * tests. + */ + + branch b_pos(st.cons_choice(ite, true, b.path), + b.to_split->next, + st.cons_unfold(c, th, b.to_unfold)); + + branch b_neg(st.cons_choice(ite, false, b.path), + b.to_split->next, + st.cons_unfold(c, el, b.to_unfold)); + + st.push_branch(b_neg); + st.push_branch(b_pos); + } + else { + // leaf of the search tree + + conditions.reset(); + subst.reset(); + convert_path(m, b.path, conditions, subst); + + // substitute, to get rid of `ite` terms + expr_ref case_rhs = subst(rhs); + for (unsigned i = 0; i < conditions.size(); ++i) { + conditions[i] = subst(conditions.get(i)); + } + + // yield new case + bool is_imm = is_i(case_rhs); + add_case(name, case_idx++, conditions, case_rhs, is_imm); + } + } + + TRACEFN("done analyzing " << get_name()); + } + + /* + * Main manager for defined functions + */ + + util::util(ast_manager & m) + : m_manager(m), m_fid(m.get_family_id("recfun")), + m_plugin(dynamic_cast(m.get_plugin(m_fid))) { + } + + util::~util() { + } + + def * util::decl_fun(symbol const& name, unsigned n, sort *const * domain, sort * range) { + return alloc(def, m(), m_fid, name, n, domain, range); + } + + void util::set_definition(replace& subst, promise_def & d, unsigned n_vars, var * const * vars, expr * rhs) { + d.set_definition(subst, n_vars, vars, rhs); + } + + app_ref util::mk_depth_limit_pred(unsigned d) { + parameter p(d); + func_decl_info info(m_fid, OP_DEPTH_LIMIT, 1, &p); + func_decl* decl = m().mk_const_decl(symbol("recfun-depth-limit"), m().mk_bool_sort(), info); + return app_ref(m().mk_const(decl), m()); + } + + // used to know which `app` are from this theory + struct is_imm_pred : is_immediate_pred { + util & u; + is_imm_pred(util & u) : u(u) {} + bool operator()(expr * rhs) override { + // find an `app` that is an application of a defined function + struct find : public i_expr_pred { + util & u; + find(util & u) : u(u) {} + bool operator()(expr * e) override { + //return is_app(e) ? u.owns_app(to_app(e)) : false; + if (! is_app(e)) return false; + + app * a = to_app(e); + return u.is_defined(a); + } + }; + find f(u); + check_pred cp(f, u.m()); + bool contains_defined_fun = cp(rhs); + return ! contains_defined_fun; + } + }; + + // set definition + void promise_def::set_definition(replace& r, unsigned n_vars, var * const * vars, expr * rhs) { + SASSERT(n_vars == d->get_arity()); + + is_imm_pred is_i(*u); + d->compute_cases(r, is_i, n_vars, vars, rhs); + } + + namespace decl { + plugin::plugin() : decl_plugin(), m_defs(), m_case_defs() {} + plugin::~plugin() { finalize(); } + + void plugin::finalize() { + for (auto& kv : m_defs) { + dealloc(kv.m_value); + } + m_defs.reset(); + // m_case_defs does not own its data, no need to deallocate + m_case_defs.reset(); + m_util = nullptr; // force deletion + } + + util & plugin::u() const { + SASSERT(m_manager); + SASSERT(m_family_id != null_family_id); + if (!m_util.get()) { + m_util = alloc(util, *m_manager); + } + return *(m_util.get()); + } + + promise_def plugin::mk_def(symbol const& name, unsigned n, sort *const * params, sort * range) { + def* d = u().decl_fun(name, n, params, range); + SASSERT(! m_defs.contains(d->get_decl())); + m_defs.insert(d->get_decl(), d); + return promise_def(&u(), d); + } + + void plugin::set_definition(replace& r, promise_def & d, unsigned n_vars, var * const * vars, expr * rhs) { + u().set_definition(r, d, n_vars, vars, rhs); + for (case_def & c : d.get_def()->get_cases()) { + m_case_defs.insert(c.get_decl(), &c); + } + } + + bool plugin::has_defs() const { + return !m_case_defs.empty(); + } + + def* plugin::mk_def(replace& subst, + symbol const& name, unsigned n, sort ** params, sort * range, + unsigned n_vars, var ** vars, expr * rhs) { + promise_def d = mk_def(name, n, params, range); + SASSERT(! m_defs.contains(d.get_def()->get_decl())); + set_definition(subst, d, n_vars, vars, rhs); + return d.get_def(); + } + + // generic declaration of symbols + func_decl * plugin::mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters, + unsigned arity, sort * const * domain, sort * range) + { + UNREACHABLE(); + return nullptr; + } + } +} diff --git a/src/ast/recfun_decl_plugin.h b/src/ast/recfun_decl_plugin.h new file mode 100644 index 000000000..0247335e8 --- /dev/null +++ b/src/ast/recfun_decl_plugin.h @@ -0,0 +1,253 @@ +/*++ +Copyright (c) 2017 Microsoft Corporation, Simon Cruanes + +Module Name: + + recfun_decl_plugin.h + +Abstract: + + Declaration and definition of (potentially recursive) functions + +Author: + + Simon Cruanes 2017-11 + +Revision History: + +--*/ + +#pragma once + +#include "ast/ast.h" +#include "util/obj_hashtable.h" + +namespace recfun { + class case_def; // const & args) const { + ast_manager& m = m_pred.get_manager(); + return app_ref(m.mk_app(m_pred, args.size(), args.c_ptr()), m); + } + + def * get_def() const { return m_def; } + expr_ref_vector const & get_guards() const { return m_guards; } + expr * get_guards_c_ptr() const { return *m_guards.c_ptr(); } + expr * get_guard(unsigned i) const { return m_guards[i]; } + expr * get_rhs() const { return m_rhs; } + unsigned num_guards() const { return m_guards.size(); } + bool is_immediate() const { return m_immediate; }; + void set_is_immediate(bool b) { m_immediate = b; } + }; + + // closure for computing whether a `rhs` expression is immediate + struct is_immediate_pred { + virtual bool operator()(expr * rhs) = 0; + }; + + class def { + friend class util; + friend class promise_def; + typedef vector cases; + + ast_manager & m; + symbol m_name; // def_map; + typedef obj_map case_def_map; + + mutable scoped_ptr m_util; + def_map m_defs; // function->def + case_def_map m_case_defs; // case_pred->def + + ast_manager & m() { return *m_manager; } + public: + plugin(); + ~plugin() override; + void finalize() override; + + util & u() const; // build or return util + + bool is_fully_interp(sort * s) const override { return false; } // might depend on unin sorts + + decl_plugin * mk_fresh() override { return alloc(plugin); } + + sort * mk_sort(decl_kind k, unsigned num_parameters, parameter const * parameters) override { + UNREACHABLE(); return nullptr; + } + + func_decl * mk_func_decl(decl_kind k, unsigned num_parameters, parameter const * parameters, + unsigned arity, sort * const * domain, sort * range) override; + + promise_def mk_def(symbol const& name, unsigned n, sort *const * params, sort * range); + + void set_definition(replace& r, promise_def & d, unsigned n_vars, var * const * vars, expr * rhs); + + def* mk_def(replace& subst, symbol const& name, unsigned n, sort ** params, sort * range, unsigned n_vars, var ** vars, expr * rhs); + + bool has_def(func_decl* f) const { return m_defs.contains(f); } + bool has_defs() const; + def const& get_def(func_decl* f) const { return *(m_defs[f]); } + promise_def get_promise_def(func_decl* f) const { return promise_def(&u(), m_defs[f]); } + def& get_def(func_decl* f) { return *(m_defs[f]); } + bool has_case_def(func_decl* f) const { return m_case_defs.contains(f); } + case_def& get_case_def(func_decl* f) { SASSERT(has_case_def(f)); return *(m_case_defs[f]); } + + func_decl_ref_vector get_rec_funs() { + func_decl_ref_vector result(m()); + for (auto& kv : m_defs) result.push_back(kv.m_key); + return result; + } + }; + } + + // Varus utils for recursive functions + class util { + friend class decl::plugin; + + ast_manager & m_manager; + family_id m_fid; + decl::plugin * m_plugin; + + bool compute_is_immediate(expr * rhs); + void set_definition(replace& r, promise_def & d, unsigned n_vars, var * const * vars, expr * rhs); + + public: + util(ast_manager &m); + ~util(); + + ast_manager & m() { return m_manager; } + decl::plugin& get_plugin() { return *m_plugin; } + + bool is_case_pred(expr * e) const { return is_app_of(e, m_fid, OP_FUN_CASE_PRED); } + bool is_defined(expr * e) const { return is_app_of(e, m_fid, OP_FUN_DEFINED); } + bool is_defined(func_decl* f) const { return is_decl_of(f, m_fid, OP_FUN_DEFINED); } + bool is_depth_limit(expr * e) const { return is_app_of(e, m_fid, OP_DEPTH_LIMIT); } + bool owns_app(app * e) const { return e->get_family_id() == m_fid; } + + //has_defs(); } + + //has_def(f)); + return m_plugin->get_def(f); + } + + case_def& get_case_def(expr* e) { + SASSERT(is_case_pred(e)); + return m_plugin->get_case_def(to_app(e)->get_decl()); + } + + app* mk_fun_defined(def const & d, unsigned n_args, expr * const * args) { + return m().mk_app(d.get_decl(), n_args, args); + } + + app* mk_fun_defined(def const & d, ptr_vector const & args) { + return mk_fun_defined(d, args.size(), args.c_ptr()); + } + + func_decl_ref_vector get_rec_funs() { + return m_plugin->get_rec_funs(); + } + + app_ref mk_depth_limit_pred(unsigned d); + + }; +} + diff --git a/src/ast/reg_decl_plugins.cpp b/src/ast/reg_decl_plugins.cpp index 985ecee9e..7e121eb7f 100644 --- a/src/ast/reg_decl_plugins.cpp +++ b/src/ast/reg_decl_plugins.cpp @@ -22,6 +22,7 @@ Revision History: #include "ast/array_decl_plugin.h" #include "ast/bv_decl_plugin.h" #include "ast/datatype_decl_plugin.h" +#include "ast/recfun_decl_plugin.h" #include "ast/dl_decl_plugin.h" #include "ast/seq_decl_plugin.h" #include "ast/pb_decl_plugin.h" @@ -40,6 +41,9 @@ void reg_decl_plugins(ast_manager & m) { if (!m.get_plugin(m.mk_family_id(symbol("datatype")))) { m.register_plugin(symbol("datatype"), alloc(datatype_decl_plugin)); } + if (!m.get_plugin(m.mk_family_id(symbol("recfun")))) { + m.register_plugin(symbol("recfun"), alloc(recfun::decl::plugin)); + } if (!m.get_plugin(m.mk_family_id(symbol("datalog_relation")))) { m.register_plugin(symbol("datalog_relation"), alloc(datalog::dl_decl_plugin)); } diff --git a/src/ast/rewriter/arith_rewriter.cpp b/src/ast/rewriter/arith_rewriter.cpp index 72ce9c761..a19074c51 100644 --- a/src/ast/rewriter/arith_rewriter.cpp +++ b/src/ast/rewriter/arith_rewriter.cpp @@ -1209,7 +1209,7 @@ br_status arith_rewriter::mk_to_int_core(expr * arg, expr_ref & result) { result = m().mk_app(get_fid(), to_app(arg)->get_decl()->get_decl_kind(), int_args.size(), int_args.c_ptr()); return BR_REWRITE1; } - if (!int_args.empty() && (m_util.is_add(arg) || m_util.is_mul(arg))) { + if (!int_args.empty() && m_util.is_add(arg)) { decl_kind k = to_app(arg)->get_decl()->get_decl_kind(); expr_ref t1(m().mk_app(get_fid(), k, int_args.size(), int_args.c_ptr()), m()); expr_ref t2(m().mk_app(get_fid(), k, real_args.size(), real_args.c_ptr()), m()); diff --git a/src/ast/rewriter/bv_bounds.cpp b/src/ast/rewriter/bv_bounds.cpp index f337ca638..1658833a8 100644 --- a/src/ast/rewriter/bv_bounds.cpp +++ b/src/ast/rewriter/bv_bounds.cpp @@ -111,7 +111,7 @@ bv_bounds::conv_res bv_bounds::convert(expr * e, vector& nis, bool ne numeral val, val1; unsigned bv_sz1; - if (0) { + if (false) { if (m_m.is_eq(e, lhs, rhs) && to_bound(lhs) && m_bv_util.is_numeral(rhs, val, bv_sz1)) { return record(to_app(lhs), val, val, negated, nis); } @@ -125,7 +125,7 @@ bv_bounds::conv_res bv_bounds::convert(expr * e, vector& nis, bool ne return record(to_app(lhs), numeral::zero(), val, negated, nis); } - if (1) { + if (true) { numeral rhs_val; unsigned rhs_sz; if (m_m.is_eq(e, lhs, rhs) @@ -343,7 +343,7 @@ bool bv_bounds::add_constraint(expr* e) { numeral val, val1; unsigned bv_sz1; - if (0) { + if (false) { if (m_m.is_eq(e, lhs, rhs) && to_bound(lhs) && m_bv_util.is_numeral(rhs, val, bv_sz1)) { return add_bound_unsigned(to_app(lhs), val, val, negated); } @@ -628,7 +628,7 @@ bool bv_bounds::is_sat_core(app * v) { numeral new_hi = lower - one; numeral ptr = lower; if (has_neg_intervals) { - SASSERT(negative_intervals != NULL); + SASSERT(negative_intervals != nullptr); std::sort(negative_intervals->begin(), negative_intervals->end(), interval_comp); intervals::const_iterator e = negative_intervals->end(); for (intervals::const_iterator i = negative_intervals->begin(); i != e; ++i) { diff --git a/src/ast/rewriter/bv_rewriter.cpp b/src/ast/rewriter/bv_rewriter.cpp index c81c7385a..3dc76da5e 100644 --- a/src/ast/rewriter/bv_rewriter.cpp +++ b/src/ast/rewriter/bv_rewriter.cpp @@ -779,10 +779,11 @@ br_status bv_rewriter::mk_extract(unsigned high, unsigned low, expr * arg, expr_ } } - if (m().is_ite(arg)) { - result = m().mk_ite(to_app(arg)->get_arg(0), - m_mk_extract(high, low, to_app(arg)->get_arg(1)), - m_mk_extract(high, low, to_app(arg)->get_arg(2))); + expr* c = nullptr, *t = nullptr, *e = nullptr; + if (m().is_ite(arg, c, t, e) && + (t->get_ref_count() == 1 || !m().is_ite(t)) && + (e->get_ref_count() == 1 || !m().is_ite(e))) { + result = m().mk_ite(c, m_mk_extract(high, low, t), m_mk_extract(high, low, e)); return BR_REWRITE2; } @@ -2679,7 +2680,7 @@ br_status bv_rewriter::mk_ite_core(expr * c, expr * t, expr * e, expr_ref & resu } const unsigned sz = m_util.get_bv_size(rhs); - if (sz == 1) { // detect (lhs = N) ? C : D, where N, C, D are 1 bit numberals + if (sz == 1) { // detect (lhs = N) ? C : D, where N, C, D are 1 bit numerals numeral rhs_n, e_n, t_n; unsigned rhs_sz, e_sz, t_sz; if (is_numeral(rhs, rhs_n, rhs_sz) diff --git a/src/ast/rewriter/bv_trailing.cpp b/src/ast/rewriter/bv_trailing.cpp index 433ef6f66..f7c9e121e 100644 --- a/src/ast/rewriter/bv_trailing.cpp +++ b/src/ast/rewriter/bv_trailing.cpp @@ -364,7 +364,7 @@ struct bv_trailing::imp { } void reset_cache(const unsigned condition) { - SASSERT(m_count_cache[0] == NULL); + SASSERT(m_count_cache[0] == nullptr); for (unsigned i = 1; i <= TRAILING_DEPTH; ++i) { if (m_count_cache[i] == nullptr) continue; TRACE("bv-trailing", tout << "may reset cache " << i << " " << condition << "\n";); diff --git a/src/ast/rewriter/datatype_rewriter.cpp b/src/ast/rewriter/datatype_rewriter.cpp index 194668b9c..4d688e682 100644 --- a/src/ast/rewriter/datatype_rewriter.cpp +++ b/src/ast/rewriter/datatype_rewriter.cpp @@ -124,7 +124,7 @@ br_status datatype_rewriter::mk_eq_core(expr * lhs, expr * rhs, expr_ref & resul // (= (+ c5 a5) b5) <<< NOT SIMPLIFIED WITH RESPECT TO ARITHMETIC // (= (cons a6 nil) (cons b6 nil))) <<< NOT SIMPLIFIED WITH RESPECT TO DATATYPE theory // - // Note that asserted_formulas::reduce() applied the simplier many times. + // Note that asserted_formulas::reduce() applied the simplifier many times. // After the first simplification step we had: // (= a1 b1) // (= (cons a2 (cons a3 (cons (+ a4 1) (cons (+ a5 c5) (cons a6 nil)))))) diff --git a/src/ast/rewriter/der.h b/src/ast/rewriter/der.h index 47e57c4fb..4dcf1e537 100644 --- a/src/ast/rewriter/der.h +++ b/src/ast/rewriter/der.h @@ -108,7 +108,7 @@ Revision History: apply var_subst using m_map to this child, and store the result in a new children array Create a new OR (new body of the quantifier) using the new children Then, we create a new quantifier using this new body, and use the function elim_unused_vars to - eliminate the ununsed variables. + eliminate the unused variables. Remark: let us implement the new version inside the class der. Use #if 0 ... #endif to comment the old version. diff --git a/src/ast/rewriter/expr_safe_replace.cpp b/src/ast/rewriter/expr_safe_replace.cpp index 0ed0efc00..c2efb520d 100644 --- a/src/ast/rewriter/expr_safe_replace.cpp +++ b/src/ast/rewriter/expr_safe_replace.cpp @@ -19,7 +19,7 @@ Revision History: --*/ #include "ast/rewriter/expr_safe_replace.h" -#include "ast/rewriter/rewriter.h" +#include "ast/rewriter/var_subst.h" #include "ast/ast_pp.h" diff --git a/src/ast/rewriter/pb2bv_rewriter.cpp b/src/ast/rewriter/pb2bv_rewriter.cpp index d1def83a1..0faf08515 100644 --- a/src/ast/rewriter/pb2bv_rewriter.cpp +++ b/src/ast/rewriter/pb2bv_rewriter.cpp @@ -458,7 +458,7 @@ struct pb2bv_rewriter::imp { result = m.mk_true(); expr_ref_vector carry(m), new_carry(m); m_base.push_back(bound + rational::one()); - for (rational b_i : m_base) { + for (const rational& b_i : m_base) { unsigned B = b_i.get_unsigned(); unsigned d_i = (bound % b_i).get_unsigned(); bound = div(bound, b_i); diff --git a/src/ast/rewriter/push_app_ite.h b/src/ast/rewriter/push_app_ite.h index 8f737ea4d..a04cb6fbc 100644 --- a/src/ast/rewriter/push_app_ite.h +++ b/src/ast/rewriter/push_app_ite.h @@ -41,7 +41,7 @@ struct push_app_ite_cfg : public default_rewriter_cfg { \brief Variation of push_app_ite that applies the transformation on nonground terms only. \remark This functor uses the app::is_ground method. This method is not - completly precise, for instance, any term containing a quantifier is marked as non ground. + completely precise, for instance, any term containing a quantifier is marked as non ground. */ class ng_push_app_ite_cfg : public push_app_ite_cfg { protected: diff --git a/src/ast/rewriter/recfun_replace.h b/src/ast/rewriter/recfun_replace.h new file mode 100644 index 000000000..5a24e8513 --- /dev/null +++ b/src/ast/rewriter/recfun_replace.h @@ -0,0 +1,41 @@ +/*++ +Copyright (c) 2018 Microsoft Corporation + +Module Name: + + recfun_replace.h + +Abstract: + + replace function for recfun. + recfun_decl_plugin relies on being able to do expression replacement. + It uses expr_safe_replace from ast/rewriter, which depends on ast. + To break the dependency cycle we hoist the relevant functionality into + an argument to functionality exposed by recfun::set_definition + +Author: + + Nikolaj Bjorner (nbjorner) 2018-11-01 + +Revision History: + + +--*/ + +#ifndef RECFUN_REPLACE_H_ +#define RECFUN_REPLACE_H_ + +#include "ast/recfun_decl_plugin.h" +#include "ast/rewriter/expr_safe_replace.h" + +class recfun_replace : public recfun::replace { + ast_manager& m; + expr_safe_replace m_replace; +public: + recfun_replace(ast_manager& m): m(m), m_replace(m) {} + void reset() override { m_replace.reset(); } + void insert(expr* s, expr* t) override { m_replace.insert(s, t); } + expr_ref operator()(expr* e) override { expr_ref r(m); m_replace(e, r); return r; } +}; + +#endif /* RECFUN_REPLACE_H_ */ diff --git a/src/ast/rewriter/rewriter.h b/src/ast/rewriter/rewriter.h index 84fef488f..4195e7de6 100644 --- a/src/ast/rewriter/rewriter.h +++ b/src/ast/rewriter/rewriter.h @@ -279,8 +279,9 @@ protected: return false; } - bool get_macro(func_decl * f, expr * & def, quantifier * & q, proof * & def_pr) { - return m_cfg.get_macro(f, def, q, def_pr); + bool get_macro(func_decl * f, expr * & def, proof * & def_pr) { + quantifier* q = nullptr; + return m_cfg.get_macro(f, def, q, def_pr); } void push_frame(expr * t, bool mcache, unsigned max_depth) { diff --git a/src/ast/rewriter/rewriter_def.h b/src/ast/rewriter/rewriter_def.h index ebe52f52a..dfa0c5467 100644 --- a/src/ast/rewriter/rewriter_def.h +++ b/src/ast/rewriter/rewriter_def.h @@ -212,6 +212,7 @@ bool rewriter_tpl::constant_fold(app * t, frame & fr) { return false; } + template template void rewriter_tpl::process_app(app * t, frame & fr) { @@ -338,15 +339,12 @@ void rewriter_tpl::process_app(app * t, frame & fr) { // TODO: add rewrite rules support expr * def = nullptr; proof * def_pr = nullptr; - quantifier * def_q = nullptr; // When get_macro succeeds, then // we know that: // forall X. f(X) = def[X] // and def_pr is a proof for this quantifier. // - // Remark: def_q is only used for proof generation. - // It is the quantifier forall X. f(X) = def[X] - if (get_macro(f, def, def_q, def_pr)) { + if (get_macro(f, def, def_pr)) { SASSERT(!f->is_associative() || !flat_assoc(f)); SASSERT(new_num_args == t->get_num_args()); SASSERT(m().get_sort(def) == m().get_sort(t)); @@ -516,7 +514,12 @@ void rewriter_tpl::process_quantifier(quantifier * q, frame & fr) { } if (ProofGen) { quantifier_ref new_q(m().update_quantifier(q, num_pats, new_pats.c_ptr(), num_no_pats, new_no_pats.c_ptr(), new_body), m()); - m_pr = q == new_q ? nullptr : m().mk_quant_intro(q, new_q, result_pr_stack().get(fr.m_spos)); + m_pr = nullptr; + if (q != new_q) { + m_pr = result_pr_stack().get(fr.m_spos); + m_pr = m().mk_bind_proof(q, m_pr); + m_pr = m().mk_quant_intro(q, new_q, m_pr); + } m_r = new_q; proof_ref pr2(m()); if (m_cfg.reduce_quantifier(new_q, new_body, new_pats.c_ptr(), new_no_pats.c_ptr(), m_r, pr2)) { diff --git a/src/ast/rewriter/seq_rewriter.cpp b/src/ast/rewriter/seq_rewriter.cpp index 84c05d53e..d46f234e2 100644 --- a/src/ast/rewriter/seq_rewriter.cpp +++ b/src/ast/rewriter/seq_rewriter.cpp @@ -33,30 +33,32 @@ Notes: expr_ref sym_expr::accept(expr* e) { ast_manager& m = m_t.get_manager(); expr_ref result(m); + var_subst subst(m); + seq_util u(m); + unsigned r1, r2, r3; switch (m_ty) { - case t_pred: { - var_subst subst(m); + case t_pred: result = subst(m_t, 1, &e); + break; + case t_not: + result = m_expr->accept(e); + result = m.mk_not(result); break; - } case t_char: SASSERT(m.get_sort(e) == m.get_sort(m_t)); SASSERT(m.get_sort(e) == m_sort); result = m.mk_eq(e, m_t); break; - case t_range: { - bv_util bv(m); - rational r1, r2, r3; - unsigned sz; - if (bv.is_numeral(m_t, r1, sz) && bv.is_numeral(e, r2, sz) && bv.is_numeral(m_s, r3, sz)) { + case t_range: + if (u.is_const_char(m_t, r1) && u.is_const_char(e, r2) && u.is_const_char(m_s, r3)) { result = m.mk_bool_val((r1 <= r2) && (r2 <= r3)); } else { - result = m.mk_and(bv.mk_ule(m_t, e), bv.mk_ule(e, m_s)); + result = m.mk_and(u.mk_le(m_t, e), u.mk_le(e, m_s)); } break; } - } + return result; } @@ -65,6 +67,7 @@ std::ostream& sym_expr::display(std::ostream& out) const { case t_char: return out << m_t; case t_range: return out << m_t << ":" << m_s; case t_pred: return out << m_t; + case t_not: return m_expr->display(out << "not "); } return out << "expression type not recognized"; } @@ -80,10 +83,11 @@ struct display_expr1 { class sym_expr_boolean_algebra : public boolean_algebra { ast_manager& m; expr_solver& m_solver; + expr_ref m_var; typedef sym_expr* T; public: sym_expr_boolean_algebra(ast_manager& m, expr_solver& s): - m(m), m_solver(s) {} + m(m), m_solver(s), m_var(m) {} T mk_false() override { expr_ref fml(m.mk_false(), m); @@ -94,6 +98,7 @@ public: return sym_expr::mk_pred(fml, m.mk_bool_sort()); } T mk_and(T x, T y) override { + seq_util u(m); if (x->is_char() && y->is_char()) { if (x->get_char() == y->get_char()) { return x; @@ -103,6 +108,21 @@ public: return sym_expr::mk_pred(fml, x->get_sort()); } } + unsigned lo1, hi1, lo2, hi2; + if (x->is_range() && y->is_range() && + u.is_const_char(x->get_lo(), lo1) && u.is_const_char(x->get_hi(), hi1) && + u.is_const_char(y->get_lo(), lo2) && u.is_const_char(y->get_hi(), hi2)) { + lo1 = std::max(lo1, lo2); + hi1 = std::min(hi1, hi2); + if (lo1 > hi1) { + expr_ref fml(m.mk_false(), m); + return sym_expr::mk_pred(fml, x->get_sort()); + } + expr_ref _start(u.mk_char(lo1), m); + expr_ref _stop(u.mk_char(hi1), m); + return sym_expr::mk_range(_start, _stop); + } + sort* s = x->get_sort(); if (m.is_bool(s)) s = y->get_sort(); var_ref v(m.mk_var(0, s), m); @@ -111,13 +131,29 @@ public: if (m.is_true(fml1)) { return y; } - if (m.is_true(fml2)) return x; - if (fml1 == fml2) return x; + if (m.is_true(fml2)) { + return x; + } + if (fml1 == fml2) { + return x; + } + if (is_complement(fml1, fml2)) { + expr_ref ff(m.mk_false(), m); + return sym_expr::mk_pred(ff, x->get_sort()); + } bool_rewriter br(m); expr_ref fml(m); br.mk_and(fml1, fml2, fml); return sym_expr::mk_pred(fml, x->get_sort()); } + + bool is_complement(expr* f1, expr* f2) { + expr* f = nullptr; + return + (m.is_not(f1, f) && f == f2) || + (m.is_not(f2, f) && f == f1); + } + T mk_or(T x, T y) override { if (x->is_char() && y->is_char() && x->get_char() == y->get_char()) { @@ -148,6 +184,7 @@ public: } } } + T mk_or(unsigned sz, T const* ts) override { switch (sz) { case 0: return mk_false(); @@ -161,15 +198,24 @@ public: } } } + lbool is_sat(T x) override { + unsigned lo, hi; + seq_util u(m); + if (x->is_char()) { return l_true; } - if (x->is_range()) { - // TBD check lower is below upper. + if (x->is_range() && u.is_const_char(x->get_lo(), lo) && u.is_const_char(x->get_hi(), hi)) { + return (lo <= hi) ? l_true : l_false; } - expr_ref v(m.mk_fresh_const("x", x->get_sort()), m); - expr_ref fml = x->accept(v); + if (x->is_not() && x->get_arg()->is_range() && u.is_const_char(x->get_arg()->get_lo(), lo) && 0 < lo) { + return l_true; + } + if (!m_var || m.get_sort(m_var) != x->get_sort()) { + m_var = m.mk_fresh_const("x", x->get_sort()); + } + expr_ref fml = x->accept(m_var); if (m.is_true(fml)) { return l_true; } @@ -178,19 +224,14 @@ public: } return m_solver.check_sat(fml); } + T mk_not(T x) override { - var_ref v(m.mk_var(0, x->get_sort()), m); - expr_ref fml(m.mk_not(x->accept(v)), m); - return sym_expr::mk_pred(fml, x->get_sort()); + return sym_expr::mk_not(m, x); } - /*virtual vector, T>> generate_min_terms(vector constraints){ - - return 0; - }*/ }; -re2automaton::re2automaton(ast_manager& m): m(m), u(m), bv(m), m_ba(nullptr), m_sa(nullptr) {} +re2automaton::re2automaton(ast_manager& m): m(m), u(m), m_ba(nullptr), m_sa(nullptr) {} re2automaton::~re2automaton() {} @@ -248,9 +289,8 @@ eautomaton* re2automaton::re2aut(expr* e) { s1.length() == 1 && s2.length() == 1) { unsigned start = s1[0]; unsigned stop = s2[0]; - unsigned nb = s1.num_bits(); - expr_ref _start(bv.mk_numeral(start, nb), m); - expr_ref _stop(bv.mk_numeral(stop, nb), m); + expr_ref _start(u.mk_char(start), m); + expr_ref _stop(u.mk_char(stop), m); TRACE("seq", tout << "Range: " << start << " " << stop << "\n";); a = alloc(eautomaton, sm, sym_expr::mk_range(_start, _stop)); return a.detach(); @@ -309,6 +349,9 @@ eautomaton* re2automaton::re2aut(expr* e) { else if (u.re.is_intersection(e, e1, e2) && m_sa && (a = re2aut(e1)) && (b = re2aut(e2))) { return m_sa->mk_product(*a, *b); } + else { + TRACE("seq", tout << "not handled " << mk_pp(e, m) << "\n";); + } return nullptr; } @@ -343,9 +386,9 @@ eautomaton* re2automaton::seq2aut(expr* e) { br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * const * args, expr_ref & result) { SASSERT(f->get_family_id() == get_fid()); - + br_status st = BR_FAILED; switch(f->get_decl_kind()) { - + case OP_SEQ_UNIT: SASSERT(num_args == 1); return mk_seq_unit(args[0], result); @@ -356,16 +399,19 @@ br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con return mk_re_plus(args[0], result); case OP_RE_STAR: SASSERT(num_args == 1); - return mk_re_star(args[0], result); + st = mk_re_star(args[0], result); + break; case OP_RE_OPTION: SASSERT(num_args == 1); return mk_re_opt(args[0], result); case OP_RE_CONCAT: if (num_args == 1) { - result = args[0]; return BR_DONE; + result = args[0]; + return BR_DONE; } SASSERT(num_args == 2); - return mk_re_concat(args[0], args[1], result); + st = mk_re_concat(args[0], args[1], result); + break; case OP_RE_UNION: if (num_args == 1) { result = args[0]; return BR_DONE; @@ -405,7 +451,8 @@ br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con return mk_seq_length(args[0], result); case OP_SEQ_EXTRACT: SASSERT(num_args == 3); - return mk_seq_extract(args[0], args[1], args[2], result); + st = mk_seq_extract(args[0], args[1], args[2], result); + break; case OP_SEQ_CONTAINS: SASSERT(num_args == 2); return mk_seq_contains(args[0], args[1], result); @@ -456,21 +503,20 @@ br_status seq_rewriter::mk_app_core(func_decl * f, unsigned num_args, expr * con case _OP_STRING_STRIDOF: UNREACHABLE(); } - return BR_FAILED; + CTRACE("seq", st != BR_FAILED, tout << result << "\n";); + return st; } /* * (seq.unit (_ BitVector 8)) ==> String constant */ br_status seq_rewriter::mk_seq_unit(expr* e, expr_ref& result) { - bv_util bvu(m()); - rational n_val; - unsigned int n_size; + unsigned ch; // specifically we want (_ BitVector 8) - if (bvu.is_bv(e) && bvu.is_numeral(e, n_val, n_size) && n_size == 8) { + if (m_util.is_const_char(e, ch)) { // convert to string constant - zstring str(n_val.get_unsigned()); - TRACE("seq_verbose", tout << "rewrite seq.unit of 8-bit value " << n_val.to_string() << " to string constant \"" << str<< "\"" << std::endl;); + zstring str(ch); + TRACE("seq_verbose", tout << "rewrite seq.unit of 8-bit value " << ch << " to string constant \"" << str<< "\"" << std::endl;); result = m_util.str.mk_string(str); return BR_DONE; } @@ -561,10 +607,12 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu zstring s; rational pos, len; + TRACE("seq", tout << mk_pp(a, m()) << " " << mk_pp(b, m()) << " " << mk_pp(c, m()) << "\n";); bool constantBase = m_util.str.is_string(a, s); bool constantPos = m_autil.is_numeral(b, pos); bool constantLen = m_autil.is_numeral(c, len); + // case 1: pos<0 or len<=0 // rewrite to "" if ( (constantPos && pos.is_neg()) || (constantLen && !len.is_pos()) ) { @@ -573,7 +621,7 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu } // case 1.1: pos >= length(base) // rewrite to "" - if (constantBase && constantPos && pos >= rational(s.length())) { + if (constantPos && constantBase && pos >= rational(s.length())) { result = m_util.str.mk_empty(m().get_sort(a)); return BR_DONE; } @@ -581,43 +629,73 @@ br_status seq_rewriter::mk_seq_extract(expr* a, expr* b, expr* c, expr_ref& resu constantPos &= pos.is_unsigned(); constantLen &= len.is_unsigned(); - if (constantBase && constantPos && constantLen) { - if (pos.get_unsigned() + len.get_unsigned() >= s.length()) { - // case 2: pos+len goes past the end of the string - unsigned _len = s.length() - pos.get_unsigned() + 1; - result = m_util.str.mk_string(s.extract(pos.get_unsigned(), _len)); - } else { - // case 3: pos+len still within string - result = m_util.str.mk_string(s.extract(pos.get_unsigned(), len.get_unsigned())); - } - return BR_DONE; - } - - if (constantPos && constantLen) { + if (constantPos && constantLen && constantBase) { 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; - } + if (_pos + _len >= s.length()) { + // case 2: pos+len goes past the end of the string + unsigned _len = s.length() - _pos + 1; + result = m_util.str.mk_string(s.extract(_pos, _len)); + } else { + // case 3: pos+len still within string + result = m_util.str.mk_string(s.extract(_pos, _len)); } - result = m_util.str.mk_concat(bs); return BR_DONE; } - return BR_FAILED; + + expr_ref_vector as(m()), bs(m()); + m_util.str.get_concat_units(a, as); + if (as.empty()) { + result = m_util.str.mk_empty(m().get_sort(a)); + return BR_DONE; + } + + if (!constantPos) { + return BR_FAILED; + } + unsigned _pos = pos.get_unsigned(); + + // (extract s 0 (len s)) = s + expr* a2 = nullptr; + if (_pos == 0 && m_util.str.is_length(c, a2) && a == a2) { + result = a; + return BR_DONE; + } + + unsigned offset = 0; + for (; offset < as.size() && m_util.str.is_unit(as.get(offset)) && offset < _pos; ++offset) {}; + if (offset == 0 && _pos > 0) { + return BR_FAILED; + } + if (_pos == 0 && !constantLen) { + return BR_FAILED; + } + // (extract (++ (unit x) (unit y)) 3 c) = empty + if (offset == as.size()) { + result = m_util.str.mk_empty(m().get_sort(a)); + return BR_DONE; + } + SASSERT(offset != 0 || _pos == 0); + + if (constantLen && _pos == offset) { + unsigned _len = len.get_unsigned(); + // (extract (++ (unit a) (unit b) (unit c) x) 1 2) = (++ (unit b) (unit c)) + unsigned i = offset; + for (; i < as.size() && m_util.str.is_unit(as.get(i)) && i - offset < _len; ++i); + if (i - offset == _len) { + result = m_util.str.mk_concat(_len, as.c_ptr() + offset); + return BR_DONE; + } + } + if (offset == 0) { + return BR_FAILED; + } + expr_ref pos1(m()); + pos1 = m_autil.mk_sub(b, m_autil.mk_int(offset)); + result = m_util.str.mk_concat(as.size() - offset, as.c_ptr() + offset); + result = m_util.str.mk_substr(result, pos1, c); + return BR_REWRITE3; } bool seq_rewriter::cannot_contain_suffix(expr* a, expr* b) { @@ -665,11 +743,17 @@ br_status seq_rewriter::mk_seq_contains(expr* a, expr* b, expr_ref& result) { result = m().mk_bool_val(c.contains(d)); return BR_DONE; } + expr* x = nullptr, *y, *z; + if (m_util.str.is_extract(b, x, y, z) && x == a) { + result = m().mk_true(); + return BR_DONE; + } + // check if subsequence of a is in b. expr_ref_vector as(m()), bs(m()); - m_util.str.get_concat(a, as); - m_util.str.get_concat(b, bs); - bool all_values = true; + m_util.str.get_concat_units(a, as); + m_util.str.get_concat_units(b, bs); + TRACE("seq", tout << mk_pp(a, m()) << " contains " << mk_pp(b, m()) << "\n";); if (bs.empty()) { @@ -677,24 +761,21 @@ br_status seq_rewriter::mk_seq_contains(expr* a, expr* b, expr_ref& result) { return BR_DONE; } - for (unsigned i = 0; all_values && i < bs.size(); ++i) { - all_values = m().is_value(bs[i].get()); + if (as.empty()) { + result = m_util.str.mk_is_empty(b); + return BR_REWRITE2; } - bool found = false; - for (unsigned i = 0; !found && i < as.size(); ++i) { - all_values &= m().is_value(as[i].get()); - if (bs.size() <= as.size() - i) { - unsigned j = 0; - for (; j < bs.size() && as[j+i].get() == bs[j].get(); ++j) {}; - found = j == bs.size(); + for (unsigned i = 0; bs.size() + i <= as.size(); ++i) { + unsigned j = 0; + for (; j < bs.size() && as.get(j+i) == bs.get(j); ++j) {}; + if (j == bs.size()) { + result = m().mk_true(); + return BR_DONE; } } - if (found) { - result = m().mk_true(); - return BR_DONE; - } - if (all_values) { + std::function is_value = [&](expr* e) { return m().is_value(e); }; + if (bs.forall(is_value) && as.forall(is_value)) { result = m().mk_false(); return BR_DONE; } @@ -709,29 +790,14 @@ br_status seq_rewriter::mk_seq_contains(expr* a, expr* b, expr_ref& result) { } } - - if (as.empty()) { - result = m().mk_eq(b, m_util.str.mk_empty(m().get_sort(b))); - return BR_REWRITE2; - } - - if (bs.size() == 1 && m_util.str.is_string(bs[0].get(), c)) { - for (auto a_i : as) { - if (m_util.str.is_string(a_i, d) && d.contains(c)) { - result = m().mk_true(); - return BR_DONE; - } - } - } - unsigned offs = 0; unsigned sz = as.size(); - expr* b0 = bs[0].get(); - expr* bL = bs[bs.size()-1].get(); + expr* b0 = bs.get(0); + expr* bL = bs.get(bs.size()-1); for (; offs < as.size() && cannot_contain_prefix(as[offs].get(), b0); ++offs) {} - for (; sz > offs && cannot_contain_suffix(as[sz-1].get(), bL); --sz) {} + for (; sz > offs && cannot_contain_suffix(as.get(sz-1), bL); --sz) {} if (offs == sz) { - result = m().mk_eq(b, m_util.str.mk_empty(m().get_sort(b))); + result = m_util.str.mk_is_empty(b); return BR_REWRITE2; } if (offs > 0 || sz < as.size()) { @@ -740,28 +806,14 @@ br_status seq_rewriter::mk_seq_contains(expr* a, expr* b, expr_ref& result) { return BR_REWRITE2; } - expr* x, *y, *z; - if (m_util.str.is_extract(b, x, y, z) && x == a) { - result = m().mk_true(); - return BR_DONE; - } - bool all_units = true; - for (unsigned i = 0; i < bs.size(); ++i) { - all_units = m_util.str.is_unit(bs[i].get()); - } - for (unsigned i = 0; i < as.size(); ++i) { - all_units = m_util.str.is_unit(as[i].get()); - } - if (all_units) { - if (as.size() < bs.size()) { - result = m().mk_false(); - return BR_DONE; - } + std::function is_unit = [&](expr *e) { return m_util.str.is_unit(e); }; + + if (bs.forall(is_unit) && as.forall(is_unit)) { expr_ref_vector ors(m()); - for (unsigned i = 0; i < as.size() - bs.size() + 1; ++i) { + for (unsigned i = 0; i + bs.size() <= as.size(); ++i) { expr_ref_vector ands(m()); for (unsigned j = 0; j < bs.size(); ++j) { - ands.push_back(m().mk_eq(as[i + j].get(), bs[j].get())); + ands.push_back(m().mk_eq(as.get(i + j), bs.get(j))); } ors.push_back(::mk_and(ands)); } @@ -769,6 +821,16 @@ br_status seq_rewriter::mk_seq_contains(expr* a, expr* b, expr_ref& result) { return BR_REWRITE_FULL; } + if (bs.size() == 1 && bs.forall(is_unit) && as.size() > 1) { + expr_ref_vector ors(m()); + for (expr* ai : as) { + ors.push_back(m_util.str.mk_contains(ai, bs.get(0))); + } + result = ::mk_or(ors); + return BR_REWRITE_FULL; + } + + return BR_FAILED; } @@ -778,46 +840,41 @@ br_status seq_rewriter::mk_seq_contains(expr* a, expr* b, expr_ref& result) { br_status seq_rewriter::mk_seq_at(expr* a, expr* b, expr_ref& result) { zstring c; rational r; - if (m_autil.is_numeral(b, r)) { - if (r.is_neg()) { - result = m_util.str.mk_empty(m().get_sort(a)); - return BR_DONE; - } - unsigned len = 0; - bool bounded = min_length(1, &a, len); - if (bounded && r >= rational(len)) { - result = m_util.str.mk_empty(m().get_sort(a)); - return BR_DONE; - } - 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)); - } - else { - result = m_util.str.mk_empty(m().get_sort(a)); - } - 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; - } - } - } - + if (!m_autil.is_numeral(b, r)) { + return BR_FAILED; } - return BR_FAILED; + if (r.is_neg()) { + result = m_util.str.mk_empty(m().get_sort(a)); + return BR_DONE; + } + if (!r.is_unsigned()) { + return BR_FAILED; + } + unsigned len = r.get_unsigned(); + + expr_ref_vector as(m()); + m_util.str.get_concat_units(a, as); + + for (unsigned i = 0; i < as.size(); ++i) { + expr* a = as.get(i); + if (m_util.str.is_unit(a)) { + if (len == i) { + result = a; + return BR_REWRITE1; + } + } + else if (i > 0) { + SASSERT(len >= i); + result = m_util.str.mk_concat(as.size() - i, as.c_ptr() + i); + result = m().mk_app(m_util.get_family_id(), OP_SEQ_AT, result, m_autil.mk_int(len - i)); + return BR_REWRITE2; + } + else { + return BR_FAILED; + } + } + result = m_util.str.mk_empty(m().get_sort(a)); + return BR_DONE; } br_status seq_rewriter::mk_seq_index(expr* a, expr* b, expr* c, expr_ref& result) { @@ -844,6 +901,10 @@ br_status seq_rewriter::mk_seq_index(expr* a, expr* b, expr* c, expr_ref& result return BR_FAILED; } +// (str.replace s t t') is the string obtained by replacing the first occurrence +// of t in s, if any, by t'. Note that if t is empty, the result is to prepend +// t' to s; also, if t does not occur in s then the result is s. + br_status seq_rewriter::mk_seq_replace(expr* a, expr* b, expr* c, expr_ref& result) { zstring s1, s2, s3; if (m_util.str.is_string(a, s1) && m_util.str.is_string(b, s2) && @@ -855,14 +916,10 @@ br_status seq_rewriter::mk_seq_replace(expr* a, expr* b, expr* c, expr_ref& resu result = a; return BR_DONE; } - if (m_util.str.is_string(b, s2) && s2.length() == 0) { + if (m_util.str.is_empty(b)) { result = m_util.str.mk_concat(c, a); return BR_REWRITE1; } - if (m_util.str.is_string(a, s1) && s1.length() == 0) { - result = a; - return BR_DONE; - } return BR_FAILED; } @@ -934,25 +991,23 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) { } } } - m_util.str.get_concat(a, as); - m_util.str.get_concat(b, bs); + m_util.str.get_concat_units(a, as); + m_util.str.get_concat_units(b, bs); unsigned i = 0; expr_ref_vector eqs(m()); for (; i < as.size() && i < bs.size(); ++i) { - expr* a = as[i].get(), *b = bs[i].get(); - if (a == b) { + expr* ai = as.get(i), *bi = bs.get(i); + if (m().are_equal(ai, bi)) { continue; } - if (m_util.str.is_unit(a) && m_util.str.is_unit(b)) { - eqs.push_back(m().mk_eq(a, b)); - continue; - } - if (m().is_value(a) && m().is_value(b) && m_util.str.is_string(a) && m_util.str.is_string(b)) { - TRACE("seq", tout << mk_pp(a, m()) << " != " << mk_pp(b, m()) << "\n";); + if (m().are_distinct(ai, bi)) { result = m().mk_false(); return BR_DONE; } - + if (m_util.str.is_unit(ai) && m_util.str.is_unit(bi)) { + eqs.push_back(m().mk_eq(ai, bi)); + continue; + } break; } if (i == as.size()) { @@ -963,7 +1018,7 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) { SASSERT(i < as.size()); if (i == bs.size()) { for (unsigned j = i; j < as.size(); ++j) { - eqs.push_back(m().mk_eq(m_util.str.mk_empty(m().get_sort(a)), as[j].get())); + eqs.push_back(m_util.str.mk_is_empty(as.get(j))); } result = mk_and(eqs); TRACE("seq", tout << result << "\n";); @@ -973,13 +1028,13 @@ br_status seq_rewriter::mk_seq_prefix(expr* a, expr* b, expr_ref& result) { SASSERT(i < as.size() && i < bs.size()); a = m_util.str.mk_concat(as.size() - i, as.c_ptr() + i); b = m_util.str.mk_concat(bs.size() - i, bs.c_ptr() + i); - result = m_util.str.mk_prefix(a, b); + eqs.push_back(m_util.str.mk_prefix(a, b)); + result = mk_and(eqs); TRACE("seq", tout << result << "\n";); - return BR_DONE; - } - else { - return BR_FAILED; + return BR_REWRITE3; } + + return BR_FAILED; } br_status seq_rewriter::mk_seq_suffix(expr* a, expr* b, expr_ref& result) { @@ -993,7 +1048,7 @@ br_status seq_rewriter::mk_seq_suffix(expr* a, expr* b, expr_ref& result) { return BR_DONE; } if (m_util.str.is_empty(b)) { - result = m().mk_eq(m_util.str.mk_empty(m().get_sort(a)), a); + result = m_util.str.mk_is_empty(a); return BR_REWRITE3; } @@ -1059,36 +1114,48 @@ br_status seq_rewriter::mk_seq_suffix(expr* a, expr* b, expr_ref& result) { } } } - expr_ref_vector as(m()), bs(m()); - m_util.str.get_concat(a, as); - m_util.str.get_concat(b, bs); - bool change = false; - while (as.size() > 0 && bs.size() > 0 && as.back() == bs.back()) { - as.pop_back(); - bs.pop_back(); - change = true; - } - if (as.size() > 0 && bs.size() > 0 && m().is_value(as.back()) && m().is_value(bs.back())) { - result = m().mk_false(); - return BR_DONE; - } - if (change) { - // suffix("", bs) <- true - if (as.empty()) { - result = m().mk_true(); + expr_ref_vector as(m()), bs(m()), eqs(m()); + m_util.str.get_concat_units(a, as); + m_util.str.get_concat_units(b, bs); + unsigned i = 1, sza = as.size(), szb = bs.size(); + for (; i <= sza && i <= szb; ++i) { + expr* ai = as.get(sza-i), *bi = bs.get(szb-i); + if (m().are_equal(ai, bi)) { + continue; + } + if (m().are_distinct(ai, bi)) { + result = m().mk_false(); return BR_DONE; } - // suffix(as, "") iff as = "" - if (bs.empty()) { - for (unsigned j = 0; j < as.size(); ++j) { - bs.push_back(m().mk_eq(m_util.str.mk_empty(m().get_sort(a)), as[j].get())); - } - result = mk_and(bs); - return BR_REWRITE3; + if (m_util.str.is_unit(ai) && m_util.str.is_unit(bi)) { + eqs.push_back(m().mk_eq(ai, bi)); + continue; } - result = m_util.str.mk_suffix(m_util.str.mk_concat(as.size(), as.c_ptr()), - m_util.str.mk_concat(bs.size(), bs.c_ptr())); - return BR_DONE; + break; + } + if (i > sza) { + result = mk_and(eqs); + TRACE("seq", tout << result << "\n";); + return BR_REWRITE3; + } + if (i > szb) { + for (unsigned j = i; j <= sza; ++j) { + expr* aj = as.get(sza-j); + eqs.push_back(m_util.str.mk_is_empty(aj)); + } + result = mk_and(eqs); + TRACE("seq", tout << result << "\n";); + return BR_REWRITE3; + } + + if (i > 1) { + SASSERT(i <= sza && i <= szb); + a = m_util.str.mk_concat(sza - i + 1, as.c_ptr()); + b = m_util.str.mk_concat(szb - i + 1, bs.c_ptr()); + eqs.push_back(m_util.str.mk_suffix(a, b)); + result = mk_and(eqs); + TRACE("seq", tout << result << "\n";); + return BR_REWRITE3; } return BR_FAILED; @@ -1239,6 +1306,7 @@ br_status seq_rewriter::mk_str_in_regexp(expr* a, expr* b, expr_ref& result) { scoped_ptr aut; expr_ref_vector seq(m()); if (!(aut = m_re2aut(b))) { + TRACE("seq", tout << "not translated to automaton " << mk_pp(b, m()) << "\n";); return BR_FAILED; } @@ -1246,15 +1314,16 @@ br_status seq_rewriter::mk_str_in_regexp(expr* a, expr* b, expr_ref& result) { TRACE("seq", tout << seq << "\n";); if (seq.empty()) { - result = m().mk_eq(a, m_util.str.mk_empty(m().get_sort(a))); + result = m_util.str.mk_is_empty(a); } else { result = m().mk_eq(a, m_util.str.mk_concat(seq)); } - return BR_REWRITE_FULL; + return BR_REWRITE3; } if (!is_sequence(a, seq)) { + TRACE("seq", tout << "not a sequence " << mk_pp(a, m()) << "\n";); return BR_FAILED; } @@ -1306,17 +1375,16 @@ br_status seq_rewriter::mk_str_in_regexp(expr* a, expr* b, expr_ref& result) { } } u_map const& frontier = maps[select_map]; - u_map::iterator it = frontier.begin(), end = frontier.end(); expr_ref_vector ors(m()); - for (; it != end; ++it) { + for (auto const& kv : frontier) { unsigned_vector states; bool has_final = false; - aut->get_epsilon_closure(it->m_key, states); + aut->get_epsilon_closure(kv.m_key, states); for (unsigned i = 0; i < states.size() && !has_final; ++i) { has_final = aut->is_final_state(states[i]); } if (has_final) { - ors.push_back(it->m_value); + ors.push_back(kv.m_value); } } result = mk_or(ors); @@ -1435,6 +1503,14 @@ br_status seq_rewriter::mk_re_inter(expr* a, expr* b, expr_ref& result) { result = a; return BR_DONE; } + expr* ac = nullptr, *bc = nullptr; + if ((m_util.re.is_complement(a, ac) && ac == b) || + (m_util.re.is_complement(b, bc) && bc == a)) { + sort* seq_sort = nullptr; + VERIFY(m_util.is_re(a, seq_sort)); + result = m_util.re.mk_empty(seq_sort); + return BR_DONE; + } return BR_FAILED; } @@ -1579,7 +1655,7 @@ br_status seq_rewriter::mk_eq_core(expr * l, expr * r, expr_ref & result) { return BR_FAILED; } for (unsigned i = 0; i < lhs.size(); ++i) { - res.push_back(m().mk_eq(lhs[i].get(), rhs[i].get())); + res.push_back(m().mk_eq(lhs.get(i), rhs.get(i))); } result = mk_and(res); return BR_REWRITE3; @@ -1907,7 +1983,7 @@ bool seq_rewriter::reduce_contains(expr* a, expr* b, expr_ref_vector& disj) { disj.push_back(m_util.str.mk_contains(m_util.str.mk_concat(m_lhs.size() - i, m_lhs.c_ptr() + i), b)); return true; } - disj.push_back(m().mk_eq(b, m_util.str.mk_empty(m().get_sort(b)))); + disj.push_back(m_util.str.mk_is_empty(b)); return true; } @@ -1978,15 +2054,13 @@ bool seq_rewriter::min_length(unsigned n, expr* const* es, unsigned& len) { bool seq_rewriter::is_string(unsigned n, expr* const* es, zstring& s) const { zstring s1; expr* e; - bv_util bv(m()); - rational val; - unsigned sz; + unsigned ch; for (unsigned i = 0; i < n; ++i) { if (m_util.str.is_string(es[i], s1)) { s = s + s1; } - else if (m_util.str.is_unit(es[i], e) && bv.is_numeral(e, val, sz)) { - s = s + zstring(val.get_unsigned()); + else if (m_util.str.is_unit(es[i], e) && m_util.is_const_char(e, ch)) { + s = s + zstring(ch); } else { return false; diff --git a/src/ast/rewriter/seq_rewriter.h b/src/ast/rewriter/seq_rewriter.h index f5878b2c2..83793a594 100644 --- a/src/ast/rewriter/seq_rewriter.h +++ b/src/ast/rewriter/seq_rewriter.h @@ -31,31 +31,38 @@ class sym_expr { enum ty { t_char, t_pred, + t_not, t_range }; - ty m_ty; - sort* m_sort; - expr_ref m_t; - expr_ref m_s; - unsigned m_ref; - sym_expr(ty ty, expr_ref& t, expr_ref& s, sort* srt) : m_ty(ty), m_sort(srt), m_t(t), m_s(s), m_ref(0) {} + ty m_ty; + sort* m_sort; + sym_expr* m_expr; + expr_ref m_t; + expr_ref m_s; + unsigned m_ref; + sym_expr(ty ty, expr_ref& t, expr_ref& s, sort* srt, sym_expr* e) : + m_ty(ty), m_sort(srt), m_expr(e), m_t(t), m_s(s), m_ref(0) {} public: + ~sym_expr() { if (m_expr) m_expr->dec_ref(); } expr_ref accept(expr* e); - static sym_expr* mk_char(expr_ref& t) { return alloc(sym_expr, t_char, t, t, t.get_manager().get_sort(t)); } + static sym_expr* mk_char(expr_ref& t) { return alloc(sym_expr, t_char, t, t, t.get_manager().get_sort(t), nullptr); } static sym_expr* mk_char(ast_manager& m, expr* t) { expr_ref tr(t, m); return mk_char(tr); } - static sym_expr* mk_pred(expr_ref& t, sort* s) { return alloc(sym_expr, t_pred, t, t, s); } - static sym_expr* mk_range(expr_ref& lo, expr_ref& hi) { return alloc(sym_expr, t_range, lo, hi, lo.get_manager().get_sort(hi)); } + static sym_expr* mk_pred(expr_ref& t, sort* s) { return alloc(sym_expr, t_pred, t, t, s, nullptr); } + static sym_expr* mk_range(expr_ref& lo, expr_ref& hi) { return alloc(sym_expr, t_range, lo, hi, lo.get_manager().get_sort(hi), nullptr); } + static sym_expr* mk_not(ast_manager& m, sym_expr* e) { expr_ref f(m); e->inc_ref(); return alloc(sym_expr, t_not, f, f, e->get_sort(), e); } void inc_ref() { ++m_ref; } void dec_ref() { --m_ref; if (m_ref == 0) dealloc(this); } std::ostream& display(std::ostream& out) const; bool is_char() const { return m_ty == t_char; } bool is_pred() const { return !is_char(); } bool is_range() const { return m_ty == t_range; } + bool is_not() const { return m_ty == t_not; } sort* get_sort() const { return m_sort; } expr* get_char() const { SASSERT(is_char()); return m_t; } expr* get_pred() const { SASSERT(is_pred()); return m_t; } expr* get_lo() const { SASSERT(is_range()); return m_t; } expr* get_hi() const { SASSERT(is_range()); return m_s; } + sym_expr* get_arg() const { SASSERT(is_not()); return m_expr; } }; class sym_expr_manager { @@ -77,7 +84,6 @@ class re2automaton { ast_manager& m; sym_expr_manager sm; seq_util u; - bv_util bv; scoped_ptr m_solver; scoped_ptr m_ba; scoped_ptr m_sa; diff --git a/src/ast/seq_decl_plugin.cpp b/src/ast/seq_decl_plugin.cpp index 07c6fd06a..20e1fb36c 100644 --- a/src/ast/seq_decl_plugin.cpp +++ b/src/ast/seq_decl_plugin.cpp @@ -20,6 +20,7 @@ Revision History: #include "ast/arith_decl_plugin.h" #include "ast/array_decl_plugin.h" #include "ast/ast_pp.h" +#include "ast/bv_decl_plugin.h" #include static bool is_hex_digit(char ch, unsigned& d) { @@ -68,14 +69,14 @@ static bool is_escape_char(char const *& s, unsigned& result) { } /* 2 octal digits */ if (is_octal_digit(*(s + 1), d1) && is_octal_digit(*(s + 2), d2) && - !is_octal_digit(*(s + 3), d3)) { + !is_octal_digit(*(s + 3), d3)) { result = d1 * 8 + d2; s += 3; return true; } /* 3 octal digits */ if (is_octal_digit(*(s + 1), d1) && is_octal_digit(*(s + 2), d2) && - is_octal_digit(*(s + 3), d3)) { + is_octal_digit(*(s + 3), d3)) { result = d1*64 + d2*8 + d3; s += 4; return true; @@ -295,13 +296,10 @@ bool zstring::operator==(const zstring& other) const { return false; } for (unsigned i = 0; i < length(); ++i) { - unsigned Xi = m_buffer[i]; - unsigned Yi = other[i]; - if (Xi != Yi) { + if (m_buffer[i] != other[i]) { return false; } } - return true; } @@ -324,19 +322,14 @@ bool operator<(const zstring& lhs, const zstring& rhs) { unsigned Ri = rhs[i]; if (Li < Ri) { return true; - } else if (Li > Ri) { + } + else if (Li > Ri) { return false; - } else { - continue; - } + } } // at this point, all compared characters are equal, // so decide based on the relative lengths - if (lhs.length() < rhs.length()) { - return true; - } else { - return false; - } + return lhs.length() < rhs.length(); } @@ -345,7 +338,8 @@ seq_decl_plugin::seq_decl_plugin(): m_init(false), m_charc_sym("Char"), m_string(nullptr), m_char(nullptr), - m_re(nullptr) {} + m_re(nullptr), + m_has_re(false) {} void seq_decl_plugin::finalize() { for (unsigned i = 0; i < m_sigs.size(); ++i) @@ -376,8 +370,8 @@ bool seq_decl_plugin::match(ptr_vector& binding, sort* s, sort* sP) { if (s->get_family_id() == sP->get_family_id() && s->get_decl_kind() == sP->get_decl_kind() && s->get_num_parameters() == sP->get_num_parameters()) { - for (unsigned i = 0, sz = s->get_num_parameters(); i < sz; ++i) { - parameter const& p = s->get_parameter(i); + for (unsigned i = 0, sz = s->get_num_parameters(); i < sz; ++i) { + parameter const& p = s->get_parameter(i); if (p.is_ast() && is_sort(p.get_ast())) { parameter const& p2 = sP->get_parameter(i); if (!match(binding, to_sort(p.get_ast()), to_sort(p2.get_ast()))) return false; @@ -434,7 +428,7 @@ void seq_decl_plugin::match_right_assoc(psig& sig, unsigned dsz, sort *const* do } void seq_decl_plugin::match(psig& sig, unsigned dsz, sort *const* dom, sort* range, sort_ref& range_out) { - ptr_vector binding; + m_binding.reset(); ast_manager& m = *m_manager; if (sig.m_dom.size() != dsz) { std::ostringstream strm; @@ -444,10 +438,10 @@ void seq_decl_plugin::match(psig& sig, unsigned dsz, sort *const* dom, sort* ran } bool is_match = true; for (unsigned i = 0; is_match && i < dsz; ++i) { - is_match = match(binding, dom[i], sig.m_dom[i].get()); + is_match = match(m_binding, dom[i], sig.m_dom[i].get()); } if (range && is_match) { - is_match = match(binding, range, sig.m_range); + is_match = match(m_binding, range, sig.m_range); } if (!is_match) { std::ostringstream strm; @@ -473,7 +467,7 @@ void seq_decl_plugin::match(psig& sig, unsigned dsz, sort *const* dom, sort* ran strm << "is ambiguous. Function takes no arguments and sort of range has not been constrained"; m.raise_exception(strm.str().c_str()); } - range_out = apply_binding(binding, sig.m_range); + range_out = apply_binding(m_binding, sig.m_range); SASSERT(range_out); } @@ -537,6 +531,7 @@ void seq_decl_plugin::init() { m_sigs[OP_SEQ_REPLACE] = alloc(psig, m, "seq.replace", 1, 3, seq3A, seqA); m_sigs[OP_SEQ_INDEX] = alloc(psig, m, "seq.indexof", 1, 3, seq2AintT, intT); m_sigs[OP_SEQ_AT] = alloc(psig, m, "seq.at", 1, 2, seqAintT, seqA); + m_sigs[OP_SEQ_NTH] = alloc(psig, m, "seq.nth", 1, 2, seqAintT, A); m_sigs[OP_SEQ_LENGTH] = alloc(psig, m, "seq.len", 1, 1, &seqA, intT); m_sigs[OP_RE_PLUS] = alloc(psig, m, "re.+", 1, 1, &reA, reA); m_sigs[OP_RE_STAR] = alloc(psig, m, "re.*", 1, 1, &reA, reA); @@ -553,7 +548,7 @@ void seq_decl_plugin::init() { m_sigs[OP_RE_OF_PRED] = alloc(psig, m, "re.of.pred", 1, 1, &predA, reA); m_sigs[OP_SEQ_TO_RE] = alloc(psig, m, "seq.to.re", 1, 1, &seqA, reA); m_sigs[OP_SEQ_IN_RE] = alloc(psig, m, "seq.in.re", 1, 2, seqAreA, boolT); - m_sigs[OP_STRING_CONST] = 0; + m_sigs[OP_STRING_CONST] = nullptr; m_sigs[_OP_STRING_STRIDOF] = alloc(psig, m, "str.indexof", 0, 3, str2TintT, intT); m_sigs[_OP_STRING_STRREPL] = alloc(psig, m, "str.replace", 0, 3, str3T, strT); m_sigs[OP_STRING_ITOS] = alloc(psig, m, "int.to.str", 0, 1, &intT, strT); @@ -662,24 +657,28 @@ func_decl * seq_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, return m.mk_func_decl(m_sigs[k]->m_name, arity, domain, rng, info); } - case OP_SEQ_UNIT: case OP_RE_PLUS: case OP_RE_STAR: case OP_RE_OPTION: case OP_RE_RANGE: case OP_RE_OF_PRED: + case OP_RE_COMPLEMENT: + m_has_re = true; + // fall-through + case OP_SEQ_UNIT: case OP_STRING_ITOS: case OP_STRING_STOI: - case OP_RE_COMPLEMENT: match(*m_sigs[k], arity, domain, range, rng); return m.mk_func_decl(m_sigs[k]->m_name, arity, domain, rng, func_decl_info(m_family_id, k)); case _OP_REGEXP_FULL_CHAR: + m_has_re = true; if (!range) range = m_re; match(*m_sigs[k], arity, domain, range, rng); return m.mk_func_decl(symbol("re.allchar"), arity, domain, rng, func_decl_info(m_family_id, OP_RE_FULL_CHAR_SET)); case OP_RE_FULL_CHAR_SET: + m_has_re = true; if (!range) range = m_re; if (range == m_re) { match(*m_sigs[k], arity, domain, range, rng); @@ -688,15 +687,18 @@ func_decl * seq_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, return m.mk_func_decl(m_sigs[k]->m_name, arity, domain, range, func_decl_info(m_family_id, k)); case OP_RE_FULL_SEQ_SET: + m_has_re = true; if (!range) range = m_re; return m.mk_func_decl(m_sigs[k]->m_name, arity, domain, range, func_decl_info(m_family_id, k)); case _OP_REGEXP_EMPTY: + m_has_re = true; if (!range) range = m_re; match(*m_sigs[k], arity, domain, range, rng); return m.mk_func_decl(symbol("re.nostr"), arity, domain, rng, func_decl_info(m_family_id, OP_RE_EMPTY_SET)); case OP_RE_EMPTY_SET: + m_has_re = true; if (!range) range = m_re; if (range == m_re) { match(*m_sigs[k], arity, domain, range, rng); @@ -705,6 +707,7 @@ func_decl * seq_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, return m.mk_func_decl(m_sigs[k]->m_name, arity, domain, range, func_decl_info(m_family_id, k)); case OP_RE_LOOP: + m_has_re = true; switch (arity) { case 1: match(*m_sigs[k], arity, domain, range, rng); @@ -727,6 +730,7 @@ func_decl * seq_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, } case _OP_RE_UNROLL: + m_has_re = true; match(*m_sigs[k], arity, domain, range, rng); return m.mk_func_decl(m_sigs[k]->m_name, arity, domain, rng, func_decl_info(m_family_id, k)); @@ -740,6 +744,7 @@ func_decl * seq_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, case OP_RE_UNION: case OP_RE_CONCAT: case OP_RE_INTERSECT: + m_has_re = true; return mk_assoc_fun(k, arity, domain, range, k, k); case OP_SEQ_CONCAT: @@ -791,13 +796,17 @@ func_decl * seq_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, return mk_str_fun(k, arity, domain, range, OP_SEQ_CONTAINS); case OP_SEQ_TO_RE: + m_has_re = true; return mk_seq_fun(k, arity, domain, range, _OP_STRING_TO_REGEXP); case _OP_STRING_TO_REGEXP: + m_has_re = true; return mk_str_fun(k, arity, domain, range, OP_SEQ_TO_RE); case OP_SEQ_IN_RE: + m_has_re = true; return mk_seq_fun(k, arity, domain, range, _OP_STRING_IN_REGEXP); case _OP_STRING_IN_REGEXP: + m_has_re = true; return mk_str_fun(k, arity, domain, range, OP_SEQ_IN_RE); case OP_SEQ_AT: @@ -805,6 +814,10 @@ func_decl * seq_decl_plugin::mk_func_decl(decl_kind k, unsigned num_parameters, case _OP_STRING_CHARAT: return mk_str_fun(k, arity, domain, range, OP_SEQ_AT); + case OP_SEQ_NTH: + match(*m_sigs[k], arity, domain, range, rng); + return m.mk_func_decl(m_sigs[k]->m_name, arity, domain, rng, func_decl_info(m_family_id, k)); + case OP_SEQ_EXTRACT: return mk_seq_fun(k, arity, domain, range, _OP_STRING_SUBSTR); case _OP_STRING_SUBSTR: @@ -842,7 +855,9 @@ void seq_decl_plugin::get_sort_names(svector & sort_names, symbol } app* seq_decl_plugin::mk_string(symbol const& s) { - parameter param(s); + zstring canonStr(s.bare_str()); + symbol canonSym(canonStr.encode().c_str()); + parameter param(canonSym); func_decl* f = m_manager->mk_const_decl(m_stringc_sym, m_string, func_decl_info(m_family_id, OP_STRING_CONST, 1, ¶m)); return m_manager->mk_const(f); @@ -897,7 +912,7 @@ bool seq_decl_plugin::are_distinct(app* a, app* b) const { } if (is_app_of(a, m_family_id, OP_SEQ_UNIT) && is_app_of(b, m_family_id, OP_SEQ_UNIT)) { - return true; + return m_manager->are_distinct(a->get_arg(0), b->get_arg(0)); } if (is_app_of(a, m_family_id, OP_SEQ_EMPTY) && is_app_of(b, m_family_id, OP_SEQ_UNIT)) { @@ -931,20 +946,38 @@ app* seq_util::mk_skolem(symbol const& name, unsigned n, expr* const* args, sort return m.mk_app(f, n, args); } -app* seq_util::str::mk_string(zstring const& s) { return u.seq.mk_string(s); } +app* seq_util::str::mk_string(zstring const& s) const { + return u.seq.mk_string(s); +} - - -app* seq_util::str::mk_char(zstring const& s, unsigned idx) { +app* seq_util::str::mk_char(zstring const& s, unsigned idx) const { bv_util bvu(m); return bvu.mk_numeral(s[idx], s.num_bits()); } -app* seq_util::str::mk_char(char ch) { +app* seq_util::str::mk_char(char ch) const { zstring s(ch, zstring::ascii); return mk_char(s, 0); } +bool seq_util::is_const_char(expr* e, unsigned& c) const { + bv_util bv(m); + rational r; + unsigned sz; + return bv.is_numeral(e, r, sz) && sz == 8 && r.is_unsigned() && (c = r.get_unsigned(), true); +} + +app* seq_util::mk_char(unsigned ch) const { + bv_util bv(m); + return bv.mk_numeral(rational(ch), 8); +} + +app* seq_util::mk_le(expr* ch1, expr* ch2) const { + bv_util bv(m); + return bv.mk_ule(ch1, ch2); +} + + bool seq_util::str::is_string(expr const* n, zstring& s) const { if (is_string(n)) { s = zstring(to_app(n)->get_decl()->get_parameter(0).get_symbol().bare_str()); @@ -955,6 +988,16 @@ bool seq_util::str::is_string(expr const* n, zstring& s) const { } } +bool seq_util::str::is_nth(expr const* n, expr*& s, unsigned& idx) const { + expr* i = nullptr; + if (!is_nth(n, s, i)) return false; + return arith_util(m).is_unsigned(i, idx); +} + +app* seq_util::str::mk_nth(expr* s, unsigned i) const { + return mk_nth(s, arith_util(m).mk_int(i)); +} + void seq_util::str::get_concat(expr* e, expr_ref_vector& es) const { expr* e1, *e2; @@ -967,6 +1010,29 @@ void seq_util::str::get_concat(expr* e, expr_ref_vector& es) const { } } +void seq_util::str::get_concat_units(expr* e, expr_ref_vector& es) const { + expr* e1, *e2; + while (is_concat(e, e1, e2)) { + get_concat_units(e1, es); + e = e2; + } + zstring s; + if (is_string(e, s)) { + unsigned sz = s.length(); + for (unsigned j = 0; j < sz; ++j) { + es.push_back(mk_unit(mk_char(s, j))); + } + } + else if (!is_empty(e)) { + es.push_back(e); + } +} + +app* seq_util::str::mk_is_empty(expr* s) const { + return m.mk_eq(s, mk_empty(get_sort(s))); +} + + app* seq_util::re::mk_loop(expr* r, unsigned lo) { parameter param(lo); return m.mk_app(m_fid, OP_RE_LOOP, 1, ¶m, 1, &r); @@ -989,7 +1055,6 @@ app* seq_util::re::mk_empty(sort* s) { return m.mk_app(m_fid, OP_RE_EMPTY_SET, 0, nullptr, 0, nullptr, s); } - bool seq_util::re::is_loop(expr const* n, expr*& body, unsigned& lo, unsigned& hi) { if (is_loop(n)) { app const* a = to_app(n); diff --git a/src/ast/seq_decl_plugin.h b/src/ast/seq_decl_plugin.h index 8bd4d2807..1148c8411 100644 --- a/src/ast/seq_decl_plugin.h +++ b/src/ast/seq_decl_plugin.h @@ -22,7 +22,6 @@ Revision History: #define SEQ_DECL_PLUGIN_H_ #include "ast/ast.h" -#include "ast/bv_decl_plugin.h" enum seq_sort_kind { @@ -41,6 +40,7 @@ enum seq_op_kind { OP_SEQ_EXTRACT, OP_SEQ_REPLACE, OP_SEQ_AT, + OP_SEQ_NTH, OP_SEQ_LENGTH, OP_SEQ_INDEX, OP_SEQ_TO_RE, @@ -139,12 +139,14 @@ class seq_decl_plugin : public decl_plugin { }; ptr_vector m_sigs; + ptr_vector m_binding; bool m_init; symbol m_stringc_sym; symbol m_charc_sym; sort* m_string; sort* m_char; sort* m_re; + bool m_has_re; void match(psig& sig, unsigned dsz, sort* const* dom, sort* range, sort_ref& rng); @@ -196,6 +198,8 @@ public: app* mk_string(symbol const& s); app* mk_string(zstring const& s); + bool has_re() const { return m_has_re; } + }; class seq_util { @@ -216,10 +220,15 @@ public: bool is_re(expr* e) const { return is_re(m.get_sort(e)); } bool is_re(expr* e, sort*& seq) const { return is_re(m.get_sort(e), seq); } bool is_char(expr* e) const { return is_char(m.get_sort(e)); } + bool is_const_char(expr* e, unsigned& c) const; + app* mk_char(unsigned ch) const; + app* mk_le(expr* ch1, expr* ch2) const; app* mk_skolem(symbol const& name, unsigned n, expr* const* args, sort* range); bool is_skolem(expr const* e) const { return is_app_of(e, m_fid, _OP_SEQ_SKOLEM); } + bool has_re() const { return seq.has_re(); } + class str { seq_util& u; ast_manager& m; @@ -232,26 +241,30 @@ public: public: str(seq_util& u): u(u), m(u.m), m_fid(u.m_fid) {} - sort* mk_seq(sort* s) { parameter param(s); return m.mk_sort(m_fid, SEQ_SORT, 1, ¶m); } + sort* mk_seq(sort* s) const { parameter param(s); return m.mk_sort(m_fid, SEQ_SORT, 1, ¶m); } sort* mk_string_sort() const { return m.mk_sort(m_fid, _STRING_SORT, 0, nullptr); } app* mk_empty(sort* s) const { return m.mk_const(m.mk_func_decl(m_fid, OP_SEQ_EMPTY, 0, nullptr, 0, (expr*const*)nullptr, s)); } - app* mk_string(zstring const& s); - app* mk_string(symbol const& s) { return u.seq.mk_string(s); } - app* mk_char(char ch); + app* mk_string(zstring const& s) const; + app* mk_string(symbol const& s) const { return u.seq.mk_string(s); } + app* mk_char(char ch) const; app* mk_concat(expr* a, expr* b) const { expr* es[2] = { a, b }; return m.mk_app(m_fid, OP_SEQ_CONCAT, 2, es); } - app* mk_concat(expr* a, expr* b, expr* c) { return mk_concat(a, mk_concat(b, c)); } + app* mk_concat(expr* a, expr* b, expr* c) const { return mk_concat(a, mk_concat(b, c)); } expr* mk_concat(unsigned n, expr* const* es) const { if (n == 1) return es[0]; SASSERT(n > 1); return m.mk_app(m_fid, OP_SEQ_CONCAT, n, es); } expr* mk_concat(expr_ref_vector const& es) const { return mk_concat(es.size(), es.c_ptr()); } app* mk_length(expr* a) const { return m.mk_app(m_fid, OP_SEQ_LENGTH, 1, &a); } - app* mk_substr(expr* a, expr* b, expr* c) { expr* es[3] = { a, b, c }; return m.mk_app(m_fid, OP_SEQ_EXTRACT, 3, es); } - app* mk_contains(expr* a, expr* b) { expr* es[2] = { a, b }; return m.mk_app(m_fid, OP_SEQ_CONTAINS, 2, es); } - app* mk_prefix(expr* a, expr* b) { expr* es[2] = { a, b }; return m.mk_app(m_fid, OP_SEQ_PREFIX, 2, es); } - app* mk_suffix(expr* a, expr* b) { expr* es[2] = { a, b }; return m.mk_app(m_fid, OP_SEQ_SUFFIX, 2, es); } - app* mk_index(expr* a, expr* b, expr* i) { expr* es[3] = { a, b, i}; return m.mk_app(m_fid, OP_SEQ_INDEX, 3, es); } - app* mk_unit(expr* u) { return m.mk_app(m_fid, OP_SEQ_UNIT, 1, &u); } - app* mk_char(zstring const& s, unsigned idx); - app* mk_itos(expr* i) { return m.mk_app(m_fid, OP_STRING_ITOS, 1, &i); } - app* mk_stoi(expr* s) { return m.mk_app(m_fid, OP_STRING_STOI, 1, &s); } + app* mk_nth(expr* s, expr* i) const { expr* es[2] = { s, i }; return m.mk_app(m_fid, OP_SEQ_NTH, 2, es); } + app* mk_nth(expr* s, unsigned i) const; + + app* mk_substr(expr* a, expr* b, expr* c) const { expr* es[3] = { a, b, c }; return m.mk_app(m_fid, OP_SEQ_EXTRACT, 3, es); } + app* mk_contains(expr* a, expr* b) const { expr* es[2] = { a, b }; return m.mk_app(m_fid, OP_SEQ_CONTAINS, 2, es); } + app* mk_prefix(expr* a, expr* b) const { expr* es[2] = { a, b }; return m.mk_app(m_fid, OP_SEQ_PREFIX, 2, es); } + app* mk_suffix(expr* a, expr* b) const { expr* es[2] = { a, b }; return m.mk_app(m_fid, OP_SEQ_SUFFIX, 2, es); } + app* mk_index(expr* a, expr* b, expr* i) const { expr* es[3] = { a, b, i}; return m.mk_app(m_fid, OP_SEQ_INDEX, 3, es); } + app* mk_unit(expr* u) const { return m.mk_app(m_fid, OP_SEQ_UNIT, 1, &u); } + app* mk_char(zstring const& s, unsigned idx) const; + app* mk_itos(expr* i) const { return m.mk_app(m_fid, OP_STRING_ITOS, 1, &i); } + app* mk_stoi(expr* s) const { return m.mk_app(m_fid, OP_STRING_STOI, 1, &s); } + app* mk_is_empty(expr* s) const; bool is_string(expr const * n) const { return is_app_of(n, m_fid, OP_STRING_CONST); } @@ -269,6 +282,8 @@ public: bool is_extract(expr const* n) const { return is_app_of(n, m_fid, OP_SEQ_EXTRACT); } bool is_contains(expr const* n) const { return is_app_of(n, m_fid, OP_SEQ_CONTAINS); } bool is_at(expr const* n) const { return is_app_of(n, m_fid, OP_SEQ_AT); } + bool is_nth(expr const* n) const { return is_app_of(n, m_fid, OP_SEQ_NTH); } + bool is_nth(expr const* n, expr*& s, unsigned& idx) const; bool is_index(expr const* n) const { return is_app_of(n, m_fid, OP_SEQ_INDEX); } bool is_replace(expr const* n) const { return is_app_of(n, m_fid, OP_SEQ_REPLACE); } bool is_prefix(expr const* n) const { return is_app_of(n, m_fid, OP_SEQ_PREFIX); } @@ -293,6 +308,7 @@ public: MATCH_TERNARY(is_extract); MATCH_BINARY(is_contains); MATCH_BINARY(is_at); + MATCH_BINARY(is_nth); MATCH_BINARY(is_index); MATCH_TERNARY(is_index); MATCH_TERNARY(is_replace); @@ -304,6 +320,7 @@ public: MATCH_UNARY(is_unit); void get_concat(expr* e, expr_ref_vector& es) const; + void get_concat_units(expr* e, expr_ref_vector& es) const; expr* get_leftmost_concat(expr* e) const { expr* e1, *e2; while (is_concat(e, e1, e2)) e = e1; return e; } expr* get_rightmost_concat(expr* e) const { expr* e1, *e2; while (is_concat(e, e1, e2)) e = e2; return e; } }; diff --git a/src/cmd_context/basic_cmds.cpp b/src/cmd_context/basic_cmds.cpp index e65eb1b32..981698db7 100644 --- a/src/cmd_context/basic_cmds.cpp +++ b/src/cmd_context/basic_cmds.cpp @@ -17,7 +17,7 @@ Notes: --*/ #include "util/gparams.h" #include "util/env_params.h" -#include "util/version.h" +#include "util/z3_version.h" #include "ast/ast_smt_pp.h" #include "ast/ast_smt2_pp.h" #include "ast/ast_pp_dot.h" @@ -137,7 +137,7 @@ ATOMIC_CMD(get_assignment_cmd, "get-assignment", "retrieve assignment", { symbol const & name = kv.m_key; macro_decls const & _m = kv.m_value; for (auto md : _m) { - if (md.m_domain.size() == 0 && ctx.m().is_bool(md.m_body)) { + if (md.m_domain.empty() && ctx.m().is_bool(md.m_body)) { model::scoped_model_completion _scm(*m, true); expr_ref val = (*m)(md.m_body); if (ctx.m().is_true(val) || ctx.m().is_false(val)) { diff --git a/src/cmd_context/check_logic.cpp b/src/cmd_context/check_logic.cpp index 57e15c6a3..47c919d4a 100644 --- a/src/cmd_context/check_logic.cpp +++ b/src/cmd_context/check_logic.cpp @@ -476,7 +476,7 @@ struct check_logic::imp { quick_for_each_expr(*this, n); return true; } - catch (failed) { + catch (const failed &) { return false; } } @@ -495,7 +495,7 @@ struct check_logic::imp { check_sort(f->get_range()); return true; } - catch (failed) { + catch (const failed &) { return false; } } diff --git a/src/cmd_context/cmd_context.cpp b/src/cmd_context/cmd_context.cpp index be3acc261..8675365c9 100644 --- a/src/cmd_context/cmd_context.cpp +++ b/src/cmd_context/cmd_context.cpp @@ -30,6 +30,7 @@ Notes: #include "ast/seq_decl_plugin.h" #include "ast/pb_decl_plugin.h" #include "ast/fpa_decl_plugin.h" +#include "ast/csp_decl_plugin.h" #include "ast/ast_pp.h" #include "ast/rewriter/var_subst.h" #include "ast/pp.h" @@ -38,6 +39,7 @@ Notes: #include "ast/well_sorted.h" #include "ast/for_each_expr.h" #include "ast/rewriter/th_rewriter.h" +#include "ast/rewriter/recfun_replace.h" #include "model/model_evaluator.h" #include "model/model_smt2_pp.h" #include "model/model_v2_pp.h" @@ -474,7 +476,6 @@ cmd_context::cmd_context(bool main_ctx, ast_manager * m, symbol const & l): m_manager(m), m_own_manager(m == nullptr), m_manager_initialized(false), - m_rec_fun_declared(false), m_pmanager(nullptr), m_sexpr_manager(nullptr), m_regular("stdout", std::cout), @@ -679,6 +680,8 @@ bool cmd_context::logic_has_datatype() const { return !has_logic() || smt_logics::logic_has_datatype(m_logic); } +bool cmd_context::logic_has_recfun() const { return true; } + void cmd_context::init_manager_core(bool new_manager) { SASSERT(m_manager != 0); SASSERT(m_pmanager != 0); @@ -691,10 +694,12 @@ void cmd_context::init_manager_core(bool new_manager) { register_plugin(symbol("bv"), alloc(bv_decl_plugin), logic_has_bv()); register_plugin(symbol("array"), alloc(array_decl_plugin), logic_has_array()); register_plugin(symbol("datatype"), alloc(datatype_decl_plugin), logic_has_datatype()); + register_plugin(symbol("recfun"), alloc(recfun::decl::plugin), logic_has_recfun()); register_plugin(symbol("seq"), alloc(seq_decl_plugin), logic_has_seq()); register_plugin(symbol("pb"), alloc(pb_decl_plugin), logic_has_pb()); register_plugin(symbol("fpa"), alloc(fpa_decl_plugin), logic_has_fpa()); register_plugin(symbol("datalog_relation"), alloc(datalog::dl_decl_plugin), !has_logic()); + register_plugin(symbol("csp"), alloc(csp_decl_plugin), smt_logics::logic_is_csp(m_logic)); } else { // the manager was created by an external module @@ -706,9 +711,11 @@ void cmd_context::init_manager_core(bool new_manager) { load_plugin(symbol("bv"), logic_has_bv(), fids); load_plugin(symbol("array"), logic_has_array(), fids); load_plugin(symbol("datatype"), logic_has_datatype(), fids); + load_plugin(symbol("recfun"), logic_has_recfun(), fids); load_plugin(symbol("seq"), logic_has_seq(), fids); load_plugin(symbol("fpa"), logic_has_fpa(), fids); load_plugin(symbol("pb"), logic_has_pb(), fids); + load_plugin(symbol("csp"), smt_logics::logic_is_csp(m_logic), fids); for (family_id fid : fids) { decl_plugin * p = m_manager->get_plugin(fid); if (p) { @@ -790,9 +797,11 @@ void cmd_context::insert(symbol const & s, func_decl * f) { if (contains_macro(s, f)) { throw cmd_exception("invalid declaration, named expression already defined with this name ", s); } +#if 0 if (m_builtin_decls.contains(s)) { throw cmd_exception("invalid declaration, builtin symbol ", s); } +#endif dictionary::entry * e = m_func_decls.insert_if_not_there2(s, func_decls()); func_decls & fs = e->get_data().m_value; if (!fs.insert(m(), f)) { @@ -827,9 +836,11 @@ void cmd_context::insert(symbol const & s, psort_decl * p) { void cmd_context::insert(symbol const & s, unsigned arity, sort *const* domain, expr * t) { expr_ref _t(t, m()); +#if 0 if (m_builtin_decls.contains(s)) { throw cmd_exception("invalid macro/named expression, builtin symbol ", s); } +#endif if (contains_macro(s, arity, domain)) { throw cmd_exception("named expression already defined"); } @@ -888,7 +899,20 @@ void cmd_context::model_del(func_decl* f) { m_mc0->hide(f); } -void cmd_context::insert_rec_fun(func_decl* f, expr_ref_vector const& binding, svector const& ids, expr* e) { + +recfun::decl::plugin& cmd_context::get_recfun_plugin() { + recfun::util u(get_ast_manager()); + return u.get_plugin(); +} + + +recfun::promise_def cmd_context::decl_rec_fun(const symbol &name, unsigned int arity, sort *const *domain, sort *range) { + SASSERT(logic_has_recfun()); + return get_recfun_plugin().mk_def(name, arity, domain, range); +} + +// insert a recursive function as a regular quantified axiom +void cmd_context::insert_rec_fun_as_axiom(func_decl *f, expr_ref_vector const& binding, svector const &ids, expr* e) { expr_ref eq(m()); app_ref lhs(m()); lhs = m().mk_app(f, binding.size(), binding.c_ptr()); @@ -907,19 +931,43 @@ void cmd_context::insert_rec_fun(func_decl* f, expr_ref_vector const& binding, s eq = m().mk_forall(ids.size(), f->get_domain(), ids.c_ptr(), eq, 0, m().rec_fun_qid(), symbol::null, 2, pats); } - // - // disable warning given the current way they are used - // (Z3 will here silently assume and not check the definitions to be well founded, - // and please use HSF for everything else). - // - if (false && !ids.empty() && !m_rec_fun_declared) { - warning_msg("recursive function definitions are assumed well-founded"); - m_rec_fun_declared = true; - } assert_expr(eq); } + +void cmd_context::insert_rec_fun(func_decl* f, expr_ref_vector const& binding, svector const& ids, expr* rhs) { + + if (gparams::get_value("smt.recfun.native") != "true") { + // just use an axiom + insert_rec_fun_as_axiom(f, binding, ids, rhs); + return; + } + + TRACE("recfun", tout<< "define recfun " << f->get_name() << " = " << mk_pp(rhs, m()) << "\n";); + + recfun::decl::plugin& p = get_recfun_plugin(); + + var_ref_vector vars(m()); + for (expr* b : binding) { + SASSERT(is_var(b)); + vars.push_back(to_var(b)); + } + + recfun::promise_def d = p.get_promise_def(f); + recfun_replace replace(m()); + p.set_definition(replace, d, vars.size(), vars.c_ptr(), rhs); +} + func_decl * cmd_context::find_func_decl(symbol const & s) const { + if (contains_macro(s)) { + throw cmd_exception("invalid function declaration reference, named expressions (aka macros) cannot be referenced ", s); + } + func_decls fs; + if (m_func_decls.find(s, fs)) { + if (fs.more_than_one()) + throw cmd_exception("ambiguous function declaration reference, provide full signature to disumbiguate ( (*) ) ", s); + return fs.first(); + } builtin_decl d; if (m_builtin_decls.find(s, d)) { try { @@ -933,15 +981,6 @@ func_decl * cmd_context::find_func_decl(symbol const & s) const { } throw cmd_exception("invalid function declaration reference, must provide signature for builtin symbol ", s); } - if (contains_macro(s)) { - throw cmd_exception("invalid function declaration reference, named expressions (aka macros) cannot be referenced ", s); - } - func_decls fs; - if (m_func_decls.find(s, fs)) { - if (fs.more_than_one()) - throw cmd_exception("ambiguous function declaration reference, provide full signature to disumbiguate ( (*) ) ", s); - return fs.first(); - } throw cmd_exception("invalid function declaration reference, unknown function ", s); return nullptr; } @@ -966,6 +1005,18 @@ static builtin_decl const & peek_builtin_decl(builtin_decl const & first, family func_decl * cmd_context::find_func_decl(symbol const & s, unsigned num_indices, unsigned const * indices, unsigned arity, sort * const * domain, sort * range) const { + + if (domain && contains_macro(s, arity, domain)) + throw cmd_exception("invalid function declaration reference, named expressions (aka macros) cannot be referenced ", s); + + func_decl * f = nullptr; + func_decls fs; + if (num_indices == 0 && m_func_decls.find(s, fs)) { + f = fs.find(arity, domain, range); + } + if (f) { + return f; + } builtin_decl d; if (domain && m_builtin_decls.find(s, d)) { family_id fid = d.m_fid; @@ -990,21 +1041,7 @@ func_decl * cmd_context::find_func_decl(symbol const & s, unsigned num_indices, throw cmd_exception("invalid function declaration reference, invalid builtin reference ", s); return f; } - - if (domain && contains_macro(s, arity, domain)) - throw cmd_exception("invalid function declaration reference, named expressions (aka macros) cannot be referenced ", s); - - if (num_indices > 0) - throw cmd_exception("invalid indexed function declaration reference, unknown builtin function ", s); - - func_decl * f = nullptr; - func_decls fs; - if (m_func_decls.find(s, fs)) { - f = fs.find(arity, domain, range); - } - if (f == nullptr) - throw cmd_exception("invalid function declaration reference, unknown function ", s); - return f; + throw cmd_exception("invalid function declaration reference, unknown function ", s); } psort_decl * cmd_context::find_psort_decl(symbol const & s) const { @@ -1041,29 +1078,6 @@ void cmd_context::mk_const(symbol const & s, expr_ref & result) const { void cmd_context::mk_app(symbol const & s, unsigned num_args, expr * const * args, unsigned num_indices, parameter const * indices, sort * range, expr_ref & result) const { - builtin_decl d; - if (m_builtin_decls.find(s, d)) { - family_id fid = d.m_fid; - decl_kind k = d.m_decl; - // Hack: if d.m_next != 0, we use the sort of args[0] (if available) to decide which plugin we use. - if (d.m_decl != 0 && num_args > 0) { - builtin_decl const & d2 = peek_builtin_decl(d, m().get_sort(args[0])->get_family_id()); - fid = d2.m_fid; - k = d2.m_decl; - } - if (num_indices == 0) { - result = m().mk_app(fid, k, 0, nullptr, num_args, args, range); - } - else { - result = m().mk_app(fid, k, num_indices, indices, num_args, args, range); - } - if (result.get() == nullptr) - throw cmd_exception("invalid builtin application ", s); - CHECK_SORT(result.get()); - return; - } - if (num_indices > 0) - throw cmd_exception("invalid use of indexed identifier, unknown builtin function ", s); expr* _t; if (macros_find(s, num_args, args, _t)) { TRACE("macro_bug", tout << "well_sorted_check_enabled(): " << well_sorted_check_enabled() << "\n"; @@ -1079,6 +1093,31 @@ void cmd_context::mk_app(symbol const & s, unsigned num_args, expr * const * arg func_decls fs; if (!m_func_decls.find(s, fs)) { + + builtin_decl d; + if (m_builtin_decls.find(s, d)) { + family_id fid = d.m_fid; + decl_kind k = d.m_decl; + // Hack: if d.m_next != 0, we use the sort of args[0] (if available) to decide which plugin we use. + if (d.m_decl != 0 && num_args > 0) { + builtin_decl const & d2 = peek_builtin_decl(d, m().get_sort(args[0])->get_family_id()); + fid = d2.m_fid; + k = d2.m_decl; + } + if (num_indices == 0) { + result = m().mk_app(fid, k, 0, nullptr, num_args, args, range); + } + else { + result = m().mk_app(fid, k, num_indices, indices, num_args, args, range); + } + if (result.get() == nullptr) + throw cmd_exception("invalid builtin application ", s); + CHECK_SORT(result.get()); + return; + } + if (num_indices > 0) + throw cmd_exception("invalid use of indexed identifier, unknown builtin function ", s); + if (num_args == 0) { throw cmd_exception("unknown constant ", s); } @@ -1088,14 +1127,17 @@ void cmd_context::mk_app(symbol const & s, unsigned num_args, expr * const * arg if (num_args == 0 && range == nullptr) { if (fs.more_than_one()) - throw cmd_exception("ambiguous constant reference, more than one constant with the same sort, use a qualified expression (as ) to disumbiguate ", s); + throw cmd_exception("ambiguous constant reference, more than one constant with the same sort, use a qualified expression (as ) to disambiguate ", s); func_decl * f = fs.first(); if (f == nullptr) { throw cmd_exception("unknown constant ", s); } - if (f->get_arity() != 0) - throw cmd_exception("invalid function application, missing arguments ", s); - result = m().mk_const(f); + if (f->get_arity() != 0) { + result = array_util(m()).mk_as_array(f); + } + else { + result = m().mk_const(f); + } } else { func_decl * f = fs.find(m(), num_args, args, range); @@ -1312,7 +1354,7 @@ void cmd_context::assert_expr(expr * t) { m().inc_ref(t); m_assertions.push_back(t); if (produce_unsat_cores()) - m_assertion_names.push_back(0); + m_assertion_names.push_back(nullptr); if (m_solver) m_solver->assert_expr(t); } @@ -1488,13 +1530,24 @@ void cmd_context::check_sat(unsigned num_assumptions, expr * const * assumptions scoped_ctrl_c ctrlc(eh); scoped_timer timer(timeout, &eh); scoped_rlimit _rlimit(m().limit(), rlimit); + expr_ref_vector asms(m()); + asms.append(num_assumptions, assumptions); if (!m_processing_pareto) { - ptr_vector cnstr(m_assertions); - cnstr.append(num_assumptions, assumptions); - get_opt()->set_hard_constraints(cnstr); + expr_ref_vector assertions(m()); + unsigned sz = m_assertions.size(); + for (unsigned i = 0; i < sz; ++i) { + if (m_assertion_names.size() > i && m_assertion_names[i]) { + asms.push_back(m_assertion_names[i]); + assertions.push_back(m().mk_implies(m_assertion_names[i], m_assertions[i])); + } + else { + assertions.push_back(m_assertions[i]); + } + } + get_opt()->set_hard_constraints(assertions); } try { - r = get_opt()->optimize(); + r = get_opt()->optimize(asms); if (r == l_true && get_opt()->is_pareto()) { m_processing_pareto = true; } @@ -1697,20 +1750,25 @@ struct contains_underspecified_op_proc { struct found {}; family_id m_array_fid; datatype_util m_dt; + seq_util m_seq; + family_id m_seq_id; - contains_underspecified_op_proc(ast_manager & m):m_array_fid(m.mk_family_id("array")), m_dt(m) {} + contains_underspecified_op_proc(ast_manager & m):m_array_fid(m.mk_family_id("array")), m_dt(m), m_seq(m), m_seq_id(m_seq.get_family_id()) {} void operator()(var * n) {} void operator()(app * n) { if (m_dt.is_accessor(n->get_decl())) throw found(); - if (n->get_family_id() != m_array_fid) - return; - decl_kind k = n->get_decl_kind(); - if (k == OP_AS_ARRAY || - k == OP_STORE || - k == OP_ARRAY_MAP || - k == OP_CONST_ARRAY) + if (n->get_family_id() == m_array_fid) { + decl_kind k = n->get_decl_kind(); + if (k == OP_AS_ARRAY || + k == OP_STORE || + k == OP_ARRAY_MAP || + k == OP_CONST_ARRAY) + throw found(); + } + if (n->get_family_id() == m_seq_id && m_seq.is_re(n)) { throw found(); + } } void operator()(quantifier * n) {} }; @@ -1802,11 +1860,8 @@ void cmd_context::validate_model() { cancel_eh eh(m().limit()); expr_ref r(m()); scoped_ctrl_c ctrlc(eh); - ptr_vector::const_iterator it = begin_assertions(); - ptr_vector::const_iterator end = end_assertions(); bool invalid_model = false; - for (; it != end; ++it) { - expr * a = *it; + for (expr * a : assertions()) { if (is_ground(a)) { r = nullptr; evaluator(a, r); @@ -1825,7 +1880,7 @@ void cmd_context::validate_model() { for_each_expr(contains_underspecified, a); for_each_expr(contains_underspecified, r); } - catch (contains_underspecified_op_proc::found) { + catch (const contains_underspecified_op_proc::found &) { continue; } TRACE("model_validate", model_smt2_pp(tout, *this, *md, 0);); @@ -1992,7 +2047,7 @@ void cmd_context::display_smt2_benchmark(std::ostream & out, unsigned num, expr if (logic != symbol::null) out << "(set-logic " << logic << ")" << std::endl; // collect uninterpreted function declarations - decl_collector decls(m(), false); + decl_collector decls(m()); for (unsigned i = 0; i < num; i++) { decls.visit(assertions[i]); } @@ -2023,8 +2078,8 @@ void cmd_context::slow_progress_sample() { svector labels; m_solver->get_labels(labels); regular_stream() << "(labels"; - for (unsigned i = 0; i < labels.size(); i++) { - regular_stream() << " " << labels[i]; + for (symbol const& s : labels) { + regular_stream() << " " << s; } regular_stream() << "))" << std::endl; } @@ -2053,7 +2108,7 @@ void cmd_context::dt_eh::operator()(sort * dt, pdecl* pd) { m_owner.insert(a); } } - if (m_owner.m_scopes.size() > 0) { + if (!m_owner.m_scopes.empty()) { m_owner.pm().inc_ref(pd); m_owner.m_psort_inst_stack.push_back(pd); } diff --git a/src/cmd_context/cmd_context.h b/src/cmd_context/cmd_context.h index a0093191d..124821561 100644 --- a/src/cmd_context/cmd_context.h +++ b/src/cmd_context/cmd_context.h @@ -32,6 +32,8 @@ Notes: #include "ast/ast.h" #include "ast/ast_printer.h" #include "ast/datatype_decl_plugin.h" +#include "ast/recfun_decl_plugin.h" +#include "ast/rewriter/seq_rewriter.h" #include "tactic/generic_model_converter.h" #include "solver/solver.h" #include "solver/progress_callback.h" @@ -148,8 +150,8 @@ public: virtual bool empty() = 0; virtual void push() = 0; virtual void pop(unsigned n) = 0; - virtual lbool optimize() = 0; - virtual void set_hard_constraints(ptr_vector & hard) = 0; + virtual lbool optimize(expr_ref_vector const& asms) = 0; + virtual void set_hard_constraints(expr_ref_vector const & hard) = 0; virtual void display_assignment(std::ostream& out) = 0; virtual bool is_pareto() = 0; virtual void set_logic(symbol const& s) = 0; @@ -199,7 +201,6 @@ protected: ast_manager * m_manager; bool m_own_manager; bool m_manager_initialized; - bool m_rec_fun_declared; pdecl_manager * m_pmanager; sexpr_manager * m_sexpr_manager; check_logic m_check_logic; @@ -291,6 +292,7 @@ protected: bool logic_has_array() const; bool logic_has_datatype() const; bool logic_has_fpa() const; + bool logic_has_recfun() const; void print_unsupported_msg() { regular_stream() << "unsupported" << std::endl; } void print_unsupported_info(symbol const& s, int line, int pos) { if (s != symbol::null) diagnostic_stream() << "; " << s << " line: " << line << " position: " << pos << std::endl;} @@ -306,6 +308,7 @@ protected: void erase_macro(symbol const& s); bool macros_find(symbol const& s, unsigned n, expr*const* args, expr*& t) const; + recfun::decl::plugin& get_recfun_plugin(); public: cmd_context(bool main_ctx = true, ast_manager * m = nullptr, symbol const & l = symbol::null); @@ -384,12 +387,14 @@ public: void insert(probe_info * p) { tactic_manager::insert(p); } void insert_user_tactic(symbol const & s, sexpr * d); void insert_aux_pdecl(pdecl * p); - void insert_rec_fun(func_decl* f, expr_ref_vector const& binding, svector const& ids, expr* e); void model_add(symbol const & s, unsigned arity, sort *const* domain, expr * t); void model_del(func_decl* f); + void insert_rec_fun(func_decl* f, expr_ref_vector const& binding, svector const& ids, expr* e); + void insert_rec_fun_as_axiom(func_decl* f, expr_ref_vector const& binding, svector const& ids, expr* e); func_decl * find_func_decl(symbol const & s) const; func_decl * find_func_decl(symbol const & s, unsigned num_indices, unsigned const * indices, unsigned arity, sort * const * domain, sort * range) const; + recfun::promise_def decl_rec_fun(const symbol &name, unsigned int arity, sort *const *domain, sort *range); psort_decl * find_psort_decl(symbol const & s) const; cmd * find_cmd(symbol const & s) const; sexpr * find_user_tactic(symbol const & s) const; @@ -452,11 +457,8 @@ public: double get_seconds() const { return m_watch.get_seconds(); } - ptr_vector::const_iterator begin_assertions() const { return m_assertions.begin(); } - ptr_vector::const_iterator end_assertions() const { return m_assertions.end(); } - - ptr_vector::const_iterator begin_assertion_names() const { return m_assertion_names.begin(); } - ptr_vector::const_iterator end_assertion_names() const { return m_assertion_names.end(); } + ptr_vector const& assertions() const { return m_assertions; } + ptr_vector const& assertion_names() const { return m_assertion_names; } /** \brief Hack: consume assertions if there are no scopes. @@ -492,4 +494,24 @@ public: std::ostream & operator<<(std::ostream & out, cmd_context::status st); + +class th_solver : public expr_solver { + cmd_context& m_ctx; + params_ref m_params; + ref m_solver; +public: + th_solver(cmd_context& ctx): m_ctx(ctx) {} + + lbool check_sat(expr* e) override { + if (!m_solver) { + m_solver = m_ctx.get_solver_factory()(m_ctx.m(), m_params, false, true, false, symbol::null); + } + m_solver->push(); + m_solver->assert_expr(e); + lbool r = m_solver->check_sat(0,nullptr); + m_solver->pop(1); + return r; + } +}; + #endif diff --git a/src/cmd_context/cmd_context_to_goal.cpp b/src/cmd_context/cmd_context_to_goal.cpp index a66f9e5de..de19805f2 100644 --- a/src/cmd_context/cmd_context_to_goal.cpp +++ b/src/cmd_context/cmd_context_to_goal.cpp @@ -28,20 +28,18 @@ void assert_exprs_from(cmd_context const & ctx, goal & t) { ast_manager & m = t.m(); bool proofs_enabled = t.proofs_enabled(); if (ctx.produce_unsat_cores()) { - ptr_vector::const_iterator it = ctx.begin_assertions(); - ptr_vector::const_iterator end = ctx.end_assertions(); - ptr_vector::const_iterator it2 = ctx.begin_assertion_names(); - SASSERT(end - it == ctx.end_assertion_names() - it2); + ptr_vector::const_iterator it = ctx.assertions().begin(); + ptr_vector::const_iterator end = ctx.assertions().end(); + ptr_vector::const_iterator it2 = ctx.assertion_names().begin(); + SASSERT(ctx.assertions().size() == ctx.assertion_names().size()); for (; it != end; ++it, ++it2) { t.assert_expr(*it, proofs_enabled ? m.mk_asserted(*it) : nullptr, m.mk_leaf(*it2)); } } else { - ptr_vector::const_iterator it = ctx.begin_assertions(); - ptr_vector::const_iterator end = ctx.end_assertions(); - for (; it != end; ++it) { - t.assert_expr(*it, proofs_enabled ? m.mk_asserted(*it) : nullptr, nullptr); + for (expr * e : ctx.assertions()) { + t.assert_expr(e, proofs_enabled ? m.mk_asserted(e) : nullptr, nullptr); } - SASSERT(ctx.begin_assertion_names() == ctx.end_assertion_names()); + SASSERT(ctx.assertion_names().empty()); } } diff --git a/src/cmd_context/eval_cmd.cpp b/src/cmd_context/eval_cmd.cpp index 3f564edff..a599cfa4a 100644 --- a/src/cmd_context/eval_cmd.cpp +++ b/src/cmd_context/eval_cmd.cpp @@ -72,6 +72,7 @@ public: unsigned timeout = m_params.get_uint("timeout", UINT_MAX); unsigned rlimit = m_params.get_uint("rlimit", 0); model_evaluator ev(*(md.get()), m_params); + ev.set_solver(alloc(th_solver, ctx)); cancel_eh eh(ctx.m().limit()); { scoped_ctrl_c ctrlc(eh); diff --git a/src/cmd_context/extra_cmds/dbg_cmds.cpp b/src/cmd_context/extra_cmds/dbg_cmds.cpp index 235576735..bdd2c8b97 100644 --- a/src/cmd_context/extra_cmds/dbg_cmds.cpp +++ b/src/cmd_context/extra_cmds/dbg_cmds.cpp @@ -91,6 +91,11 @@ UNARY_CMD(pp_shared_cmd, "dbg-pp-shared", "", "display shared subterms of ctx.regular_stream() << ")" << std::endl; }); +UNARY_CMD(assert_not_cmd, "assert-not", "", "assert negation", CPK_EXPR, expr *, { + expr_ref ne(ctx.m().mk_not(arg), ctx.m()); + ctx.assert_expr(ne); +}); + UNARY_CMD(num_shared_cmd, "dbg-num-shared", "", "return the number of shared subterms", CPK_EXPR, expr *, { shared_occs s(ctx.m()); s(arg); @@ -537,6 +542,7 @@ void install_dbg_cmds(cmd_context & ctx) { ctx.insert(alloc(shift_vars_cmd)); ctx.insert(alloc(pp_shared_cmd)); ctx.insert(alloc(num_shared_cmd)); + ctx.insert(alloc(assert_not_cmd)); ctx.insert(alloc(size_cmd)); ctx.insert(alloc(subst_cmd)); ctx.insert(alloc(bool_rewriter_cmd)); diff --git a/src/cmd_context/pdecl.h b/src/cmd_context/pdecl.h index 12e6399fe..8742424c3 100644 --- a/src/cmd_context/pdecl.h +++ b/src/cmd_context/pdecl.h @@ -36,7 +36,7 @@ protected: void inc_ref() { m_ref_count++; } void dec_ref() { SASSERT(m_ref_count > 0); --m_ref_count; } virtual bool is_psort() const { return false; } - virtual size_t obj_size() const = 0; + virtual size_t obj_size() const { UNREACHABLE(); return sizeof(*this); } pdecl(unsigned id, unsigned num_params):m_id(id), m_num_params(num_params), m_ref_count(0) {} virtual void finalize(pdecl_manager & m) {} virtual ~pdecl() {} @@ -53,7 +53,7 @@ public: class psort_inst_cache; #if defined(__APPLE__) && defined(__MACH__) -// CMW: for some unknown reason, llvm on OSX does not like the name `psort' +// CMW: for some unknown reason, llvm on macOS does not like the name `psort' #define psort Z3_psort #endif @@ -74,9 +74,9 @@ public: virtual bool is_sort_wrapper() const { return false; } virtual sort * instantiate(pdecl_manager & m, sort * const * s) { return nullptr; } // we use hash-consing for psorts. - virtual char const * hcons_kind() const = 0; - virtual unsigned hcons_hash() const = 0; - virtual bool hcons_eq(psort const * other) const = 0; + virtual char const * hcons_kind() const { UNREACHABLE(); return nullptr; } + virtual unsigned hcons_hash() const { UNREACHABLE(); return 0; } + virtual bool hcons_eq(psort const * other) const { UNREACHABLE(); return false; } void reset_cache(pdecl_manager& m) override; }; diff --git a/src/cmd_context/simplify_cmd.cpp b/src/cmd_context/simplify_cmd.cpp index de548562e..077a46659 100644 --- a/src/cmd_context/simplify_cmd.cpp +++ b/src/cmd_context/simplify_cmd.cpp @@ -24,29 +24,10 @@ Notes: #include "util/scoped_timer.h" #include "util/scoped_ctrl_c.h" #include "util/cancel_eh.h" -#include "ast/rewriter/seq_rewriter.h" #include class simplify_cmd : public parametric_cmd { - class th_solver : public expr_solver { - cmd_context& m_ctx; - params_ref m_params; - ref m_solver; - public: - th_solver(cmd_context& ctx): m_ctx(ctx) {} - - lbool check_sat(expr* e) override { - if (!m_solver) { - m_solver = m_ctx.get_solver_factory()(m_ctx.m(), m_params, false, true, false, symbol::null); - } - m_solver->push(); - m_solver->assert_expr(e); - lbool r = m_solver->check_sat(0,nullptr); - m_solver->pop(1); - return r; - } - }; expr * m_target; public: diff --git a/src/cmd_context/tactic_cmds.cpp b/src/cmd_context/tactic_cmds.cpp index cf0fd5111..7fdca8cdd 100644 --- a/src/cmd_context/tactic_cmds.cpp +++ b/src/cmd_context/tactic_cmds.cpp @@ -85,7 +85,7 @@ ATOMIC_CMD(get_user_tactics_cmd, "get-user-tactics", "display tactics defined us void help_tactic(cmd_context & ctx) { std::ostringstream buf; buf << "combinators:\n"; - buf << "- (and-then +) executes the given tactics sequencially.\n"; + buf << "- (and-then +) executes the given tactics sequentially.\n"; buf << "- (or-else +) tries the given tactics in sequence until one of them succeeds (i.e., the first that doesn't fail).\n"; buf << "- (par-or +) executes the given tactics in parallel until one of them succeeds (i.e., the first that doesn't fail).\n"; buf << "- (par-then ) executes tactic1 and then tactic2 to every subgoal produced by tactic1. All subgoals are processed in parallel.\n"; @@ -224,7 +224,7 @@ public: ctx.display_sat_result(r); result->set_status(r); if (r == l_undef) { - if (reason_unknown != "") { + if (!reason_unknown.empty()) { result->m_unknown = reason_unknown; // ctx.diagnostic_stream() << "\"" << escaped(reason_unknown.c_str(), true) << "\"" << std::endl; } diff --git a/src/math/automata/automaton.h b/src/math/automata/automaton.h index de72d6b2d..d642d2379 100644 --- a/src/math/automata/automaton.h +++ b/src/math/automata/automaton.h @@ -428,7 +428,18 @@ public: add(mv); } } + else if (1 == out_degree(src) && (is_final_state(src) || !is_final_state(dst))) { + moves const& mvs = m_delta[dst]; + moves mvs1; + for (move const& mv : mvs) { + mvs1.push_back(move(m, src, mv.dst(), mv.t())); + } + for (move const& mv : mvs1) { + add(mv); + } + } else { + TRACE("seq", tout << "epsilon not removed " << out_degree(src) << " " << is_final_state(src) << " " << is_final_state(dst) << "\n";); continue; } remove(src, dst, nullptr); @@ -600,13 +611,14 @@ private: } } +#if 0 void remove_dead_states() { unsigned_vector remap; for (unsigned i = 0; i < m_delta.size(); ++i) { } } - +#endif void add(move const& mv) { if (!is_duplicate_cheap(mv)) { diff --git a/src/math/euclid/euclidean_solver.cpp b/src/math/euclid/euclidean_solver.cpp index 70b424375..4b65ab6ea 100644 --- a/src/math/euclid/euclidean_solver.cpp +++ b/src/math/euclid/euclidean_solver.cpp @@ -690,7 +690,7 @@ struct euclidean_solver::imp { m().del(eq.m_as[j]); eq.m_as.shrink(new_sz); eq.m_xs.shrink(new_sz); - // ajust c + // adjust c mpz new_c; decompose(m_next_pos_a, m_next_a, eq.m_c, new_c, eq.m_c); // create auxiliary equation diff --git a/src/math/polynomial/algebraic_numbers.cpp b/src/math/polynomial/algebraic_numbers.cpp index aa4fc5a39..17360f35b 100644 --- a/src/math/polynomial/algebraic_numbers.cpp +++ b/src/math/polynomial/algebraic_numbers.cpp @@ -948,7 +948,7 @@ namespace algebraic_numbers { // zero is a root of p, and r_i is an isolating interval containing zero, // then c is zero reset(c); - TRACE("algebraic", tout << "reseting\nresult: "; display_root(tout, c); tout << "\n";); + TRACE("algebraic", tout << "resetting\nresult: "; display_root(tout, c); tout << "\n";); return; } int zV = upm().sign_variations_at_zero(seq); @@ -1728,7 +1728,7 @@ namespace algebraic_numbers { COMPARE_INTERVAL(); // if cell_a and cell_b, contain the same polynomial, - // and the intervals are overlaping, then they are + // and the intervals are overlapping, then they are // the same root. if (compare_p(cell_a, cell_b)) { m_compare_poly_eq++; @@ -1825,7 +1825,7 @@ namespace algebraic_numbers { // Here is an unexplored option for comparing numbers. // - // The isolating intervals of a and b are still overlaping + // The isolating intervals of a and b are still overlapping // Then we compute // r(x) = Resultant(x - y1 + y2, p1(y1), p2(y2)) // where p1(y1) and p2(y2) are the polynomials defining a and b. @@ -1989,7 +1989,7 @@ namespace algebraic_numbers { TRACE("anum_eval_sign", tout << "all variables are assigned to rationals, value of p: " << r << "\n";); return qm().sign(r); } - catch (opt_var2basic::failed) { + catch (const opt_var2basic::failed &) { // continue } diff --git a/src/math/polynomial/polynomial.cpp b/src/math/polynomial/polynomial.cpp index 35a95ce82..8f7f08c7f 100644 --- a/src/math/polynomial/polynomial.cpp +++ b/src/math/polynomial/polynomial.cpp @@ -67,7 +67,7 @@ namespace polynomial { bool first = true; out << "["; for (unsigned i = 0; i < m_var2degree.size(); ++ i) { - if (m_var2degree.size() > 0) { + if (!m_var2degree.empty()) { if (!first) { out << ","; } @@ -100,7 +100,7 @@ namespace polynomial { struct lt_var { bool operator()(power const & p1, power const & p2) { - // CMW: The assertion below does not hold on OSX, because + // CMW: The assertion below does not hold on macOS, because // their implementation of std::sort will try to compare // two items at the same index instead of comparing // the indices directly. I suspect that the purpose of @@ -4052,7 +4052,7 @@ namespace polynomial { // select a new random value in GF(p) that is not in vals, and store it in r void peek_fresh(scoped_numeral_vector const & vals, unsigned p, scoped_numeral & r) { - SASSERT(vals.size() < p); // otherwise we cant keep the fresh value + SASSERT(vals.size() < p); // otherwise we can't keep the fresh value unsigned sz = vals.size(); while (true) { m().set(r, rand() % p); @@ -4149,7 +4149,7 @@ namespace polynomial { TRACE("mgcd_detail", tout << "counter: " << counter << "\nidx: " << idx << "\nq: " << q << "\ndeg_q: " << deg_q << "\nmin_deg_q: " << min_deg_q << "\nnext_x: x" << vars[idx+1] << "\nmax_var(q): " << q_var << "\n";); if (deg_q < min_deg_q) { - TRACE("mgcd_detail", tout << "reseting...\n";); + TRACE("mgcd_detail", tout << "resetting...\n";); counter = 0; min_deg_q = deg_q; // start from scratch @@ -4493,7 +4493,7 @@ namespace polynomial { } #endif } - catch (sparse_mgcd_failed) { + catch (const sparse_mgcd_failed &) { flet use_prs(m_use_prs_gcd, false); gcd_prs(u, v, x, r); } diff --git a/src/math/polynomial/polynomial.h b/src/math/polynomial/polynomial.h index 374a51084..169ee8273 100644 --- a/src/math/polynomial/polynomial.h +++ b/src/math/polynomial/polynomial.h @@ -131,12 +131,12 @@ namespace polynomial { ~factors(); /** - \brief Numer of distinct factors (not counting multiplicities). + \brief Number of distinct factors (not counting multiplicities). */ unsigned distinct_factors() const { return m_factors.size(); } /** - \brief Numer of distinct factors (counting multiplicities). + \brief Number of distinct factors (counting multiplicities). */ unsigned total_factors() const { return m_total_factors; } diff --git a/src/math/polynomial/upolynomial.cpp b/src/math/polynomial/upolynomial.cpp index cc2442981..0290a5924 100644 --- a/src/math/polynomial/upolynomial.cpp +++ b/src/math/polynomial/upolynomial.cpp @@ -96,7 +96,7 @@ namespace upolynomial { void core_manager::factors::display(std::ostream & out) const { out << nm().to_string(m_constant); - if (m_factors.size() > 0) { + if (!m_factors.empty()) { for (unsigned i = 0; i < m_factors.size(); ++ i) { out << " * ("; m_upm.display(out, m_factors[i]); @@ -362,7 +362,7 @@ namespace upolynomial { set_size(sz-1, buffer); } - // Divide coeffients of p by their GCD + // Divide coefficients of p by their GCD void core_manager::normalize(unsigned sz, numeral * p) { if (sz == 0) return; @@ -395,7 +395,7 @@ namespace upolynomial { } } - // Divide coeffients of p by their GCD + // Divide coefficients of p by their GCD void core_manager::normalize(numeral_vector & p) { normalize(p.size(), p.c_ptr()); } @@ -568,7 +568,7 @@ namespace upolynomial { SASSERT(!is_alias(p1, buffer)); SASSERT(!is_alias(p2, buffer)); unsigned d; rem(sz1, p1, sz2, p2, d, buffer); - // We don't ned to flip the sign if d is odd and leading coefficient of p2 is negative + // We don't need to flip the sign if d is odd and leading coefficient of p2 is negative if (d % 2 == 0 || (sz2 > 0 && m().is_pos(p2[sz2-1]))) neg(buffer.size(), buffer.c_ptr()); } @@ -1339,12 +1339,10 @@ namespace upolynomial { // Return the number of sign changes in the coefficients of p unsigned manager::sign_changes(unsigned sz, numeral const * p) { unsigned r = 0; - int sign, prev_sign; - sign = 0; - prev_sign = 0; + int prev_sign = 0; unsigned i = 0; for (; i < sz; i++) { - sign = sign_of(p[i]); + int sign = sign_of(p[i]); if (sign == 0) continue; if (sign != prev_sign && prev_sign != 0) @@ -2005,7 +2003,7 @@ namespace upolynomial { continue; bool pos_a_n_k = m().is_pos(a_n_k); if (pos_a_n_k == pos_a_n) - continue; // must have oposite signs + continue; // must have opposite signs unsigned log2_a_n_k = pos_a_n_k ? m().log2(a_n_k) : m().mlog2(a_n_k); if (log2_a_n > log2_a_n_k) continue; @@ -2103,7 +2101,7 @@ namespace upolynomial { frame_stack.pop_back(); } - // Auxiliar method for isolating the roots of p in the interval (0, 1). + // Auxiliary method for isolating the roots of p in the interval (0, 1). // The basic idea is to split the interval in: (0, 1/2) and (1/2, 1). // This is accomplished by analyzing the roots in the interval (0, 1) of the following polynomials. // p1(x) := 2^n * p(x/2) where n = sz-1 @@ -2574,10 +2572,10 @@ namespace upolynomial { We say an interval (a, b) of a polynomial p is ISOLATING if p has only one root in the interval (a, b). - We say an isolating interval (a, b) of a square free polynomial p is REFINEABLE if + We say an isolating interval (a, b) of a square free polynomial p is REFINABLE if sign(p(a)) = -sign(p(b)) - Not every isolating interval (a, b) of a square free polynomial p is refineable, because + Not every isolating interval (a, b) of a square free polynomial p is refinable, because sign(p(a)) or sign(p(b)) may be zero. Refinable intervals of square free polynomials are useful, because we can increase precision diff --git a/src/math/polynomial/upolynomial.h b/src/math/polynomial/upolynomial.h index 439b4be9f..ad6942ffb 100644 --- a/src/math/polynomial/upolynomial.h +++ b/src/math/polynomial/upolynomial.h @@ -256,12 +256,12 @@ namespace upolynomial { void derivative(numeral_vector const & p, numeral_vector & d_p) { derivative(p.size(), p.c_ptr(), d_p); } /** - \brief Divide coeffients of p by their GCD + \brief Divide coefficients of p by their GCD */ void normalize(unsigned sz, numeral * p); /** - \brief Divide coeffients of p by their GCD + \brief Divide coefficients of p by their GCD */ void normalize(numeral_vector & p); diff --git a/src/math/polynomial/upolynomial_factorization.cpp b/src/math/polynomial/upolynomial_factorization.cpp index 5d9d3f1f1..45cc3f86d 100644 --- a/src/math/polynomial/upolynomial_factorization.cpp +++ b/src/math/polynomial/upolynomial_factorization.cpp @@ -532,7 +532,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.empty()) { TRACE("polynomial::factorization::bughunt", tout << "sage: R. = ZZ['x']" << endl; tout << "sage: A = "; upm.display(tout, A); tout << endl; @@ -1072,7 +1072,8 @@ bool factor_square_free(z_manager & upm, numeral_vector const & f, factors & fs, prime_iterator prime_it; scoped_numeral gcd_tmp(nm); unsigned trials = 0; - while (trials < params.m_p_trials) { + TRACE("polynomial::factorization::bughunt", tout << "trials: " << params.m_p_trials << "\n";); + while (trials <= params.m_p_trials) { upm.checkpoint(); // construct prime to check uint64_t next_prime = prime_it.next(); diff --git a/src/math/polynomial/upolynomial_factorization_int.h b/src/math/polynomial/upolynomial_factorization_int.h index e422c15a6..816914545 100644 --- a/src/math/polynomial/upolynomial_factorization_int.h +++ b/src/math/polynomial/upolynomial_factorization_int.h @@ -195,7 +195,7 @@ namespace upolynomial { // the index we are currently trying to fix int current_i = m_current_size - 1; - // the value we found as plausable (-1 we didn't find anything) + // the value we found as plausible (-1 we didn't find anything) int current_value = -1; if (remove_current) { @@ -401,7 +401,7 @@ namespace upolynomial { } else { if (selection_i >= m_current.size() || (int) current < m_current[selection_i]) { SASSERT(m_factors.get_degree(current) == 1); - if (out.size() == 0) { + if (out.empty()) { upm.set(m_factors[current].size(), m_factors[current].c_ptr(), out); } else { upm.mul(out.size(), out.c_ptr(), m_factors[current].size(), m_factors[current].c_ptr(), out); diff --git a/src/math/realclosure/mpz_matrix.h b/src/math/realclosure/mpz_matrix.h index 92716ec0d..99ff8bce4 100644 --- a/src/math/realclosure/mpz_matrix.h +++ b/src/math/realclosure/mpz_matrix.h @@ -107,7 +107,7 @@ public: this method will give preference to the row that occurs first. \remark The vector r must have at least A.n() capacity - The numer of linear independent rows is returned. + The number of linear independent rows is returned. Store the new matrix in B. */ diff --git a/src/math/realclosure/rcf_params.pyg b/src/math/realclosure/rcf_params.pyg index 36c13035b..fc15dbe93 100644 --- a/src/math/realclosure/rcf_params.pyg +++ b/src/math/realclosure/rcf_params.pyg @@ -6,5 +6,5 @@ def_module_params('rcf', ('initial_precision', UINT, 24, "a value k that is the initial interval size (as 1/2^k) when creating transcendentals and approximated division"), ('inf_precision', UINT, 24, "a value k that is the initial interval size (i.e., (0, 1/2^l)) used as an approximation for infinitesimal values"), ('max_precision', UINT, 128, "during sign determination we switch from interval arithmetic to complete methods when the interval size is less than 1/2^k, where k is the max_precision"), - ('lazy_algebraic_normalization', BOOL, True, "during sturm-seq and square-free polynomial computations, only normalize algebraic polynomial expressions when the definining polynomial is monic") + ('lazy_algebraic_normalization', BOOL, True, "during sturm-seq and square-free polynomial computations, only normalize algebraic polynomial expressions when the defining polynomial is monic") )) diff --git a/src/math/realclosure/realclosure.cpp b/src/math/realclosure/realclosure.cpp index d41937c29..3e05be734 100644 --- a/src/math/realclosure/realclosure.cpp +++ b/src/math/realclosure/realclosure.cpp @@ -154,7 +154,7 @@ namespace realclosure { struct value { unsigned m_ref_count; //!< Reference counter - bool m_rational; //!< True if the value is represented as an abitrary precision rational value. + bool m_rational; //!< True if the value is represented as an arbitrary precision rational value. mpbqi m_interval; //!< approximation as an interval with binary rational end-points // When performing an operation OP, we may have to make the width (upper - lower) of m_interval very small. // The precision (i.e., a small interval) needed for executing OP is usually unnecessary for subsequent operations, @@ -283,7 +283,7 @@ namespace realclosure { struct algebraic : public extension { polynomial m_p; mpbqi m_iso_interval; - sign_det * m_sign_det; //!< != 0 if m_iso_interval constains more than one root of m_p. + sign_det * m_sign_det; //!< != 0 if m_iso_interval constrains more than one root of m_p. unsigned m_sc_idx; //!< != UINT_MAX if m_sign_det != 0, in this case m_sc_idx < m_sign_det->m_sign_conditions.size() bool m_depends_on_infinitesimals; //!< True if the polynomial p depends on infinitesimal extensions. @@ -1741,7 +1741,7 @@ namespace realclosure { \brief In the sign determination algorithm main loop, we keep processing polynomials q, and checking whether they discriminate the roots of the target polynomial. - The vectors sc_cardinalities contains the cardinalites of the new realizable sign conditions. + The vectors sc_cardinalities contains the cardinalities of the new realizable sign conditions. That is, we started we a sequence of sign conditions sc_1, ..., sc_n, If q2_used is true, then we expanded this sequence as @@ -1750,7 +1750,7 @@ namespace realclosure { Thus, q is useful (i.e., it is a discriminator for the roots of p) IF If !q2_used, then There is an i s.t. sc_cardinalities[2*i] > 0 && sc_cardinalities[2*i] > 0 - If q2_used, then There is an i s.t. AtLeatTwo(sc_cardinalities[3*i] > 0, sc_cardinalities[3*i+1] > 0, sc_cardinalities[3*i+2] > 0) + If q2_used, then There is an i s.t. AtLeastTwo(sc_cardinalities[3*i] > 0, sc_cardinalities[3*i+1] > 0, sc_cardinalities[3*i+2] > 0) */ bool keep_new_sc_assignment(unsigned sz, int const * sc_cardinalities, bool q2_used) { SASSERT(q2_used || sz % 2 == 0); @@ -2038,7 +2038,7 @@ namespace realclosure { // We should keep q only if it discriminated something. // That is, // If !use_q2, then There is an i s.t. sc_cardinalities[2*i] > 0 && sc_cardinalities[2*i] > 0 - // If use_q2, then There is an i s.t. AtLeatTwo(sc_cardinalities[3*i] > 0, sc_cardinalities[3*i+1] > 0, sc_cardinalities[3*i+2] > 0) + // If use_q2, then There is an i s.t. AtLeastTwo(sc_cardinalities[3*i] > 0, sc_cardinalities[3*i+1] > 0, sc_cardinalities[3*i+2] > 0) if (!keep_new_sc_assignment(sc_cardinalities.size(), sc_cardinalities.c_ptr(), use_q2)) { // skip q since it did not reduced the cardinality of the existing sign conditions. continue; @@ -3466,11 +3466,11 @@ namespace realclosure { // --------------------------------- bool is_monic(value_ref_buffer const & p) { - return p.size() > 0 && is_rational_one(p[p.size() - 1]); + return !p.empty() && is_rational_one(p[p.size() - 1]); } bool is_monic(polynomial const & p) { - return p.size() > 0 && is_rational_one(p[p.size() - 1]); + return !p.empty() && is_rational_one(p[p.size() - 1]); } /** @@ -4790,7 +4790,7 @@ namespace realclosure { /** \brief Determine the sign of the new rational function value. - The idea is to keep refinining the interval until interval of v does not contain 0. + The idea is to keep refining the interval until interval of v does not contain 0. After a couple of steps we switch to expensive sign determination procedure. Return false if v is actually zero. @@ -5474,7 +5474,7 @@ namespace realclosure { } else { // Let sdt be alpha->sdt(); - // In pricipal, the signs of the polynomials sdt->qs can be used + // In principal, the signs of the polynomials sdt->qs can be used // to discriminate the roots of new_p. The signs of this polynomials // depend only on alpha, and not on the polynomial used to define alpha // So, in principle, we can reuse m_qs and m_sign_conditions. diff --git a/src/math/simplex/model_based_opt.cpp b/src/math/simplex/model_based_opt.cpp index 8a771e07c..4053c41b7 100644 --- a/src/math/simplex/model_based_opt.cpp +++ b/src/math/simplex/model_based_opt.cpp @@ -606,7 +606,7 @@ namespace opt { } } - void model_based_opt::mk_coeffs_without(vector& dst, vector const src, unsigned x) { + void model_based_opt::mk_coeffs_without(vector& dst, vector const& src, unsigned x) { for (var const & v : src) { if (v.m_id != x) dst.push_back(v); } diff --git a/src/math/simplex/model_based_opt.h b/src/math/simplex/model_based_opt.h index e52d0cfe0..30442fc58 100644 --- a/src/math/simplex/model_based_opt.h +++ b/src/math/simplex/model_based_opt.h @@ -132,7 +132,7 @@ namespace opt { void normalize(unsigned row_id); - void mk_coeffs_without(vector& dst, vector const src, unsigned x); + void mk_coeffs_without(vector& dst, vector const& src, unsigned x); unsigned new_row(); diff --git a/src/math/simplex/network_flow.h b/src/math/simplex/network_flow.h index d4c7df77f..f4147b16f 100644 --- a/src/math/simplex/network_flow.h +++ b/src/math/simplex/network_flow.h @@ -148,7 +148,7 @@ namespace smt { vector m_potentials; // nodes + 1 |-> initial: +/- 1 // Duals of flows which are convenient to compute dual solutions // become solutions to Dual simplex. - vector m_flows; // edges + nodes |-> assignemnt Basic feasible flows + vector m_flows; // edges + nodes |-> assignment Basic feasible flows svector m_states; unsigned m_step; edge_id m_enter_id; diff --git a/src/math/subpaving/subpaving_t.h b/src/math/subpaving/subpaving_t.h index 02c538828..ec514df8f 100644 --- a/src/math/subpaving/subpaving_t.h +++ b/src/math/subpaving/subpaving_t.h @@ -202,7 +202,7 @@ public: public: node(context_t & s, unsigned id); node(node * parent, unsigned id); - // return unique indentifier. + // return unique identifier. unsigned id() const { return m_id; } bound_array_manager & bm() const { return m_bm; } bound_array & lowers() { return m_lowers; } diff --git a/src/math/subpaving/subpaving_t_def.h b/src/math/subpaving/subpaving_t_def.h index cf93fbfad..b13f41c54 100644 --- a/src/math/subpaving/subpaving_t_def.h +++ b/src/math/subpaving/subpaving_t_def.h @@ -248,7 +248,7 @@ public: /** - \brief Auxiliary static method used to diplay a bound specified by (x, k, lower, open). + \brief Auxiliary static method used to display a bound specified by (x, k, lower, open). */ template void context_t::display(std::ostream & out, numeral_manager & nm, display_var_proc const & proc, var x, numeral & k, bool lower, bool open) { diff --git a/src/math/subpaving/tactic/subpaving_tactic.cpp b/src/math/subpaving/tactic/subpaving_tactic.cpp index 935fd5e19..7a3f2e7b3 100644 --- a/src/math/subpaving/tactic/subpaving_tactic.cpp +++ b/src/math/subpaving/tactic/subpaving_tactic.cpp @@ -183,7 +183,7 @@ class subpaving_tactic : public tactic { process_clause(g.form(i)); } } - catch (subpaving::exception) { + catch (const subpaving::exception &) { throw tactic_exception("failed to internalize goal into subpaving module"); } } @@ -195,7 +195,7 @@ class subpaving_tactic : public tactic { try { (*m_ctx)(); } - catch (subpaving::exception) { + catch (const subpaving::exception &) { throw tactic_exception("failed building subpaving tree..."); } if (m_display) { diff --git a/src/model/model.cpp b/src/model/model.cpp index 83adfc87e..de6bb4db8 100644 --- a/src/model/model.cpp +++ b/src/model/model.cpp @@ -85,7 +85,7 @@ struct model::value_proc : public some_value_proc { expr * operator()(sort * s) override { ptr_vector * u = nullptr; if (m_model.m_usort2universe.find(s, u)) { - if (u->size() > 0) + if (!u->empty()) return u->get(0); } return nullptr; @@ -312,7 +312,8 @@ void model::collect_occs(top_sort& ts, func_decl* f) { func_interp* fi = get_func_interp(f); if (fi) { e = fi->get_else(); - collect_occs(ts, e); + if (e != nullptr) + collect_occs(ts, e); } } } @@ -351,7 +352,7 @@ bool model::can_inline_def(top_sort& ts, func_decl* f) { expr_ref model::cleanup_expr(top_sort& ts, expr* e, unsigned current_partition) { - if (!e) return expr_ref(0, m); + if (!e) return expr_ref(nullptr, m); TRACE("model", tout << "cleaning up:\n" << mk_pp(e, m) << "\n";); @@ -409,8 +410,7 @@ expr_ref model::cleanup_expr(top_sort& ts, expr* e, unsigned current_partition) } else if (f->is_skolem() && can_inline_def(ts, f) && (fi = get_func_interp(f)) && fi->get_interp() && (!ts.partition_ids().find(f, pid) || pid != current_partition)) { - var_subst vs(m); - // ? TBD args.reverse(); + var_subst vs(m, false); new_t = vs(fi->get_interp(), args.size(), args.c_ptr()); } #if 0 @@ -453,7 +453,7 @@ void model::remove_decls(ptr_vector & decls, func_decl_set const & s) expr_ref model::get_inlined_const_interp(func_decl* f) { expr* v = get_const_interp(f); - if (!v) return expr_ref(0, m); + if (!v) return expr_ref(nullptr, m); top_sort st(m); expr_ref result1(v, m); expr_ref result2 = cleanup_expr(st, v, UINT_MAX); @@ -468,6 +468,10 @@ expr_ref model::operator()(expr* t) { return m_mev(t); } +void model::set_solver(expr_solver* s) { + m_mev.set_solver(s); +} + expr_ref_vector model::operator()(expr_ref_vector const& ts) { expr_ref_vector rs(m); for (expr* t : ts) rs.push_back((*this)(t)); diff --git a/src/model/model.h b/src/model/model.h index 0b74de771..2599a3fcd 100644 --- a/src/model/model.h +++ b/src/model/model.h @@ -95,6 +95,7 @@ public: bool is_false(expr* t); bool is_true(expr_ref_vector const& ts); void reset_eval_cache(); + void set_solver(expr_solver* solver); class scoped_model_completion { bool m_old_completion; diff --git a/src/model/model_evaluator.cpp b/src/model/model_evaluator.cpp index 0fe1fe7c6..b0e97e5e4 100644 --- a/src/model/model_evaluator.cpp +++ b/src/model/model_evaluator.cpp @@ -627,3 +627,7 @@ bool model_evaluator::eval(expr_ref_vector const& ts, expr_ref& r, bool model_co tmp = mk_and(ts); return eval(tmp, r, model_completion); } + +void model_evaluator::set_solver(expr_solver* solver) { + m_imp->m_cfg.m_seq_rw.set_solver(solver); +} diff --git a/src/model/model_evaluator.h b/src/model/model_evaluator.h index 8666e3519..1959af246 100644 --- a/src/model/model_evaluator.h +++ b/src/model/model_evaluator.h @@ -25,6 +25,7 @@ Revision History: class model; class model_core; +class expr_solver; typedef rewriter_exception model_evaluator_exception; @@ -55,6 +56,8 @@ public: bool is_false(expr * t); bool is_true(expr_ref_vector const& ts); + void set_solver(expr_solver* solver); + /** * best effort evaluator of extensional array equality. */ diff --git a/src/model/model_smt2_pp.cpp b/src/model/model_smt2_pp.cpp index 807e2b4e7..b2a4f02aa 100644 --- a/src/model/model_smt2_pp.cpp +++ b/src/model/model_smt2_pp.cpp @@ -21,6 +21,7 @@ Revision History: #include "model/model_smt2_pp.h" #include "ast/ast_smt2_pp.h" #include "ast/func_decl_dependencies.h" +#include "ast/recfun_decl_plugin.h" #include "ast/pp.h" using namespace format_ns; @@ -60,11 +61,9 @@ static void pp_uninterp_sorts(std::ostream & out, ast_printer_context & ctx, mod ctx.display(buffer, s, 13); buffer << ":\n"; pp_indent(buffer, TAB_SZ); - ptr_vector::const_iterator it = u.begin(); - ptr_vector::const_iterator end = u.end(); - for (; it != end; ++it) { - SASSERT(is_app(*it)); - app * c = to_app(*it); + for (expr* e : u) { + SASSERT(is_app(e)); + app * c = to_app(e); pp_symbol(buffer, c->get_decl()->get_name()); buffer << " "; } @@ -87,9 +86,8 @@ static void pp_uninterp_sorts(std::ostream & out, ast_printer_context & ctx, mod out << "\n"; pp_indent(out, indent); out << ";; definitions for universe elements:\n"; - it = u.begin(); - for (; it != end; ++it) { - app * c = to_app(*it); + for (expr * e : u) { + app * c = to_app(e); pp_indent(out, indent); out << "(declare-fun "; unsigned len = pp_symbol(out, c->get_decl()->get_name()); @@ -101,9 +99,8 @@ static void pp_uninterp_sorts(std::ostream & out, ast_printer_context & ctx, mod out << ";; cardinality constraint:\n"; f_conds.reset(); format * var = mk_string(m, "x"); - it = u.begin(); - for (; it != end; ++it) { - app * c = to_app(*it); + for (expr* e : u) { + app * c = to_app(e); symbol csym = c->get_decl()->get_name(); std::string cname; if (is_smt2_quoted_symbol(csym)) @@ -170,10 +167,7 @@ void sort_fun_decls(ast_manager & m, model_core const & md, ptr_bufferget_else(), deps); - func_decl_set::iterator it2 = deps.begin(); - func_decl_set::iterator end2 = deps.end(); - for (; it2 != end2; ++it2) { - func_decl * d = *it2; + for (func_decl * d : deps) { if (d->get_arity() > 0 && md.has_interpretation(d) && !visited.contains(d)) { todo.push_back(d); visited.insert(d); @@ -189,8 +183,10 @@ void sort_fun_decls(ast_manager & m, model_core const & md, ptr_buffer var_names; ptr_buffer f_var_names; ptr_buffer f_arg_decls; @@ -200,6 +196,9 @@ static void pp_funs(std::ostream & out, ast_printer_context & ctx, model_core co sort_fun_decls(m, md, func_decls); for (unsigned i = 0; i < func_decls.size(); i++) { func_decl * f = func_decls[i]; + if (recfun_util.is_defined(f)) { + continue; + } func_interp * f_i = md.get_func_interp(f); SASSERT(f->get_arity() == f_i->get_arity()); format_ref body(fm(m)); diff --git a/src/muz/base/dl_context.cpp b/src/muz/base/dl_context.cpp index 1c9abf78c..e8578f327 100644 --- a/src/muz/base/dl_context.cpp +++ b/src/muz/base/dl_context.cpp @@ -658,7 +658,7 @@ namespace datalog { void context::add_table_fact(func_decl * pred, unsigned num_args, unsigned args[]) { if (pred->get_arity() != num_args) { std::ostringstream out; - out << "miss-matched number of arguments passed to " << mk_ismt2_pp(pred, m) << " " << num_args << " passed"; + out << "mismatched number of arguments passed to " << mk_ismt2_pp(pred, m) << " " << num_args << " passed"; throw default_exception(out.str()); } table_fact fact; @@ -1243,7 +1243,7 @@ namespace datalog { void context::declare_vars(expr_ref_vector& rules, mk_fresh_name& fresh_names, std::ostream& out) { // // replace bound variables in rules by 'var declarations' - // First remove quantifers, then replace bound variables + // First remove quantifiers, then replace bound variables // by fresh constants. // smt2_pp_environment_dbg env(m); diff --git a/src/muz/base/dl_context.h b/src/muz/base/dl_context.h index 23926c3d1..a14ef163f 100644 --- a/src/muz/base/dl_context.h +++ b/src/muz/base/dl_context.h @@ -615,7 +615,7 @@ namespace datalog { void ensure_engine(); - // auxilary functions for SMT2 pretty-printer. + // auxiliary functions for SMT2 pretty-printer. void declare_vars(expr_ref_vector& rules, mk_fresh_name& mk_fresh, std::ostream& out); //undefined and private copy constructor and operator= diff --git a/src/muz/base/dl_rule.cpp b/src/muz/base/dl_rule.cpp index 0dbeba5b3..fe1f101b1 100644 --- a/src/muz/base/dl_rule.cpp +++ b/src/muz/base/dl_rule.cpp @@ -422,7 +422,7 @@ namespace datalog { try { quick_for_each_expr(proc, fml); } - catch (contains_predicate_proc::found) { + catch (const contains_predicate_proc::found &) { return true; } return false; diff --git a/src/muz/base/dl_rule.h b/src/muz/base/dl_rule.h index 7e85199cf..45b75c254 100644 --- a/src/muz/base/dl_rule.h +++ b/src/muz/base/dl_rule.h @@ -110,7 +110,7 @@ namespace datalog { /** \brief Manager for the \c rule class - \remark \c rule_manager objects are interchangable as long as they + \remark \c rule_manager objects are interchangeable as long as they contain the same \c ast_manager object. */ class rule_manager diff --git a/src/muz/base/dl_rule_set.h b/src/muz/base/dl_rule_set.h index e870e369c..633676ec7 100644 --- a/src/muz/base/dl_rule_set.h +++ b/src/muz/base/dl_rule_set.h @@ -230,7 +230,7 @@ namespace datalog { bool is_closed() const { return m_stratifier != 0; } unsigned get_num_rules() const { return m_rules.size(); } - bool empty() const { return m_rules.size() == 0; } + bool empty() const { return m_rules.empty(); } rule * get_rule(unsigned i) const { return m_rules[i]; } rule * last() const { return m_rules[m_rules.size()-1]; } diff --git a/src/muz/base/dl_util.h b/src/muz/base/dl_util.h index 1a2b64dc4..7e38b9e9f 100644 --- a/src/muz/base/dl_util.h +++ b/src/muz/base/dl_util.h @@ -97,7 +97,7 @@ namespace datalog { \brief Auxiliary function used to create a tail based on \c pred for a new rule. The variables in \c pred are re-assigned using \c next_idx and \c varidx2var. A variable is considered non-local to the rule if it is in the set \c non_local_vars. - Non-local variables are coppied to new_rule_args, and their sorts to \c new_rule_domain. + Non-local variables are copied to new_rule_args, and their sorts to \c new_rule_domain. The new predicate is stored in \c new_pred. */ void mk_new_rule_tail(ast_manager & m, app * pred, @@ -276,7 +276,7 @@ namespace datalog { } unsigned n = container.size(); unsigned ofs = 1; - int r_i = 1; + unsigned r_i = 1; for(unsigned i=removed_cols[0]+1; im_key); m_pinned.push_back(new_sorts[i].get()); } - if (new_sorts.size() > 0) { + if (!new_sorts.empty()) { TRACE("bmc", dtu.display_datatype(new_sorts[0].get(), tout);); } del_datatype_decls(dts.size(), dts.c_ptr()); diff --git a/src/muz/ddnf/ddnf.cpp b/src/muz/ddnf/ddnf.cpp index a4fe5f0fa..d3460738c 100644 --- a/src/muz/ddnf/ddnf.cpp +++ b/src/muz/ddnf/ddnf.cpp @@ -332,7 +332,7 @@ namespace datalog { void internalize() { - // populate maps (should be bit-sets) of decendants. + // populate maps (should be bit-sets) of descendants. if (m_internalized) { return; } diff --git a/src/muz/fp/datalog_parser.cpp b/src/muz/fp/datalog_parser.cpp index a23d654b0..0724d471a 100644 --- a/src/muz/fp/datalog_parser.cpp +++ b/src/muz/fp/datalog_parser.cpp @@ -101,7 +101,7 @@ public: resize_data(0); #if _WINDOWS errno_t err = fopen_s(&m_file, fname, "rb"); - m_ok = (m_file != NULL) && (err == 0); + m_ok = (m_file != nullptr) && (err == 0); #else m_file = fopen(fname, "rb"); m_ok = (m_file != nullptr); @@ -120,7 +120,7 @@ public: This operation invalidates the line previously retrieved. - This operatio can be called only if we are not at the end of file. + This operation can be called only if we are not at the end of file. User is free to modify the content of the returned array until the terminating NULL character. */ @@ -876,7 +876,7 @@ protected: /** \brief Parse predicate arguments. If \c f==0, they are arguments of a predicate declaration. - If parsing a declaration, argumens names are pushed to the \c arg_names vector. + If parsing a declaration, argument names are pushed to the \c arg_names vector. */ dtoken parse_args(dtoken tok, func_decl* f, expr_ref_vector& args, svector & arg_names) { if (tok != TK_LP) { @@ -1057,7 +1057,7 @@ protected: line.push_back(ch); ch = strm.get(); } - return line.size() > 0; + return !line.empty(); } void add_rule(app* head, unsigned sz, app* const* body, const bool * is_neg) { diff --git a/src/muz/fp/dl_cmds.cpp b/src/muz/fp/dl_cmds.cpp index 231dca0d3..8bea46bea 100644 --- a/src/muz/fp/dl_cmds.cpp +++ b/src/muz/fp/dl_cmds.cpp @@ -332,10 +332,8 @@ public: private: void set_background(cmd_context& ctx) { datalog::context& dlctx = m_dl_ctx->dlctx(); - ptr_vector::const_iterator it = ctx.begin_assertions(); - ptr_vector::const_iterator end = ctx.end_assertions(); - for (; it != end; ++it) { - dlctx.assert_expr(*it); + for (expr * e : ctx.assertions()) { + dlctx.assert_expr(e); } } diff --git a/src/muz/rel/dl_base.h b/src/muz/rel/dl_base.h index 4d202f2a2..d307912be 100644 --- a/src/muz/rel/dl_base.h +++ b/src/muz/rel/dl_base.h @@ -295,7 +295,7 @@ namespace datalog { Precondition: &orig.get_plugin()==this */ virtual base_object * mk_empty(const signature & s, family_id kind) { - SASSERT(kind==get_kind()); //if plugin uses multiple kinds, this function needs to be overriden + SASSERT(kind==get_kind()); //if plugin uses multiple kinds, this function needs to be overridden return mk_empty(s); } @@ -1120,10 +1120,7 @@ namespace datalog { virtual bool operator==(const iterator_core & it) { //we worry about the equality operator only because of checking //the equality with the end() iterator - if(is_finished() && it.is_finished()) { - return true; - } - return false; + return is_finished() && it.is_finished(); } private: //private and undefined copy constructor and assignment operator @@ -1153,10 +1150,7 @@ namespace datalog { virtual bool operator==(const row_iterator_core & it) { //we worry about the equality operator only because of checking //the equality with the end() iterator - if(is_finished() && it.is_finished()) { - return true; - } - return false; + return is_finished() && it.is_finished(); } private: //private and undefined copy constructor and assignment operator diff --git a/src/muz/rel/dl_compiler.h b/src/muz/rel/dl_compiler.h index d7bdcad34..6bc2a819f 100644 --- a/src/muz/rel/dl_compiler.h +++ b/src/muz/rel/dl_compiler.h @@ -148,7 +148,7 @@ namespace datalog { void make_join(reg_idx t1, reg_idx t2, const variable_intersection & vars, reg_idx & result, bool reuse_t1, instruction_block & acc); void make_min(reg_idx source, reg_idx & target, const unsigned_vector & group_by_cols, - const unsigned min_col, instruction_block & acc); + unsigned min_col, instruction_block & acc); void make_join_project(reg_idx t1, reg_idx t2, const variable_intersection & vars, const unsigned_vector & removed_cols, reg_idx & result, bool reuse_t1, instruction_block & acc); void make_filter_interpreted_and_project(reg_idx src, app_ref & cond, diff --git a/src/muz/rel/dl_finite_product_relation.cpp b/src/muz/rel/dl_finite_product_relation.cpp index fb80a2105..ccb4584f7 100644 --- a/src/muz/rel/dl_finite_product_relation.cpp +++ b/src/muz/rel/dl_finite_product_relation.cpp @@ -487,7 +487,7 @@ namespace datalog { res->init(*res_table, joined_orelations, true); - if(m_tr_table_joined_cols.size()) { + if(!m_tr_table_joined_cols.empty()) { //There were some shared variables between the table and the relation part. //We enforce those equalities here. if(!m_filter_tr_identities) { @@ -1319,7 +1319,7 @@ namespace datalog { if(!m_table_cond_columns.empty()) { //We will keep the table variables that appear in the condition together - //with the index column and then iterate throught the tuples, evaluating + //with the index column and then iterate through the tuples, evaluating //the rest of the condition on the inner relations. unsigned_vector removed_cols; unsigned table_data_col_cnt = r.m_table_sig.size()-1; diff --git a/src/muz/rel/dl_instruction.cpp b/src/muz/rel/dl_instruction.cpp index f7d1665d2..2b76d99f7 100644 --- a/src/muz/rel/dl_instruction.cpp +++ b/src/muz/rel/dl_instruction.cpp @@ -640,7 +640,7 @@ namespace datalog { reg_idx m_src; reg_idx m_tgt; reg_idx m_delta; - bool m_widen; //if true, widening is performed intead of an union + bool m_widen; //if true, widening is performed instead of an union public: instr_union(reg_idx src, reg_idx tgt, reg_idx delta, bool widen) : m_src(src), m_tgt(tgt), m_delta(delta), m_widen(widen) {} diff --git a/src/muz/rel/dl_instruction.h b/src/muz/rel/dl_instruction.h index 6e0b7bfe5..918763a95 100644 --- a/src/muz/rel/dl_instruction.h +++ b/src/muz/rel/dl_instruction.h @@ -285,7 +285,7 @@ namespace datalog { const unsigned * cols1, const unsigned * cols2, unsigned removed_col_cnt, const unsigned * removed_cols, reg_idx result); static instruction * mk_min(reg_idx source, reg_idx target, const unsigned_vector & group_by_cols, - const unsigned min_col); + unsigned min_col); static instruction * mk_rename(reg_idx src, unsigned cycle_len, const unsigned * permutation_cycle, reg_idx tgt); static instruction * mk_filter_by_negation(reg_idx tgt, reg_idx neg_rel, unsigned col_cnt, diff --git a/src/muz/rel/dl_relation_manager.h b/src/muz/rel/dl_relation_manager.h index bd7b9ae8c..f81785332 100644 --- a/src/muz/rel/dl_relation_manager.h +++ b/src/muz/rel/dl_relation_manager.h @@ -253,7 +253,7 @@ namespace datalog { \brief Return functor that transforms a table into one that lacks columns listed in \c removed_cols array. - The \c removed_cols cotains columns of table \c t in strictly ascending order. + The \c removed_cols contains columns of table \c t in strictly ascending order. */ relation_transformer_fn * mk_project_fn(const relation_base & t, unsigned col_cnt, const unsigned * removed_cols); @@ -263,7 +263,7 @@ namespace datalog { } /** - \brief Return an operation that is a composition of a join an a project operation. + \brief Return an operation that is a composition of a join and a project operation. */ relation_join_fn * mk_join_project_fn(const relation_base & t1, const relation_base & t2, unsigned joined_col_cnt, const unsigned * cols1, const unsigned * cols2, @@ -420,7 +420,7 @@ namespace datalog { \brief Return functor that transforms a table into one that lacks columns listed in \c removed_cols array. - The \c removed_cols cotains columns of table \c t in strictly ascending order. + The \c removed_cols contains columns of table \c t in strictly ascending order. If a project operation removes a non-functional column, all functional columns become non-functional (so that none of the values in functional columns are lost) @@ -433,7 +433,7 @@ namespace datalog { } /** - \brief Return an operation that is a composition of a join an a project operation. + \brief Return an operation that is a composition of a join and a project operation. This operation is equivalent to the two operations performed separately, unless functional columns are involved. diff --git a/src/muz/rel/dl_sieve_relation.h b/src/muz/rel/dl_sieve_relation.h index 5f20cecb4..2d89faa5b 100644 --- a/src/muz/rel/dl_sieve_relation.h +++ b/src/muz/rel/dl_sieve_relation.h @@ -170,7 +170,7 @@ namespace datalog { SASSERT(is_inner_col(idx)); return m_sig2inner[idx]; } - bool no_sieved_columns() const { return m_ignored_cols.size()==0; } + bool no_sieved_columns() const { return m_ignored_cols.empty(); } bool no_inner_columns() const { return m_ignored_cols.size()==get_signature().size(); } relation_base & get_inner() { return *m_inner; } diff --git a/src/muz/rel/dl_sparse_table.cpp b/src/muz/rel/dl_sparse_table.cpp index bb48211c7..db62d14d5 100644 --- a/src/muz/rel/dl_sparse_table.cpp +++ b/src/muz/rel/dl_sparse_table.cpp @@ -568,7 +568,7 @@ namespace datalog { } /** - In this function we modify the content of table functional columns without reseting indexes. + In this function we modify the content of table functional columns without resetting indexes. This is ok as long as we do not allow indexing on functional columns. */ void sparse_table::ensure_fact(const table_fact & f) { @@ -1216,7 +1216,7 @@ namespace datalog { verbose_action _va("filter_by_negation"); - if (m_cols1.size() == 0) { + if (m_cols1.empty()) { if (!neg.empty()) { tgt.reset(); } diff --git a/src/muz/rel/dl_sparse_table.h b/src/muz/rel/dl_sparse_table.h index 43a967729..46f6f3932 100644 --- a/src/muz/rel/dl_sparse_table.h +++ b/src/muz/rel/dl_sparse_table.h @@ -72,7 +72,7 @@ namespace datalog { ~sparse_table_plugin() override; bool can_handle_signature(const table_signature & s) override - { return s.size()>0; } + { return !s.empty(); } table_base * mk_empty(const table_signature & s) override; sparse_table * mk_clone(const sparse_table & t); diff --git a/src/muz/rel/rel_context.h b/src/muz/rel/rel_context.h index 0a31c4e9f..dbcc42248 100644 --- a/src/muz/rel/rel_context.h +++ b/src/muz/rel/rel_context.h @@ -85,7 +85,7 @@ namespace datalog { /** \brief Restrict the set of used predicates to \c res. - The function deallocates unsused relations, it does not deal with rules. + The function deallocates unused relations, it does not deal with rules. */ void restrict_predicates(func_decl_set const& predicates) override; diff --git a/src/muz/spacer/spacer_context.cpp b/src/muz/spacer/spacer_context.cpp index dd6656954..76e7e24c6 100644 --- a/src/muz/spacer/spacer_context.cpp +++ b/src/muz/spacer/spacer_context.cpp @@ -1210,7 +1210,7 @@ expr_ref pred_transformer::get_origin_summary (model &mdl, if (!is_quantifier(s) && !mdl.is_true(s)) { TRACE("spacer", tout << "Summary not true in the model: " << mk_pp(s, m) << "\n";); - return expr_ref(m); + // return expr_ref(m); } } @@ -1325,7 +1325,7 @@ bool pred_transformer::is_qblocked (pob &n) { // assert cti s->assert_expr(n.post()); - lbool res = s->check_sat(0, 0); + lbool res = s->check_sat(0, nullptr); // if (res == l_false) { // expr_ref_vector core(m); @@ -2366,7 +2366,6 @@ void context::updt_params() { } } - void context::reset() { TRACE("spacer", tout << "\n";); @@ -2503,7 +2502,7 @@ void context::add_cover(int level, func_decl* p, expr* property, bool bg) } void context::add_invariant (func_decl *p, expr *property) -{add_cover (infty_level(), p, property, true);} +{add_cover (infty_level(), p, property, use_bg_invs());} expr_ref context::get_reachable(func_decl *p) { pred_transformer* pt = nullptr; @@ -2737,13 +2736,13 @@ lbool context::solve(unsigned from_lvl) // } } VERIFY (validate ()); - } catch (unknown_exception) + } catch (const unknown_exception &) {} if (m_last_result == l_true) { m_stats.m_cex_depth = get_cex_depth (); } - + if (m_params.print_statistics ()) { statistics st; collect_statistics (st); @@ -2927,10 +2926,6 @@ expr_ref context::get_answer() } } -/** - \brief Retrieve satisfying assignment with explanation. -*/ -expr_ref context::mk_sat_answer() {return get_ground_sat_answer();} expr_ref context::mk_unsat_answer() const @@ -2953,8 +2948,7 @@ proof_ref context::get_ground_refutation() { ground_sat_answer_op op(*this); return op(*m_query); } -expr_ref context::get_ground_sat_answer() -{ +expr_ref context::get_ground_sat_answer() const { if (m_last_result != l_true) { IF_VERBOSE(0, verbose_stream() << "Sat answer unavailable when result is false\n";); @@ -3064,7 +3058,7 @@ expr_ref context::get_ground_sat_answer() ground_fact_conjs.push_back(m.mk_eq(sig_arg, sig_val)); ground_arg_vals.push_back(sig_val); } - if (ground_fact_conjs.size () > 0) { + if (!ground_fact_conjs.empty()) { expr_ref ground_fact(m); ground_fact = mk_and(ground_fact_conjs); m_pm.formula_o2n(ground_fact, ground_fact, i); @@ -3082,6 +3076,20 @@ expr_ref context::get_ground_sat_answer() return expr_ref(m.mk_and(cex.size(), cex.c_ptr()), m); } +void context::display_certificate(std::ostream &out) const { + switch(m_last_result) { + case l_false: + out << mk_pp(mk_unsat_answer(), m); + break; + case l_true: + out << mk_pp(mk_sat_answer(), m); + break; + case l_undef: + out << "unknown"; + break; + } +} + ///this is where everything starts lbool context::solve_core (unsigned from_lvl) { diff --git a/src/muz/spacer/spacer_context.h b/src/muz/spacer/spacer_context.h index 0d8b2daf6..494de1c23 100644 --- a/src/muz/spacer/spacer_context.h +++ b/src/muz/spacer/spacer_context.h @@ -1007,7 +1007,10 @@ class context { const vector& reach_pred_used, pob_ref_buffer &out); - expr_ref mk_sat_answer(); + /** + \brief Retrieve satisfying assignment with explanation. + */ + expr_ref mk_sat_answer() const {return get_ground_sat_answer();} expr_ref mk_unsat_answer() const; unsigned get_cex_depth (); @@ -1083,7 +1086,7 @@ public: * get bottom-up (from query) sequence of ground predicate instances * (for e.g. P(0,1,0,0,3)) that together form a ground derivation to query */ - expr_ref get_ground_sat_answer (); + expr_ref get_ground_sat_answer () const; proof_ref get_ground_refutation(); void get_rules_along_trace (datalog::rule_ref_vector& rules); @@ -1092,7 +1095,7 @@ public: void reset(); std::ostream& display(std::ostream& out) const; - void display_certificate(std::ostream& out) const {NOT_IMPLEMENTED_YET();} + void display_certificate(std::ostream& out) const; pob& get_root() const {return m_pob_queue.get_root();} void set_query(func_decl* q) {m_query_pred = q;} diff --git a/src/muz/spacer/spacer_farkas_learner.cpp b/src/muz/spacer/spacer_farkas_learner.cpp index d97bee49f..b8d8324fb 100644 --- a/src/muz/spacer/spacer_farkas_learner.cpp +++ b/src/muz/spacer/spacer_farkas_learner.cpp @@ -7,8 +7,8 @@ Module Name: Abstract: - Proviced abstract interface and some inplementations of algorithms - for strenghtning lemmas + Provides abstract interface and some implementations of algorithms + for strenghtening lemmas Author: @@ -95,7 +95,7 @@ bool farkas_learner::is_pure_expr(func_decl_set const& symbs, expr* e, ast_manag is_pure_expr_proc proc(symbs, m); try { for_each_expr(proc, e); - } catch (is_pure_expr_proc::non_pure) { + } catch (const is_pure_expr_proc::non_pure &) { return false; } return true; @@ -161,7 +161,7 @@ bool farkas_learner::is_pure_expr(func_decl_set const& symbs, expr* e, ast_manag in a clausal version. NB: the routine is not interpolating, though an interpolating variant would - be preferrable because then we can also use it for model propagation. + be preferable because then we can also use it for model propagation. We collect the unit derivable nodes from bs. These are the weakenings of bs, besides the diff --git a/src/muz/spacer/spacer_generalizers.cpp b/src/muz/spacer/spacer_generalizers.cpp index b0fb6c2d3..9d2c00c33 100644 --- a/src/muz/spacer/spacer_generalizers.cpp +++ b/src/muz/spacer/spacer_generalizers.cpp @@ -50,7 +50,7 @@ namespace{ contains_array_op_proc(ast_manager &manager) : m(manager), m_array_fid(m.mk_family_id("array")) {} - virtual bool operator()(expr *e) { + bool operator()(expr *e) override { return is_app(e) && to_app(e)->get_family_id() == m_array_fid; } }; @@ -107,8 +107,7 @@ void lemma_bool_inductive_generalizer::operator()(lemma_ref &lemma) { expand_literals(m, extra_lits); SASSERT(extra_lits.size() > 0); bool found = false; - if (extra_lits.get(0) != lit) { - SASSERT(extra_lits.size() > 1); + if (extra_lits.get(0) != lit && extra_lits.size() > 1) { for (unsigned j = 0, sz = extra_lits.size(); !found && j < sz; ++j) { cube[i] = extra_lits.get(j); if (pt.check_inductive(lemma->level(), cube, uses_level, weakness)) { diff --git a/src/muz/spacer/spacer_generalizers.h b/src/muz/spacer/spacer_generalizers.h index 45ae472bd..e83cc1bc9 100644 --- a/src/muz/spacer/spacer_generalizers.h +++ b/src/muz/spacer/spacer_generalizers.h @@ -117,11 +117,11 @@ class lemma_quantifier_generalizer : public lemma_generalizer { int m_offset; public: lemma_quantifier_generalizer(context &ctx, bool normalize_cube = true); - virtual ~lemma_quantifier_generalizer() {} - virtual void operator()(lemma_ref &lemma); + ~lemma_quantifier_generalizer() override {} + void operator()(lemma_ref &lemma) override; - virtual void collect_statistics(statistics& st) const; - virtual void reset_statistics() {m_st.reset();} + void collect_statistics(statistics& st) const override; + void reset_statistics() override {m_st.reset();} private: bool generalize(lemma_ref &lemma, app *term); diff --git a/src/muz/spacer/spacer_iuc_proof.cpp b/src/muz/spacer/spacer_iuc_proof.cpp index b6a522b76..949507fb4 100644 --- a/src/muz/spacer/spacer_iuc_proof.cpp +++ b/src/muz/spacer/spacer_iuc_proof.cpp @@ -88,7 +88,7 @@ bool iuc_proof::is_core_pure(expr* e) const try { for_each_expr(proc, e); } - catch (is_pure_expr_proc::non_pure) + catch (const is_pure_expr_proc::non_pure &) {return false;} return true; diff --git a/src/muz/spacer/spacer_iuc_solver.cpp b/src/muz/spacer/spacer_iuc_solver.cpp index 27b8ee357..32f33f773 100644 --- a/src/muz/spacer/spacer_iuc_solver.cpp +++ b/src/muz/spacer/spacer_iuc_solver.cpp @@ -72,7 +72,7 @@ app* iuc_solver::mk_proxy (expr *v) if (is_uninterp_const(e)) { return to_app(v); } } - def_manager &def = m_defs.size () > 0 ? m_defs.back () : m_base_defs; + def_manager &def = !m_defs.empty() ? m_defs.back () : m_base_defs; return def.mk_proxy (v); } diff --git a/src/muz/spacer/spacer_manager.cpp b/src/muz/spacer/spacer_manager.cpp index 856207463..817d620c9 100644 --- a/src/muz/spacer/spacer_manager.cpp +++ b/src/muz/spacer/spacer_manager.cpp @@ -247,7 +247,7 @@ bool has_zk_const(expr *e){ try { for_each_expr(p, e); } - catch (has_zk_const_ns::found) { + catch (const has_zk_const_ns::found &) { return true; } return false; diff --git a/src/muz/spacer/spacer_proof_utils.cpp b/src/muz/spacer/spacer_proof_utils.cpp index ed02513f1..a73d24d49 100644 --- a/src/muz/spacer/spacer_proof_utils.cpp +++ b/src/muz/spacer/spacer_proof_utils.cpp @@ -600,7 +600,7 @@ namespace spacer { proof* hypothesis_reducer::reduce_core(proof* pf) { SASSERT(m.is_false(m.get_fact(pf))); - proof *res = NULL; + proof *res = nullptr; ptr_vector todo; todo.push_back(pf); diff --git a/src/muz/spacer/spacer_quant_generalizer.cpp b/src/muz/spacer/spacer_quant_generalizer.cpp index a11ab4d9e..63b204736 100644 --- a/src/muz/spacer/spacer_quant_generalizer.cpp +++ b/src/muz/spacer/spacer_quant_generalizer.cpp @@ -120,7 +120,7 @@ struct index_lt_proc : public std::binary_function { for (expr *e : v) quick_for_each_expr(fn, visited, e); } - catch (has_nlira_functor::found ) { + catch (const has_nlira_functor::found &) { return true; } return false; @@ -186,7 +186,7 @@ void lemma_quantifier_generalizer::find_candidates(expr *e, std::sort(candidates.c_ptr(), candidates.c_ptr() + candidates.size(), index_lt_proc(m)); - // keep actual select indecies in the order found at the back of + // keep actual select indices in the order found at the back of // candidate list. There is no particular reason for this order candidates.append(extra); } @@ -199,24 +199,24 @@ bool lemma_quantifier_generalizer::match_sk_idx(expr *e, app_ref_vector const &z contains_app has_zk(m, zks.get(0)); if (!contains_selects(e, m)) return false; - app_ref_vector indicies(m); - get_select_indices(e, indicies); - if (indicies.size() > 2) return false; + app_ref_vector indices(m); + get_select_indices(e, indices); + if (indices.size() > 2) return false; unsigned i=0; - if (indicies.size() == 1) { - if (!has_zk(indicies.get(0))) return false; + if (indices.size() == 1) { + if (!has_zk(indices.get(0))) return false; } else { - if (has_zk(indicies.get(0)) && !has_zk(indicies.get(1))) + if (has_zk(indices.get(0)) && !has_zk(indices.get(1))) i = 0; - else if (!has_zk(indicies.get(0)) && has_zk(indicies.get(1))) + else if (!has_zk(indices.get(0)) && has_zk(indices.get(1))) i = 1; - else if (!has_zk(indicies.get(0)) && !has_zk(indicies.get(1))) + else if (!has_zk(indices.get(0)) && !has_zk(indices.get(1))) return false; } - idx = indicies.get(i); + idx = indices.get(i); sk = zks.get(0); return true; } diff --git a/src/muz/spacer/spacer_unsat_core_plugin.cpp b/src/muz/spacer/spacer_unsat_core_plugin.cpp index aeb509c2e..77e88fb32 100644 --- a/src/muz/spacer/spacer_unsat_core_plugin.cpp +++ b/src/muz/spacer/spacer_unsat_core_plugin.cpp @@ -124,7 +124,7 @@ namespace spacer { * We can rewrite (E2) to rewrite (E1) to * (BP*Fark(BP)) => (neg(A*Fark(A) + BNP*Fark(BNP) + (neg D)*Fark(D))) (E3) * and since we can derive (A*Fark(A) + BNP*Fark(BNP) + (neg D)*Fark(D)) from - * A, BNP and D, we also know that it is inconsisent. Therefore + * A, BNP and D, we also know that it is inconsistent. Therefore * neg(A*Fark(A) + BNP*Fark(BNP) + (neg D)*Fark(D)) is a solution. * * Finally we also need the following workaround: diff --git a/src/muz/spacer/spacer_util.cpp b/src/muz/spacer/spacer_util.cpp index ec01218f1..2a5f1e2cc 100644 --- a/src/muz/spacer/spacer_util.cpp +++ b/src/muz/spacer/spacer_util.cpp @@ -891,7 +891,7 @@ namespace { for_each_expr(cs, fml); return false; } - catch(found) { + catch(const found &) { return true; } } diff --git a/src/muz/tab/tab_context.cpp b/src/muz/tab/tab_context.cpp index c60c770bf..3b8fd2ee0 100644 --- a/src/muz/tab/tab_context.cpp +++ b/src/muz/tab/tab_context.cpp @@ -415,7 +415,7 @@ namespace tb { try { quick_for_each_expr(p, t); } - catch (non_constructor) { + catch (const non_constructor &) { return false; } return true; @@ -1097,7 +1097,7 @@ namespace tb { m_S1.apply(2, delta, expr_offset(src.get_constraint(), 1), tmp2); constraint = m.mk_and(tmp, tmp2); - // perform trival quantifier-elimination: + // perform trivial quantifier-elimination: uint_set index_set; expr_free_vars fv; fv(head); diff --git a/src/muz/transforms/dl_mk_array_instantiation.cpp b/src/muz/transforms/dl_mk_array_instantiation.cpp index 6a8f0ce81..a94383453 100644 --- a/src/muz/transforms/dl_mk_array_instantiation.cpp +++ b/src/muz/transforms/dl_mk_array_instantiation.cpp @@ -253,7 +253,7 @@ namespace datalog { all_selects.push_back(rewrite_select(array, select_ops[i])); } } - if(all_selects.size()==0) + if(all_selects.empty()) { expr_ref_vector dummy_args(m); dummy_args.push_back(array); @@ -300,7 +300,7 @@ namespace datalog { expr_ref_vector res(m); svector chosen(arg_correspondance.size(), 0u); - while(1) + while(true) { expr_ref_vector new_args(m); for(unsigned i=0;iinherit_predicates(source); diff --git a/src/muz/transforms/dl_mk_subsumption_checker.cpp b/src/muz/transforms/dl_mk_subsumption_checker.cpp index da41b4ba4..c970aedeb 100644 --- a/src/muz/transforms/dl_mk_subsumption_checker.cpp +++ b/src/muz/transforms/dl_mk_subsumption_checker.cpp @@ -45,7 +45,7 @@ namespace datalog { unsigned pt_len = r->get_positive_tail_size(); if(pt_len != r->get_uninterpreted_tail_size()) { - // we dont' expect rules with negative tails to be total + // we don't expect rules with negative tails to be total return false; } @@ -97,7 +97,7 @@ namespace datalog { void mk_subsumption_checker::scan_for_total_rules(const rule_set & rules) { bool new_discovered; //we cycle through the rules until we keep discovering new total relations - //(discovering a total relation migh reveal other total relations) + //(discovering a total relation might reveal other total relations) do { new_discovered = false; rule_set::iterator rend = rules.end(); diff --git a/src/muz/transforms/dl_mk_synchronize.h b/src/muz/transforms/dl_mk_synchronize.h index 6f4b3ca40..77f45e91f 100644 --- a/src/muz/transforms/dl_mk_synchronize.h +++ b/src/muz/transforms/dl_mk_synchronize.h @@ -126,7 +126,7 @@ namespace datalog { */ mk_synchronize(context & ctx, unsigned priority = 22500); - rule_set * operator()(rule_set const & source); + rule_set * operator()(rule_set const & source) override; }; }; diff --git a/src/nlsat/nlsat_evaluator.cpp b/src/nlsat/nlsat_evaluator.cpp index a93c4fb3e..e04b95a40 100644 --- a/src/nlsat/nlsat_evaluator.cpp +++ b/src/nlsat/nlsat_evaluator.cpp @@ -377,7 +377,7 @@ namespace nlsat { } /** - \brief Return the sign of the polynomial in the current interpration. + \brief Return the sign of the polynomial in the current interpretation. \pre All variables of p are assigned in the current interpretation. */ @@ -469,7 +469,7 @@ namespace nlsat { } } - // Evalute the sign of p1^e1*...*pn^en (of atom a) in cell c of table t. + // Evaluate the sign of p1^e1*...*pn^en (of atom a) in cell c of table t. int sign_at(ineq_atom * a, sign_table const & t, unsigned c) const { int sign = 1; unsigned num_ps = a->size(); @@ -556,7 +556,7 @@ namespace nlsat { result = m_ism.mk(true, true, dummy, true, true, dummy, jst); } else { - // save -oo as begining of infeasible interval + // save -oo as beginning of infeasible interval prev_open = true; prev_inf = true; prev_root_id = UINT_MAX; diff --git a/src/nlsat/nlsat_solver.cpp b/src/nlsat/nlsat_solver.cpp index f430f3a0c..6ea764a0a 100644 --- a/src/nlsat/nlsat_solver.cpp +++ b/src/nlsat/nlsat_solver.cpp @@ -190,7 +190,7 @@ namespace nlsat { } ~imp() { - reset(); + clear(); } void mk_true_bvar() { @@ -230,6 +230,14 @@ namespace nlsat { m_assignment.reset(); } + void clear() { + m_explain.reset(); + m_lemma.reset(); + m_lazy_clause.reset(); + undo_until_size(0); + del_clauses(); + del_unref_atoms(); + } void checkpoint() { if (!m_rlimit.inc()) throw solver_exception(m_rlimit.get_cancel_msg()); diff --git a/src/opt/maxres.cpp b/src/opt/maxres.cpp index f52c56a60..75a42886c 100644 --- a/src/opt/maxres.cpp +++ b/src/opt/maxres.cpp @@ -108,6 +108,7 @@ private: bool m_pivot_on_cs; // prefer smaller correction set to core. bool m_dump_benchmarks; // display benchmarks (into wcnf format) + std::string m_trace_id; typedef ptr_vector exprs; @@ -144,7 +145,7 @@ public: } } - virtual ~maxres() {} + ~maxres() override {} bool is_literal(expr* l) { return @@ -152,6 +153,14 @@ public: (m.is_not(l, l) && is_uninterp_const(l)); } + void add(expr_ref_vector const& es) { + for (expr* e : es) add(e); + } + + void add(expr* e) { + s().assert_expr(e); + } + void add_soft(expr* e, rational const& w) { TRACE("opt", tout << mk_pp(e, m) << " |-> " << w << "\n";); expr_ref asum(m), fml(m); @@ -168,7 +177,7 @@ public: else { asum = mk_fresh_bool("soft"); fml = m.mk_iff(asum, e); - s().assert_expr(fml); + add(fml); } new_assumption(asum, w); } @@ -194,11 +203,8 @@ public: if (is_sat != l_true) return is_sat; while (m_lower < m_upper) { TRACE("opt_verbose", - display_vec(tout, m_asms); - s().display(tout); - tout << "\n"; - display(tout); - ); + s().display(tout << m_asms << "\n") << "\n"; + display(tout);); is_sat = check_sat_hill_climb(m_asms); if (m.canceled()) { return l_undef; @@ -206,8 +212,7 @@ public: switch (is_sat) { case l_true: CTRACE("opt", !m_model->is_true(m_asms), - tout << *m_model; - tout << "assumptions: "; + tout << *m_model << "assumptions: "; for (expr* a : m_asms) tout << mk_pp(a, m) << " -> " << (*m_model)(a) << " "; tout << "\n";); SASSERT(m_model->is_true(m_asms)); @@ -320,6 +325,7 @@ public: void found_optimum() { IF_VERBOSE(1, verbose_stream() << "found optimum\n";); + verify_assumptions(); m_lower.reset(); for (soft& s : m_soft) { s.is_true = m_model->is_true(s.s); @@ -332,7 +338,7 @@ public: } - virtual lbool operator()() { + lbool operator()() override { m_defs.reset(); switch(m_st) { case s_primal: @@ -343,12 +349,19 @@ public: return l_undef; } - virtual void collect_statistics(statistics& st) const { + void collect_statistics(statistics& st) const override { st.update("maxres-cores", m_stats.m_num_cores); st.update("maxres-correction-sets", m_stats.m_num_cs); } - lbool get_cores(vector& cores) { + struct weighted_core { + exprs m_core; + rational m_weight; + weighted_core(exprs const& c, rational const& w): + m_core(c), m_weight(w) {} + }; + + lbool get_cores(vector& cores) { // assume m_s is unsat. lbool is_sat = l_false; cores.reset(); @@ -361,7 +374,7 @@ public: get_mus_model(mdl); is_sat = minimize_core(_core); core.append(_core.size(), _core.c_ptr()); - // verify_core(core); + verify_core(core); ++m_stats.m_num_cores; if (is_sat != l_true) { IF_VERBOSE(100, verbose_stream() << "(opt.maxres minimization failed)\n";); @@ -373,13 +386,16 @@ public: m_lower = m_upper; return l_true; } + + // 1. remove all core literals from m_asms // 2. re-add literals of higher weight than min-weight. // 3. 'core' stores the core literals that are // re-encoded as assumptions, afterwards + cores.push_back(weighted_core(core, core_weight(core))); + remove_soft(core, m_asms); - split_core(core); - cores.push_back(core); + split_core(core); if (core.size() >= m_max_core_size) break; if (cores.size() >= m_max_num_cores) break; @@ -389,7 +405,7 @@ public: TRACE("opt", tout << "sat: " << is_sat << " num cores: " << cores.size() << "\n"; - for (auto const& c : cores) display_vec(tout, c); + for (auto const& c : cores) display_vec(tout, c.m_core); tout << "num assumptions: " << m_asms.size() << "\n";); return is_sat; @@ -456,7 +472,7 @@ public: } lbool process_unsat() { - vector cores; + vector cores; lbool is_sat = get_cores(cores); if (is_sat != l_true) { return is_sat; @@ -478,9 +494,9 @@ public: return result; } - void process_unsat(vector const& cores) { + void process_unsat(vector const& cores) { for (auto const & c : cores) { - process_unsat(c); + process_unsat(c.m_core, c.m_weight); } } @@ -491,16 +507,15 @@ public: } } - void process_unsat(exprs const& core) { + void process_unsat(exprs const& core, rational w) { IF_VERBOSE(3, verbose_stream() << "(maxres cs model valid: " << (m_csmodel.get() != nullptr) << " cs size:" << m_correction_set_size << " core: " << core.size() << ")\n";); expr_ref fml(m); SASSERT(!core.empty()); - rational w = core_weight(core); TRACE("opt", display_vec(tout << "minimized core: ", core);); - IF_VERBOSE(10, display_vec(verbose_stream() << "core: ", core);); + IF_VERBOSE(10, display_vec(verbose_stream() << "core: ", core);); max_resolve(core, w); fml = mk_not(m, mk_and(m, core.size(), core.c_ptr())); - s().assert_expr(fml); + add(fml); m_lower += w; if (m_st == s_primal_dual) { m_lower = std::min(m_lower, m_upper); @@ -636,10 +651,10 @@ public: else { dd = mk_fresh_bool("d"); fml = m.mk_implies(dd, d); - s().assert_expr(fml); + add(fml); m_defs.push_back(fml); fml = m.mk_implies(dd, b_i); - s().assert_expr(fml); + add(fml); m_defs.push_back(fml); fml = m.mk_and(d, b_i); update_model(dd, fml); @@ -650,7 +665,7 @@ public: fml = m.mk_implies(asum, cls); update_model(asum, cls); new_assumption(asum, w); - s().assert_expr(fml); + add(fml); m_defs.push_back(fml); } } @@ -682,7 +697,7 @@ public: d = mk_fresh_bool("d"); fml = m.mk_implies(d, cls); update_model(d, cls); - s().assert_expr(fml); + add(fml); m_defs.push_back(fml); } @@ -691,10 +706,10 @@ public: } asum = mk_fresh_bool("a"); fml = m.mk_implies(asum, b_i1); - s().assert_expr(fml); + add(fml); m_defs.push_back(fml); fml = m.mk_implies(asum, cls); - s().assert_expr(fml); + add(fml); m_defs.push_back(fml); new_assumption(asum, w); @@ -702,7 +717,7 @@ public: update_model(asum, fml); } fml = m.mk_or(cs.size(), cs.c_ptr()); - s().assert_expr(fml); + add(fml); } void update_assignment(model_ref & mdl) { @@ -747,7 +762,7 @@ public: s.is_true = m_model->is_true(s.s); } - // DEBUG_CODE(verify_assignment();); + verify_assignment(); m_upper = upper; @@ -768,7 +783,7 @@ public: } fml = u.mk_lt(nsoft.size(), weights.c_ptr(), nsoft.c_ptr(), m_upper); TRACE("opt", tout << "block upper bound " << fml << "\n";);; - s().assert_expr(fml); + add(fml); } void remove_soft(exprs const& core, expr_ref_vector& asms) { @@ -781,7 +796,7 @@ public: TRACE("opt", tout << "after remove: " << asms << "\n";); } - virtual void updt_params(params_ref& _p) { + void updt_params(params_ref& _p) override { maxsmt_solver_base::updt_params(_p); opt_params p(_p); m_hill_climb = p.maxres_hill_climb(); @@ -816,43 +831,53 @@ public: return l_true; } - virtual void commit_assignment() { + void commit_assignment() override { if (m_found_feasible_optimum) { TRACE("opt", tout << "Committing feasible solution\n" << m_defs << " " << m_asms;); - s().assert_expr(m_defs); - s().assert_expr(m_asms); + add(m_defs); + add(m_asms); } // else: there is only a single assignment to these soft constraints. } void verify_core(exprs const& core) { - IF_VERBOSE(3, verbose_stream() << "verify core\n";); - ref smt_solver = mk_smt_solver(m, m_params, symbol()); - smt_solver->assert_expr(s().get_assertions()); - smt_solver->assert_expr(core); - lbool is_sat = smt_solver->check_sat(0, nullptr); - if (is_sat == l_true) { - IF_VERBOSE(0, verbose_stream() << "not a core\n";); - } + return; + IF_VERBOSE(3, verbose_stream() << "verify core " << s().check_sat(core.size(), core.c_ptr()) << "\n";); + ref _solver = mk_smt_solver(m, m_params, symbol()); + _solver->assert_expr(s().get_assertions()); + _solver->assert_expr(core); + lbool is_sat = _solver->check_sat(0, nullptr); + IF_VERBOSE(0, verbose_stream() << "core status (l_false:) " << is_sat << "\n"); + VERIFY(is_sat == l_false); + } + + void verify_assumptions() { + return; + IF_VERBOSE(1, verbose_stream() << "verify assumptions\n";); + ref _solver = mk_smt_solver(m, m_params, symbol()); + _solver->assert_expr(s().get_assertions()); + _solver->assert_expr(m_asms); + lbool is_sat = _solver->check_sat(0, nullptr); + IF_VERBOSE(1, verbose_stream() << "assignment status (l_true) " << is_sat << "\n";); + VERIFY(is_sat == l_true); } void verify_assignment() { + return; IF_VERBOSE(1, verbose_stream() << "verify assignment\n";); - ref smt_solver = mk_smt_solver(m, m_params, symbol()); - smt_solver->assert_expr(s().get_assertions()); + ref _solver = mk_smt_solver(m, m_params, symbol()); + _solver->assert_expr(s().get_assertions()); expr_ref n(m); for (soft& s : m_soft) { n = s.s; if (!s.is_true) { n = mk_not(m, n); } - smt_solver->assert_expr(n); + _solver->assert_expr(n); } - lbool is_sat = smt_solver->check_sat(0, nullptr); - if (is_sat == l_false) { - IF_VERBOSE(0, verbose_stream() << "assignment is infeasible\n";); - } - IF_VERBOSE(1, verbose_stream() << "verified\n";); + lbool is_sat = _solver->check_sat(0, nullptr); + IF_VERBOSE(1, verbose_stream() << "assignment status (l_true) " << is_sat << "\n"); + VERIFY(is_sat == l_true); } }; diff --git a/src/opt/opt_cmds.cpp b/src/opt/opt_cmds.cpp index d8e301e08..f01df0bdd 100644 --- a/src/opt/opt_cmds.cpp +++ b/src/opt/opt_cmds.cpp @@ -56,33 +56,33 @@ public: m_opt(opt) {} - virtual ~assert_soft_cmd() { + ~assert_soft_cmd() override { } - virtual void reset(cmd_context & ctx) { + void reset(cmd_context & ctx) override { m_idx = 0; m_formula = nullptr; } - virtual char const * get_usage() const { return " [:weight ] [:id ]"; } - virtual char const * get_main_descr() const { return "assert soft constraint with optional weight and identifier"; } + char const * get_usage() const override { return " [:weight ] [:id ]"; } + char const * get_main_descr() const override { return "assert soft constraint with optional weight and identifier"; } // command invocation - virtual void prepare(cmd_context & ctx) { + void prepare(cmd_context & ctx) override { reset(ctx); } - virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { + cmd_arg_kind next_arg_kind(cmd_context & ctx) const override { if (m_idx == 0) return CPK_EXPR; return parametric_cmd::next_arg_kind(ctx); } - virtual void init_pdescrs(cmd_context & ctx, param_descrs & p) { + void init_pdescrs(cmd_context & ctx, param_descrs & p) override { p.insert("weight", CPK_NUMERAL, "(default: 1) penalty of not satisfying constraint."); p.insert("id", CPK_SYMBOL, "(default: null) partition identifier for soft constraints."); } - virtual void set_next_arg(cmd_context & ctx, expr * t) { + void set_next_arg(cmd_context & ctx, expr * t) override { SASSERT(m_idx == 0); if (!ctx.m().is_bool(t)) { throw cmd_exception("Invalid type for expression. Expected Boolean type."); @@ -91,11 +91,11 @@ public: ++m_idx; } - virtual void failure_cleanup(cmd_context & ctx) { + void failure_cleanup(cmd_context & ctx) override { reset(ctx); } - virtual void execute(cmd_context & ctx) { + void execute(cmd_context & ctx) override { if (!m_formula) { throw cmd_exception("assert-soft requires a formulas as argument."); } @@ -107,7 +107,7 @@ public: reset(ctx); } - virtual void finalize(cmd_context & ctx) { + void finalize(cmd_context & ctx) override { } }; @@ -123,14 +123,14 @@ public: m_opt(opt) {} - virtual void reset(cmd_context & ctx) { } - virtual char const * get_usage() const { return ""; } - virtual char const * get_descr(cmd_context & ctx) const { return "check sat modulo objective function";} - virtual unsigned get_arity() const { return 1; } - virtual void prepare(cmd_context & ctx) {} - virtual cmd_arg_kind next_arg_kind(cmd_context & ctx) const { return CPK_EXPR; } + void reset(cmd_context & ctx) override { } + char const * get_usage() const override { return ""; } + char const * get_descr(cmd_context & ctx) const override { return "check sat modulo objective function";} + unsigned get_arity() const override { return 1; } + void prepare(cmd_context & ctx) override {} + cmd_arg_kind next_arg_kind(cmd_context & ctx) const override { return CPK_EXPR; } - virtual void set_next_arg(cmd_context & ctx, expr * t) { + void set_next_arg(cmd_context & ctx, expr * t) override { if (!is_app(t)) { throw cmd_exception("malformed objective term: it cannot be a quantifier or bound variable"); } @@ -138,11 +138,11 @@ public: ctx.print_success(); } - virtual void failure_cleanup(cmd_context & ctx) { + void failure_cleanup(cmd_context & ctx) override { reset(ctx); } - virtual void execute(cmd_context & ctx) { + void execute(cmd_context & ctx) override { } }; @@ -154,18 +154,18 @@ public: m_opt(opt) {} - virtual void reset(cmd_context & ctx) { } - virtual char const * get_usage() const { return "(get-objectives)"; } - virtual char const * get_descr(cmd_context & ctx) const { return "retrieve the objective values (after optimization)"; } - virtual unsigned get_arity() const { return 0; } - virtual void prepare(cmd_context & ctx) {} + void reset(cmd_context & ctx) override { } + char const * get_usage() const override { return "(get-objectives)"; } + char const * get_descr(cmd_context & ctx) const override { return "retrieve the objective values (after optimization)"; } + unsigned get_arity() const override { return 0; } + void prepare(cmd_context & ctx) override {} - virtual void failure_cleanup(cmd_context & ctx) { + void failure_cleanup(cmd_context & ctx) override { reset(ctx); } - virtual void execute(cmd_context & ctx) { + void execute(cmd_context & ctx) override { if (!ctx.ignore_check()) { get_opt(ctx, m_opt).display_assignment(ctx.regular_stream()); } diff --git a/src/opt/opt_context.cpp b/src/opt/opt_context.cpp index 5d4eb3fc5..66c175ac8 100644 --- a/src/opt/opt_context.cpp +++ b/src/opt/opt_context.cpp @@ -79,13 +79,13 @@ namespace opt { m_hard.push_back(hard); } - bool context::scoped_state::set(ptr_vector & hard) { + bool context::scoped_state::set(expr_ref_vector const & hard) { bool eq = hard.size() == m_hard.size(); for (unsigned i = 0; eq && i < hard.size(); ++i) { - eq = hard[i] == m_hard[i].get(); + eq = hard.get(i) == m_hard.get(i); } m_hard.reset(); - m_hard.append(hard.size(), hard.c_ptr()); + m_hard.append(hard); return !eq; } @@ -130,6 +130,7 @@ namespace opt { m_fm(alloc(generic_model_converter, m, "opt")), m_model_fixed(), m_objective_refs(m), + m_core(m), m_enable_sat(false), m_is_clausal(false), m_pp_neat(false), @@ -173,11 +174,10 @@ namespace opt { } void context::get_unsat_core(expr_ref_vector & r) { - throw default_exception("Unsat cores are not supported with optimization"); + r.append(m_core); } - - void context::set_hard_constraints(ptr_vector& fmls) { + void context::set_hard_constraints(expr_ref_vector const& fmls) { if (m_scoped_state.set(fmls)) { clear_state(); } @@ -253,7 +253,7 @@ namespace opt { m_hard_constraints.append(s.m_hard); } - lbool context::optimize() { + lbool context::optimize(expr_ref_vector const& asms) { if (m_pareto) { return execute_pareto(); } @@ -263,7 +263,10 @@ namespace opt { clear_state(); init_solver(); import_scoped_state(); - normalize(); + normalize(asms); + if (m_hard_constraints.size() == 1 && m.is_false(m_hard_constraints.get(0))) { + return l_false; + } internalize(); update_solver(); if (contains_quantifiers()) { @@ -281,7 +284,9 @@ namespace opt { symbol pri = optp.priority(); IF_VERBOSE(1, verbose_stream() << "(optimize:check-sat)\n"); - lbool is_sat = s.check_sat(0,0); + + lbool is_sat = s.check_sat(asms.size(),asms.c_ptr()); + TRACE("opt", s.display(tout << "initial search result: " << is_sat << "\n");); if (is_sat != l_false) { s.get_model(m_model); @@ -289,9 +294,13 @@ namespace opt { model_updated(m_model.get()); } if (is_sat != l_true) { - TRACE("opt", tout << m_hard_constraints << "\n";); + TRACE("opt", tout << m_hard_constraints << " " << asms << "\n";); + if (!asms.empty()) { + s.get_unsat_core(m_core); + } return is_sat; } + s.assert_expr(asms); IF_VERBOSE(1, verbose_stream() << "(optimize:sat)\n"); TRACE("opt", model_smt2_pp(tout, m, *m_model, 0);); m_optsmt.setup(*m_opt_solver.get()); @@ -473,13 +482,12 @@ namespace opt { ++j; } } - if (r == l_true && m_box_models.size() > 0) { + if (r == l_true && !m_box_models.empty()) { m_model = m_box_models[0]; } return r; } - expr_ref context::mk_le(unsigned i, model_ref& mdl) { objective const& obj = m_objectives[i]; return mk_cmp(false, mdl, obj); @@ -489,8 +497,7 @@ namespace opt { objective const& obj = m_objectives[i]; return mk_cmp(true, mdl, obj); } - - + expr_ref context::mk_gt(unsigned i, model_ref& mdl) { expr_ref result = mk_le(i, mdl); result = mk_not(m, result); @@ -702,7 +709,7 @@ namespace opt { quick_for_each_expr(proc, visited, f); } } - catch (is_bv::found) { + catch (const is_bv::found &) { return false; } return true; @@ -733,7 +740,7 @@ namespace opt { try { quick_for_each_expr(proc, visited, p); } - catch (is_propositional_fn::found) { + catch (const is_propositional_fn::found &) { return false; } return true; @@ -751,22 +758,25 @@ namespace opt { return m_arith.is_numeral(e, n) || m_bv.is_numeral(e, n, sz); } - void context::normalize() { + void context::normalize(expr_ref_vector const& asms) { expr_ref_vector fmls(m); to_fmls(fmls); - simplify_fmls(fmls); + simplify_fmls(fmls, asms); from_fmls(fmls); } - void context::simplify_fmls(expr_ref_vector& fmls) { + void context::simplify_fmls(expr_ref_vector& fmls, expr_ref_vector const& asms) { if (m_is_clausal) { return; } - goal_ref g(alloc(goal, m, true, false)); + goal_ref g(alloc(goal, m, true, !asms.empty())); for (expr* fml : fmls) { g->assert_expr(fml); } + for (expr * a : asms) { + g->assert_expr(a, a); + } tactic_ref tac0 = and_then(mk_simplify_tactic(m, m_params), mk_propagate_values_tactic(m), @@ -788,6 +798,7 @@ namespace opt { set_simplify(tac0.get()); } goal_ref_buffer result; + TRACE("opt", g->display(tout);); (*m_simplify)(g, result); SASSERT(result.size() == 1); goal* r = result[0]; @@ -795,8 +806,27 @@ namespace opt { fmls.reset(); expr_ref tmp(m); for (unsigned i = 0; i < r->size(); ++i) { - fmls.push_back(r->form(i)); + if (asms.empty()) { + fmls.push_back(r->form(i)); + continue; + } + + ptr_vector deps; + expr_dependency_ref core(r->dep(i), m); + m.linearize(core, deps); + if (!deps.empty()) { + fmls.push_back(m.mk_implies(m.mk_and(deps.size(), deps.c_ptr()), r->form(i))); + } + else { + fmls.push_back(r->form(i)); + } } + if (r->inconsistent()) { + ptr_vector core_elems; + expr_dependency_ref core(r->dep(0), m); + m.linearize(core, core_elems); + m_core.append(core_elems.size(), core_elems.c_ptr()); + } } bool context::is_maximize(expr* fml, app_ref& term, expr_ref& orig_term, unsigned& index) { @@ -1084,11 +1114,7 @@ namespace opt { } term = m_arith.mk_add(args.size(), args.c_ptr()); } - else if (m_arith.is_arith_expr(term) && !is_mul_const(term)) { - TRACE("opt", tout << "Purifying " << term << "\n";); - term = purify(fm, term); - } - else if (m.is_ite(term)) { + else if (m.is_ite(term) || !is_mul_const(term)) { TRACE("opt", tout << "Purifying " << term << "\n";); term = purify(fm, term); } @@ -1399,6 +1425,7 @@ namespace opt { m_box_index = UINT_MAX; m_model.reset(); m_model_fixed.reset(); + m_core.reset(); } void context::set_pareto(pareto_base* p) { @@ -1541,12 +1568,12 @@ namespace opt { mdl->set_model_completion(true); for (expr * f : fmls) { if (!mdl->is_true(f)) { - //IF_VERBOSE(0, m_fm->display(verbose_stream() << "fm\n")); - IF_VERBOSE(0, m_model_converter->display(verbose_stream() << "mc\n")); - IF_VERBOSE(0, verbose_stream() << "Failed to validate " << mk_pp(f, m) << "\n" << tmp << "\n"); - IF_VERBOSE(0, model_smt2_pp(verbose_stream(), m, *mdl, 0)); - IF_VERBOSE(11, verbose_stream() << to_string_internal() << "\n"); - exit(0); + IF_VERBOSE(0, + verbose_stream() << "Failed to validate " << mk_pp(f, m) << "\n" << tmp << "\n"; + m_fm->display(verbose_stream() << "fm\n"); + m_model_converter->display(verbose_stream() << "mc\n"); + model_smt2_pp(verbose_stream(), m, *mdl, 0); + verbose_stream() << to_string_internal() << "\n"); } } } diff --git a/src/opt/opt_context.h b/src/opt/opt_context.h index 1172e68b6..fe0d4a13e 100644 --- a/src/opt/opt_context.h +++ b/src/opt/opt_context.h @@ -133,7 +133,7 @@ namespace opt { void push(); void pop(); void add(expr* hard); - bool set(ptr_vector & hard); + bool set(expr_ref_vector const& hard); unsigned add(expr* soft, rational const& weight, symbol const& id); unsigned add(app* obj, bool is_max); unsigned get_index(symbol const& id) { return m_indices[id]; } @@ -164,6 +164,7 @@ namespace opt { obj_map m_objective_fns; obj_map m_objective_orig; func_decl_ref_vector m_objective_refs; + expr_ref_vector m_core; tactic_ref m_simplify; bool m_enable_sat; bool m_enable_sls; @@ -186,8 +187,8 @@ namespace opt { void push() override; void pop(unsigned n) override; bool empty() override { return m_scoped_state.m_objectives.empty(); } - void set_hard_constraints(ptr_vector & hard) override; - lbool optimize() override; + void set_hard_constraints(expr_ref_vector const& hard) override; + lbool optimize(expr_ref_vector const& asms) override; void set_model(model_ref& _m) override { m_model = _m; } void get_model_core(model_ref& _m) override; void get_box_model(model_ref& _m, unsigned index) override; @@ -254,7 +255,7 @@ namespace opt { void reset_maxsmts(); void import_scoped_state(); - void normalize(); + void normalize(expr_ref_vector const& asms); void internalize(); bool is_maximize(expr* fml, app_ref& term, expr_ref& orig_term, unsigned& index); bool is_minimize(expr* fml, app_ref& term, expr_ref& orig_term, unsigned& index); @@ -270,7 +271,7 @@ namespace opt { expr* mk_objective_fn(unsigned index, objective_t ty, unsigned sz, expr*const* args); void to_fmls(expr_ref_vector& fmls); void from_fmls(expr_ref_vector const& fmls); - void simplify_fmls(expr_ref_vector& fmls); + void simplify_fmls(expr_ref_vector& fmls, expr_ref_vector const& asms); void mk_atomic(expr_ref_vector& terms); void update_lower() { update_bound(true); } diff --git a/src/opt/opt_pareto.cpp b/src/opt/opt_pareto.cpp index fe92c3ba6..ada5d0d14 100644 --- a/src/opt/opt_pareto.cpp +++ b/src/opt/opt_pareto.cpp @@ -71,7 +71,7 @@ namespace opt { fmls.push_back(mk_or(gt)); fml = mk_and(fmls); IF_VERBOSE(10, verbose_stream() << "dominates: " << fml << "\n";); - TRACE("opt", tout << fml << "\n"; model_smt2_pp(tout, m, *m_model, 0);); + TRACE("opt", model_smt2_pp(tout << fml << "\n", m, *m_model, 0);); m_solver->assert_expr(fml); } diff --git a/src/opt/opt_parse.cpp b/src/opt/opt_parse.cpp index fec97d675..09845ff07 100644 --- a/src/opt/opt_parse.cpp +++ b/src/opt/opt_parse.cpp @@ -323,6 +323,15 @@ struct asymbol { asymbol(rational const& r, unsigned l): m_is_num(true), m_num(r), m_line(l) {} }; +std::ostream& operator<<(std::ostream& out, asymbol const& c) { + if (c.m_is_num) { + return out << c.m_num; + } + else { + return out << c.m_sym; + } +} + class lp_tokenizer { vector m_tokens; unsigned m_pos; @@ -416,6 +425,7 @@ private: } if (c == '.') { in.next(); + c = in.ch(); while (is_num(c) && !in.eof()) { n = n*rational(10) + rational(c - '0'); in.next(); @@ -426,6 +436,7 @@ private: if (div > 1) n = n / rational(div); if (neg) n.neg(); m_tokens.push_back(asymbol(n, in.line())); + IF_VERBOSE(10, verbose_stream() << "num: " << m_tokens.back() << "\n"); continue; } m_buffer.reset(); @@ -445,6 +456,7 @@ private: } m_buffer.push_back(0); m_tokens.push_back(asymbol(symbol(m_buffer.c_ptr()), in.line())); + IF_VERBOSE(10, verbose_stream() << "tok: " << m_tokens.back() << "\n"); } } @@ -466,6 +478,7 @@ private: is_num(c) || c == '!' || c == '"' || + c == '-' || c == '#' || c == '$' || c == '%' || @@ -612,6 +625,7 @@ private: name = peek(0); tok.next(2); } + IF_VERBOSE(10, verbose_stream() << name << "\n"); rational val(0); symbol var; parse_indicator(var, val); @@ -624,6 +638,9 @@ private: } void parse_expr(lin_term& terms) { + if (is_relation()) { + return; + } bool pos = true; if (peek(0) == "-") { pos = false; @@ -693,6 +710,7 @@ private: return false; } + bool is_relation() { return peek(0) == "=" || peek(0) == "=<" || peek(0) == ">=" || peek(0) == "=>" || peek(0) == "<="; } bool is_section() { return is_general() || is_binary() || is_bounds() || is_end();} bool is_bounds() { return peek(0) == "bounds"; } bool is_general() { return peek(0) == "general" || peek(0) == "gen" || peek(0) == "generals"; } @@ -770,6 +788,11 @@ private: } void parse_general() { + if (peek(1) == ":" && peek(3) == "=") { + symbol const& v = peek(2); + std::cout << "TBD: " << v << "\n"; + return; + } symbol const& v = peek(0); bound b; m_bounds.find(v, b); diff --git a/src/opt/pb_sls.cpp b/src/opt/pb_sls.cpp index 9054e2b00..17c3f9128 100644 --- a/src/opt/pb_sls.cpp +++ b/src/opt/pb_sls.cpp @@ -403,10 +403,8 @@ namespace smt { } int new_break_count = flip(~lit); if (-break_count != new_break_count) { - verbose_stream() << lit << "\n"; - IF_VERBOSE(0, display(verbose_stream(), cls);); - display(verbose_stream()); - exit(0); + IF_VERBOSE(0, display(verbose_stream() << lit << "\n", cls); + display(verbose_stream())); } // VERIFY(-break_count == flip(~lit)); } diff --git a/src/opt/sortmax.cpp b/src/opt/sortmax.cpp index 1fafa12bd..df361f24a 100644 --- a/src/opt/sortmax.cpp +++ b/src/opt/sortmax.cpp @@ -39,9 +39,9 @@ namespace opt { sortmax(maxsat_context& c, weights_t& ws, expr_ref_vector const& soft): maxsmt_solver_base(c, ws, soft), m_sort(*this), m_trail(m), m_fresh(m) {} - virtual ~sortmax() {} + ~sortmax() override {} - lbool operator()() { + lbool operator()() override { obj_map soft; if (!init()) { return l_false; diff --git a/src/opt/wmax.cpp b/src/opt/wmax.cpp index e4eb7e06b..ee7f92a23 100644 --- a/src/opt/wmax.cpp +++ b/src/opt/wmax.cpp @@ -49,9 +49,9 @@ namespace opt { m_trail(m), m_defs(m) {} - virtual ~wmax() {} + ~wmax() override {} - lbool operator()() { + lbool operator()() override { TRACE("opt", tout << "weighted maxsat\n";); scoped_ensure_theory wth(*this); obj_map soft; diff --git a/src/parsers/smt2/marshal.cpp b/src/parsers/smt2/marshal.cpp index 11244760a..327414300 100644 --- a/src/parsers/smt2/marshal.cpp +++ b/src/parsers/smt2/marshal.cpp @@ -36,11 +36,12 @@ std::string marshal(expr_ref e, ast_manager &m) { expr_ref unmarshal(std::istream &is, ast_manager &m) { cmd_context ctx(false, &m); ctx.set_ignore_check(true); - if (!parse_smt2_commands(ctx, is)) { return expr_ref(nullptr, m); } + if (!parse_smt2_commands(ctx, is)) { + return expr_ref(nullptr, m); + } - ptr_vector::const_iterator it = ctx.begin_assertions(); - ptr_vector::const_iterator end = ctx.end_assertions(); - unsigned size = static_cast(end - it); + ptr_vector::const_iterator it = ctx.assertions().begin(); + unsigned size = ctx.assertions().size(); return expr_ref(mk_and(m, size, it), m); } diff --git a/src/parsers/smt2/smt2parser.cpp b/src/parsers/smt2/smt2parser.cpp index 403ea4c85..64f9c36fd 100644 --- a/src/parsers/smt2/smt2parser.cpp +++ b/src/parsers/smt2/smt2parser.cpp @@ -114,6 +114,7 @@ namespace smt2 { symbol m_define_fun_rec; symbol m_define_funs_rec; symbol m_match; + symbol m_case; symbol m_underscore; typedef std::pair named_expr; @@ -345,7 +346,8 @@ namespace smt2 { // consume garbage // return true if managed to recover from the error... bool sync_after_error() { - while (true) { + unsigned num_errors = 0; + while (num_errors < 100) { try { while (curr_is_rparen()) next(); @@ -373,8 +375,10 @@ namespace smt2 { catch (scanner_exception & ex) { SASSERT(ex.has_pos()); error(ex.line(), ex.pos(), ex.msg()); + ++num_errors; } } + return false; } void check_next(scanner::token t, char const * msg) { @@ -382,7 +386,9 @@ namespace smt2 { next(); return; } - throw parser_exception(msg); + std::ostringstream str; + str << msg << " got " << curr_id(); + throw parser_exception(str.str()); } symbol const & curr_id() const { return m_scanner.get_id(); } @@ -406,6 +412,7 @@ namespace smt2 { bool curr_id_is_underscore() const { SASSERT(curr_is_identifier()); return curr_id() == m_underscore; } bool curr_id_is_as() const { SASSERT(curr_is_identifier()); return curr_id() == m_as; } bool curr_id_is_match() const { SASSERT(curr_is_identifier()); return curr_id() == m_match; } + bool curr_id_is_case() const { return curr_id() == m_case; } bool curr_id_is_forall() const { SASSERT(curr_is_identifier()); return curr_id() == m_forall; } bool curr_id_is_exists() const { SASSERT(curr_is_identifier()); return curr_id() == m_exists; } bool curr_id_is_lambda() const { SASSERT(curr_is_identifier()); return curr_id() == m_lambda; } @@ -625,8 +632,6 @@ namespace smt2 { args.push_back(u); next(); } - if (args.empty()) - throw parser_exception("invalid indexed sort, index expected"); sort * r = d->instantiate(pm(), args.size(), args.c_ptr()); if (r == nullptr) throw parser_exception("invalid sort application"); @@ -1321,7 +1326,13 @@ namespace smt2 { /** * SMT-LIB 2.6 pattern matches are of the form - * (match t ((p1 t1) ... (pm+1 tm+1))) + * + * (match t ((p1 t1) ... (pm+1 tm+1))) + * + * precursor form is + * + * (match t (case p1 t1) (case p2 t2) ... ) + * */ void push_match_frame() { SASSERT(curr_is_identifier()); @@ -1338,21 +1349,42 @@ namespace smt2 { sort* srt = m().get_sort(t); check_lparen_next("pattern bindings should be enclosed in a parenthesis"); - while (!curr_is_rparen()) { - m_env.begin_scope(); - unsigned num_bindings = m_num_bindings; - check_lparen_next("invalid pattern binding, '(' expected"); - parse_match_pattern(srt); - patterns.push_back(expr_stack().back()); - expr_stack().pop_back(); - parse_expr(); - cases.push_back(expr_stack().back()); - expr_stack().pop_back(); - m_num_bindings = num_bindings; - m_env.end_scope(); - check_rparen_next("invalid pattern binding, ')' expected"); + if (curr_id_is_case()) { + while (curr_id_is_case()) { + next(); + m_env.begin_scope(); + unsigned num_bindings = m_num_bindings; + parse_match_pattern(srt); + patterns.push_back(expr_stack().back()); + expr_stack().pop_back(); + parse_expr(); + cases.push_back(expr_stack().back()); + expr_stack().pop_back(); + m_num_bindings = num_bindings; + m_env.end_scope(); + check_rparen_next("invalid pattern binding, ')' expected"); + if (curr_is_lparen()) { + next(); + } + } + } + else { + while (!curr_is_rparen()) { + m_env.begin_scope(); + unsigned num_bindings = m_num_bindings; + parse_match_pattern(srt); + patterns.push_back(expr_stack().back()); + expr_stack().pop_back(); + check_lparen_next("invalid pattern binding, '(' expected"); + parse_expr(); + cases.push_back(expr_stack().back()); + expr_stack().pop_back(); + m_num_bindings = num_bindings; + m_env.end_scope(); + check_rparen_next("invalid pattern binding, ')' expected"); + } + next(); } - next(); m_num_expr_frames = num_frames + 1; expr_stack().push_back(compile_patterns(t, patterns, cases)); } @@ -1410,6 +1442,12 @@ namespace smt2 { // compute match condition and substitution // t is shifted by size of subst. expr_ref bind_match(expr* t, expr* pattern, expr_ref_vector& subst) { + if (m().get_sort(t) != m().get_sort(pattern)) { + std::ostringstream str; + str << "sorts of pattern " << expr_ref(pattern, m()) << " and term " + << expr_ref(t, m()) << " are not aligned"; + throw parser_exception(str.str()); + } expr_ref tsh(m()); if (is_var(pattern)) { shifter()(t, 1, tsh); @@ -1520,11 +1558,22 @@ namespace smt2 { check_identifier("invalid indexed identifier, symbol expected"); symbol r = curr_id(); next(); - unsigned num_indices = 0; while (!curr_is_rparen()) { if (curr_is_int()) { - unsigned u = curr_unsigned(); - m_param_stack.push_back(parameter(u)); + if (!curr_numeral().is_unsigned()) { + m_param_stack.push_back(parameter(curr_numeral())); + } + else { + m_param_stack.push_back(parameter(curr_unsigned())); + } + next(); + } + else if (curr_is_float()) { + m_param_stack.push_back(parameter(curr_numeral())); + next(); + } + else if (curr_is_keyword()) { + m_param_stack.push_back(parameter(curr_id())); next(); } else if (curr_is_identifier() || curr_is_lparen()) { @@ -1533,10 +1582,7 @@ namespace smt2 { else { throw parser_exception("invalid indexed identifier, integer, identifier or '(' expected"); } - num_indices++; } - if (num_indices == 0) - throw parser_exception("invalid indexed identifier, index expected"); next(); return r; } @@ -1857,13 +1903,31 @@ namespace smt2 { unsigned num_args = expr_stack().size() - fr->m_expr_spos; unsigned num_indices = m_param_stack.size() - fr->m_param_spos; expr_ref t_ref(m()); - m_ctx.mk_app(fr->m_f, - num_args, - expr_stack().c_ptr() + fr->m_expr_spos, - num_indices, - m_param_stack.c_ptr() + fr->m_param_spos, - fr->m_as_sort ? sort_stack().back() : nullptr, - t_ref); + local l; + if (m_env.find(fr->m_f, l)) { + push_local(l); + t_ref = expr_stack().back(); + for (unsigned i = 0; i < num_args; ++i) { + expr* arg = expr_stack().get(fr->m_expr_spos + i); + expr* args[2] = { t_ref.get(), arg }; + m_ctx.mk_app(symbol("select"), + 2, + args, + 0, + nullptr, + nullptr, + t_ref); + } + } + else { + m_ctx.mk_app(fr->m_f, + num_args, + expr_stack().c_ptr() + fr->m_expr_spos, + num_indices, + m_param_stack.c_ptr() + fr->m_param_spos, + fr->m_as_sort ? sort_stack().back() : nullptr, + t_ref); + } expr_stack().shrink(fr->m_expr_spos); m_param_stack.shrink(fr->m_param_spos); if (fr->m_as_sort) @@ -1987,7 +2051,7 @@ namespace smt2 { if (expr_stack().size() == fr->m_expr_spos) { if (!ignore_bad_patterns()) throw parser_exception("invalid empty pattern"); - // ingoring empty pattern + // ignoring empty pattern expr_stack().shrink(fr->m_expr_spos); } else { @@ -2216,10 +2280,14 @@ namespace smt2 { parse_expr(); if (m().get_sort(expr_stack().back()) != sort_stack().back()) throw parser_exception("invalid function/constant definition, sort mismatch"); - if (is_fun) - m_ctx.insert(id, num_vars, sort_stack().c_ptr() + sort_spos, expr_stack().back()); - else - m_ctx.model_add(id, num_vars, sort_stack().c_ptr() + sort_spos, expr_stack().back()); + sort* const* sorts = sort_stack().c_ptr() + sort_spos; + expr* t = expr_stack().back(); + if (is_fun) { + m_ctx.insert(id, num_vars, sorts, t); + } + else { + m_ctx.model_add(id, num_vars, sorts, t); + } check_rparen("invalid function/constant definition, ')' expected"); // restore stacks & env symbol_stack().shrink(sym_spos); @@ -2311,7 +2379,7 @@ namespace smt2 { next(); } - void parse_rec_fun_decl(func_decl_ref& f, expr_ref_vector& bindings, svector& ids) { + recfun::promise_def parse_rec_fun_decl(func_decl_ref& f, expr_ref_vector& bindings, svector& ids) { SASSERT(m_num_bindings == 0); check_identifier("invalid function/constant definition, symbol expected"); symbol id = curr_id(); @@ -2322,7 +2390,8 @@ namespace smt2 { unsigned num_vars = parse_sorted_vars(); SASSERT(num_vars == m_num_bindings); parse_sort("Invalid recursive function definition"); - f = m().mk_func_decl(id, num_vars, sort_stack().c_ptr() + sort_spos, sort_stack().back()); + recfun::promise_def pdef = m_ctx.decl_rec_fun(id, num_vars, sort_stack().c_ptr() + sort_spos, sort_stack().back()); + f = pdef.get_def()->get_decl(); bindings.append(num_vars, expr_stack().c_ptr() + expr_spos); ids.append(num_vars, symbol_stack().c_ptr() + sym_spos); symbol_stack().shrink(sym_spos); @@ -2330,6 +2399,7 @@ namespace smt2 { expr_stack().shrink(expr_spos); m_env.end_scope(); m_num_bindings = 0; + return pdef; } void parse_rec_fun_bodies(func_decl_ref_vector const& decls, vector const& bindings, vector >const & ids) { @@ -2608,7 +2678,7 @@ namespace smt2 { check_rparen("invalid get-value command, ')' expected"); model_ref md; - if (!m_ctx.is_model_available(md) || m_ctx.get_check_sat_result() == 0) + if (!m_ctx.is_model_available(md) || m_ctx.get_check_sat_result() == nullptr) throw cmd_exception("model is not available"); if (index != 0) { m_ctx.get_opt()->get_box_model(md, index); @@ -2698,7 +2768,7 @@ namespace smt2 { next(); } unsigned spos = sort_stack().size(); - parse_sorts("Invalid function name. Expecting sort list startig with '(' to disambiguate function name"); + parse_sorts("Invalid function name. Expecting sort list starting with '(' to disambiguate function name"); unsigned domain_size = sort_stack().size() - spos; parse_sort("Invalid function name"); func_decl * d = m_ctx.find_func_decl(id, indices.size(), indices.c_ptr(), domain_size, sort_stack().c_ptr() + spos, sort_stack().back()); @@ -3005,6 +3075,7 @@ namespace smt2 { m_define_fun_rec("define-fun-rec"), m_define_funs_rec("define-funs-rec"), m_match("match"), + m_case("case"), m_underscore("_"), m_num_open_paren(0), m_current_file(filename) { @@ -3049,7 +3120,7 @@ namespace smt2 { bool operator()() { m_num_bindings = 0; - bool found_errors = false; + unsigned found_errors = 0; try { scan_core(); @@ -3058,7 +3129,7 @@ namespace smt2 { error(ex.msg()); if (!sync_after_error()) return false; - found_errors = true; + found_errors++; } while (true) { @@ -3070,7 +3141,7 @@ namespace smt2 { parse_cmd(); break; case scanner::EOF_TOKEN: - return !found_errors; + return found_errors == 0; default: throw parser_exception("invalid command, '(' expected"); break; @@ -3084,7 +3155,7 @@ namespace smt2 { << ": " << ex.msg() << "\")" << std::endl; exit(ex.error_code()); } - catch (stop_parser_exception) { + catch (const stop_parser_exception &) { m_scanner.stop_caching(); return !found_errors; } diff --git a/src/parsers/smt2/smt2scanner.cpp b/src/parsers/smt2/smt2scanner.cpp index 9a9e69b67..e1725dada 100644 --- a/src/parsers/smt2/smt2scanner.cpp +++ b/src/parsers/smt2/smt2scanner.cpp @@ -64,6 +64,26 @@ namespace smt2 { next(); } } + + void scanner::read_multiline_comment() { + SASSERT(curr() == '|'); + next(); + while (true) { + char c = curr(); + if (m_at_eof) + return; + if (c == '\n') { + new_line(); + next(); + continue; + } + next(); + if (c == '|' && curr() == '#') { + next(); + return; + } + } + } scanner::token scanner::read_quoted_symbol() { SASSERT(curr() == '|'); @@ -235,6 +255,10 @@ namespace smt2 { throw scanner_exception("invalid empty bit-vector literal", m_line, m_spos); return BV_TOKEN; } + else if ('|') { + read_multiline_comment(); + return NULL_TOKEN; + } else { throw scanner_exception("invalid bit-vector literal, expecting 'x' or 'b'", m_line, m_spos); } @@ -295,6 +319,8 @@ namespace smt2 { scanner::token scanner::scan() { while (true) { signed char c = curr(); + token t; + m_pos = m_spos; if (m_at_eof) @@ -329,7 +355,9 @@ namespace smt2 { case '0': return read_number(); case '#': - return read_bv_literal(); + t = read_bv_literal(); + if (t == NULL_TOKEN) break; + return t; case '-': if (m_smtlib2_compliant) return read_symbol(); diff --git a/src/parsers/smt2/smt2scanner.h b/src/parsers/smt2/smt2scanner.h index 5283c57cf..5fad416b0 100644 --- a/src/parsers/smt2/smt2scanner.h +++ b/src/parsers/smt2/smt2scanner.h @@ -92,6 +92,7 @@ namespace smt2 { token read_symbol(); token read_quoted_symbol(); void read_comment(); + void read_multiline_comment(); token read_number(); token read_signed_number(); token read_string(); diff --git a/src/parsers/util/simple_parser.cpp b/src/parsers/util/simple_parser.cpp index c9d00ebcc..48c42c240 100644 --- a/src/parsers/util/simple_parser.cpp +++ b/src/parsers/util/simple_parser.cpp @@ -118,7 +118,7 @@ bool simple_parser::parse(std::istream & in, expr_ref & result) { if (!result) throw parser_error(); } - catch (parser_error) { + catch (const parser_error &) { warning_msg("parser error"); return false; } diff --git a/src/qe/nlarith_util.cpp b/src/qe/nlarith_util.cpp index 12977b449..c2d95a1ee 100644 --- a/src/qe/nlarith_util.cpp +++ b/src/qe/nlarith_util.cpp @@ -684,7 +684,7 @@ namespace nlarith { void get_coefficients(poly const& p, app*& a, app*& b, app*& c) { a = b = c = z(); - if (p.size() > 0) c = p[0]; + if (!p.empty()) c = p[0]; if (p.size() > 1) b = p[1]; if (p.size() > 2) a = p[2]; SASSERT(p.size() <= 3); @@ -1359,7 +1359,7 @@ namespace nlarith { void quot_rem(poly const& u, poly const& v, poly& q, poly& r, app_ref& lc, unsigned& power) { lc = v.empty()?num(0):v[v.size()-1]; power = 0; - if (u.size() < v.size() || v.size() == 0) { + if (u.size() < v.size() || v.empty()) { q.reset(); r.reset(); r.append(u); diff --git a/src/qe/qe.h b/src/qe/qe.h index 1027f0b61..1eb7b7e4a 100644 --- a/src/qe/qe.h +++ b/src/qe/qe.h @@ -253,7 +253,7 @@ namespace qe { /** \brief Guarded definitions. - A realizer to a an existential quantified formula is a disjunction + A realizer to an existential quantified formula is a disjunction together with a substitution from the existentially quantified variables to terms such that: 1. The original formula (exists (vars) fml) is equivalent to the disjunction of guards. diff --git a/src/qe/qe_arith.cpp b/src/qe/qe_arith.cpp index cd81167e3..a0aea08da 100644 --- a/src/qe/qe_arith.cpp +++ b/src/qe/qe_arith.cpp @@ -387,7 +387,7 @@ namespace qe { for (row const& r : rows) { expr_ref_vector ts(m); expr_ref t(m), s(m), val(m); - if (r.m_vars.size() == 0) { + if (r.m_vars.empty()) { continue; } if (r.m_vars.size() == 1 && r.m_vars[0].m_coeff.is_neg() && r.m_type != opt::t_mod) { diff --git a/src/qe/qe_arith_plugin.cpp b/src/qe/qe_arith_plugin.cpp index f8c519285..a09c4046e 100644 --- a/src/qe/qe_arith_plugin.cpp +++ b/src/qe/qe_arith_plugin.cpp @@ -316,7 +316,7 @@ namespace qe { void mk_bound_aux(rational const& a, expr* t, rational const& b, expr* s, expr_ref& result) { SASSERT(a.is_neg() == b.is_neg()); expr_ref tt(t, m), ss(s, m), e(m); - // hack to fix wierd gcc compilation error + // hack to fix weird gcc compilation error rational abs_a(a); rational abs_b(b); if (abs_a.is_neg()) abs_a.neg(); diff --git a/src/qe/qe_datatype_plugin.cpp b/src/qe/qe_datatype_plugin.cpp index 81a402ba4..25332d164 100644 --- a/src/qe/qe_datatype_plugin.cpp +++ b/src/qe/qe_datatype_plugin.cpp @@ -46,7 +46,7 @@ Copyright (c) 2015 Microsoft Corporation // -> \/_i R_C(t_i) & phi[t_i/x] \/ phi[false, true] // // Justification: -// - We will asume that each of t_i, s_j are constructor terms. +// - We will assume that each of t_i, s_j are constructor terms. // - We can assume that x \notin t_i, x \notin s_j, or otherwise use simplification. // - We can assume that x occurs only in equalities or disequalities, or the recognizer, since // otherwise, we could simplify equalities, or QE does not apply. diff --git a/src/qe/qe_datatypes.cpp b/src/qe/qe_datatypes.cpp index 5499d638d..4109d7fd9 100644 --- a/src/qe/qe_datatypes.cpp +++ b/src/qe/qe_datatypes.cpp @@ -61,7 +61,7 @@ namespace qe { project_nonrec(model, vars, lits); } } - catch (cant_project) { + catch (const cant_project &) { TRACE("qe", tout << "can't project:" << mk_pp(var, m) << "\n";); return false; } @@ -77,6 +77,7 @@ namespace qe { ptr_vector const& acc = *dt.get_constructor_accessors(f); for (unsigned i = 0; i < acc.size(); ++i) { arg = m.mk_fresh_const(acc[i]->get_name().str().c_str(), acc[i]->get_range()); + vars.push_back(arg); model.register_decl(arg->get_decl(), m_val->get_arg(i)); args.push_back(arg); } diff --git a/src/qe/qe_lite.cpp b/src/qe/qe_lite.cpp index da45d17ca..4585c88c1 100644 --- a/src/qe/qe_lite.cpp +++ b/src/qe/qe_lite.cpp @@ -394,7 +394,7 @@ namespace eq { expr* const* args = &e; if (is_lambda(q)) { r = q; - pr = 0; + pr = nullptr; return; } flatten_args(q, num_args, args); @@ -1816,7 +1816,7 @@ namespace fm { } // An integer variable x may be eliminated, if - // 1- All variables in the contraints it occur are integer. + // 1- All variables in the constraints it occur are integer. // 2- The coefficient of x in all lower bounds (or all upper bounds) is unit. bool can_eliminate(var x) const { if (!is_int(x)) @@ -2370,6 +2370,7 @@ void qe_lite::operator()(uint_set const& index_set, bool index_of_bound, expr_re (*m_impl)(index_set, index_of_bound, fmls); } +namespace { class qe_lite_tactic : public tactic { struct imp { @@ -2494,7 +2495,6 @@ public: (*m_imp)(in, result); } - void collect_statistics(statistics & st) const override { // m_imp->collect_statistics(st); } @@ -2503,14 +2503,14 @@ public: // m_imp->reset_statistics(); } - void cleanup() override { ast_manager & m = m_imp->m; - dealloc(m_imp); - m_imp = alloc(imp, m, m_params); + m_imp->~imp(); + m_imp = new (m_imp) imp(m, m_params); } }; +} tactic * mk_qe_lite_tactic(ast_manager & m, params_ref const & p) { return alloc(qe_lite_tactic, m, p); diff --git a/src/qe/qe_lite.h b/src/qe/qe_lite.h index 63ad8bedd..3251fa3f8 100644 --- a/src/qe/qe_lite.h +++ b/src/qe/qe_lite.h @@ -18,8 +18,7 @@ Revision History: --*/ -#ifndef QE_LITE_H_ -#define QE_LITE_H_ +#pragma once #include "ast/ast.h" #include "util/uint_set.h" @@ -67,5 +66,3 @@ tactic * mk_qe_lite_tactic(ast_manager & m, params_ref const & p = params_ref()) /* ADD_TACTIC("qe-light", "apply light-weight quantifier elimination.", "mk_qe_lite_tactic(m, p)") */ - -#endif diff --git a/src/qe/qe_mbi.cpp b/src/qe/qe_mbi.cpp index b7f0d0d49..b7de8d302 100644 --- a/src/qe/qe_mbi.cpp +++ b/src/qe/qe_mbi.cpp @@ -30,6 +30,7 @@ Notes: #include "ast/ast_util.h" #include "ast/for_each_expr.h" +#include "ast/rewriter/expr_safe_replace.h" #include "ast/rewriter/bool_rewriter.h" #include "ast/arith_decl_plugin.h" #include "model/model_evaluator.h" @@ -95,101 +96,6 @@ namespace qe { m_solver->assert_expr(mk_not(mk_and(lits))); } - // ------------------------------- - // euf_mbi - - struct euf_mbi_plugin::is_atom_proc { - ast_manager& m; - expr_ref_vector& m_atoms; - is_atom_proc(expr_ref_vector& atoms): m(atoms.m()), m_atoms(atoms) {} - void operator()(app* a) { - if (m.is_eq(a)) { - m_atoms.push_back(a); - } - else if (m.is_bool(a) && a->get_family_id() != m.get_basic_family_id()) { - m_atoms.push_back(a); - } - } - void operator()(expr*) {} - }; - - euf_mbi_plugin::euf_mbi_plugin(solver* s, solver* sNot): - mbi_plugin(s->get_manager()), - m_atoms(m), - m_solver(s), - m_dual_solver(sNot) { - params_ref p; - p.set_bool("core.minimize", true); - m_solver->updt_params(p); - m_dual_solver->updt_params(p); - expr_ref_vector fmls(m); - m_solver->get_assertions(fmls); - expr_fast_mark1 marks; - is_atom_proc proc(m_atoms); - for (expr* e : fmls) { - quick_for_each_expr(proc, marks, e); - } - } - - mbi_result euf_mbi_plugin::operator()(expr_ref_vector& lits, model_ref& mdl) { - lbool r = m_solver->check_sat(lits); - switch (r) { - case l_false: - lits.reset(); - m_solver->get_unsat_core(lits); - // optionally minimize core using superposition. - return mbi_unsat; - case l_true: { - m_solver->get_model(mdl); - model_evaluator mev(*mdl.get()); - lits.reset(); - for (expr* e : m_atoms) { - if (mev.is_true(e)) { - lits.push_back(e); - } - else if (mev.is_false(e)) { - lits.push_back(m.mk_not(e)); - } - } - TRACE("qe", tout << "atoms from model: " << lits << "\n";); - r = m_dual_solver->check_sat(lits); - expr_ref_vector core(m); - term_graph tg(m); - switch (r) { - case l_false: - // use the dual solver to find a 'small' implicant - m_dual_solver->get_unsat_core(core); - TRACE("qe", tout << "core: " << core << "\n";); - // project the implicant onto vars - tg.set_vars(m_shared, false); - tg.add_lits(core); - lits.reset(); - lits.append(tg.project(*mdl)); - TRACE("qe", tout << "project: " << lits << "\n";); - return mbi_sat; - case l_undef: - return mbi_undef; - case l_true: - UNREACHABLE(); - return mbi_undef; - } - return mbi_sat; - } - default: - // TBD: if not running solver to completion, then: - // 1. extract unit literals from m_solver. - // 2. run a cc over the units - // 3. extract equalities or other assignments over the congruence classes - // 4. ensure that at least some progress is made over original lits. - return mbi_undef; - } - } - - void euf_mbi_plugin::block(expr_ref_vector const& lits) { - m_solver->assert_expr(mk_not(mk_and(lits))); - } - - // ------------------------------- // euf_arith_mbi @@ -219,29 +125,50 @@ namespace qe { struct euf_arith_mbi_plugin::is_arith_var_proc { ast_manager& m; - app_ref_vector& m_pvars; - app_ref_vector& m_svars; + app_ref_vector& m_avars; arith_util arith; - obj_hashtable m_shared; - is_arith_var_proc(func_decl_ref_vector const& shared, app_ref_vector& pvars, app_ref_vector& svars): - m(pvars.m()), m_pvars(pvars), m_svars(svars), arith(m) { - for (func_decl* f : shared) m_shared.insert(f); + obj_hashtable m_seen; + is_arith_var_proc(app_ref_vector& avars): + m(avars.m()), m_avars(avars), arith(m) { } void operator()(app* a) { - if (!arith.is_int_real(a) || a->get_family_id() == arith.get_family_id()) { + if (is_arith_op(a) || a->get_family_id() == m.get_basic_family_id()) { // no-op } - else if (m_shared.contains(a->get_decl())) { - m_svars.push_back(a); + else if (!arith.is_int_real(a)) { + for (expr* arg : *a) { + if (is_app(arg) && !m_seen.contains(arg) && is_arith_op(to_app(arg))) { + m_avars.push_back(to_app(arg)); + m_seen.insert(arg); + } + } } - else { - m_pvars.push_back(a); + else if (!m_seen.contains(a)) { + m_seen.insert(a); + m_avars.push_back(a); } } + bool is_arith_op(app* a) { + return a->get_family_id() == arith.get_family_id(); + } void operator()(expr*) {} - }; + void euf_arith_mbi_plugin::filter_private_arith(app_ref_vector& avars) { + arith_util a(m); + unsigned j = 0; + obj_hashtable shared; + for (func_decl* f : m_shared) shared.insert(f); + for (unsigned i = 0; i < avars.size(); ++i) { + app* v = avars.get(i); + if (!shared.contains(v->get_decl()) && + v->get_family_id() != a.get_family_id()) { + avars[j++] = v; + } + } + avars.shrink(j); + } + euf_arith_mbi_plugin::euf_arith_mbi_plugin(solver* s, solver* sNot): mbi_plugin(s->get_manager()), m_atoms(m), @@ -290,28 +217,15 @@ namespace qe { } } + + /** + * \brief extract arithmetical variables and arithmetical terms in shared positions. + */ app_ref_vector euf_arith_mbi_plugin::get_arith_vars(model_ref& mdl, expr_ref_vector& lits) { - arith_util a(m); - app_ref_vector pvars(m), svars(m); // private and shared arithmetic variables. - is_arith_var_proc _proc(m_shared, pvars, svars); + app_ref_vector avars(m); + is_arith_var_proc _proc(avars); for_each_expr(_proc, lits); - rational v1, v2; - for (expr* p : pvars) { - VERIFY(a.is_numeral((*mdl)(p), v1)); - for (expr* s : svars) { - VERIFY(a.is_numeral((*mdl)(s), v2)); - if (v1 < v2) { - lits.push_back(a.mk_lt(p, s)); - } - else if (v2 < v1) { - lits.push_back(a.mk_lt(s, p)); - } - else { - lits.push_back(m.mk_eq(s, p)); - } - } - } - return pvars; + return avars; } mbi_result euf_arith_mbi_plugin::operator()(expr_ref_vector& lits, model_ref& mdl) { @@ -324,93 +238,13 @@ namespace qe { TRACE("qe", tout << "unsat core: " << lits << "\n";); // optionally minimize core using superposition. return mbi_unsat; - case l_true: { + case l_true: m_solver->get_model(mdl); if (!get_literals(mdl, lits)) { return mbi_undef; } - TRACE("qe", tout << lits << "\n";); - - // 1. Extract projected variables, add inequalities between - // projected variables and non-projected terms according to model. - // 2. Extract disequalities implied by congruence closure. - // 3. project arithmetic variables from pure literals. - // 4. Add projected definitions as equalities to EUF. - // 5. project remaining literals with respect to EUF. - - app_ref_vector avars = get_arith_vars(mdl, lits); - TRACE("qe", tout << "vars: " << avars << " lits: " << lits << "\n";); - - // 2. - term_graph tg1(m); - func_decl_ref_vector no_shared(m); - tg1.set_vars(no_shared, false); - tg1.add_lits(lits); - arith_util a(m); - expr_ref_vector foreign = tg1.shared_occurrences(a.get_family_id()); - obj_hashtable _foreign; - for (expr* e : foreign) _foreign.insert(e); - vector partition = tg1.get_partition(*mdl); - expr_ref_vector diseq = tg1.get_ackerman_disequalities(); - lits.append(diseq); - TRACE("qe", tout << "diseq: " << diseq << "\n"; - tout << "foreign: " << foreign << "\n"; - for (auto const& v : partition) { - tout << "partition: {"; - bool first = true; - for (expr* e : v) { - if (first) first = false; else tout << ", "; - tout << expr_ref(e, m); - } - tout << "}\n"; - } - ); - vector refined_partition; - for (auto & p : partition) { - unsigned j = 0; - for (expr* e : p) { - if (_foreign.contains(e) || - (is_app(e) && m_shared.contains(to_app(e)->get_decl()))) { - p[j++] = e; - } - } - p.shrink(j); - if (!p.empty()) refined_partition.push_back(p); - } - TRACE("qe", - for (auto const& v : refined_partition) { - tout << "partition: {"; - bool first = true; - for (expr* e : v) { - if (first) first = false; else tout << ", "; - tout << expr_ref(e, m); - } - tout << "}\n"; - }); - - - - arith_project_plugin ap(m); - ap.set_check_purified(false); - - // 3. - auto defs = ap.project(*mdl.get(), avars, lits); - - // 4. - for (auto const& def : defs) { - lits.push_back(m.mk_eq(def.var, def.term)); - } - TRACE("qe", tout << "# arith defs " << defs.size() << " avars: " << avars << " " << lits << "\n";); - - // 5. - term_graph tg2(m); - tg2.set_vars(m_shared, false); - tg2.add_lits(lits); - lits.reset(); - lits.append(tg2.project()); - TRACE("qe", tout << "project: " << lits << "\n";); + project(mdl, lits); return mbi_sat; - } default: // TBD: if not running solver to completion, then: // 1. extract unit literals from m_solver. @@ -421,6 +255,103 @@ namespace qe { } } + void euf_arith_mbi_plugin::project(model_ref& mdl, expr_ref_vector& lits) { + TRACE("qe", tout << lits << "\n" << *mdl << "\n";); + + // 1. arithmetical variables - atomic and in purified positions + app_ref_vector avars = get_arith_vars(mdl, lits); + TRACE("qe", tout << "vars: " << avars << "\nlits: " << lits << "\n";); + + // 2. project private non-arithmetical variables from lits + project_euf(mdl, lits, avars); + + // 3. Order arithmetical variables and purified positions + order_avars(mdl, lits, avars); + TRACE("qe", tout << "ordered: " << lits << "\n";); + + // 4. Perform arithmetical projection + arith_project_plugin ap(m); + ap.set_check_purified(false); + auto defs = ap.project(*mdl.get(), avars, lits); + TRACE("qe", tout << "aproject: " << lits << "\n";); + + // 5. Substitute solution into lits + substitute(defs, lits); + TRACE("qe", tout << "substitute: " << lits << "\n";); + } + + /** + * \brief substitute solution to arithmetical variables into lits + */ + void euf_arith_mbi_plugin::substitute(vector const& defs, expr_ref_vector& lits) { + for (auto const& def : defs) { + expr_safe_replace rep(m); + rep.insert(def.var, def.term); + rep(lits); + } + } + + /** + * \brief project non-arithmetical private symbols. + */ + void euf_arith_mbi_plugin::project_euf(model_ref& mdl, expr_ref_vector& lits, app_ref_vector& avars) { + term_graph tg(m); + func_decl_ref_vector shared(m_shared); + for (app* a : avars) shared.push_back(a->get_decl()); + tg.set_vars(shared, false); + tg.add_lits(lits); + lits.reset(); + lits.append(tg.project(*mdl.get())); + TRACE("qe", tout << "project: " << lits << "\n";); + } + + /** + * \brief Order arithmetical variables: + * 1. add literals that order the variable according to the model. + * 2. remove non-atomic arithmetical terms from projection. + * 2. sort arithmetical terms, such that deepest terms are first. + */ + void euf_arith_mbi_plugin::order_avars(model_ref& mdl, expr_ref_vector& lits, app_ref_vector& avars) { + arith_util a(m); + model_evaluator mev(*mdl.get()); + vector> vals; + for (app* v : avars) { + rational val; + expr_ref tmp = mev(v); + VERIFY(a.is_numeral(tmp, val)); + vals.push_back(std::make_pair(val, v)); + } + struct compare_first { + bool operator()(std::pair const& x, + std::pair const& y) const { + return x.first < y.first; + } + }; + // add linear order between avars + compare_first cmp; + std::sort(vals.begin(), vals.end(), cmp); + for (unsigned i = 1; i < vals.size(); ++i) { + if (vals[i-1].first == vals[i].first) { + lits.push_back(m.mk_eq(vals[i-1].second, vals[i].second)); + } + else { + lits.push_back(a.mk_lt(vals[i-1].second, vals[i].second)); + } + } + // filter out only private variables + filter_private_arith(avars); + + // sort avars based on depth + struct compare_depth { + bool operator()(app* x, app* y) const { + return x->get_depth() > y->get_depth(); + } + }; + compare_depth cmpd; + std::sort(avars.c_ptr(), avars.c_ptr() + avars.size(), cmpd); + TRACE("qe", tout << lits << "\navars:" << avars << "\n" << *mdl << "\n";); + } + void euf_arith_mbi_plugin::block(expr_ref_vector const& lits) { collect_atoms(lits); m_fmls.push_back(mk_not(mk_and(lits))); diff --git a/src/qe/qe_mbi.h b/src/qe/qe_mbi.h index fdc4c3c6a..23294ee6e 100644 --- a/src/qe/qe_mbi.h +++ b/src/qe/qe_mbi.h @@ -20,6 +20,8 @@ Revision History: #pragma once +#include "qe/qe_arith.h" + namespace qe { enum mbi_result { mbi_sat, @@ -47,7 +49,7 @@ namespace qe { /** * \brief Utility that works modulo a background state. * - vars - * variables to preferrably project onto (other variables would require quantification to fit interpolation signature) + * variables to preferably project onto (other variables would require quantification to fit interpolation signature) * - lits * set of literals to check satisfiability with respect to. * - mdl @@ -91,17 +93,6 @@ namespace qe { void block(expr_ref_vector const& lits) override; }; - class euf_mbi_plugin : public mbi_plugin { - expr_ref_vector m_atoms; - solver_ref m_solver; - solver_ref m_dual_solver; - struct is_atom_proc; - public: - euf_mbi_plugin(solver* s, solver* sNot); - ~euf_mbi_plugin() override {} - mbi_result operator()(expr_ref_vector& lits, model_ref& mdl) override; - void block(expr_ref_vector const& lits) override; - }; class euf_arith_mbi_plugin : public mbi_plugin { expr_ref_vector m_atoms; @@ -115,6 +106,11 @@ namespace qe { app_ref_vector get_arith_vars(model_ref& mdl, expr_ref_vector& lits); bool get_literals(model_ref& mdl, expr_ref_vector& lits); void collect_atoms(expr_ref_vector const& fmls); + void project(model_ref& mdl, expr_ref_vector& lits); + void project_euf(model_ref& mdl, expr_ref_vector& lits, app_ref_vector& avars); + void order_avars(model_ref& mdl, expr_ref_vector& lits, app_ref_vector& avars); + void substitute(vector const& defs, expr_ref_vector& lits); + void filter_private_arith(app_ref_vector& avars); public: euf_arith_mbi_plugin(solver* s, solver* emptySolver); ~euf_arith_mbi_plugin() override {} diff --git a/src/qe/qe_solve_plugin.cpp b/src/qe/qe_solve_plugin.cpp index 6ec840de1..dae1faf6f 100644 --- a/src/qe/qe_solve_plugin.cpp +++ b/src/qe/qe_solve_plugin.cpp @@ -156,7 +156,7 @@ namespace qe { std::swap(e1, e2); } // y + -1*x == 0 --> y = x - expr *a0 = 0, *a1 = 0, *x = 0; + expr *a0 = nullptr, *a1 = nullptr, *x = nullptr; if (a.is_zero(e2) && a.is_add(e1, a0, a1)) { if (a.is_times_minus_one(a1, x)) { e1 = a0; diff --git a/src/qe/qe_term_graph.cpp b/src/qe/qe_term_graph.cpp index faa9cfed8..274c25293 100644 --- a/src/qe/qe_term_graph.cpp +++ b/src/qe/qe_term_graph.cpp @@ -62,7 +62,7 @@ namespace qe { is_pure_ns::proc v(is_var); quick_for_each_expr(v, e); } - catch (is_pure_ns::found) { + catch (const is_pure_ns::found &) { return false; } return true; @@ -669,7 +669,7 @@ namespace qe { // Here we could also walk equivalence classes that // contain interpreted values by sort and extract - // disequalities bewteen non-unique value + // disequalities between non-unique value // representatives. these disequalities are implied // and can be mined using other means, such as theory // aware core minimization @@ -774,11 +774,13 @@ namespace qe { TRACE("qe", tout << "literals: " << res << "\n";); } - void mk_distinct(expr_ref_vector& res) { - vector> decl2terms; // terms that use function f - ptr_vector decls; - decl2terms.reset(); + vector> m_decl2terms; // terms that use function f + ptr_vector m_decls; + + void collect_decl2terms() { // Collect the projected function symbols. + m_decl2terms.reset(); + m_decls.reset(); for (term *t : m_tg.m_terms) { expr* e = t->get_expr(); if (!is_app(e)) continue; @@ -787,38 +789,61 @@ namespace qe { func_decl* d = a->get_decl(); if (d->get_arity() == 0) continue; unsigned id = d->get_decl_id(); - decl2terms.reserve(id+1); - if (decl2terms[id].empty()) decls.push_back(d); - decl2terms[id].push_back(t); + m_decl2terms.reserve(id+1); + if (m_decl2terms[id].empty()) m_decls.push_back(d); + m_decl2terms[id].push_back(t); } - + } + + void args_are_distinct(expr_ref_vector& res) { // // for each projected function that occurs // (may occur) in multiple congruence classes, // produce assertions that non-congruent arguments - // are forced distinct. + // are distinct. // - for (func_decl* d : decls) { + for (func_decl* d : m_decls) { unsigned id = d->get_decl_id(); - ptr_vector const& terms = decl2terms[id]; + ptr_vector const& terms = m_decl2terms[id]; if (terms.size() <= 1) continue; unsigned arity = d->get_arity(); for (unsigned i = 0; i < arity; ++i) { - obj_hashtable roots; + obj_hashtable roots, root_vals; + expr_ref_vector pinned(m); for (term* t : terms) { expr* arg = to_app(t->get_expr())->get_arg(i); term const& root = m_tg.get_term(arg)->get_root(); - roots.insert(root.get_expr()); + expr* r = root.get_expr(); + // if a model is given, then use the equivalence class induced + // by the model. Otherwise, use the congruence class. + if (m_model) { + expr_ref tmp(m); + tmp = (*m_model)(r); + if (!root_vals.contains(tmp)) { + root_vals.insert(tmp); + roots.insert(r); + pinned.push_back(tmp); + } + } + else { + roots.insert(r); + } } if (roots.size() > 1) { ptr_buffer args; for (expr* r : roots) { args.push_back(r); } + TRACE("qe", tout << "function: " << d->get_name() << "\n";); res.push_back(m.mk_distinct(args.size(), args.c_ptr())); } } } + } + + void mk_distinct(expr_ref_vector& res) { + collect_decl2terms(); + args_are_distinct(res); TRACE("qe", tout << res << "\n";); } @@ -965,6 +990,7 @@ namespace qe { m_pinned.reset(); m_model.reset(); } + expr_ref_vector project() { expr_ref_vector res(m); purify(); diff --git a/src/qe/qsat.cpp b/src/qe/qsat.cpp index c87b1c2eb..d1816d807 100644 --- a/src/qe/qsat.cpp +++ b/src/qe/qsat.cpp @@ -549,9 +549,15 @@ namespace qe { solver& s() { return *m_solver; } solver const& s() const { return *m_solver; } - void reset() { + void init() { m_solver = mk_smt_solver(m, m_params, symbol::null); } + void reset_statistics() { + init(); + } + void clear() { + m_solver = nullptr; + } void assert_expr(expr* e) { m_solver->assert_expr(e); } @@ -696,7 +702,7 @@ namespace qe { m_level -= num_scopes; } - void reset() override { + void clear() { m_st.reset(); m_fa.s().collect_statistics(m_st); m_ex.s().collect_statistics(m_st); @@ -707,9 +713,15 @@ namespace qe { m_pred_abs.reset(); m_vars.reset(); m_model = nullptr; - m_fa.reset(); - m_ex.reset(); m_free_vars.reset(); + m_fa.clear(); + m_ex.clear(); + } + + void reset() override { + clear(); + m_fa.init(); + m_ex.init(); } /** @@ -1198,7 +1210,7 @@ namespace qe { } ~qsat() override { - reset(); + clear(); } void updt_params(params_ref const & p) override { @@ -1266,9 +1278,9 @@ namespace qe { in->reset(); in->inc_depth(); result.push_back(in.get()); - if (in->models_enabled()) { + if (in->models_enabled()) { model_converter_ref mc; - mc = model2model_converter(m_model.get()); + mc = model2model_converter(m_model_save.get()); mc = concat(m_pred_abs.fmc(), mc.get()); in->add(mc.get()); } @@ -1294,8 +1306,8 @@ namespace qe { void reset_statistics() override { m_stats.reset(); - m_fa.reset(); - m_ex.reset(); + m_fa.reset_statistics(); + m_ex.reset_statistics(); } void cleanup() override { diff --git a/src/sat/ba_solver.cpp b/src/sat/ba_solver.cpp index de6635d09..b1502d98e 100644 --- a/src/sat/ba_solver.cpp +++ b/src/sat/ba_solver.cpp @@ -49,6 +49,11 @@ namespace sat { return static_cast(*this); } + ba_solver::pb_base const& ba_solver::constraint::to_pb_base() const{ + SASSERT(is_pb() || is_card()); + return static_cast(*this); + } + ba_solver::xr& ba_solver::constraint::to_xr() { SASSERT(is_xr()); return static_cast(*this); @@ -59,6 +64,13 @@ namespace sat { return static_cast(*this); } + unsigned ba_solver::constraint::fold_max_var(unsigned w) const { + if (lit() != null_literal) w = std::max(w, lit().var()); + for (unsigned i = 0; i < size(); ++i) w = std::max(w, get_lit(i).var()); + return w; + } + + std::ostream& operator<<(std::ostream& out, ba_solver::constraint const& cnstr) { if (cnstr.lit() != null_literal) out << cnstr.lit() << " == "; switch (cnstr.tag()) { @@ -664,7 +676,6 @@ namespace sat { verbose_stream() << "alit: " << alit << "\n"; verbose_stream() << "num watch " << num_watch << "\n"); UNREACHABLE(); - exit(0); return l_undef; } @@ -1009,27 +1020,13 @@ namespace sat { // --------------------------- // conflict resolution - void ba_solver::normalize_active_coeffs() { - reset_active_var_set(); - unsigned i = 0, j = 0, sz = m_active_vars.size(); - for (; i < sz; ++i) { - bool_var v = m_active_vars[i]; - if (!m_active_var_set.contains(v) && get_coeff(v) != 0) { - m_active_var_set.insert(v); - if (j != i) { - m_active_vars[j] = m_active_vars[i]; - } - ++j; - } - } - m_active_vars.shrink(j); - } void ba_solver::inc_coeff(literal l, unsigned offset) { SASSERT(offset > 0); bool_var v = l.var(); SASSERT(v != null_bool_var); m_coeffs.reserve(v + 1, 0); + TRACE("ba_verbose", tout << l << " " << offset << "\n";); int64_t coeff0 = m_coeffs[v]; if (coeff0 == 0) { @@ -1066,59 +1063,114 @@ namespace sat { return m_coeffs.get(v, 0); } + uint64_t ba_solver::get_coeff(literal lit) const { + int64_t c1 = get_coeff(lit.var()); + SASSERT(c1 < 0 == lit.sign()); + int64_t c = std::abs(c1); + m_overflow |= (c != c1); + return static_cast(c); + } + + ba_solver::wliteral ba_solver::get_wliteral(bool_var v) { + int64_t c1 = get_coeff(v); + literal l = literal(v, c1 < 0); + c1 = std::abs(c1); + unsigned c = static_cast(c1); + // TRACE("ba", tout << l << " " << c << "\n";); + m_overflow |= c != c1; + return wliteral(c, l); + } + unsigned ba_solver::get_abs_coeff(bool_var v) const { - int64_t c = get_coeff(v); - if (c < INT_MIN+1 || c > UINT_MAX) { - m_overflow = true; - return UINT_MAX; - } - return static_cast(std::abs(c)); + int64_t c1 = std::abs(get_coeff(v)); + unsigned c = static_cast(c1); + m_overflow |= c != c1; + return c; } int ba_solver::get_int_coeff(bool_var v) const { - int64_t c = m_coeffs.get(v, 0); - if (c < INT_MIN || c > INT_MAX) { - m_overflow = true; - return 0; - } - return static_cast(c); + int64_t c1 = m_coeffs.get(v, 0); + int c = static_cast(c1); + m_overflow |= c != c1; + return c; } void ba_solver::inc_bound(int64_t i) { - if (i < INT_MIN || i > INT_MAX) { - m_overflow = true; - return; - } int64_t new_bound = m_bound; new_bound += i; - if (new_bound < 0) { - m_overflow = true; - } - else if (new_bound > UINT_MAX) { - m_overflow = true; - } - else { - m_bound = static_cast(new_bound); - } + unsigned nb = static_cast(new_bound); + m_overflow |= new_bound < 0 || nb != new_bound; + m_bound = nb; } void ba_solver::reset_coeffs() { - for (unsigned i = 0; i < m_active_vars.size(); ++i) { + for (unsigned i = m_active_vars.size(); i-- > 0; ) { m_coeffs[m_active_vars[i]] = 0; } m_active_vars.reset(); } + void ba_solver::init_visited() { + m_visited_ts++; + if (m_visited_ts == 0) { + m_visited_ts = 1; + m_visited.reset(); + } + while (m_visited.size() < 2*s().num_vars()) { + m_visited.push_back(0); + } + } + static bool _debug_conflict = false; static literal _debug_consequent = null_literal; static unsigned_vector _debug_var2position; // #define DEBUG_CODE(_x_) _x_ - lbool ba_solver::resolve_conflict() { + void ba_solver::bail_resolve_conflict(unsigned idx) { + literal_vector const& lits = s().m_trail; + while (m_num_marks > 0) { + bool_var v = lits[idx].var(); + if (s().is_marked(v)) { + s().reset_mark(v); + --m_num_marks; + } + if (idx == 0 && !_debug_conflict) { + _debug_conflict = true; + _debug_var2position.reserve(s().num_vars()); + for (unsigned i = 0; i < lits.size(); ++i) { + _debug_var2position[lits[i].var()] = i; + } + IF_VERBOSE(0, + active2pb(m_A); + uint64_t c = 0; + for (wliteral l : m_A.m_wlits) c += l.first; + verbose_stream() << "sum of coefficients: " << c << "\n"; + display(verbose_stream(), m_A, true); + verbose_stream() << "conflicting literal: " << s().m_not_l << "\n";); + + for (literal l : lits) { + if (s().is_marked(l.var())) { + IF_VERBOSE(0, verbose_stream() << "missing mark: " << l << "\n";); + s().reset_mark(l.var()); + } + } + m_num_marks = 0; + resolve_conflict(); + } + --idx; + } + } + + lbool ba_solver::resolve_conflict() { if (0 == m_num_propagations_since_pop) { return l_undef; } + + if (s().m_config.m_pb_resolve == PB_ROUNDING) { + return resolve_conflict_rs(); + } + m_overflow = false; reset_coeffs(); m_num_marks = 0; @@ -1127,6 +1179,9 @@ namespace sat { justification js = s().m_conflict; TRACE("ba", tout << consequent << " " << js << "\n";); m_conflict_lvl = s().get_max_lvl(consequent, js); + if (m_conflict_lvl == 0) { + return l_undef; + } if (consequent != null_literal) { consequent.neg(); process_antecedent(consequent, 1); @@ -1256,7 +1311,6 @@ namespace sat { process_next_resolvent: // find the next marked variable in the assignment stack - // bool_var v; while (true) { consequent = lits[idx]; @@ -1290,77 +1344,354 @@ namespace sat { DEBUG_CODE(for (bool_var i = 0; i < static_cast(s().num_vars()); ++i) SASSERT(!s().is_marked(i));); SASSERT(validate_lemma()); - normalize_active_coeffs(); - if (!create_asserting_lemma()) { goto bail_out; } + active2lemma(); + DEBUG_CODE(VERIFY(validate_conflict(m_lemma, m_A));); - TRACE("ba", tout << m_lemma << "\n";); - - if (get_config().m_drat) { - svector ps; // TBD fill in - drat_add(m_lemma, ps); - } - - s().m_lemma.reset(); - s().m_lemma.append(m_lemma); - for (unsigned i = 1; i < m_lemma.size(); ++i) { - CTRACE("ba", s().is_marked(m_lemma[i].var()), tout << "marked: " << m_lemma[i] << "\n";); - s().mark(m_lemma[i].var()); - } - return l_true; bail_out: + if (m_overflow) { + ++m_stats.m_num_overflow; + m_overflow = false; + } + bail_resolve_conflict(idx); + return l_undef; + } - m_overflow = false; + unsigned ba_solver::ineq::bv_coeff(bool_var v) const { + for (unsigned i = size(); i-- > 0; ) { + if (lit(i).var() == v) return coeff(i); + } + UNREACHABLE(); + return 0; + } + + void ba_solver::ineq::divide(unsigned c) { + if (c == 1) return; + for (unsigned i = size(); i-- > 0; ) { + m_wlits[i].first = (coeff(i) + c - 1) / c; + } + m_k = (m_k + c - 1) / c; + } + + /** + * Remove literal at position i, subtract coefficient from bound. + */ + void ba_solver::ineq::weaken(unsigned i) { + unsigned ci = coeff(i); + SASSERT(m_k >= ci); + m_k -= ci; + m_wlits[i] = m_wlits.back(); + m_wlits.pop_back(); + } + + /** + * Round coefficient of inequality to 1. + */ + void ba_solver::round_to_one(ineq& ineq, bool_var v) { + unsigned c = ineq.bv_coeff(v); + if (c == 1) return; + unsigned sz = ineq.size(); + for (unsigned i = 0; i < sz; ++i) { + unsigned ci = ineq.coeff(i); + unsigned q = ci % c; + if (q != 0 && !is_false(ineq.lit(i))) { + if (q == ci) { + ineq.weaken(i); + --i; + --sz; + } + else { + ineq.m_wlits[i].first -= q; + ineq.m_k -= q; + } + } + } + ineq.divide(c); + TRACE("ba", display(tout << "var: " << v << " " << c << ": ", ineq, true);); + } + + void ba_solver::round_to_one(bool_var w) { + unsigned c = get_abs_coeff(w); + if (c == 1 || c == 0) return; + for (bool_var v : m_active_vars) { + wliteral wl = get_wliteral(v); + unsigned q = wl.first % c; + if (q != 0 && !is_false(wl.second)) { + m_coeffs[v] = wl.first - q; + m_bound -= q; + SASSERT(m_bound > 0); + } + } + SASSERT(validate_lemma()); + divide(c); + SASSERT(validate_lemma()); + TRACE("ba", active2pb(m_B); display(tout, m_B, true);); + } + + void ba_solver::divide(unsigned c) { + SASSERT(c != 0); + if (c == 1) return; + reset_active_var_set(); + unsigned j = 0, sz = m_active_vars.size(); + for (unsigned i = 0; i < sz; ++i) { + bool_var v = m_active_vars[i]; + int ci = get_int_coeff(v); + if (!test_and_set_active(v) || ci == 0) continue; + if (ci > 0) { + m_coeffs[v] = (ci + c - 1) / c; + } + else { + m_coeffs[v] = -static_cast((-ci + c - 1) / c); + } + m_active_vars[j++] = v; + } + m_active_vars.shrink(j); + m_bound = static_cast((m_bound + c - 1) / c); + } + + void ba_solver::resolve_on(literal consequent) { + round_to_one(consequent.var()); + m_coeffs[consequent.var()] = 0; + } + + void ba_solver::resolve_with(ineq const& ineq) { + TRACE("ba", display(tout, ineq, true);); + inc_bound(ineq.m_k); + TRACE("ba", tout << "bound: " << m_bound << "\n";); + + for (unsigned i = ineq.size(); i-- > 0; ) { + literal l = ineq.lit(i); + inc_coeff(l, static_cast(ineq.coeff(i))); + TRACE("ba", tout << "bound: " << m_bound << " lit: " << l << " coeff: " << ineq.coeff(i) << "\n";); + } + } + + void ba_solver::reset_marks(unsigned idx) { while (m_num_marks > 0) { - bool_var v = lits[idx].var(); + SASSERT(idx > 0); + bool_var v = s().m_trail[idx].var(); if (s().is_marked(v)) { s().reset_mark(v); --m_num_marks; } - if (idx == 0 && !_debug_conflict) { - _debug_conflict = true; - _debug_var2position.reserve(s().num_vars()); - for (unsigned i = 0; i < lits.size(); ++i) { - _debug_var2position[lits[i].var()] = i; - } - IF_VERBOSE(0, - active2pb(m_A); - uint64_t c = 0; - for (uint64_t c1 : m_A.m_coeffs) c += c1; - verbose_stream() << "sum of coefficients: " << c << "\n"; - display(verbose_stream(), m_A, true); - verbose_stream() << "conflicting literal: " << s().m_not_l << "\n";); + --idx; + } + } + + /** + * \brief mark variables that are on the assignment stack but + * below the current processing level. + */ + void ba_solver::mark_variables(ineq const& ineq) { + for (wliteral wl : ineq.m_wlits) { + literal l = wl.second; + if (!is_false(l)) continue; + bool_var v = l.var(); + unsigned level = lvl(v); + if (!s().is_marked(v) && !is_visited(v) && level == m_conflict_lvl) { + s().mark(v); + ++m_num_marks; + } + } + } - for (literal l : lits) { - if (s().is_marked(l.var())) { - IF_VERBOSE(0, verbose_stream() << "missing mark: " << l << "\n";); - s().reset_mark(l.var()); + lbool ba_solver::resolve_conflict_rs() { + if (0 == m_num_propagations_since_pop) { + return l_undef; + } + m_overflow = false; + reset_coeffs(); + init_visited(); + m_num_marks = 0; + m_bound = 0; + literal consequent = s().m_not_l; + justification js = s().m_conflict; + m_conflict_lvl = s().get_max_lvl(consequent, js); + if (m_conflict_lvl == 0) { + return l_undef; + } + if (consequent != null_literal) { + consequent.neg(); + process_antecedent(consequent, 1); + } + TRACE("ba", tout << consequent << " " << js << "\n";); + unsigned idx = s().m_trail.size() - 1; + + do { + TRACE("ba", s().display_justification(tout << "process consequent: " << consequent << " : ", js) << "\n"; + if (consequent != null_literal) { active2pb(m_A); display(tout, m_A, true); } + ); + + switch (js.get_kind()) { + case justification::NONE: + SASSERT(consequent != null_literal); + round_to_one(consequent.var()); + inc_bound(1); + inc_coeff(consequent, 1); + break; + case justification::BINARY: + SASSERT(consequent != null_literal); + round_to_one(consequent.var()); + inc_bound(1); + inc_coeff(consequent, 1); + process_antecedent(js.get_literal()); + break; + case justification::TERNARY: + SASSERT(consequent != null_literal); + round_to_one(consequent.var()); + inc_bound(1); + inc_coeff(consequent, 1); + process_antecedent(js.get_literal1()); + process_antecedent(js.get_literal2()); + break; + case justification::CLAUSE: { + clause & c = s().get_clause(js); + unsigned i = 0; + if (consequent != null_literal) { + round_to_one(consequent.var()); + inc_coeff(consequent, 1); + if (c[0] == consequent) { + i = 1; + } + else { + SASSERT(c[1] == consequent); + process_antecedent(c[0]); + i = 2; } } - m_num_marks = 0; - resolve_conflict(); + inc_bound(1); + unsigned sz = c.size(); + for (; i < sz; i++) + process_antecedent(c[i]); + break; } + case justification::EXT_JUSTIFICATION: { + ++m_stats.m_num_resolves; + ext_justification_idx index = js.get_ext_justification_idx(); + constraint& cnstr = index2constraint(index); + SASSERT(!cnstr.was_removed()); + switch (cnstr.tag()) { + case card_t: + case pb_t: { + pb_base const& p = cnstr.to_pb_base(); + unsigned k = p.k(), sz = p.size(); + m_A.reset(0); + for (unsigned i = 0; i < sz; ++i) { + literal l = p.get_lit(i); + unsigned c = p.get_coeff(i); + if (l == consequent || !is_visited(l.var())) { + m_A.push(l, c); + } + else { + SASSERT(k > c); + TRACE("ba", tout << "visited: " << l << "\n";); + k -= c; + } + } + SASSERT(k > 0); + if (p.lit() != null_literal) m_A.push(~p.lit(), k); + m_A.m_k = k; + break; + } + default: + constraint2pb(cnstr, consequent, 1, m_A); + break; + } + mark_variables(m_A); + if (consequent == null_literal) { + SASSERT(validate_ineq(m_A)); + m_bound = static_cast(m_A.m_k); + for (wliteral wl : m_A.m_wlits) { + process_antecedent(wl.second, wl.first); + } + } + else { + round_to_one(consequent.var()); + if (cnstr.is_pb()) round_to_one(m_A, consequent.var()); + SASSERT(validate_ineq(m_A)); + resolve_with(m_A); + } + break; + } + default: + UNREACHABLE(); + break; + } + + SASSERT(validate_lemma()); + cut(); + + // find the next marked variable in the assignment stack + bool_var v; + while (true) { + consequent = s().m_trail[idx]; + v = consequent.var(); + mark_visited(v); + if (s().is_marked(v)) { + int64_t c = get_coeff(v); + if (c == 0 || ((c < 0) == consequent.sign())) { + s().reset_mark(v); + --m_num_marks; + } + else { + break; + } + } + if (idx == 0) { + TRACE("ba", tout << "there is no consequent\n";); + goto bail_out; + } + --idx; + } + + SASSERT(lvl(v) == m_conflict_lvl); + s().reset_mark(v); --idx; + --m_num_marks; + js = s().m_justification[v]; + } + while (m_num_marks > 0 && !m_overflow); + TRACE("ba", active2pb(m_A); display(tout, m_A, true);); + + // TBD: check if this is useful + if (!m_overflow && consequent != null_literal) { + round_to_one(consequent.var()); + } + if (!m_overflow && create_asserting_lemma()) { + active2lemma(); + return l_true; + } + + bail_out: + TRACE("ba", tout << "bail " << m_overflow << "\n";); + if (m_overflow) { + ++m_stats.m_num_overflow; + m_overflow = false; } return l_undef; } - bool ba_solver::create_asserting_lemma() { - bool adjusted = false; - adjust_conflict_level: + bool ba_solver::create_asserting_lemma() { int64_t bound64 = m_bound; int64_t slack = -bound64; - for (bool_var v : m_active_vars) { - slack += get_abs_coeff(v); + reset_active_var_set(); + unsigned j = 0, sz = m_active_vars.size(); + for (unsigned i = 0; i < sz; ++i) { + bool_var v = m_active_vars[i]; + unsigned c = get_abs_coeff(v); + if (!test_and_set_active(v) || c == 0) continue; + slack += c; + m_active_vars[j++] = v; } + m_active_vars.shrink(j); m_lemma.reset(); m_lemma.push_back(null_literal); unsigned num_skipped = 0; @@ -1395,29 +1726,34 @@ namespace sat { } } if (slack >= 0) { + TRACE("ba", tout << "slack is non-negative\n";); IF_VERBOSE(20, verbose_stream() << "(sat.card slack: " << slack << " skipped: " << num_skipped << ")\n";); return false; } if (m_overflow) { + TRACE("ba", tout << "overflow\n";); return false; } if (m_lemma[0] == null_literal) { if (m_lemma.size() == 1) { s().set_conflict(justification()); - return false; } + TRACE("ba", tout << "no asserting literal\n";); return false; - unsigned old_level = m_conflict_lvl; - m_conflict_lvl = 0; - for (unsigned i = 1; i < m_lemma.size(); ++i) { - m_conflict_lvl = std::max(m_conflict_lvl, lvl(m_lemma[i])); - } - IF_VERBOSE(1, verbose_stream() << "(sat.backjump :new-level " << m_conflict_lvl << " :old-level " << old_level << ")\n";); - adjusted = true; - goto adjust_conflict_level; } - if (!adjusted) { - active2card(); + + TRACE("ba", tout << m_lemma << "\n";); + + if (get_config().m_drat) { + svector ps; // TBD fill in + drat_add(m_lemma, ps); + } + + s().m_lemma.reset(); + s().m_lemma.append(m_lemma); + for (unsigned i = 1; i < m_lemma.size(); ++i) { + CTRACE("ba", s().is_marked(m_lemma[i].var()), tout << "marked: " << m_lemma[i] << "\n";); + s().mark(m_lemma[i].var()); } return true; } @@ -1461,10 +1797,16 @@ namespace sat { } if (g >= 2) { - normalize_active_coeffs(); - for (bool_var v : m_active_vars) { + reset_active_var_set(); + unsigned j = 0, sz = m_active_vars.size(); + for (unsigned i = 0; i < sz; ++i) { + bool_var v = m_active_vars[i]; + int64_t c = m_coeffs[v]; + if (!test_and_set_active(v) || c == 0) continue; m_coeffs[v] /= static_cast(g); + m_active_vars[j++] = v; } + m_active_vars.shrink(j); m_bound = (m_bound + g - 1) / g; ++m_stats.m_num_cut; } @@ -1500,9 +1842,8 @@ namespace sat { bool_var v = l.var(); unsigned level = lvl(v); - if (level > 0 && !s().is_marked(v) && level == m_conflict_lvl) { + if (!s().is_marked(v) && level == m_conflict_lvl) { s().mark(v); - TRACE("sat_verbose", tout << "Mark: v" << v << "\n";); ++m_num_marks; if (_debug_conflict && _debug_consequent != null_literal && _debug_var2position[_debug_consequent.var()] < _debug_var2position[l.var()]) { IF_VERBOSE(0, verbose_stream() << "antecedent " << l << " is above consequent in stack\n";); @@ -1527,7 +1868,9 @@ namespace sat { return p; } - ba_solver::ba_solver(): m_solver(0), m_lookahead(0), m_unit_walk(0), m_constraint_id(0), m_ba(*this), m_sort(m_ba) { + ba_solver::ba_solver() + : m_solver(nullptr), m_lookahead(nullptr), m_unit_walk(nullptr), + m_constraint_id(0), m_ba(*this), m_sort(m_ba) { TRACE("ba", tout << this << "\n";); m_num_propagations_since_pop = 0; } @@ -2262,7 +2605,6 @@ namespace sat { IF_VERBOSE(0, s().display_watches(verbose_stream())); UNREACHABLE(); - exit(1); return false; } } @@ -2323,9 +2665,20 @@ namespace sat { } c.set_psm(r); } + + unsigned ba_solver::max_var(unsigned w) const { + for (constraint* cp : m_constraints) { + w = cp->fold_max_var(w); + } + for (constraint* cp : m_learned) { + w = cp->fold_max_var(w); + } + return w; + } void ba_solver::gc() { - if (m_learned.size() >= 2 * m_constraints.size()) { + if (m_learned.size() >= 2 * m_constraints.size() && + (s().at_search_lvl() || s().at_base_lvl())) { for (auto & c : m_learned) update_psm(*c); std::stable_sort(m_learned.begin(), m_learned.end(), constraint_glue_psm_lt()); gc_half("glue-psm"); @@ -2342,8 +2695,12 @@ namespace sat { constraint* c = m_learned[i]; if (!m_constraint_to_reinit.contains(c)) { remove_constraint(*c, "gc"); + m_allocator.deallocate(c->obj_size(), c); ++removed; } + else { + m_learned[new_sz++] = c; + } } m_stats.m_num_gc += removed; m_learned.shrink(new_sz); @@ -2493,7 +2850,8 @@ namespace sat { set_non_external(); if (get_config().m_elim_vars) elim_pure(); for (unsigned sz = m_constraints.size(), i = 0; i < sz; ++i) subsumption(*m_constraints[i]); - for (unsigned sz = m_learned.size(), i = 0; i < sz; ++i) subsumption(*m_learned[i]); + for (unsigned sz = m_learned.size(), i = 0; i < sz; ++i) subsumption(*m_learned[i]); + unit_strengthen(); cleanup_clauses(); cleanup_constraints(); update_pure(); @@ -2519,7 +2877,7 @@ namespace sat { * ~lit does not occur in clauses * ~lit is only in one constraint use list * lit == C - * -> ignore assignemnts to ~lit for C + * -> ignore assignments to ~lit for C * * ~lit does not occur in clauses * lit is only in one constraint use list @@ -2939,9 +3297,10 @@ namespace sat { bool found_dup = false; bool found_root = false; + init_visited(); for (unsigned i = 0; i < c.size(); ++i) { literal l = c.get_lit(i); - if (is_marked(l)) { + if (is_visited(l)) { found_dup = true; break; } @@ -2951,10 +3310,7 @@ namespace sat { } } for (unsigned i = 0; i < c.size(); ++i) { - literal l = c.get_lit(i); - unmark_visited(l); - unmark_visited(~l); - found_root |= l.var() == root.var(); + found_root |= c.get_lit(i).var() == root.var(); } if (found_root) { @@ -3111,6 +3467,98 @@ namespace sat { return pure_literals; } + /** + * Strengthen inequalities using binary implication information. + * + * x -> ~y, x -> ~z, y + z + u >= 2 + * ---------------------------------- + * y + z + u + ~x >= 3 + * + * for c : constraints + * for l : c: + * slack <- of c under root(~l) + * if slack < 0: + * add ~root(~l) to c, k <- k + 1 + */ + void ba_solver::unit_strengthen() { + big big(s().m_rand); + big.init(s(), true); + for (unsigned sz = m_constraints.size(), i = 0; i < sz; ++i) + unit_strengthen(big, *m_constraints[i]); + for (unsigned sz = m_learned.size(), i = 0; i < sz; ++i) + unit_strengthen(big, *m_learned[i]); + } + + void ba_solver::unit_strengthen(big& big, constraint& c) { + if (c.was_removed()) return; + switch (c.tag()) { + case card_t: + unit_strengthen(big, c.to_card()); + break; + case pb_t: + unit_strengthen(big, c.to_pb()); + break; + default: + break; + } + } + + void ba_solver::unit_strengthen(big& big, pb_base& p) { + if (p.lit() != null_literal) return; + unsigned sz = p.size(); + for (unsigned i = 0; i < sz; ++i) { + literal u = p.get_lit(i); + literal r = big.get_root(u); + if (r == u) continue; + unsigned k = p.k(), b = 0; + for (unsigned j = 0; j < sz; ++j) { + literal v = p.get_lit(j); + if (r == big.get_root(v)) { + b += p.get_coeff(j); + } + } + if (b > k) { + r.neg(); + unsigned coeff = b - k; + + svector wlits; + // add coeff * r to p + wlits.push_back(wliteral(coeff, r)); + for (unsigned j = 0; j < sz; ++j) { + u = p.get_lit(j); + unsigned c = p.get_coeff(j); + if (r == u) { + wlits[0].first += c; + } + else if (~r == u) { + if (coeff == c) { + wlits[0] = wlits.back(); + wlits.pop_back(); + b -= c; + } + else if (coeff < c) { + wlits[0].first = c - coeff; + wlits[0].second.neg(); + b -= coeff; + } + else { + // coeff > c + wlits[0].first = coeff - c; + b -= c; + } + } + else { + wlits.push_back(wliteral(c, u)); + } + } + ++m_stats.m_num_big_strengthenings; + p.set_removed(); + add_pb_ge(null_literal, wlits, b, p.learned()); + return; + } + } + } + void ba_solver::subsumption(constraint& cnstr) { if (cnstr.was_removed()) return; switch (cnstr.tag()) { @@ -3199,10 +3647,10 @@ namespace sat { unsigned common = 0; comp.reset(); for (literal l : c2) { - if (is_marked(l)) { + if (is_visited(l)) { ++common; } - else if (is_marked(~l)) { + else if (is_visited(~l)) { comp.push_back(l); } else { @@ -3224,10 +3672,10 @@ namespace sat { self = false; for (literal l : c2) { - if (is_marked(l)) { + if (is_visited(l)) { ++common; } - else if (is_marked(~l)) { + else if (is_visited(~l)) { ++complement; } else { @@ -3251,10 +3699,10 @@ namespace sat { unsigned num_sub = 0; for (unsigned i = 0; i < p2.size(); ++i) { literal l = p2.get_lit(i); - if (is_marked(l) && m_weights[l.index()] <= p2.get_coeff(i)) { + if (is_visited(l) && m_weights[l.index()] <= p2.get_coeff(i)) { ++num_sub; } - if (p1.size() + i > p2.size() + num_sub) return false; + if (p1.size() + i > p2.size() + num_sub) return false; } return num_sub == p1.size(); } @@ -3319,7 +3767,7 @@ namespace sat { clear_watch(c2); unsigned j = 0; for (unsigned i = 0; i < c2.size(); ++i) { - if (!is_marked(~c2[i])) { + if (!is_visited(~c2[i])) { c2[j++] = c2[i]; } } @@ -3355,7 +3803,7 @@ namespace sat { void ba_solver::binary_subsumption(card& c1, literal lit) { if (c1.k() + 1 != c1.size()) return; - SASSERT(is_marked(lit)); + SASSERT(is_visited(lit)); SASSERT(!c1.was_removed()); watch_list & wlist = get_wlist(~lit); watch_list::iterator it = wlist.begin(); @@ -3363,7 +3811,7 @@ namespace sat { watch_list::iterator end = wlist.end(); for (; it != end; ++it) { watched w = *it; - if (w.is_binary_clause() && is_marked(w.get_literal())) { + if (w.is_binary_clause() && is_visited(w.get_literal())) { ++m_stats.m_num_bin_subsumes; IF_VERBOSE(10, verbose_stream() << c1 << " subsumes (" << lit << " " << w.get_literal() << ")\n";); if (!w.is_learned()) { @@ -3385,6 +3833,7 @@ namespace sat { return; } clause_vector removed_clauses; + init_visited(); for (literal l : c1) mark_visited(l); for (unsigned i = 0; i < std::min(c1.size(), c1.k() + 1); ++i) { literal lit = c1[i]; @@ -3392,7 +3841,6 @@ namespace sat { clause_subsumption(c1, lit, removed_clauses); binary_subsumption(c1, lit); } - for (literal l : c1) unmark_visited(l); m_clause_removed |= !removed_clauses.empty(); for (clause *c : removed_clauses) { c->set_removed(true); @@ -3404,6 +3852,7 @@ namespace sat { if (p1.was_removed() || p1.lit() != null_literal) { return; } + init_visited(); for (wliteral l : p1) { SASSERT(m_weights.size() <= l.second.index() || m_weights[l.second.index()] == 0); m_weights.setx(l.second.index(), l.first, 0); @@ -3415,7 +3864,6 @@ namespace sat { } for (wliteral l : p1) { m_weights[l.second.index()] = 0; - unmark_visited(l.second); } } @@ -3612,10 +4060,11 @@ namespace sat { } } - void ba_solver::display(std::ostream& out, ineq& ineq, bool values) const { - for (unsigned i = 0; i < ineq.m_lits.size(); ++i) { - out << ineq.m_coeffs[i] << "*" << ineq.m_lits[i] << " "; - if (values) out << value(ineq.m_lits[i]) << " "; + void ba_solver::display(std::ostream& out, ineq const& ineq, bool values) const { + for (unsigned i = 0; i < ineq.size(); ++i) { + if (ineq.coeff(i) != 1) out << ineq.coeff(i) << "*"; + out << ineq.lit(i) << " "; + if (values) out << value(ineq.lit(i)) << " "; } out << ">= " << ineq.m_k << "\n"; } @@ -3705,6 +4154,10 @@ namespace sat { st.update("ba resolves", m_stats.m_num_resolves); st.update("ba cuts", m_stats.m_num_cut); st.update("ba gc", m_stats.m_num_gc); + st.update("ba overflow", m_stats.m_num_overflow); + st.update("ba big strengthenings", m_stats.m_num_big_strengthenings); + st.update("ba lemmas", m_stats.m_num_lemmas); + st.update("ba subsumes", m_stats.m_num_bin_subsumes + m_stats.m_num_clause_subsumes + m_stats.m_num_pb_subsumes); } bool ba_solver::validate_unit_propagation(card const& c, literal alit) const { @@ -3799,62 +4252,88 @@ namespace sat { int64_t val = -bound64; reset_active_var_set(); for (bool_var v : m_active_vars) { - if (m_active_var_set.contains(v)) continue; - int64_t coeff = get_coeff(v); - if (coeff == 0) continue; - m_active_var_set.insert(v); - literal lit(v, false); - if (coeff < 0 && value(lit) != l_true) { - val -= coeff; - } - else if (coeff > 0 && value(lit) != l_false) { - val += coeff; + if (!test_and_set_active(v)) continue; + wliteral wl = get_wliteral(v); + if (wl.first == 0) continue; + if (!is_false(wl.second)) { + val += wl.first; } } - CTRACE("ba", val >= 0, active2pb(m_A); display(tout, m_A);); + CTRACE("ba", val >= 0, active2pb(m_A); display(tout, m_A, true);); return val < 0; } + /** + * the slack of inequalities on the stack should be non-positive. + */ + bool ba_solver::validate_ineq(ineq const& ineq) const { + int64_t k = -static_cast(ineq.m_k); + for (wliteral wl : ineq.m_wlits) { + if (!is_false(wl.second)) + k += wl.first; + } + CTRACE("ba", k > 0, display(tout, ineq, true);); + return k <= 0; + } + void ba_solver::reset_active_var_set() { while (!m_active_var_set.empty()) m_active_var_set.erase(); } - void ba_solver::active2pb(ineq& p) { - reset_active_var_set(); - p.reset(m_bound); - for (bool_var v : m_active_vars) { - if (m_active_var_set.contains(v)) continue; - int64_t coeff = get_coeff(v); - if (coeff == 0) continue; + bool ba_solver::test_and_set_active(bool_var v) { + if (m_active_var_set.contains(v)) { + return false; + } + else { m_active_var_set.insert(v); - literal lit(v, coeff < 0); - p.m_lits.push_back(lit); - p.m_coeffs.push_back(std::abs(coeff)); + return true; + } + } + + void ba_solver::active2pb(ineq& p) { + p.reset(m_bound); + active2wlits(p.m_wlits); + } + + void ba_solver::active2wlits() { + m_wlits.reset(); + active2wlits(m_wlits); + } + + void ba_solver::active2wlits(svector& wlits) { + uint64_t sum = 0; + reset_active_var_set(); + for (bool_var v : m_active_vars) { + if (!test_and_set_active(v)) continue; + wliteral wl = get_wliteral(v); + if (wl.first == 0) continue; + wlits.push_back(wl); + sum += wl.first; + } + m_overflow |= sum >= UINT_MAX/2; + } + + ba_solver::constraint* ba_solver::active2lemma() { + switch (s().m_config.m_pb_lemma_format) { + case PB_LEMMA_CARDINALITY: + return active2card(); + case PB_LEMMA_PB: + return active2constraint(); + default: + UNREACHABLE(); + return nullptr; } } ba_solver::constraint* ba_solver::active2constraint() { - reset_active_var_set(); - m_wlits.reset(); - uint64_t sum = 0; - if (m_bound == 1) return nullptr; - if (m_overflow) return nullptr; - - for (bool_var v : m_active_vars) { - int coeff = get_int_coeff(v); - if (m_active_var_set.contains(v) || coeff == 0) continue; - m_active_var_set.insert(v); - literal lit(v, coeff < 0); - m_wlits.push_back(wliteral(get_abs_coeff(v), lit)); - sum += get_abs_coeff(v); - } - - if (m_overflow || sum >= UINT_MAX/2) { + active2wlits(); + if (m_overflow) { return nullptr; } - else { - return add_pb_ge(null_literal, m_wlits, m_bound, true); - } + constraint* c = add_pb_ge(null_literal, m_wlits, m_bound, true); + TRACE("ba", if (c) display(tout, *c, true);); + ++m_stats.m_num_lemmas; + return c; } /* @@ -3889,11 +4368,9 @@ namespace sat { ba_solver::constraint* ba_solver::active2card() { - normalize_active_coeffs(); - m_wlits.reset(); - for (bool_var v : m_active_vars) { - int coeff = get_int_coeff(v); - m_wlits.push_back(std::make_pair(get_abs_coeff(v), literal(v, coeff < 0))); + active2wlits(); + if (m_overflow) { + return nullptr; } std::sort(m_wlits.begin(), m_wlits.end(), compare_wlit()); unsigned k = 0; @@ -3928,7 +4405,9 @@ namespace sat { ++num_max_level; } } - if (m_overflow) return nullptr; + if (m_overflow) { + return nullptr; + } if (slack >= k) { #if 0 @@ -3947,8 +4426,9 @@ namespace sat { } constraint* c = add_at_least(null_literal, lits, k, true); + ++m_stats.m_num_lemmas; + if (c) { - // IF_VERBOSE(0, verbose_stream() << *c << "\n";); lits.reset(); for (wliteral wl : m_wlits) { if (value(wl.second) == l_false) lits.push_back(wl.second); @@ -3963,15 +4443,18 @@ namespace sat { void ba_solver::justification2pb(justification const& js, literal lit, unsigned offset, ineq& ineq) { switch (js.get_kind()) { case justification::NONE: + SASSERT(lit != null_literal); ineq.reset(offset); ineq.push(lit, offset); break; case justification::BINARY: + SASSERT(lit != null_literal); ineq.reset(offset); ineq.push(lit, offset); ineq.push(js.get_literal(), offset); break; case justification::TERNARY: + SASSERT(lit != null_literal); ineq.reset(offset); ineq.push(lit, offset); ineq.push(js.get_literal1(), offset); @@ -3986,35 +4469,7 @@ namespace sat { case justification::EXT_JUSTIFICATION: { ext_justification_idx index = js.get_ext_justification_idx(); constraint& cnstr = index2constraint(index); - switch (cnstr.tag()) { - case card_t: { - card& c = cnstr.to_card(); - ineq.reset(offset*c.k()); - for (literal l : c) ineq.push(l, offset); - if (c.lit() != null_literal) ineq.push(~c.lit(), offset*c.k()); - break; - } - case pb_t: { - pb& p = cnstr.to_pb(); - ineq.reset(p.k()); - for (wliteral wl : p) ineq.push(wl.second, wl.first); - if (p.lit() != null_literal) ineq.push(~p.lit(), p.k()); - break; - } - case xr_t: { - xr& x = cnstr.to_xr(); - literal_vector ls; - get_antecedents(lit, x, ls); - ineq.reset(offset); - for (literal l : ls) ineq.push(~l, offset); - literal lxr = x.lit(); - if (lxr != null_literal) ineq.push(~lxr, offset); - break; - } - default: - UNREACHABLE(); - break; - } + constraint2pb(cnstr, lit, offset, ineq); break; } default: @@ -4023,6 +4478,38 @@ namespace sat { } } + void ba_solver::constraint2pb(constraint& cnstr, literal lit, unsigned offset, ineq& ineq) { + switch (cnstr.tag()) { + case card_t: { + card& c = cnstr.to_card(); + ineq.reset(offset*c.k()); + for (literal l : c) ineq.push(l, offset); + if (c.lit() != null_literal) ineq.push(~c.lit(), offset*c.k()); + break; + } + case pb_t: { + pb& p = cnstr.to_pb(); + ineq.reset(offset * p.k()); + for (wliteral wl : p) ineq.push(wl.second, offset * wl.first); + if (p.lit() != null_literal) ineq.push(~p.lit(), offset * p.k()); + break; + } + case xr_t: { + xr& x = cnstr.to_xr(); + literal_vector ls; + SASSERT(lit != null_literal); + get_antecedents(lit, x, ls); + ineq.reset(offset); + for (literal l : ls) ineq.push(~l, offset); + literal lxr = x.lit(); + if (lxr != null_literal) ineq.push(~lxr, offset); + break; + } + default: + UNREACHABLE(); + break; + } + } // validate that m_A & m_B implies m_C @@ -4030,14 +4517,14 @@ namespace sat { return true; u_map coeffs; uint64_t k = m_A.m_k + m_B.m_k; - for (unsigned i = 0; i < m_A.m_lits.size(); ++i) { - uint64_t coeff = m_A.m_coeffs[i]; - SASSERT(!coeffs.contains(m_A.m_lits[i].index())); - coeffs.insert(m_A.m_lits[i].index(), coeff); + for (unsigned i = 0; i < m_A.size(); ++i) { + uint64_t coeff = m_A.coeff(i); + SASSERT(!coeffs.contains(m_A.lit(i).index())); + coeffs.insert(m_A.lit(i).index(), coeff); } - for (unsigned i = 0; i < m_B.m_lits.size(); ++i) { - uint64_t coeff1 = m_B.m_coeffs[i], coeff2; - literal lit = m_B.m_lits[i]; + for (unsigned i = 0; i < m_B.size(); ++i) { + uint64_t coeff1 = m_B.coeff(i), coeff2; + literal lit = m_B.lit(i); if (coeffs.find((~lit).index(), coeff2)) { if (coeff1 == coeff2) { coeffs.remove((~lit).index()); @@ -4062,11 +4549,11 @@ namespace sat { } } // C is above the sum of A and B - for (unsigned i = 0; i < m_C.m_lits.size(); ++i) { - literal lit = m_C.m_lits[i]; + for (unsigned i = 0; i < m_C.size(); ++i) { + literal lit = m_C.lit(i); uint64_t coeff; if (coeffs.find(lit.index(), coeff)) { - if (coeff > m_C.m_coeffs[i] && m_C.m_coeffs[i] < m_C.m_k) { + if (coeff > m_C.coeff(i) && m_C.coeff(i) < m_C.m_k) { goto violated; } coeffs.remove(lit.index()); @@ -4113,15 +4600,15 @@ namespace sat { */ literal ba_solver::translate_to_sat(solver& s, u_map& translation, ineq const& pb) { SASSERT(pb.m_k > 0); - if (pb.m_lits.size() > 1) { + if (pb.size() > 1) { ineq a, b; a.reset(pb.m_k); b.reset(pb.m_k); - for (unsigned i = 0; i < pb.m_lits.size()/2; ++i) { - a.push(pb.m_lits[i], pb.m_coeffs[i]); + for (unsigned i = 0; i < pb.size()/2; ++i) { + a.push(pb.lit(i), pb.coeff(i)); } - for (unsigned i = pb.m_lits.size()/2; i < pb.m_lits.size(); ++i) { - b.push(pb.m_lits[i], pb.m_coeffs[i]); + for (unsigned i = pb.size()/2; i < pb.size(); ++i) { + b.push(pb.lit(i), pb.coeff(i)); } bool_var v = s.mk_var(); literal lit(v, false); @@ -4133,8 +4620,8 @@ namespace sat { s.mk_clause(lits); return lit; } - if (pb.m_coeffs[0] >= pb.m_k) { - return translate_to_sat(s, translation, pb.m_lits[0]); + if (pb.coeff(0) >= pb.m_k) { + return translate_to_sat(s, translation, pb.lit(0)); } else { return null_literal; @@ -4186,9 +4673,9 @@ namespace sat { ba_solver::ineq ba_solver::negate(ineq const& a) const { ineq result; uint64_t sum = 0; - for (unsigned i = 0; i < a.m_lits.size(); ++i) { - result.push(~a.m_lits[i], a.m_coeffs[i]); - sum += a.m_coeffs[i]; + for (unsigned i = 0; i < a.size(); ++i) { + result.push(~a.lit(i), a.coeff(i)); + sum += a.coeff(i); } SASSERT(sum >= a.m_k + 1); result.m_k = sum + 1 - a.m_k; @@ -4207,15 +4694,15 @@ namespace sat { TRACE("ba", tout << "literal " << l << " is not false\n";); return false; } - if (!p.m_lits.contains(l)) { + if (!p.contains(l)) { TRACE("ba", tout << "lemma contains literal " << l << " not in inequality\n";); return false; } } uint64_t value = 0; - for (unsigned i = 0; i < p.m_lits.size(); ++i) { - uint64_t coeff = p.m_coeffs[i]; - if (!lits.contains(p.m_lits[i])) { + for (unsigned i = 0; i < p.size(); ++i) { + uint64_t coeff = p.coeff(i); + if (!lits.contains(p.lit(i))) { value += coeff; } } diff --git a/src/sat/ba_solver.h b/src/sat/ba_solver.h index bae59f45a..141ca0887 100644 --- a/src/sat/ba_solver.h +++ b/src/sat/ba_solver.h @@ -25,6 +25,7 @@ Revision History: #include "sat/sat_solver.h" #include "sat/sat_lookahead.h" #include "sat/sat_unit_walk.h" +#include "sat/sat_big.h" #include "util/scoped_ptr_vector.h" #include "util/sorting_network.h" @@ -41,8 +42,11 @@ namespace sat { unsigned m_num_bin_subsumes; unsigned m_num_clause_subsumes; unsigned m_num_pb_subsumes; + unsigned m_num_big_strengthenings; unsigned m_num_cut; unsigned m_num_gc; + unsigned m_num_overflow; + unsigned m_num_lemmas; stats() { reset(); } void reset() { memset(this, 0, sizeof(*this)); } }; @@ -57,6 +61,7 @@ namespace sat { class card; class pb; class xr; + class pb_base; class constraint { protected: @@ -96,6 +101,7 @@ namespace sat { bool is_clear() const { return m_watch == null_literal && m_lit != null_literal; } bool is_pure() const { return m_pure; } void set_pure() { m_pure = true; } + unsigned fold_max_var(unsigned w) const; size_t obj_size() const { return m_obj_size; } card& to_card(); @@ -104,6 +110,7 @@ namespace sat { card const& to_card() const; pb const& to_pb() const; xr const& to_xr() const; + pb_base const& to_pb_base() const; bool is_card() const { return m_tag == card_t; } bool is_pb() const { return m_tag == pb_t; } bool is_xr() const { return m_tag == xr_t; } @@ -118,7 +125,7 @@ namespace sat { }; friend std::ostream& operator<<(std::ostream& out, constraint const& c); - + // base class for pb and cardinality constraints class pb_base : public constraint { protected: @@ -128,7 +135,7 @@ namespace sat { virtual void set_k(unsigned k) { VERIFY(k < 4000000000); m_k = k; } virtual unsigned get_coeff(unsigned i) const { UNREACHABLE(); return 0; } unsigned k() const { return m_k; } - virtual bool well_formed() const; + bool well_formed() const override; }; class card : public pb_base { @@ -140,13 +147,13 @@ namespace sat { literal& operator[](unsigned i) { return m_lits[i]; } literal const* begin() const { return m_lits; } literal const* end() const { return static_cast(m_lits) + m_size; } - virtual void negate(); - virtual void swap(unsigned i, unsigned j) { std::swap(m_lits[i], m_lits[j]); } - virtual literal_vector literals() const { return literal_vector(m_size, m_lits); } - virtual bool is_watching(literal l) const; - virtual literal get_lit(unsigned i) const { return m_lits[i]; } - virtual void set_lit(unsigned i, literal l) { m_lits[i] = l; } - virtual unsigned get_coeff(unsigned i) const { return 1; } + void negate() override; + void swap(unsigned i, unsigned j) override { std::swap(m_lits[i], m_lits[j]); } + literal_vector literals() const override { return literal_vector(m_size, m_lits); } + bool is_watching(literal l) const override; + literal get_lit(unsigned i) const override { return m_lits[i]; } + void set_lit(unsigned i, literal l) override { m_lits[i] = l; } + unsigned get_coeff(unsigned i) const override { return 1; } }; @@ -173,14 +180,14 @@ namespace sat { void update_max_sum(); void set_num_watch(unsigned s) { m_num_watch = s; } bool is_cardinality() const; - virtual void negate(); - virtual void set_k(unsigned k) { m_k = k; VERIFY(k < 4000000000); update_max_sum(); } - virtual void swap(unsigned i, unsigned j) { std::swap(m_wlits[i], m_wlits[j]); } - virtual literal_vector literals() const { literal_vector lits; for (auto wl : *this) lits.push_back(wl.second); return lits; } - virtual bool is_watching(literal l) const; - virtual literal get_lit(unsigned i) const { return m_wlits[i].second; } - virtual void set_lit(unsigned i, literal l) { m_wlits[i].second = l; } - virtual unsigned get_coeff(unsigned i) const { return m_wlits[i].first; } + void negate() override; + void set_k(unsigned k) override { m_k = k; VERIFY(k < 4000000000); update_max_sum(); } + void swap(unsigned i, unsigned j) override { std::swap(m_wlits[i], m_wlits[j]); } + literal_vector literals() const override { literal_vector lits; for (auto wl : *this) lits.push_back(wl.second); return lits; } + bool is_watching(literal l) const override; + literal get_lit(unsigned i) const override { return m_wlits[i].second; } + void set_lit(unsigned i, literal l) override { m_wlits[i].second = l; } + unsigned get_coeff(unsigned i) const override { return m_wlits[i].first; } }; class xr : public constraint { @@ -191,25 +198,31 @@ namespace sat { literal operator[](unsigned i) const { return m_lits[i]; } literal const* begin() const { return m_lits; } literal const* end() const { return begin() + m_size; } - virtual void negate() { m_lits[0].neg(); } - virtual void swap(unsigned i, unsigned j) { std::swap(m_lits[i], m_lits[j]); } - virtual bool is_watching(literal l) const; - virtual literal_vector literals() const { return literal_vector(size(), begin()); } - virtual literal get_lit(unsigned i) const { return m_lits[i]; } - virtual void set_lit(unsigned i, literal l) { m_lits[i] = l; } - virtual bool well_formed() const; + void negate() override { m_lits[0].neg(); } + void swap(unsigned i, unsigned j) override { std::swap(m_lits[i], m_lits[j]); } + bool is_watching(literal l) const override; + literal_vector literals() const override { return literal_vector(size(), begin()); } + literal get_lit(unsigned i) const override { return m_lits[i]; } + void set_lit(unsigned i, literal l) override { m_lits[i] = l; } + bool well_formed() const override; }; protected: struct ineq { - literal_vector m_lits; - svector m_coeffs; + svector m_wlits; uint64_t m_k; ineq(): m_k(0) {} - void reset(uint64_t k) { m_lits.reset(); m_coeffs.reset(); m_k = k; } - void push(literal l, uint64_t c) { m_lits.push_back(l); m_coeffs.push_back(c); } + unsigned size() const { return m_wlits.size(); } + literal lit(unsigned i) const { return m_wlits[i].second; } + unsigned coeff(unsigned i) const { return m_wlits[i].first; } + void reset(uint64_t k) { m_wlits.reset(); m_k = k; } + void push(literal l, unsigned c) { m_wlits.push_back(wliteral(c,l)); } + unsigned bv_coeff(bool_var v) const; + void divide(unsigned c); + void weaken(unsigned i); + bool contains(literal l) const { for (auto wl : m_wlits) if (wl.second == l) return true; return false; } }; solver* m_solver; @@ -273,7 +286,8 @@ namespace sat { // simplification routines - svector m_visited; + svector m_visited; + unsigned m_visited_ts; vector> m_cnstr_use_list; use_list m_clause_use_list; bool m_simplify_change; @@ -292,9 +306,11 @@ namespace sat { void binary_subsumption(card& c1, literal lit); void clause_subsumption(card& c1, literal lit, clause_vector& removed_clauses); void card_subsumption(card& c1, literal lit); - void mark_visited(literal l) { m_visited[l.index()] = true; } - void unmark_visited(literal l) { m_visited[l.index()] = false; } - bool is_marked(literal l) const { return m_visited[l.index()] != 0; } + void init_visited(); + void mark_visited(literal l) { m_visited[l.index()] = m_visited_ts; } + void mark_visited(bool_var v) { mark_visited(literal(v, false)); } + bool is_visited(bool_var v) const { return is_visited(literal(v, false)); } + bool is_visited(literal l) const { return m_visited[l.index()] == m_visited_ts; } unsigned get_num_unblocked_bin(literal l); literal get_min_occurrence_literal(card const& c); void init_use_lists(); @@ -302,6 +318,9 @@ namespace sat { unsigned set_non_external(); unsigned elim_pure(); bool elim_pure(literal lit); + void unit_strengthen(); + void unit_strengthen(big& big, constraint& cs); + void unit_strengthen(big& big, pb_base& p); void subsumption(constraint& c1); void subsumption(card& c1); void gc_half(char const* _method); @@ -396,10 +415,23 @@ namespace sat { lbool eval(model const& m, pb const& p) const; double get_reward(pb const& p, literal_occs_fun& occs) const; + // RoundingPb conflict resolution + lbool resolve_conflict_rs(); + void round_to_one(ineq& ineq, bool_var v); + void round_to_one(bool_var v); + void divide(unsigned c); + void resolve_on(literal lit); + void resolve_with(ineq const& ineq); + void reset_marks(unsigned idx); + void mark_variables(ineq const& ineq); + + void bail_resolve_conflict(unsigned idx); + // access solver inline lbool value(bool_var v) const { return value(literal(v, false)); } inline lbool value(literal lit) const { return m_lookahead ? m_lookahead->value(lit) : m_solver->value(lit); } inline lbool value(model const& m, literal l) const { return l.sign() ? ~m[l.var()] : m[l.var()]; } + inline bool is_false(literal lit) const { return l_false == value(lit); } inline unsigned lvl(literal lit) const { return m_lookahead || m_unit_walk ? 0 : m_solver->lvl(lit); } inline unsigned lvl(bool_var v) const { return m_lookahead || m_unit_walk ? 0 : m_solver->lvl(v); } @@ -426,9 +458,11 @@ namespace sat { mutable bool m_overflow; void reset_active_var_set(); - void normalize_active_coeffs(); + bool test_and_set_active(bool_var v); void inc_coeff(literal l, unsigned offset); int64_t get_coeff(bool_var v) const; + uint64_t get_coeff(literal lit) const; + wliteral get_wliteral(bool_var v); unsigned get_abs_coeff(bool_var v) const; int get_int_coeff(bool_var v) const; unsigned get_bound() const; @@ -436,6 +470,7 @@ namespace sat { literal get_asserting_literal(literal conseq); void process_antecedent(literal l, unsigned offset); + void process_antecedent(literal l) { process_antecedent(l, 1); } void process_card(card& c, unsigned offset); void cut(); bool create_asserting_lemma(); @@ -446,6 +481,7 @@ namespace sat { bool validate_conflict(pb const& p) const; bool validate_assign(literal_vector const& lits, literal lit); bool validate_lemma(); + bool validate_ineq(ineq const& ineq) const; bool validate_unit_propagation(card const& c, literal alit) const; bool validate_unit_propagation(pb const& p, literal alit) const; bool validate_unit_propagation(pb const& p, literal_vector const& r, literal alit) const; @@ -464,12 +500,17 @@ namespace sat { ineq m_A, m_B, m_C; void active2pb(ineq& p); + constraint* active2lemma(); constraint* active2constraint(); constraint* active2card(); + void active2wlits(); + void active2wlits(svector& wlits); void justification2pb(justification const& j, literal lit, unsigned offset, ineq& p); + void constraint2pb(constraint& cnstr, literal lit, unsigned offset, ineq& p); bool validate_resolvent(); + unsigned get_coeff(ineq const& pb, literal lit); - void display(std::ostream& out, ineq& p, bool values = false) const; + void display(std::ostream& out, ineq const& p, bool values = false) const; void display(std::ostream& out, card const& c, bool values) const; void display(std::ostream& out, pb const& p, bool values) const; void display(std::ostream& out, xr const& c, bool values) const; @@ -484,44 +525,45 @@ namespace sat { public: ba_solver(); - virtual ~ba_solver(); - virtual void set_solver(solver* s) { m_solver = s; } - virtual void set_lookahead(lookahead* l) { m_lookahead = l; } - virtual void set_unit_walk(unit_walk* u) { m_unit_walk = u; } + ~ba_solver() override; + void set_solver(solver* s) override { m_solver = s; } + void set_lookahead(lookahead* l) override { m_lookahead = l; } + void set_unit_walk(unit_walk* u) override { m_unit_walk = u; } void add_at_least(bool_var v, literal_vector const& lits, unsigned k); void add_pb_ge(bool_var v, svector const& wlits, unsigned k); void add_xr(literal_vector const& lits); - virtual bool propagate(literal l, ext_constraint_idx idx); - virtual lbool resolve_conflict(); - virtual void get_antecedents(literal l, ext_justification_idx idx, literal_vector & r); - virtual void asserted(literal l); - virtual check_result check(); - virtual void push(); - virtual void pop(unsigned n); - virtual void simplify(); - virtual void clauses_modifed(); - virtual lbool get_phase(bool_var v); - virtual bool set_root(literal l, literal r); - virtual void flush_roots(); - virtual std::ostream& display(std::ostream& out) const; - virtual std::ostream& display_justification(std::ostream& out, ext_justification_idx idx) const; - virtual void collect_statistics(statistics& st) const; - virtual extension* copy(solver* s); - virtual extension* copy(lookahead* s, bool learned); - virtual void find_mutexes(literal_vector& lits, vector & mutexes); - virtual void pop_reinit(); - virtual void gc(); - virtual double get_reward(literal l, ext_justification_idx idx, literal_occs_fun& occs) const; - virtual bool is_extended_binary(ext_justification_idx idx, literal_vector & r); - virtual void init_use_list(ext_use_list& ul); - virtual bool is_blocked(literal l, ext_constraint_idx idx); - virtual bool check_model(model const& m) const; + bool propagate(literal l, ext_constraint_idx idx) override; + lbool resolve_conflict() override; + void get_antecedents(literal l, ext_justification_idx idx, literal_vector & r) override; + void asserted(literal l) override; + check_result check() override; + void push() override; + void pop(unsigned n) override; + void simplify() override; + void clauses_modifed() override; + lbool get_phase(bool_var v) override; + bool set_root(literal l, literal r) override; + void flush_roots() override; + std::ostream& display(std::ostream& out) const override; + std::ostream& display_justification(std::ostream& out, ext_justification_idx idx) const override; + void collect_statistics(statistics& st) const override; + extension* copy(solver* s) override; + extension* copy(lookahead* s, bool learned) override; + void find_mutexes(literal_vector& lits, vector & mutexes) override; + void pop_reinit() override; + void gc() override; + unsigned max_var(unsigned w) const override; + double get_reward(literal l, ext_justification_idx idx, literal_occs_fun& occs) const override; + bool is_extended_binary(ext_justification_idx idx, literal_vector & r) override; + void init_use_list(ext_use_list& ul) override; + bool is_blocked(literal l, ext_constraint_idx idx) override; + bool check_model(model const& m) const override; ptr_vector const & constraints() const { return m_constraints; } void display(std::ostream& out, constraint const& c, bool values) const; - virtual bool validate(); + bool validate() override; }; diff --git a/src/sat/dimacs.cpp b/src/sat/dimacs.cpp index 463418b23..970e682b3 100644 --- a/src/sat/dimacs.cpp +++ b/src/sat/dimacs.cpp @@ -21,6 +21,8 @@ Revision History: #undef min #include "sat/sat_solver.h" +struct lex_error {}; + class stream_buffer { std::istream & m_stream; int m_val; @@ -67,7 +69,7 @@ void skip_line(Buffer & in) { } template -int parse_int(Buffer & in) { +int parse_int(Buffer & in, std::ostream& err) { int val = 0; bool neg = false; skip_whitespace(in); @@ -81,9 +83,8 @@ int parse_int(Buffer & in) { } if (*in < '0' || *in > '9') { - std::cerr << "(error, \"unexpected char: " << *in << " line: " << in.line() << "\")\n"; - exit(3); - exit(ERR_PARSER); + err << "(error, \"unexpected char: " << *in << " line: " << in.line() << "\")\n"; + throw lex_error(); } while (*in >= '0' && *in <= '9') { @@ -95,14 +96,14 @@ int parse_int(Buffer & in) { } template -void read_clause(Buffer & in, sat::solver & solver, sat::literal_vector & lits) { +void read_clause(Buffer & in, std::ostream& err, sat::solver & solver, sat::literal_vector & lits) { int parsed_lit; int var; lits.reset(); while (true) { - parsed_lit = parse_int(in); + parsed_lit = parse_int(in, err); if (parsed_lit == 0) break; var = abs(parsed_lit); @@ -114,24 +115,30 @@ void read_clause(Buffer & in, sat::solver & solver, sat::literal_vector & lits) } template -void parse_dimacs_core(Buffer & in, sat::solver & solver) { +bool parse_dimacs_core(Buffer & in, std::ostream& err, sat::solver & solver) { sat::literal_vector lits; - while (true) { - skip_whitespace(in); - if (*in == EOF) { - break; - } - else if (*in == 'c' || *in == 'p') { - skip_line(in); - } - else { - read_clause(in, solver, lits); - solver.mk_clause(lits.size(), lits.c_ptr()); + try { + while (true) { + skip_whitespace(in); + if (*in == EOF) { + break; + } + else if (*in == 'c' || *in == 'p') { + skip_line(in); + } + else { + read_clause(in, err, solver, lits); + solver.mk_clause(lits.size(), lits.c_ptr()); + } } } + catch (lex_error) { + return false; + } + return true; } -void parse_dimacs(std::istream & in, sat::solver & solver) { +bool parse_dimacs(std::istream & in, std::ostream& err, sat::solver & solver) { stream_buffer _in(in); - parse_dimacs_core(_in, solver); + return parse_dimacs_core(_in, err, solver); } diff --git a/src/sat/dimacs.h b/src/sat/dimacs.h index 50ebec0c8..4c5d51502 100644 --- a/src/sat/dimacs.h +++ b/src/sat/dimacs.h @@ -21,7 +21,7 @@ Revision History: #include "sat/sat_types.h" -void parse_dimacs(std::istream & s, sat::solver & solver); +bool parse_dimacs(std::istream & s, std::ostream& err, sat::solver & solver); #endif /* DIMACS_PARSER_H_ */ diff --git a/src/sat/sat_bdd.cpp b/src/sat/sat_bdd.cpp index bd1745765..e7b0632d8 100644 --- a/src/sat/sat_bdd.cpp +++ b/src/sat/sat_bdd.cpp @@ -87,7 +87,7 @@ namespace sat { try { return apply_rec(arg1, arg2, op); } - catch (mem_out) { + catch (const mem_out &) { try_reorder(); if (!first) throw; first = false; @@ -546,7 +546,7 @@ namespace sat { try { return bdd(mk_not_rec(b.root), this); } - catch (mem_out) { + catch (const mem_out &) { try_reorder(); if (!first) throw; first = false; @@ -575,7 +575,7 @@ namespace sat { try { return bdd(mk_ite_rec(c.root, t.root, e.root), this); } - catch (mem_out) { + catch (const mem_out &) { try_reorder(); if (!first) throw; first = false; diff --git a/src/sat/sat_big.cpp b/src/sat/sat_big.cpp index 35898a110..c1eeecd27 100644 --- a/src/sat/sat_big.cpp +++ b/src/sat/sat_big.cpp @@ -22,7 +22,8 @@ Revision History: namespace sat { big::big(random_gen& rand): - m_rand(rand) { + m_rand(rand), + m_include_cardinality(false) { } void big::init(solver& s, bool learned) { @@ -42,22 +43,22 @@ namespace sat { m_roots[v.index()] = false; edges.push_back(v); } -#if 0 - if (w.is_ext_constraint() && + if (m_include_cardinality && + w.is_ext_constraint() && s.m_ext && - learned && + learned && // cannot (yet) observe if ext constraints are learned !seen_idx.contains(w.get_ext_constraint_idx()) && s.m_ext->is_extended_binary(w.get_ext_constraint_idx(), r)) { seen_idx.insert(w.get_ext_constraint_idx(), true); - for (unsigned i = 0; i < r.size(); ++i) { - literal u = r[i]; - for (unsigned j = i + 1; j < r.size(); ++j) { - // add ~r[i] -> r[j] - literal v = r[j]; - literal u = ~r[j]; + for (unsigned i = 0; i < std::min(4u, r.size()); ++i) { + shuffle(r.size(), r.c_ptr(), m_rand); + literal u = r[0]; + for (unsigned j = 1; j < r.size(); ++j) { + literal v = ~r[j]; + // add u -> v m_roots[v.index()] = false; m_dag[u.index()].push_back(v); - // add ~r[j] -> r[i] + // add ~v -> ~u v.neg(); u.neg(); m_roots[u.index()] = false; @@ -65,7 +66,6 @@ namespace sat { } } } -#endif } } done_adding_edges(); @@ -268,6 +268,16 @@ namespace sat { return out << v; } + literal big::get_root(literal l) { + literal r = l; + do { + l = r; + r = m_root[l.index()]; + } + while (r != l); + return r; + } + void big::display(std::ostream& out) const { unsigned idx = 0; for (auto& next : m_dag) { diff --git a/src/sat/sat_big.h b/src/sat/sat_big.h index 898ddd1e8..25093fd60 100644 --- a/src/sat/sat_big.h +++ b/src/sat/sat_big.h @@ -34,6 +34,7 @@ namespace sat { svector m_left, m_right; literal_vector m_root, m_parent; bool m_learned; + bool m_include_cardinality; svector> m_del_bin; @@ -54,6 +55,9 @@ namespace sat { // static svector> s_del_bin; big(random_gen& rand); + + void set_include_cardinality(bool f) { m_include_cardinality = f; } + /** \brief initialize a BIG from a solver. */ @@ -77,7 +81,7 @@ namespace sat { int get_left(literal l) const { return m_left[l.index()]; } int get_right(literal l) const { return m_right[l.index()]; } literal get_parent(literal l) const { return m_parent[l.index()]; } - literal get_root(literal l) const { return m_root[l.index()]; } + literal get_root(literal l); bool reaches(literal u, literal v) const { return m_left[u.index()] < m_left[v.index()] && m_right[v.index()] < m_right[u.index()]; } bool connected(literal u, literal v) const { return reaches(u, v) || reaches(~v, ~u); } void display(std::ostream& out) const; diff --git a/src/sat/sat_clause.cpp b/src/sat/sat_clause.cpp index 3cbd3015b..31a4bba72 100644 --- a/src/sat/sat_clause.cpp +++ b/src/sat/sat_clause.cpp @@ -111,7 +111,7 @@ namespace sat { clause_offset clause::get_new_offset() const { unsigned o1 = m_lits[0].index(); -#if defined(_AMD64_) || defined(_M_IA64) +#if defined(__LP64__) || defined(_WIN64) if (sizeof(clause_offset) == 8) { unsigned o2 = m_lits[1].index(); return (clause_offset)o1 + (((clause_offset)o2) << 32); @@ -122,7 +122,7 @@ namespace sat { void clause::set_new_offset(clause_offset offset) { m_lits[0] = to_literal(static_cast(offset)); -#if defined(_AMD64_) || defined(_M_IA64) +#if defined(__LP64__) || defined(_WIN64) if (sizeof(offset) == 8) { m_lits[1] = to_literal(static_cast(offset >> 32)); } diff --git a/src/sat/sat_config.cpp b/src/sat/sat_config.cpp index c7f2377c9..5516cdb7c 100644 --- a/src/sat/sat_config.cpp +++ b/src/sat/sat_config.cpp @@ -86,6 +86,7 @@ namespace sat { m_local_search_mode = local_search_mode::gsat; else m_local_search_mode = local_search_mode::wsat; + m_local_search_dbg_flips = p.local_search_dbg_flips(); m_unit_walk = p.unit_walk(); m_unit_walk_threads = p.unit_walk_threads(); m_lookahead_simplify = p.lookahead_simplify(); @@ -122,8 +123,11 @@ namespace sat { m_lookahead_cube_psat_clause_base = p.lookahead_cube_psat_clause_base(); m_lookahead_cube_psat_trigger = p.lookahead_cube_psat_trigger(); m_lookahead_global_autarky = p.lookahead_global_autarky(); + m_lookahead_delta_fraction = p.lookahead_delta_fraction(); m_lookahead_use_learned = p.lookahead_use_learned(); - + if (m_lookahead_delta_fraction < 0 || m_lookahead_delta_fraction > 1.0) { + throw sat_param_exception("invalid value for delta fraction. It should be a number in the interval 0 to 1"); + } // These parameters are not exposed m_next_simplify1 = _p.get_uint("next_simplify", 30000); @@ -152,6 +156,8 @@ namespace sat { m_gc_burst = p.gc_burst(); m_gc_defrag = p.gc_defrag(); + m_force_cleanup = p.force_cleanup(); + m_minimize_lemmas = p.minimize_lemmas(); m_core_minimize = p.core_minimize(); m_core_minimize_partial = p.core_minimize_partial(); @@ -196,6 +202,22 @@ namespace sat { else throw sat_param_exception("invalid PB solver: solver, totalizer, circuit, sorting, segmented"); + s = p.pb_resolve(); + if (s == "cardinality") + m_pb_resolve = PB_CARDINALITY; + else if (s == "rounding") + m_pb_resolve = PB_ROUNDING; + else + throw sat_param_exception("invalid PB resolve: 'cardinality' or 'rounding' expected"); + + s = p.pb_lemma_format(); + if (s == "cardinality") + m_pb_lemma_format = PB_LEMMA_CARDINALITY; + else if (s == "pb") + m_pb_lemma_format = PB_LEMMA_PB; + else + throw sat_param_exception("invalid PB lemma format: 'cardinality' or 'pb' expected"); + m_card_solver = p.cardinality_solver(); sat_simplifier_params sp(_p); diff --git a/src/sat/sat_config.h b/src/sat/sat_config.h index 37efe69ed..deb67b197 100644 --- a/src/sat/sat_config.h +++ b/src/sat/sat_config.h @@ -60,6 +60,16 @@ namespace sat { PB_SEGMENTED }; + enum pb_resolve { + PB_CARDINALITY, + PB_ROUNDING + }; + + enum pb_lemma_format { + PB_LEMMA_CARDINALITY, + PB_LEMMA_PB + }; + enum reward_t { ternary_reward, unit_literal_reward, @@ -105,6 +115,7 @@ namespace sat { unsigned m_local_search_threads; bool m_local_search; local_search_mode m_local_search_mode; + bool m_local_search_dbg_flips; unsigned m_unit_walk_threads; bool m_unit_walk; bool m_lookahead_simplify; @@ -118,6 +129,7 @@ namespace sat { double m_lookahead_cube_psat_trigger; reward_t m_lookahead_reward; bool m_lookahead_global_autarky; + double m_lookahead_delta_fraction; bool m_lookahead_use_learned; bool m_incremental; @@ -136,6 +148,8 @@ namespace sat { bool m_gc_burst; bool m_gc_defrag; + bool m_force_cleanup; + bool m_minimize_lemmas; bool m_dyn_sub_res; @@ -148,6 +162,8 @@ namespace sat { pb_solver m_pb_solver; bool m_card_solver; + pb_resolve m_pb_resolve; + pb_lemma_format m_pb_lemma_format; // branching heuristic settings. branching_heuristic m_branching_heuristic; diff --git a/src/sat/sat_drat.cpp b/src/sat/sat_drat.cpp index 00a3fa076..529a6bc57 100644 --- a/src/sat/sat_drat.cpp +++ b/src/sat/sat_drat.cpp @@ -26,7 +26,7 @@ Notes: namespace sat { drat::drat(solver& s): s(s), - m_out(0), + m_out(nullptr), m_inconsistent(false), m_check_unsat(false), m_check_sat(false), @@ -288,7 +288,6 @@ namespace sat { display(tout); s.display(tout);); UNREACHABLE(); - exit(0); } } diff --git a/src/sat/sat_extension.h b/src/sat/sat_extension.h index e687ab2b0..41aebb97e 100644 --- a/src/sat/sat_extension.h +++ b/src/sat/sat_extension.h @@ -80,6 +80,7 @@ namespace sat { virtual void init_use_list(ext_use_list& ul) = 0; virtual bool is_blocked(literal l, ext_constraint_idx) = 0; virtual bool check_model(model const& m) const = 0; + virtual unsigned max_var(unsigned w) const = 0; }; }; diff --git a/src/sat/sat_local_search.cpp b/src/sat/sat_local_search.cpp index af2447fc2..b65abfd23 100644 --- a/src/sat/sat_local_search.cpp +++ b/src/sat/sat_local_search.cpp @@ -529,7 +529,7 @@ namespace sat { } lbool local_search::check() { - return check(0, 0); + return check(0, nullptr); } #define PROGRESS(tries, flips) \ @@ -553,6 +553,7 @@ namespace sat { PROGRESS(tries, total_flips); for (tries = 1; !m_unsat_stack.empty() && m_limit.inc(); ++tries) { + ++m_stats.m_num_restarts; for (step = 0; step < m_max_steps && !m_unsat_stack.empty(); ++step) { pick_flip_walksat(); if (m_unsat_stack.size() < m_best_unsat) { @@ -622,7 +623,6 @@ namespace sat { break; } - // remove unit clauses from assumptions. m_constraints.shrink(num_constraints() - sz); @@ -779,8 +779,11 @@ namespace sat { } void local_search::flip_walksat(bool_var flipvar) { + ++m_stats.m_num_flips; VERIFY(!is_unit(flipvar)); m_vars[flipvar].m_value = !cur_solution(flipvar); + m_vars[flipvar].m_flips++; + m_vars[flipvar].m_slow_break.update(abs(m_vars[flipvar].m_slack_score)); bool flip_is_true = cur_solution(flipvar); coeff_vector const& truep = m_vars[flipvar].m_watch[flip_is_true]; @@ -1062,6 +1065,19 @@ namespace sat { return out << "v" << v << " := " << (vi.m_value?"true":"false") << " bias: " << vi.m_bias << "\n"; } + void local_search::collect_statistics(statistics& st) const { + if (m_config.dbg_flips()) { + unsigned i = 0; + for (var_info const& vi : m_vars) { + IF_VERBOSE(0, verbose_stream() << "flips: " << i << " " << vi.m_flips << " " << vi.m_slow_break << "\n"); + ++i; + } + } + st.update("local-search-flips", m_stats.m_num_flips); + st.update("local-search-restarts", m_stats.m_num_restarts); + } + + bool local_search::check_goodvar() { unsigned g = 0; for (unsigned v = 0; v < num_vars(); ++v) { diff --git a/src/sat/sat_local_search.h b/src/sat/sat_local_search.h index 8a63898c3..849b4f26b 100644 --- a/src/sat/sat_local_search.h +++ b/src/sat/sat_local_search.h @@ -23,6 +23,8 @@ #include "sat/sat_types.h" #include "sat/sat_config.h" #include "util/rlimit.h" +#include "util/ema.h" +#include "util/statistics.h" namespace sat { @@ -33,18 +35,21 @@ namespace sat { int m_best_known_value; local_search_mode m_mode; bool m_phase_sticky; + bool m_dbg_flips; public: local_search_config() { m_random_seed = 0; m_best_known_value = INT_MAX; m_mode = local_search_mode::wsat; m_phase_sticky = false; + m_dbg_flips = false; } unsigned random_seed() const { return m_random_seed; } unsigned best_known_value() const { return m_best_known_value; } local_search_mode mode() const { return m_mode; } bool phase_sticky() const { return m_phase_sticky; } + bool dbg_flips() const { return m_dbg_flips; } void set_random_seed(unsigned s) { m_random_seed = s; } void set_best_known_value(unsigned v) { m_best_known_value = v; } @@ -53,6 +58,7 @@ namespace sat { m_mode = cfg.m_local_search_mode; m_random_seed = cfg.m_random_seed; m_phase_sticky = cfg.m_phase_sticky; + m_dbg_flips = cfg.m_local_search_dbg_flips; } }; @@ -74,6 +80,13 @@ namespace sat { int coefficient; // non-zero integer ob_term(bool_var v, int c): var_id(v), coefficient(c) {} }; + + struct stats { + unsigned m_num_flips; + unsigned m_num_restarts; + void reset() { memset(this, 0, sizeof(*this)); } + stats() { reset(); } + }; struct var_info { bool m_value; // current solution @@ -89,6 +102,8 @@ namespace sat { bool_var_vector m_neighbors; // neighborhood variables coeff_vector m_watch[2]; literal_vector m_bin[2]; + unsigned m_flips; + ema m_slow_break; var_info(): m_value(true), m_bias(50), @@ -97,7 +112,9 @@ namespace sat { m_in_goodvar_stack(false), m_score(0), m_slack_score(0), - m_cscc(0) + m_cscc(0), + m_flips(0), + m_slow_break(1e-5) {} }; @@ -115,10 +132,12 @@ namespace sat { literal const* end() const { return m_literals.end(); } }; + stats m_stats; + local_search_config m_config; // objective function: maximize - svector ob_constraint; // the objective function *constraint*, sorted in decending order + svector ob_constraint; // the objective function *constraint*, sorted in descending order // information about the variable int_vector coefficient_in_ob_constraint; // var! initialized to be 0 @@ -145,7 +164,6 @@ namespace sat { inline void set_best_unsat(); /* TBD: other scores */ - vector m_constraints; @@ -169,8 +187,8 @@ namespace sat { // unsat constraint stack bool m_is_unsat; - unsigned_vector m_unsat_stack; // store all the unsat constraits - unsigned_vector m_index_in_unsat_stack; // which position is a contraint in the unsat_stack + unsigned_vector m_unsat_stack; // store all the unsat constraints + unsigned_vector m_index_in_unsat_stack; // which position is a constraint in the unsat_stack // configuration changed decreasing variables (score>0 and conf_change==true) bool_var_vector m_goodvar_stack; @@ -277,7 +295,7 @@ namespace sat { lbool check(); - lbool check(unsigned sz, literal const* assumptions, parallel* p = 0); + lbool check(unsigned sz, literal const* assumptions, parallel* p = nullptr); local_search_config& config() { return m_config; } @@ -293,6 +311,8 @@ namespace sat { model& get_model() { return m_model; } + void collect_statistics(statistics& st) const; + }; } diff --git a/src/sat/sat_lookahead.cpp b/src/sat/sat_lookahead.cpp index 3833e2a52..0e364180c 100644 --- a/src/sat/sat_lookahead.cpp +++ b/src/sat/sat_lookahead.cpp @@ -16,6 +16,8 @@ Author: Notes: + + --*/ #include @@ -31,7 +33,7 @@ namespace sat { } lookahead::scoped_ext::~scoped_ext() { - if (p.m_s.m_ext) p.m_s.m_ext->set_lookahead(0); + if (p.m_s.m_ext) p.m_s.m_ext->set_lookahead(nullptr); } lookahead::scoped_assumptions::scoped_assumptions(lookahead& p, literal_vector const& lits): p(p), lits(lits) { @@ -995,6 +997,7 @@ namespace sat { void lookahead::init(bool learned) { m_delta_trigger = 0.0; m_delta_decrease = 0.0; + m_delta_fraction = m_s.m_config.m_lookahead_delta_fraction; m_config.m_dl_success = 0.8; m_inconsistent = false; m_qhead = 0; @@ -1215,10 +1218,10 @@ namespace sat { lookahead& lh; public: lookahead_literal_occs_fun(lookahead& lh): lh(lh) {} - double operator()(literal l) { return lh.literal_occs(l); } + double operator()(literal l) override { return lh.literal_occs(l); } }; - // Ternary clause managagement: + // Ternary clause management: void lookahead::add_ternary(literal u, literal v, literal w) { SASSERT(u != w && u != v && v != w && ~u != w && ~u != v && ~w != v); @@ -1375,7 +1378,7 @@ namespace sat { } - // new n-ary clause managment + // new n-ary clause management void lookahead::add_clause(clause const& c) { SASSERT(c.size() > 3); @@ -1634,7 +1637,7 @@ namespace sat { } // Sum_{ clause C that contains ~l } 1 - // FIXME: counts occurences of ~l; misleading + // FIXME: counts occurrences of ~l; misleading double lookahead::literal_occs(literal l) { double result = m_binary[l.index()].size(); result += literal_big_occs(l); @@ -1642,7 +1645,7 @@ namespace sat { } // Sum_{ clause C that contains ~l such that |C| > 2} 1 - // FIXME: counts occurences of ~l; misleading + // FIXME: counts occurrences of ~l; misleading double lookahead::literal_big_occs(literal l) { double result = m_nary_count[(~l).index()]; result += m_ternary_count[(~l).index()]; @@ -1716,7 +1719,7 @@ namespace sat { } // VERIFY(!missed_propagation()); if (unsat) { - TRACE("sat", tout << "backtracking and settting " << ~lit << "\n";); + TRACE("sat", tout << "backtracking and setting " << ~lit << "\n";); lookahead_backtrack(); assign(~lit); propagate(); @@ -1812,7 +1815,7 @@ namespace sat { ++m_stats.m_double_lookahead_rounds; num_units = double_look(l, base); if (!inconsistent()) { - m_delta_trigger = get_lookahead_reward(l); + m_delta_trigger = m_delta_fraction*get_lookahead_reward(l); dl_disable(l); } } @@ -2055,6 +2058,15 @@ namespace sat { return h; } + bool lookahead::should_cutoff(unsigned depth) { + return depth > 0 && + ((m_config.m_cube_cutoff == depth_cutoff && depth == m_config.m_cube_depth) || + (m_config.m_cube_cutoff == freevars_cutoff && m_freevars.size() <= m_init_freevars * m_config.m_cube_freevars) || + (m_config.m_cube_cutoff == psat_cutoff && psat_heur() >= m_config.m_cube_psat_trigger) || + (m_config.m_cube_cutoff == adaptive_freevars_cutoff && m_freevars.size() < m_cube_state.m_freevars_threshold) || + (m_config.m_cube_cutoff == adaptive_psat_cutoff && psat_heur() >= m_cube_state.m_psat_threshold)); + } + lbool lookahead::cube(bool_var_vector& vars, literal_vector& lits, unsigned backtrack_level) { scoped_ext _scoped_ext(*this); lits.reset(); @@ -2087,7 +2099,9 @@ namespace sat { m_cube_state.m_freevars_threshold = m_freevars.size(); m_cube_state.m_psat_threshold = m_config.m_cube_cutoff == adaptive_psat_cutoff ? psat_heur() : dbl_max; // MN. only compute PSAT if enabled m_cube_state.inc_conflict(); - if (!backtrack(m_cube_state.m_cube, m_cube_state.m_is_decision)) return l_false; + if (!backtrack(m_cube_state.m_cube, m_cube_state.m_is_decision)) { + return l_false; + } continue; } pick_up_work: @@ -2100,22 +2114,13 @@ namespace sat { } backtrack_level = UINT_MAX; depth = m_cube_state.m_cube.size(); - if ((m_config.m_cube_cutoff == depth_cutoff && depth == m_config.m_cube_depth) || - (m_config.m_cube_cutoff == freevars_cutoff && m_freevars.size() <= m_init_freevars * m_config.m_cube_freevars) || - (m_config.m_cube_cutoff == psat_cutoff && psat_heur() >= m_config.m_cube_psat_trigger) || - (m_config.m_cube_cutoff == adaptive_freevars_cutoff && m_freevars.size() < m_cube_state.m_freevars_threshold) || - (m_config.m_cube_cutoff == adaptive_psat_cutoff && psat_heur() >= m_cube_state.m_psat_threshold)) { + if (should_cutoff(depth)) { double dec = (1.0 - pow(m_config.m_cube_fraction, depth)); m_cube_state.m_freevars_threshold *= dec; m_cube_state.m_psat_threshold *= 2.0 - dec; set_conflict(); m_cube_state.inc_cutoff(); -#if 0 - // return cube of all literals, not just the ones in the main cube - lits.append(m_trail.size() - init_trail, m_trail.c_ptr() + init_trail); -#else lits.append(m_cube_state.m_cube); -#endif vars.reset(); for (auto v : m_freevars) if (in_reduced_clause(v)) vars.push_back(v); backtrack(m_cube_state.m_cube, m_cube_state.m_is_decision); @@ -2129,12 +2134,16 @@ namespace sat { m_cube_state.m_freevars_threshold = prev_nfreevars; m_cube_state.m_psat_threshold = prev_psat; m_cube_state.inc_conflict(); - if (!backtrack(m_cube_state.m_cube, m_cube_state.m_is_decision)) return l_false; + if (!backtrack(m_cube_state.m_cube, m_cube_state.m_is_decision)) { + return l_false; + } continue; } if (lit == null_literal) { vars.reset(); for (auto v : m_freevars) if (in_reduced_clause(v)) vars.push_back(v); + m_model.reset(); + init_model(); return l_true; } TRACE("sat", tout << "choose: " << lit << " cube: " << m_cube_state.m_cube << "\n";); @@ -2156,7 +2165,7 @@ namespace sat { if (is_undef(lit)) { val = l_undef; } - if (is_true(lit)) { + else if (is_true(lit)) { val = l_true; } else { diff --git a/src/sat/sat_lookahead.h b/src/sat/sat_lookahead.h index df954bdf1..2d725f415 100644 --- a/src/sat/sat_lookahead.h +++ b/src/sat/sat_lookahead.h @@ -198,6 +198,7 @@ namespace sat { config m_config; double m_delta_trigger; double m_delta_decrease; + double m_delta_fraction; drat m_drat; literal_vector m_assumptions; @@ -471,7 +472,7 @@ namespace sat { watch_list& get_wlist(literal l) { return m_watches[l.index()]; } watch_list const& get_wlist(literal l) const { return m_watches[l.index()]; } - // new clause managment: + // new clause management: void add_ternary(literal u, literal v, literal w); void propagate_ternary(literal l); lbool propagate_ternary(literal l1, literal l2); @@ -558,6 +559,8 @@ namespace sat { double psat_heur(); + bool should_cutoff(unsigned depth); + public: lookahead(solver& s) : m_s(s), diff --git a/src/sat/sat_model_converter.cpp b/src/sat/sat_model_converter.cpp index d132f1cd4..17885f4e5 100644 --- a/src/sat/sat_model_converter.cpp +++ b/src/sat/sat_model_converter.cpp @@ -95,7 +95,7 @@ namespace sat { IF_VERBOSE(0, display(verbose_stream() << "violated ate\n", *it) << "\n"); IF_VERBOSE(0, for (unsigned v = 0; v < m.size(); ++v) verbose_stream() << v << " := " << m[v] << "\n";); IF_VERBOSE(0, display(verbose_stream())); - exit(0); + UNREACHABLE(); first = false; } if (!sat && it->get_kind() != ATE && v0 != null_bool_var) { diff --git a/src/sat/sat_model_converter.h b/src/sat/sat_model_converter.h index 65e132729..2ca340e5d 100644 --- a/src/sat/sat_model_converter.h +++ b/src/sat/sat_model_converter.h @@ -119,6 +119,7 @@ namespace sat { void add_ate(clause const& c); bool empty() const { return m_entries.empty(); } + unsigned size() const { return m_entries.size(); } void reset(); bool check_invariant(unsigned num_vars) const; diff --git a/src/sat/sat_par.cpp b/src/sat/sat_par.cpp deleted file mode 100644 index e3d5727ed..000000000 --- a/src/sat/sat_par.cpp +++ /dev/null @@ -1,45 +0,0 @@ -/*++ -Copyright (c) 2017 Microsoft Corporation - -Module Name: - - sat_par.cpp - -Abstract: - - Utilities for parallel SAT solving. - -Author: - - Nikolaj Bjorner (nbjorner) 2017-1-29. - -Revision History: - ---*/ -#include "sat/sat_par.h" - - -namespace sat { - - par::par() {} - - void par::exchange(literal_vector const& in, unsigned& limit, literal_vector& out) { - #pragma omp critical (par_solver) - { - if (limit < m_units.size()) { - // this might repeat some literals. - out.append(m_units.size() - limit, m_units.c_ptr() + limit); - } - for (unsigned i = 0; i < in.size(); ++i) { - literal lit = in[i]; - if (!m_unit_set.contains(lit.index())) { - m_unit_set.insert(lit.index()); - m_units.push_back(lit); - } - } - limit = m_units.size(); - } - } - -}; - diff --git a/src/sat/sat_par.h b/src/sat/sat_par.h deleted file mode 100644 index 001036a98..000000000 --- a/src/sat/sat_par.h +++ /dev/null @@ -1,39 +0,0 @@ -/*++ -Copyright (c) 2017 Microsoft Corporation - -Module Name: - - sat_par.h - -Abstract: - - Utilities for parallel SAT solving. - -Author: - - Nikolaj Bjorner (nbjorner) 2017-1-29. - -Revision History: - ---*/ -#ifndef SAT_PAR_H_ -#define SAT_PAR_H_ - -#include "sat/sat_types.h" -#include "util/hashtable.h" -#include "util/map.h" - -namespace sat { - - class par { - typedef hashtable index_set; - literal_vector m_units; - index_set m_unit_set; - public: - par(); - void exchange(literal_vector const& in, unsigned& limit, literal_vector& out); - }; - -}; - -#endif diff --git a/src/sat/sat_parallel.cpp b/src/sat/sat_parallel.cpp index c6e29f64c..ce2080f8c 100644 --- a/src/sat/sat_parallel.cpp +++ b/src/sat/sat_parallel.cpp @@ -232,7 +232,7 @@ namespace sat { } if (m_consumer_ready && (m_num_clauses == 0 || (m_num_clauses > s.m_clauses.size()))) { // time to update local search with new clauses. - // there could be multiple local search engines runing at the same time. + // there could be multiple local search engines running at the same time. IF_VERBOSE(1, verbose_stream() << "(sat-parallel refresh :from " << m_num_clauses << " :to " << s.m_clauses.size() << ")\n";); m_solver_copy = alloc(solver, s.m_params, s.rlimit()); m_solver_copy->copy(s); @@ -285,17 +285,6 @@ namespace sat { return copied; } - void parallel::set_phase(local_search& s) { - #pragma omp critical (par_solver) - { - m_consumer_ready = true; - m_phase.reserve(s.num_vars(), l_undef); - for (unsigned i = 0; i < s.num_vars(); ++i) { - m_phase[i] = s.get_phase(i) ? l_true : l_false; - } - m_num_clauses = s.num_non_binary_clauses(); - } - } bool parallel::copy_solver(solver& s) { bool copied = false; diff --git a/src/sat/sat_parallel.h b/src/sat/sat_parallel.h index 256623380..afb148ed4 100644 --- a/src/sat/sat_parallel.h +++ b/src/sat/sat_parallel.h @@ -104,8 +104,6 @@ namespace sat { void get_phase(solver& s); - void set_phase(local_search& s); - bool get_phase(local_search& s); bool copy_solver(solver& s); diff --git a/src/sat/sat_params.pyg b/src/sat/sat_params.pyg index 89776c479..cca45aa72 100644 --- a/src/sat/sat_params.pyg +++ b/src/sat/sat_params.pyg @@ -15,7 +15,7 @@ def_module_params('sat', ('restart.margin', DOUBLE, 1.1, 'margin between fast and slow restart factors. For ema'), ('restart.emafastglue', DOUBLE, 3e-2, 'ema alpha factor for fast moving average'), ('restart.emaslowglue', DOUBLE, 1e-5, 'ema alpha factor for slow moving average'), - ('variable_decay', UINT, 110, 'multiplier (divided by 100) for the VSIDS activity increement'), + ('variable_decay', UINT, 110, 'multiplier (divided by 100) for the VSIDS activity increment'), ('inprocess.max', UINT, UINT_MAX, 'maximal number of inprocessing passes'), ('branching.heuristic', SYMBOL, 'vsids', 'branching heuristic vsids, lrb or chb'), ('branching.anti_exploration', BOOL, False, 'apply anti-exploration heuristic for branch selection'), @@ -31,6 +31,7 @@ def_module_params('sat', ('gc.burst', BOOL, False, 'perform eager garbage collection during initialization'), ('gc.defrag', BOOL, True, 'defragment clauses when garbage collecting'), ('simplify.delay', UINT, 0, 'set initial delay of simplification by a conflict count'), + ('force_cleanup', BOOL, False, 'force cleanup to remove tautologies and simplify clauses'), ('minimize_lemmas', BOOL, True, 'minimize learned clauses'), ('dyn_sub_res', BOOL, True, 'dynamic subsumption resolution for minimizing learned clauses'), ('core.minimize', BOOL, False, 'minimize computed core'), @@ -42,25 +43,51 @@ def_module_params('sat', ('drat.check_sat', BOOL, False, 'build up internal trace, check satisfying model'), ('cardinality.solver', BOOL, True, 'use cardinality solver'), ('pb.solver', SYMBOL, 'solver', 'method for handling Pseudo-Boolean constraints: circuit (arithmetical circuit), sorting (sorting circuit), totalizer (use totalizer encoding), solver (use native solver)'), - ('xor.solver', BOOL, False, 'use xor solver'), + ('xor.solver', BOOL, False, 'use xor solver'), ('cardinality.encoding', SYMBOL, 'grouped', 'encoding used for at-most-k constraints: grouped, bimander, ordered, unate, circuit'), + ('pb.resolve', SYMBOL, 'cardinality', 'resolution strategy for boolean algebra solver: cardinality, rounding'), + ('pb.lemma_format', SYMBOL, 'cardinality', 'generate either cardinality or pb lemmas'), ('local_search', BOOL, False, 'use local search instead of CDCL'), ('local_search_threads', UINT, 0, 'number of local search threads to find satisfiable solution'), ('local_search_mode', SYMBOL, 'wsat', 'local search algorithm, either default wsat or qsat'), + ('local_search_dbg_flips', BOOL, False, 'write debug information for number of flips'), ('unit_walk', BOOL, False, 'use unit-walk search instead of CDCL'), ('unit_walk_threads', UINT, 0, 'number of unit-walk search threads to find satisfiable solution'), ('lookahead.cube.cutoff', SYMBOL, 'depth', 'cutoff type used to create lookahead cubes: depth, freevars, psat, adaptive_freevars, adaptive_psat'), + # - depth: the maximal cutoff is fixed to the value of lookahead.cube.depth. + # So if the value is 10, at most 1024 cubes will be generated of length 10. + # - freevars: cutoff based on a variable fraction of lookahead.cube.freevars. + # Cut if the number of current unassigned variables drops below a fraction of number of initial variables. + # - psat: Let psat_heur := (Sum_{clause C} (psat.clause_base ^ {-|C|+1})) / |freevars|^psat.var_exp + # Cut if the value of psat_heur exceeds psat.trigger + # - adaptive_freevars: Cut if the number of current unassigned variables drops below a fraction of free variables + # at the time of the last conflict. The fraction is increased every time the cutoff is created. + # - adative_psat: Cut based on psat_heur in an adaptive way. ('lookahead.cube.fraction', DOUBLE, 0.4, 'adaptive fraction to create lookahead cubes. Used when lookahead.cube.cutoff is adaptive_freevars or adaptive_psat'), ('lookahead.cube.depth', UINT, 1, 'cut-off depth to create cubes. Used when lookahead.cube.cutoff is depth.'), - ('lookahead.cube.freevars', DOUBLE, 0.8, 'cube free fariable fraction. Used when lookahead.cube.cutoff is freevars'), + ('lookahead.cube.freevars', DOUBLE, 0.8, 'cube free variable fraction. Used when lookahead.cube.cutoff is freevars'), ('lookahead.cube.psat.var_exp', DOUBLE, 1, 'free variable exponent for PSAT cutoff'), ('lookahead.cube.psat.clause_base', DOUBLE, 2, 'clause base for PSAT cutoff'), ('lookahead.cube.psat.trigger', DOUBLE, 5, 'trigger value to create lookahead cubes for PSAT cutoff. Used when lookahead.cube.cutoff is psat'), - ('lookahead_search', BOOL, False, 'use lookahead solver'), ('lookahead.preselect', BOOL, False, 'use pre-selection of subset of variables for branching'), ('lookahead_simplify', BOOL, False, 'use lookahead solver during simplification'), ('lookahead.use_learned', BOOL, False, 'use learned clauses when selecting lookahead literal'), ('lookahead_simplify.bca', BOOL, True, 'add learned binary clauses as part of lookahead simplification'), ('lookahead.global_autarky', BOOL, False, 'prefer to branch on variables that occur in clauses that are reduced'), - ('lookahead.reward', SYMBOL, 'march_cu', 'select lookahead heuristic: ternary, heule_schur (Heule Schur), heuleu (Heule Unit), unit, or march_cu'))) + ('lookahead.delta_fraction', DOUBLE, 1.0, 'number between 0 and 1, the smaller the more literals are selected for double lookahead'), + ('lookahead.reward', SYMBOL, 'march_cu', 'select lookahead heuristic: ternary, heule_schur (Heule Schur), heuleu (Heule Unit), unit, or march_cu')) + # reward function used to determine which literal to cube on. + # - ternary: reward function useful for random 3-SAT instances. Used by Heule and Knuth in March. + # - heule_schur: reward function based on "Schur Number 5", Heule, AAAI 2018 + # The score of a literal lit is: + # Sum_{C in Clauses | lit in C} 2 ^ (- |C|+1) + # * Sum_{lit' in C | lit' != lit} lit_occs(~lit') + # / | C | + # where lit_occs(lit) is the number of clauses containing lit. + # - heuleu: The score of a literal lit is: Sum_{C in Clauses | lit in C} 2 ^ (-|C| + 1) + # - unit: heule_schur + also counts number of unit clauses. + # - march_cu: default reward function used in a version of March + # Each reward function also comes with its own variant of "mix_diff", which + # is the function for combining reward metrics for the positive and negative variant of a literal. + ) diff --git a/src/sat/sat_scc.h b/src/sat/sat_scc.h index 146bd2366..1ba646992 100644 --- a/src/sat/sat_scc.h +++ b/src/sat/sat_scc.h @@ -60,7 +60,6 @@ namespace sat { void ensure_big(bool learned) { m_big.ensure_big(m_solver, learned); } int get_left(literal l) const { return m_big.get_left(l); } int get_right(literal l) const { return m_big.get_right(l); } - literal get_root(literal l) const { return m_big.get_root(l); } bool connected(literal u, literal v) const { return m_big.connected(u, v); } }; }; diff --git a/src/sat/sat_simplifier.cpp b/src/sat/sat_simplifier.cpp index d19cd14d4..21d264af5 100644 --- a/src/sat/sat_simplifier.cpp +++ b/src/sat/sat_simplifier.cpp @@ -984,7 +984,7 @@ namespace sat { queue m_queue; literal_vector m_covered_clause; // covered clause - svector m_covered_antecedent; // explainations for literals in covered clause + svector m_covered_antecedent; // explanations for literals in covered clause literal_vector m_intersection; // current resolution intersection literal_vector m_tautology; // literals that are used in blocking tautology literal_vector m_new_intersection; diff --git a/src/sat/sat_simplifier.h b/src/sat/sat_simplifier.h index 3787b5894..990b87b10 100644 --- a/src/sat/sat_simplifier.h +++ b/src/sat/sat_simplifier.h @@ -74,7 +74,7 @@ namespace sat { // config bool m_abce; // block clauses using asymmetric added literals bool m_cce; // covered clause elimination - bool m_acce; // cce with asymetric literal addition + bool m_acce; // cce with asymmetric literal addition bool m_bca; // blocked (binary) clause addition. unsigned m_bce_delay; bool m_bce; // blocked clause elimination diff --git a/src/sat/sat_simplifier_params.pyg b/src/sat/sat_simplifier_params.pyg index 3757aad2d..60ca4a49b 100644 --- a/src/sat/sat_simplifier_params.pyg +++ b/src/sat/sat_simplifier_params.pyg @@ -2,7 +2,7 @@ def_module_params(module_name='sat', class_name='sat_simplifier_params', export=True, params=(('bce', BOOL, False, 'eliminate blocked clauses'), - ('abce', BOOL, False, 'eliminate blocked clauses using asymmmetric literals'), + ('abce', BOOL, False, 'eliminate blocked clauses using asymmetric literals'), ('cce', BOOL, False, 'eliminate covered clauses'), ('ate', BOOL, True, 'asymmetric tautology elimination'), ('acce', BOOL, False, 'eliminate covered clauses using asymmetric added literals'), @@ -11,7 +11,7 @@ def_module_params(module_name='sat', ('bce_delay', UINT, 2, 'delay eliminate blocked clauses until simplification round'), ('retain_blocked_clauses', BOOL, True, 'retain blocked clauses as lemmas'), ('blocked_clause_limit', UINT, 100000000, 'maximum number of literals visited during blocked clause elimination'), - ('override_incremental', BOOL, False, 'override incemental safety gaps. Enable elimination of blocked clauses and variables even if solver is reused'), + ('override_incremental', BOOL, False, 'override incremental safety gaps. Enable elimination of blocked clauses and variables even if solver is reused'), ('resolution.limit', UINT, 500000000, 'approx. maximum number of literals visited during variable elimination'), ('resolution.occ_cutoff', UINT, 10, 'first cutoff (on number of positive/negative occurrences) for Boolean variable elimination'), ('resolution.occ_cutoff_range1', UINT, 8, 'second cutoff (number of positive/negative occurrences) for Boolean variable elimination, for problems containing less than res_cls_cutoff1 clauses'), diff --git a/src/sat/sat_solver.cpp b/src/sat/sat_solver.cpp index 7ddc80813..fc5fce252 100644 --- a/src/sat/sat_solver.cpp +++ b/src/sat/sat_solver.cpp @@ -66,18 +66,21 @@ namespace sat { m_next_simplify = 0; m_num_checkpoints = 0; m_simplifications = 0; - m_ext = 0; + m_ext = nullptr; m_cuber = nullptr; + m_local_search = nullptr; m_mc.set_solver(this); } solver::~solver() { - m_ext = 0; + m_ext = nullptr; SASSERT(check_invariant()); TRACE("sat", tout << "Delete clauses\n";); del_clauses(m_clauses); TRACE("sat", tout << "Delete learned\n";); del_clauses(m_learned); + dealloc(m_cuber); + m_cuber = nullptr; } void solver::del_clauses(clause_vector& clauses) { @@ -340,12 +343,6 @@ namespace sat { } void solver::mk_bin_clause(literal l1, literal l2, bool learned) { -#if 0 - if ((l1.var() == 2039 || l2.var() == 2039) && - (l1.var() == 27042 || l2.var() == 27042)) { - IF_VERBOSE(1, verbose_stream() << "mk_bin: " << l1 << " " << l2 << " " << learned << "\n"); - } -#endif if (find_binary_watch(get_wlist(~l1), ~l2)) { assign(l1, justification()); return; @@ -762,9 +759,9 @@ namespace sat { m_not_l = not_l; } - void solver::assign_core(literal l, justification j) { + void solver::assign_core(literal l, unsigned lvl, justification j) { SASSERT(value(l) == l_undef); - TRACE("sat_assign_core", tout << l << " " << j << " level: " << scope_lvl() << "\n";); + TRACE("sat_assign_core", tout << l << " " << j << " level: " << lvl << "\n";); if (at_base_lvl()) { if (m_config.m_drat) m_drat.add(l, !j.is_none()); j = justification(); // erase justification for level 0 @@ -772,7 +769,7 @@ namespace sat { m_assignment[l.index()] = l_true; m_assignment[(~l).index()] = l_false; bool_var v = l.var(); - m_level[v] = scope_lvl(); + m_level[v] = lvl; m_justification[v] = j; m_phase[v] = static_cast(l.sign()); m_assigned_since_gc[v] = true; @@ -880,7 +877,7 @@ namespace sat { return false; case l_undef: m_stats.m_bin_propagate++; - assign_core(l1, justification(not_l)); + assign_core(l1, scope_lvl(), justification(not_l)); break; case l_true: break; // skip @@ -895,11 +892,11 @@ namespace sat { val2 = value(l2); if (val1 == l_false && val2 == l_undef) { m_stats.m_ter_propagate++; - assign_core(l2, justification(l1, not_l)); + assign_core(l2, scope_lvl(), justification(l1, not_l)); } else if (val1 == l_undef && val2 == l_false) { m_stats.m_ter_propagate++; - assign_core(l1, justification(l2, not_l)); + assign_core(l1, scope_lvl(), justification(l2, not_l)); } else if (val1 == l_false && val2 == l_false) { CONFLICT_CLEANUP(); @@ -923,7 +920,7 @@ namespace sat { if (c[0] == not_l) std::swap(c[0], c[1]); CTRACE("propagate_bug", c[1] != not_l, tout << "l: " << l << " " << c << "\n";); - if (c.was_removed() || c[1] != not_l) { + if (c.was_removed() || c.size() == 1 || c[1] != not_l) { // Remark: this method may be invoked when the watch lists are not in a consistent state, // and may contain dead/removed clauses, or clauses with removed literals. // See: method propagate_unit at sat_simplifier.cpp @@ -962,7 +959,7 @@ namespace sat { it2++; m_stats.m_propagate++; c.mark_used(); - assign_core(c[0], justification(cls_off)); + assign_core(c[0], scope_lvl(), justification(cls_off)); #ifdef UPDATE_GLUE if (update && c.is_learned() && c.glue() > 2) { unsigned glue; @@ -1014,14 +1011,39 @@ namespace sat { } lbool solver::cube(bool_var_vector& vars, literal_vector& lits, unsigned backtrack_level) { - if (!m_cuber) { + bool is_first = !m_cuber; + if (is_first) { m_cuber = alloc(lookahead, *this); } lbool result = m_cuber->cube(vars, lits, backtrack_level); m_cuber->update_cube_statistics(m_aux_stats); - if (result == l_false) { + switch (result) { + case l_false: dealloc(m_cuber); m_cuber = nullptr; + if (is_first) { + pop_to_base_level(); + set_conflict(justification()); + } + break; + case l_true: { + lits.reset(); + pop_to_base_level(); + model const& mdl = m_cuber->get_model(); + for (bool_var v = 0; v < mdl.size(); ++v) { + if (value(v) != l_undef) { + continue; + } + literal l(v, false); + if (mdl[v] != l_true) l.neg(); + push(); + assign_core(l, scope_lvl(), justification()); + } + mk_model(); + break; + } + default: + break; } return result; } @@ -1059,7 +1081,7 @@ namespace sat { init_assumptions(num_lits, lits); propagate(false); if (check_inconsistent()) return l_false; - cleanup(); + cleanup(m_config.m_force_cleanup); if (m_config.m_unit_walk) { return do_unit_walk(); @@ -1079,6 +1101,10 @@ namespace sat { m_restart_threshold = m_config.m_restart_initial; } + if (reached_max_conflicts()) { + return l_undef; + } + // iff3_finder(*this)(); simplify_problem(); if (check_inconsistent()) return l_false; @@ -1116,7 +1142,7 @@ namespace sat { } } - catch (abort_solver) { + catch (const abort_solver &) { m_reason_unknown = "sat.giveup"; return l_undef; } @@ -1129,13 +1155,16 @@ namespace sat { lbool solver::do_local_search(unsigned num_lits, literal const* lits) { scoped_limits scoped_rl(rlimit()); - local_search srch; + SASSERT(!m_local_search); + m_local_search = alloc(local_search); + local_search& srch = *m_local_search; srch.config().set_config(m_config); srch.import(*this, false); scoped_rl.push_child(&srch.rlimit()); - lbool r = srch.check(num_lits, lits, 0); + lbool r = srch.check(num_lits, lits, nullptr); m_model = srch.get_model(); - // srch.collect_statistics(m_aux_stats); + m_local_search = nullptr; + dealloc(&srch); return r; } @@ -1270,7 +1299,7 @@ namespace sat { if (!canceled) { rlimit().reset_cancel(); } - set_par(0, 0); + set_par(nullptr, 0); ls.reset(); uw.reset(); if (finished_id == -1) { @@ -1431,7 +1460,7 @@ namespace sat { if (should_restart()) return l_undef; if (at_base_lvl()) { - cleanup(); // cleaner may propagate frozen clauses + cleanup(false); // cleaner may propagate frozen clauses if (inconsistent()) { TRACE("sat", tout << "conflict at level 0\n";); return l_false; @@ -1627,7 +1656,7 @@ namespace sat { SASSERT(at_base_lvl()); - m_cleaner(); + m_cleaner(m_config.m_force_cleanup); CASSERT("sat_simplify_bug", check_invariant()); m_scc(); @@ -1691,17 +1720,6 @@ namespace sat { #endif } - unsigned solver::get_hash() const { - unsigned result = 0; - for (clause* cp : m_clauses) { - result = combine_hash(cp->size(), combine_hash(result, cp->id())); - } - for (clause* cp : m_learned) { - result = combine_hash(cp->size(), combine_hash(result, cp->id())); - } - return result; - } - bool solver::set_root(literal l, literal r) { return !m_ext || m_ext->set_root(l, r); } @@ -1767,7 +1785,7 @@ namespace sat { TRACE("sat", for (bool_var v = 0; v < num; v++) tout << v << ": " << m_model[v] << "\n";); if (m_clone) { - IF_VERBOSE(SAT_VB_LVL, verbose_stream() << "\"checking model (on original set of clauses)\"\n";); + IF_VERBOSE(1, verbose_stream() << "\"checking model (on original set of clauses)\"\n";); if (!m_clone->check_model(m_model)) { //IF_VERBOSE(0, display(verbose_stream())); //IF_VERBOSE(0, display_watches(verbose_stream())); @@ -2647,7 +2665,7 @@ namespace sat { for (unsigned i = head; i < sz; i++) { literal l = m_trail[i]; bool_var v = l.var(); - TRACE("forget_phase", tout << "forgeting phase of l: " << l << "\n";); + TRACE("forget_phase", tout << "forgetting phase of l: " << l << "\n";); m_phase[v] = PHASE_NOT_AVAILABLE; } } @@ -3256,17 +3274,19 @@ namespace sat { } void solver::gc_var(bool_var v) { - if (v > 0) { - bool_var w = max_var(m_learned, v-1); - w = max_var(m_clauses, w); - w = max_var(true, w); - w = max_var(false, w); - v = m_mc.max_var(w); - for (literal lit : m_trail) { - if (lit.var() > w) w = lit.var(); - } - v = std::max(v, w + 1); + bool_var w = max_var(m_learned, v); + w = max_var(m_clauses, w); + w = max_var(true, w); + w = max_var(false, w); + v = m_mc.max_var(w); + for (literal lit : m_trail) { + w = std::max(w, lit.var()); } + if (m_ext) { + w = m_ext->max_var(w); + } + v = w + 1; + // v is an index of a variable that does not occur in solver state. if (v < m_level.size()) { for (bool_var i = v; i < m_level.size(); ++i) { @@ -3359,6 +3379,7 @@ namespace sat { m_asymm_branch.collect_statistics(st); m_probing.collect_statistics(st); if (m_ext) m_ext->collect_statistics(st); + if (m_local_search) m_local_search->collect_statistics(st); st.copy(m_aux_stats); } @@ -3668,10 +3689,10 @@ namespace sat { // Simplification // // ----------------------- - void solver::cleanup() { + void solver::cleanup(bool force) { if (!at_base_lvl() || inconsistent()) return; - if (m_cleaner() && m_ext) + if (m_cleaner(force) && m_ext) m_ext->clauses_modifed(); } diff --git a/src/sat/sat_solver.h b/src/sat/sat_solver.h index ad972b2af..8402fc898 100644 --- a/src/sat/sat_solver.h +++ b/src/sat/sat_solver.h @@ -37,7 +37,6 @@ Revision History: #include "sat/sat_drat.h" #include "sat/sat_parallel.h" #include "sat/sat_local_search.h" -#include "sat/sat_par.h" #include "util/params.h" #include "util/statistics.h" #include "util/stopwatch.h" @@ -164,6 +163,7 @@ namespace sat { bool m_par_syncing_clauses; class lookahead* m_cuber; + class local_search* m_local_search; statistics m_aux_stats; @@ -306,11 +306,11 @@ namespace sat { TRACE("sat_assign", tout << l << " previous value: " << value(l) << "\n";); switch (value(l)) { case l_false: set_conflict(j, ~l); break; - case l_undef: assign_core(l, j); break; + case l_undef: assign_core(l, scope_lvl(), j); break; case l_true: return; } } - void assign_core(literal l, justification jst); + void assign_core(literal l, unsigned lvl, justification jst); void set_conflict(justification c, literal not_l); void set_conflict(justification c) { set_conflict(c, null_literal); } lbool status(clause const & c) const; @@ -543,6 +543,7 @@ namespace sat { void user_push(); void user_pop(unsigned num_scopes); void pop_to_base_level(); + unsigned num_user_scopes() const { return m_user_scope_literals.size(); } reslimit& rlimit() { return m_rlimit; } // ----------------------- // @@ -550,7 +551,7 @@ namespace sat { // // ----------------------- public: - void cleanup(); + void cleanup(bool force); void simplify(bool learned = true); void asymmetric_branching(); unsigned scc_bin(); @@ -570,8 +571,6 @@ namespace sat { private: - unsigned get_hash() const; - typedef hashtable index_set; u_map m_antecedents; diff --git a/src/sat/sat_solver/CMakeLists.txt b/src/sat/sat_solver/CMakeLists.txt index 14eb4ac25..45a673367 100644 --- a/src/sat/sat_solver/CMakeLists.txt +++ b/src/sat/sat_solver/CMakeLists.txt @@ -8,4 +8,6 @@ z3_add_component(sat_solver core_tactics sat_tactic solver + TACTIC_HEADERS + inc_sat_solver.h ) diff --git a/src/sat/sat_solver/inc_sat_solver.cpp b/src/sat/sat_solver/inc_sat_solver.cpp index ff55598c2..13780529a 100644 --- a/src/sat/sat_solver/inc_sat_solver.cpp +++ b/src/sat/sat_solver/inc_sat_solver.cpp @@ -259,7 +259,7 @@ public: return m_num_scopes; } - void assert_expr_core2(expr * t, expr * a) override { + void assert_expr_core2(expr * t, expr * a) override { if (a) { m_asmsf.push_back(a); assert_expr_core(m.mk_implies(a, t)); @@ -308,10 +308,19 @@ public: return nullptr; } + expr_ref_vector last_cube(bool is_sat) { + expr_ref_vector result(m); + result.push_back(is_sat ? m.mk_true() : m.mk_false()); + return result; + } + expr_ref_vector cube(expr_ref_vector& vs, unsigned backtrack_level) override { if (!is_internalized()) { lbool r = internalize_formulas(); - if (r != l_true) return expr_ref_vector(m); + if (r != l_true) { + IF_VERBOSE(0, verbose_stream() << "internalize produced " << r << "\n"); + return expr_ref_vector(m); + } } convert_internalized(); obj_hashtable _vs; @@ -323,14 +332,6 @@ public: } sat::literal_vector lits; lbool result = m_solver.cube(vars, lits, backtrack_level); - if (result == l_false || lits.empty()) { - expr_ref_vector result(m); - result.push_back(m.mk_false()); - return result; - } - if (result == l_true) { - return expr_ref_vector(m); - } expr_ref_vector fmls(m); expr_ref_vector lit2expr(m); lit2expr.resize(m_solver.num_vars() * 2); @@ -345,6 +346,17 @@ public: vs.push_back(x); } } + switch (result) { + case l_true: + return last_cube(true); + case l_false: + return last_cube(false); + default: + break; + } + if (lits.empty()) { + set_reason_unknown(m_solver.get_reason_unknown()); + } return fmls; } @@ -473,6 +485,7 @@ public: } void convert_internalized() { + m_solver.pop_to_base_level(); if (!is_internalized() && m_fmls_head > 0) { internalize_formulas(); } @@ -800,12 +813,11 @@ private: } sat::model const & ll_m = m_solver.get_model(); mdl = alloc(model, m); - for (auto const& kv : m_map) { - expr * n = kv.m_key; - if (is_app(n) && to_app(n)->get_num_args() > 0) { + for (sat::bool_var v = 0; v < ll_m.size(); ++v) { + expr* n = m_sat_mc->var2expr(v); + if (!n || !is_app(n) || to_app(n)->get_num_args() > 0) { continue; } - sat::bool_var v = kv.m_value; switch (sat::value_at(v, ll_m)) { case l_true: mdl->register_decl(to_app(n)->get_decl(), m.mk_true()); @@ -817,23 +829,23 @@ private: break; } } - //IF_VERBOSE(0, model_v2_pp(verbose_stream(), *mdl, true);); if (m_sat_mc) { - //IF_VERBOSE(0, m_sat_mc->display(verbose_stream() << "satmc\n");); + // IF_VERBOSE(0, m_sat_mc->display(verbose_stream() << "satmc\n");); (*m_sat_mc)(mdl); } if (m_mcs.back()) { //IF_VERBOSE(0, m_mc0->display(verbose_stream() << "mc0\n");); (*m_mcs.back())(mdl); } - TRACE("sat", model_smt2_pp(tout, m, *mdl, 0);); - + TRACE("sat", model_smt2_pp(tout, m, *mdl, 0);); - if (!gparams::get_ref().get_bool("model_validate", false)) return; + if (!gparams::get_ref().get_bool("model_validate", false)) { + return; + } IF_VERBOSE(1, verbose_stream() << "Verifying solution\n";); model_evaluator eval(*mdl); - eval.set_model_completion(false); + // eval.set_model_completion(false); bool all_true = true; //unsigned i = 0; for (expr * f : m_fmls) { @@ -843,14 +855,15 @@ private: tout << "Evaluation failed: " << mk_pp(f, m) << " to " << mk_pp(f, m) << "\n"; model_smt2_pp(tout, m, *(mdl.get()), 0);); if (!m.is_true(tmp)) { - IF_VERBOSE(0, verbose_stream() << "failed to verify: " << mk_pp(f, m) << "\n";); + IF_VERBOSE(0, verbose_stream() << "failed to verify: " << mk_pp(f, m) << "\n"); + IF_VERBOSE(0, verbose_stream() << "evaluated to " << tmp << "\n"); all_true = false; } //IF_VERBOSE(0, verbose_stream() << (i++) << ": " << mk_pp(f, m) << "\n"); } if (!all_true) { IF_VERBOSE(0, verbose_stream() << m_params << "\n"); - IF_VERBOSE(0, m_sat_mc->display(verbose_stream() << "sat mc\n")); + // IF_VERBOSE(0, m_sat_mc->display(verbose_stream() << "sat mc\n")); IF_VERBOSE(0, if (m_mcs.back()) m_mcs.back()->display(verbose_stream() << "mc0\n")); //IF_VERBOSE(0, m_solver.display(verbose_stream())); IF_VERBOSE(0, for (auto const& kv : m_map) verbose_stream() << mk_pp(kv.m_key, m) << " |-> " << kv.m_value << "\n"); diff --git a/src/sat/sat_solver/inc_sat_solver.h b/src/sat/sat_solver/inc_sat_solver.h index 71ec48b99..b1cf7ad37 100644 --- a/src/sat/sat_solver/inc_sat_solver.h +++ b/src/sat/sat_solver/inc_sat_solver.h @@ -28,6 +28,9 @@ solver* mk_inc_sat_solver(ast_manager& m, params_ref const& p, bool incremental_ tactic* mk_psat_tactic(ast_manager& m, params_ref const& p); +/* + ADD_TACTIC('psat', '(try to) solve goal using a parallel SAT solver.', 'mk_psat_tactic(m, p)') +*/ void inc_sat_display(std::ostream& out, solver& s, unsigned sz, expr*const* soft, rational const* _weights); diff --git a/src/sat/tactic/goal2sat.cpp b/src/sat/tactic/goal2sat.cpp index dc4dfc3a8..68e18375f 100644 --- a/src/sat/tactic/goal2sat.cpp +++ b/src/sat/tactic/goal2sat.cpp @@ -72,7 +72,7 @@ struct goal2sat::imp { imp(ast_manager & _m, params_ref const & p, sat::solver & s, atom2bool_var & map, dep2asm_map& dep2asm, bool default_external): m(_m), pb(m), - m_ext(0), + m_ext(nullptr), m_solver(s), m_map(map), m_dep2asm(dep2asm), @@ -82,6 +82,7 @@ struct goal2sat::imp { m_is_lemma(false) { updt_params(p); m_true = sat::null_bool_var; + mk_true(); } void updt_params(params_ref const & p) { @@ -443,13 +444,23 @@ struct goal2sat::imp { convert_to_wlits(t, lits, wlits); } + void push_result(bool root, sat::literal lit, unsigned num_args) { + if (root) { + m_result_stack.reset(); + mk_clause(lit); + } + else { + m_result_stack.shrink(m_result_stack.size() - num_args); + m_result_stack.push_back(lit); + } + } + void convert_pb_ge(app* t, bool root, bool sign) { rational k = pb.get_k(t); check_unsigned(k); svector wlits; convert_pb_args(t, wlits); - unsigned sz = m_result_stack.size(); - if (root) { + if (root && m_solver.num_user_scopes() == 0) { m_result_stack.reset(); unsigned k1 = k.get_unsigned(); if (sign) { @@ -466,8 +477,7 @@ struct goal2sat::imp { sat::literal lit(v, sign); m_ext->add_pb_ge(v, wlits, k.get_unsigned()); TRACE("goal2sat", tout << "root: " << root << " lit: " << lit << "\n";); - m_result_stack.shrink(sz - t->get_num_args()); - m_result_stack.push_back(lit); + push_result(root, lit, t->get_num_args()); } } @@ -481,8 +491,7 @@ struct goal2sat::imp { k += rational(wl.first); } check_unsigned(k); - unsigned sz = m_result_stack.size(); - if (root) { + if (root && m_solver.num_user_scopes() == 0) { m_result_stack.reset(); unsigned k1 = k.get_unsigned(); if (sign) { @@ -499,19 +508,19 @@ struct goal2sat::imp { sat::literal lit(v, sign); m_ext->add_pb_ge(v, wlits, k.get_unsigned()); TRACE("goal2sat", tout << "root: " << root << " lit: " << lit << "\n";); - m_result_stack.shrink(sz - t->get_num_args()); - m_result_stack.push_back(lit); + push_result(root, lit, t->get_num_args()); } } void convert_pb_eq(app* t, bool root, bool sign) { - IF_VERBOSE(0, verbose_stream() << "pbeq: " << mk_pp(t, m) << "\n";); + //IF_VERBOSE(0, verbose_stream() << "pbeq: " << mk_pp(t, m) << "\n";); rational k = pb.get_k(t); SASSERT(k.is_unsigned()); svector wlits; convert_pb_args(t, wlits); - sat::bool_var v1 = (root && !sign) ? sat::null_bool_var : m_solver.mk_var(true); - sat::bool_var v2 = (root && !sign) ? sat::null_bool_var : m_solver.mk_var(true); + bool base_assert = (root && !sign && m_solver.num_user_scopes() == 0); + sat::bool_var v1 = base_assert ? sat::null_bool_var : m_solver.mk_var(true); + sat::bool_var v2 = base_assert ? sat::null_bool_var : m_solver.mk_var(true); m_ext->add_pb_ge(v1, wlits, k.get_unsigned()); k.neg(); for (wliteral& wl : wlits) { @@ -520,7 +529,7 @@ struct goal2sat::imp { } check_unsigned(k); m_ext->add_pb_ge(v2, wlits, k.get_unsigned()); - if (root && !sign) { + if (base_assert) { m_result_stack.reset(); } else { @@ -531,22 +540,16 @@ struct goal2sat::imp { mk_clause(~l, l2); mk_clause(~l1, ~l2, l); m_cache.insert(t, l); - m_result_stack.shrink(m_result_stack.size() - t->get_num_args()); if (sign) l.neg(); - m_result_stack.push_back(l); - if (root) { - m_result_stack.reset(); - mk_clause(l); - } + push_result(root, l, t->get_num_args()); } } void convert_at_least_k(app* t, rational const& k, bool root, bool sign) { SASSERT(k.is_unsigned()); sat::literal_vector lits; - unsigned sz = m_result_stack.size(); convert_pb_args(t->get_num_args(), lits); - if (root) { + if (root && m_solver.num_user_scopes() == 0) { m_result_stack.reset(); m_ext->add_at_least(sat::null_bool_var, lits, k.get_unsigned()); } @@ -557,20 +560,18 @@ struct goal2sat::imp { m_cache.insert(t, lit); if (sign) lit.neg(); TRACE("goal2sat", tout << "root: " << root << " lit: " << lit << "\n";); - m_result_stack.shrink(sz - t->get_num_args()); - m_result_stack.push_back(lit); + push_result(root, lit, t->get_num_args()); } } void convert_at_most_k(app* t, rational const& k, bool root, bool sign) { SASSERT(k.is_unsigned()); sat::literal_vector lits; - unsigned sz = m_result_stack.size(); convert_pb_args(t->get_num_args(), lits); for (sat::literal& l : lits) { l.neg(); } - if (root) { + if (root && m_solver.num_user_scopes() == 0) { m_result_stack.reset(); m_ext->add_at_least(sat::null_bool_var, lits, lits.size() - k.get_unsigned()); } @@ -579,9 +580,8 @@ struct goal2sat::imp { sat::literal lit(v, false); m_ext->add_at_least(v, lits, lits.size() - k.get_unsigned()); m_cache.insert(t, lit); - m_result_stack.shrink(sz - t->get_num_args()); if (sign) lit.neg(); - m_result_stack.push_back(lit); + push_result(root, lit, t->get_num_args()); } } @@ -609,13 +609,8 @@ struct goal2sat::imp { mk_clause(~l, l2); mk_clause(~l1, ~l2, l); m_cache.insert(t, l); - m_result_stack.shrink(m_result_stack.size() - t->get_num_args()); if (sign) l.neg(); - m_result_stack.push_back(l); - if (root) { - mk_clause(l); - m_result_stack.reset(); - } + push_result(root, l, t->get_num_args()); } } @@ -1063,7 +1058,7 @@ void sat2goal::mc::insert(sat::bool_var v, app * atom, bool aux) { expr_ref sat2goal::mc::lit2expr(sat::literal l) { if (!m_var2expr.get(l.var())) { - app* aux = m.mk_fresh_const(0, m.mk_bool_sort()); + app* aux = m.mk_fresh_const(nullptr, m.mk_bool_sort()); m_var2expr.set(l.var(), aux); if (!m_gmc) m_gmc = alloc(generic_model_converter, m, "sat2goal"); m_gmc->hide(aux->get_decl()); @@ -1107,7 +1102,7 @@ struct sat2goal::imp { SASSERT(m_lit2expr.get((~l).index()) == 0); app* aux = mc ? mc->var2expr(l.var()) : nullptr; if (!aux) { - aux = m.mk_fresh_const(0, m.mk_bool_sort()); + aux = m.mk_fresh_const(nullptr, m.mk_bool_sort()); if (mc) { mc->insert(l.var(), aux, true); } diff --git a/src/sat/tactic/goal2sat.h b/src/sat/tactic/goal2sat.h index d86b2d7e4..514b65311 100644 --- a/src/sat/tactic/goal2sat.h +++ b/src/sat/tactic/goal2sat.h @@ -86,7 +86,7 @@ public: public: mc(ast_manager& m); - virtual ~mc() {} + ~mc() override {} // flush model converter from SAT solver to this structure. void flush_smc(sat::solver& s, atom2bool_var const& map); void operator()(model_ref& md) override; diff --git a/src/sat/tactic/sat_tactic.cpp b/src/sat/tactic/sat_tactic.cpp index 149a4e853..e6369a918 100644 --- a/src/sat/tactic/sat_tactic.cpp +++ b/src/sat/tactic/sat_tactic.cpp @@ -17,12 +17,10 @@ Notes: --*/ #include "ast/ast_pp.h" +#include "model/model_v2_pp.h" #include "tactic/tactical.h" #include "sat/tactic/goal2sat.h" #include "sat/sat_solver.h" -#include "solver/parallel_tactic.h" -#include "solver/parallel_params.hpp" -#include "model/model_v2_pp.h" class sat_tactic : public tactic { @@ -107,7 +105,7 @@ class sat_tactic : public tactic { else { // get simplified problem. #if 0 - IF_VERBOSE(TACTIC_VERBOSITY_LVL, verbose_stream() << "\"formula constains interpreted atoms, recovering formula from sat solver...\"\n";); + IF_VERBOSE(TACTIC_VERBOSITY_LVL, verbose_stream() << "\"formula constrains interpreted atoms, recovering formula from sat solver...\"\n";); #endif m_solver.pop_to_base_level(); ref mc; diff --git a/src/shell/dimacs_frontend.cpp b/src/shell/dimacs_frontend.cpp index 3a2af72cf..738566ce2 100644 --- a/src/shell/dimacs_frontend.cpp +++ b/src/shell/dimacs_frontend.cpp @@ -136,7 +136,7 @@ void verify_solution(char const * file_name) { std::cerr << "(error \"failed to open file '" << file_name << "'\")" << std::endl; exit(ERR_OPEN_FILE); } - parse_dimacs(in, solver); + parse_dimacs(in, std::cerr, solver); sat::model const & m = g_solver->get_model(); for (unsigned i = 1; i < m.size(); i++) { @@ -178,10 +178,10 @@ unsigned read_dimacs(char const * file_name) { std::cerr << "(error \"failed to open file '" << file_name << "'\")" << std::endl; exit(ERR_OPEN_FILE); } - parse_dimacs(in, solver); + parse_dimacs(in, std::cerr, solver); } else { - parse_dimacs(std::cin, solver); + parse_dimacs(std::cin, std::cerr, solver); } IF_VERBOSE(20, solver.display_status(verbose_stream());); diff --git a/src/shell/main.cpp b/src/shell/main.cpp index bb1c19b47..b036628b1 100644 --- a/src/shell/main.cpp +++ b/src/shell/main.cpp @@ -26,7 +26,7 @@ Revision History: #include "shell/smtlib_frontend.h" #include "shell/z3_log_frontend.h" #include "util/warning.h" -#include "util/version.h" +#include "util/z3_version.h" #include "shell/dimacs_frontend.h" #include "shell/datalog_frontend.h" #include "shell/opt_frontend.h" @@ -60,7 +60,7 @@ void error(const char * msg) { void display_usage() { std::cout << "Z3 [version " << Z3_MAJOR_VERSION << "." << Z3_MINOR_VERSION << "." << Z3_BUILD_NUMBER; std::cout << " - "; -#ifdef _AMD64_ +#if defined(__LP64__) || defined(_WIN64) std::cout << "64"; #else std::cout << "32"; @@ -91,7 +91,7 @@ void display_usage() { std::cout << " -pp:name display Z3 parameter description, if 'name' is not provided, then all module names are listed.\n"; std::cout << " --" << " all remaining arguments are assumed to be part of the input file name. This option allows Z3 to read files with strange names such as: -foo.smt2.\n"; std::cout << "\nResources:\n"; - // timeout and memout are now available on Linux and OSX too. + // timeout and memout are now available on Linux and macOS too. std::cout << " -T:timeout set the timeout (in seconds).\n"; std::cout << " -t:timeout set the soft timeout (in milli seconds). It only kills the current query.\n"; std::cout << " -memory:Megabytes set a limit for virtual memory consumption.\n"; @@ -161,7 +161,7 @@ void parse_cmd_line_args(int argc, char ** argv) { if (strcmp(opt_name, "version") == 0) { std::cout << "Z3 version " << Z3_MAJOR_VERSION << "." << Z3_MINOR_VERSION << "." << Z3_BUILD_NUMBER; std::cout << " - "; -#ifdef _AMD64_ +#if defined(__LP64__) || defined(_WIN64) std::cout << "64"; #else std::cout << "32"; diff --git a/src/shell/opt_frontend.cpp b/src/shell/opt_frontend.cpp index 0a2a8f4a1..afa7b79c5 100644 --- a/src/shell/opt_frontend.cpp +++ b/src/shell/opt_frontend.cpp @@ -108,7 +108,8 @@ static unsigned parse_opt(std::istream& in, opt_format f) { unsigned rlimit = std::stoi(gparams::get_value("rlimit")); scoped_timer timer(timeout, &eh); scoped_rlimit _rlimit(m.limit(), rlimit); - lbool r = opt.optimize(); + expr_ref_vector asms(m); + lbool r = opt.optimize(asms); switch (r) { case l_true: std::cout << "sat\n"; break; case l_false: std::cout << "unsat\n"; break; diff --git a/src/smt/CMakeLists.txt b/src/smt/CMakeLists.txt index fb1997fb4..52d3a5943 100644 --- a/src/smt/CMakeLists.txt +++ b/src/smt/CMakeLists.txt @@ -13,6 +13,7 @@ z3_add_component(smt old_interval.cpp qi_queue.cpp smt_almost_cg_table.cpp + smt_arith_value.cpp smt_case_split_queue.cpp smt_cg_table.cpp smt_checker.cpp @@ -55,9 +56,11 @@ z3_add_component(smt theory_dl.cpp theory_dummy.cpp theory_fpa.cpp + theory_jobscheduler.cpp theory_lra.cpp theory_opt.cpp theory_pb.cpp + theory_recfun.cpp theory_seq.cpp theory_str.cpp theory_utvpi.cpp diff --git a/src/smt/arith_eq_solver.cpp b/src/smt/arith_eq_solver.cpp index 128b35dd1..677132804 100644 --- a/src/smt/arith_eq_solver.cpp +++ b/src/smt/arith_eq_solver.cpp @@ -12,14 +12,11 @@ Abstract: Author: Nikolaj Bjorner (nbjorner) 2012-02-25 - + --*/ #include "smt/arith_eq_solver.h" -arith_eq_solver::~arith_eq_solver() { -} - arith_eq_solver::arith_eq_solver(ast_manager & m, params_ref const& p): m(m), m_params(p), @@ -93,9 +90,9 @@ void arith_eq_solver::gcd_normalize(vector& values) { if (g.is_zero() || g.is_one()) { return; } - for (unsigned i = 0; i < values.size(); ++i) { - values[i] = values[i] / g; - SASSERT(values[i].is_int()); + for (auto &value : values) { + value /= g; + SASSERT(value.is_int()); } } @@ -116,9 +113,9 @@ unsigned arith_eq_solver::find_abs_min(vector& values) { #ifdef _TRACE static void print_row(std::ostream& out, vector const& row) { - for(unsigned i = 0; i < row.size(); ++i) { - out << row[i] << " "; - } + for(unsigned i = 0; i < row.size(); ++i) { + out << row[i] << " "; + } out << "\n"; } @@ -165,7 +162,7 @@ bool arith_eq_solver::solve_integer_equation( bool& is_fresh ) { - TRACE("arith_eq_solver", + TRACE("arith_eq_solver", tout << "solving: "; print_row(tout, values); ); @@ -174,31 +171,31 @@ bool arith_eq_solver::solve_integer_equation( // // Given: // a1*x1 + a2*x2 + .. + a_n*x_n + a_{n+1} = 0 - // + // // Assume gcd(a1,..,a_n,a_{n+1}) = 1 // Assume gcd(a1,...,a_n) divides a_{n+1} (eg. gcd(a1,..,an) = 1) - // + // // post-condition: values[index] = -1. - // + // // Let a_index be index of least absolute value. // // If |a_index| = 1, then return row and index. // Otherwise: // Let m = |a_index| + 1 // Set - // - // m*x_index' - // = + // + // m*x_index' + // = // ((a1 mod_hat m)*x1 + (a2 mod_hat m)*x2 + .. + (a_n mod_hat m)*x_n + (k mod_hat m)) - // = + // = // (a1'*x1 + a2'*x2 + .. (-)1*x_index + ...) - // + // // <=> Normalize signs so that sign to x_index is -1. // (-)a1'*x1 + (-)a2'*x2 + .. -1*x_index + ... + m*x_index' = 0 - // + // // Return row, where the coefficient to x_index is implicit. // Instead used the coefficient 'm' at position 'index'. - // + // gcd_normalize(values); if (!gcd_test(values)) { @@ -216,8 +213,8 @@ bool arith_eq_solver::solve_integer_equation( return true; } if (a.is_one()) { - for (unsigned i = 0; i < values.size(); ++i) { - values[i].neg(); + for (auto &value : values) { + value.neg(); } } is_fresh = !abs_a.is_one(); @@ -225,19 +222,19 @@ bool arith_eq_solver::solve_integer_equation( if (is_fresh) { numeral m = abs_a + numeral(1); - for (unsigned i = 0; i < values.size(); ++i) { - values[i] = mod_hat(values[i], m); + for (auto &value : values) { + value = mod_hat(value, m); } if (values[index].is_one()) { - for (unsigned i = 0; i < values.size(); ++i) { - values[i].neg(); + for (auto &value : values) { + value.neg(); } } SASSERT(values[index].is_minus_one()); values[index] = m; } - TRACE("arith_eq_solver", + TRACE("arith_eq_solver", tout << "solved at index " << index << ": "; print_row(tout, values); ); @@ -253,7 +250,7 @@ void arith_eq_solver::substitute( ) { SASSERT(1 <= index && index < s.size()); - TRACE("arith_eq_solver", + TRACE("arith_eq_solver", tout << "substitute " << index << ":\n"; print_row(tout, r); print_row(tout, s); @@ -272,21 +269,21 @@ void arith_eq_solver::substitute( // s encodes an equation that contains a variable // with a unit coefficient. // - // Let + // Let // c = r[index] // s = s[index]*x + s'*y = 0 // r = c*x + r'*y = 0 - // - // => + // + // => // // 0 - // = - // -sign(s[index])*c*s + r - // = + // = + // -sign(s[index])*c*s + r + // = // -s[index]*sign(s[index])*c*x - sign(s[index])*c*s'*y + c*x + r'*y - // = + // = // -c*x - sign(s[index])*c*s'*y + c*x + r'*y - // = + // = // -sign(s[index])*c*s'*y + r'*y // numeral sign_s = s[index].is_pos()?numeral(1):numeral(-1); @@ -301,36 +298,36 @@ void arith_eq_solver::substitute( // // s encodes a substitution using an auxiliary variable. // the auxiliary variable is at position 'index'. - // - // Let + // + // Let // c = r[index] // s = s[index]*x + s'*y = 0 // r = c*x + r'*y = 0 // // s encodes : x |-> s[index]*x' + s'*y // - // Set: + // Set: // // r := c*s + r'*y - // + // r[index] = numeral(0); for (unsigned i = 0; i < r.size(); ++i) { r[i] += c*s[i]; - } + } for (unsigned i = r.size(); i < s.size(); ++i) { r.push_back(c*s[i]); } - } + } - TRACE("arith_eq_solver", + TRACE("arith_eq_solver", tout << "result: "; print_row(tout, r); ); } bool arith_eq_solver::solve_integer_equations( - vector& rows, + vector& rows, row& unsat_row ) { @@ -340,10 +337,10 @@ bool arith_eq_solver::solve_integer_equations( // // Naive integer equation solver where only units are eliminated. -// +// bool arith_eq_solver::solve_integer_equations_units( - vector& rows, + vector& rows, row& unsat_row ) { @@ -351,7 +348,7 @@ bool arith_eq_solver::solve_integer_equations_units( TRACE("arith_eq_solver", print_rows(tout << "solving:\n", rows);); unsigned_vector todo, done; - + for (unsigned i = 0; i < rows.size(); ++i) { todo.push_back(i); row& r = rows[i]; @@ -360,9 +357,9 @@ bool arith_eq_solver::solve_integer_equations_units( unsat_row = r; TRACE("arith_eq_solver", print_row(tout << "input is unsat: ", unsat_row); ); return false; - } + } } - for (unsigned i = 0; i < todo.size(); ++i) { + for (unsigned i = 0; i < todo.size(); ++i) { row& r = rows[todo[i]]; gcd_normalize(r); if (!gcd_test(r)) { @@ -388,7 +385,7 @@ bool arith_eq_solver::solve_integer_equations_units( todo.push_back(done[j]); done.erase(done.begin()+j); --j; - } + } } } else { @@ -396,7 +393,7 @@ bool arith_eq_solver::solve_integer_equations_units( } } - TRACE("arith_eq_solver", + TRACE("arith_eq_solver", tout << ((done.size()<=1)?"solved ":"incomplete check ") << done.size() << "\n"; for (unsigned i = 0; i < done.size(); ++i) { print_row(tout, rows[done[i]]); @@ -411,12 +408,12 @@ bool arith_eq_solver::solve_integer_equations_units( // // Partial solver based on the omega test equalities. -// unsatisfiability is not preserved when eliminating +// unsatisfiability is not preserved when eliminating // auxiliary variables. // bool arith_eq_solver::solve_integer_equations_omega( - vector & rows, + vector & rows, row& unsat_row ) { @@ -460,16 +457,16 @@ bool arith_eq_solver::solve_integer_equations_omega( // // solved_row: -x_index + m*sigma + r1 = 0 // unsat_row: k*sigma + r2 = 0 - // - // <=> - // + // + // <=> + // // solved_row: -k*x_index + k*m*sigma + k*r1 = 0 // unsat_row: m*k*sigma + m*r2 = 0 // // => // // m*k*sigma + m*r2 + k*x_index - k*m*sigma - k*r1 = 0 - // + // for (unsigned l = 0; l < unsat_row.size(); ++l) { unsat_row[l] *= m; unsat_row[l] -= k*solved_row[l]; @@ -479,7 +476,7 @@ bool arith_eq_solver::solve_integer_equations_omega( } gcd_normalize(unsat_row); - TRACE("arith_eq_solver", + TRACE("arith_eq_solver", tout << "gcd: "; print_row(tout, solved_row); print_row(tout, unsat_row); @@ -495,7 +492,7 @@ bool arith_eq_solver::solve_integer_equations_omega( return false; } else if (r[index].is_zero()) { - // Row is trival + // Row is trivial rows_solved.pop_back(); continue; } @@ -525,18 +522,18 @@ bool arith_eq_solver::solve_integer_equations_omega( // // Eliminate variables by searching for combination of rows where -// the coefficients have gcd = 1. -// +// the coefficients have gcd = 1. +// bool arith_eq_solver::solve_integer_equations_gcd( - vector & rows, + vector & rows, row& unsat_row ) -{ +{ unsigned_vector live, useful, gcd_pos; vector gcds; rational u, v; - + if (rows.empty()) { return true; } @@ -548,7 +545,7 @@ bool arith_eq_solver::solve_integer_equations_gcd( unsat_row = r; TRACE("arith_eq_solver", print_row(tout << "input is unsat: ", unsat_row); ); return false; - } + } } unsigned max_column = rows[0].size(); bool change = true; @@ -579,7 +576,7 @@ bool arith_eq_solver::solve_integer_equations_gcd( if (j == live.size()) { continue; } - + change = true; // found gcd, now identify reduced set of rows with GCD = 1. g = abs(rows[live[j]][i]); @@ -592,7 +589,7 @@ bool arith_eq_solver::solve_integer_equations_gcd( useful.push_back(gcd_pos[j]); g = gcd(g, gcds[j]); SASSERT(j == 0 || gcd(g,gcds[j-1]).is_one()); - } + } } // // we now have a set "useful" of rows whose combined GCD = 1. @@ -600,7 +597,7 @@ bool arith_eq_solver::solve_integer_equations_gcd( // row& r0 = rows[useful[0]]; for (j = 1; j < useful.size(); ++j) { - row& r1 = rows[useful[j]]; + row& r1 = rows[useful[j]]; g = gcd(r0[i], r1[i], u, v); for (unsigned k = 0; k < max_column; ++k) { r0[k] = u*r0[k] + v*r1[k]; @@ -611,8 +608,8 @@ bool arith_eq_solver::solve_integer_equations_gcd( return false; } live.erase(live.begin()+live_pos); - for (j = 0; j < live.size(); ++j) { - row& r = rows[live[j]]; + for (unsigned l : live) { + row& r = rows[l]; if (!r[i].is_zero()) { substitute(r, r0, i); gcd_normalize(r); @@ -626,12 +623,9 @@ bool arith_eq_solver::solve_integer_equations_gcd( } } - TRACE("arith_eq_solver", + TRACE("arith_eq_solver", tout << ((live.size()<=1)?"solved ":"incomplete check ") << live.size() << "\n"; - for (unsigned i = 0; i < live.size(); ++i) { - print_row(tout, rows[live[i]]); - } - ); + for (unsigned l : live) print_row(tout, rows[l]); ); return true; } diff --git a/src/smt/arith_eq_solver.h b/src/smt/arith_eq_solver.h index b2db35ee1..68e58334d 100644 --- a/src/smt/arith_eq_solver.h +++ b/src/smt/arith_eq_solver.h @@ -12,7 +12,7 @@ Abstract: Author: Nikolaj Bjorner (nbjorner) 2012-02-25 - + --*/ #ifndef ARITH_EQ_SOLVER_H_ #define ARITH_EQ_SOLVER_H_ @@ -35,45 +35,45 @@ class arith_eq_solver { void prop_mod_const(expr * e, unsigned depth, numeral const& k, expr_ref& result); - bool gcd_test(vector& value); + bool gcd_test(vector& values); unsigned find_abs_min(vector& values); void gcd_normalize(vector& values); void substitute(vector& r, vector const& s, unsigned index); bool solve_integer_equations_units( - vector > & rows, + vector > & rows, vector& unsat_row ); - + bool solve_integer_equations_omega( - vector > & rows, + vector > & rows, vector& unsat_row ); void compute_hnf(vector >& A); bool solve_integer_equations_hermite( - vector > & rows, + vector > & rows, vector& unsat_row ); bool solve_integer_equations_gcd( - vector > & rows, + vector > & rows, vector& unsat_row ); public: arith_eq_solver(ast_manager & m, params_ref const& p = params_ref()); - ~arith_eq_solver(); + ~arith_eq_solver() = default; // Integer linear solver for a single equation. // The array values contains integer coefficients - // + // // Determine integer solutions to: // // a+k = 0 // // where a = sum_i a_i*k_i - // + // typedef vector row; typedef vector matrix; @@ -90,14 +90,14 @@ public: // a+k = 0 // // where a = sum_i a_i*k_i - // + // // Solution, if there is any, is returned as a substitution. // The return value is "true". // If there is no solution, then return "false". // together with equality "eq_unsat", such that // // eq_unsat = 0 - // + // // is implied and is unsatisfiable over the integers. // diff --git a/src/smt/asserted_formulas.cpp b/src/smt/asserted_formulas.cpp index d364404da..164d36ae2 100644 --- a/src/smt/asserted_formulas.cpp +++ b/src/smt/asserted_formulas.cpp @@ -449,7 +449,7 @@ void asserted_formulas::propagate_values() { m_expr2depth.reset(); m_scoped_substitution.push(); unsigned prop = num_prop; - TRACE("propagate_values", tout << "before:\n"; display(tout);); + TRACE("propagate_values", display(tout << "before:\n");); unsigned i = m_qhead; unsigned sz = m_formulas.size(); for (; i < sz; i++) { @@ -482,15 +482,13 @@ unsigned asserted_formulas::propagate_values(unsigned i) { expr_ref new_n(m); proof_ref new_pr(m); m_rewriter(n, new_n, new_pr); + TRACE("propagate_values", tout << n << "\n" << new_n << "\n";); if (m.proofs_enabled()) { proof * pr = m_formulas[i].get_proof(); new_pr = m.mk_modus_ponens(pr, new_pr); } justified_expr j(m, new_n, new_pr); m_formulas[i] = j; - if (m_formulas[i].get_fml() != new_n) { - std::cout << "NOT updated\n"; - } if (m.is_false(j.get_fml())) { m_inconsistent = true; } diff --git a/src/smt/mam.cpp b/src/smt/mam.cpp index 00e079989..a6b5e5515 100644 --- a/src/smt/mam.cpp +++ b/src/smt/mam.cpp @@ -2376,6 +2376,13 @@ namespace smt { SASSERT(m_n2 != 0); if (m_n1->get_root() != m_n2->get_root()) goto backtrack; + + // We will use the common root when instantiating the quantifier => log the necessary equalities + if (m_ast_manager.has_trace_stream()) { + m_used_enodes.push_back(std::make_tuple(m_n1, m_n1->get_root())); + m_used_enodes.push_back(std::make_tuple(m_n2, m_n2->get_root())); + } + m_pc = m_pc->m_next; goto main_loop; @@ -2571,6 +2578,12 @@ namespace smt { m_n1 = m_context.get_enode_eq_to(static_cast(m_pc)->m_label, static_cast(m_pc)->m_num_args, m_args.c_ptr()); \ if (m_n1 == 0 || !m_context.is_relevant(m_n1)) \ goto backtrack; \ + update_max_generation(m_n1, nullptr); \ + if (m_ast_manager.has_trace_stream()) { \ + for (unsigned i = 0; i < static_cast(m_pc)->m_num_args; ++i) { \ + m_used_enodes.push_back(std::make_tuple(m_n1->get_arg(i), m_n1->get_arg(i)->get_root())); \ + } \ + } \ m_registers[static_cast(m_pc)->m_oreg] = m_n1; \ m_pc = m_pc->m_next; \ goto main_loop; diff --git a/src/smt/params/qi_params.h b/src/smt/params/qi_params.h index 0f6c03f5b..d1434103b 100644 --- a/src/smt/params/qi_params.h +++ b/src/smt/params/qi_params.h @@ -64,14 +64,14 @@ struct qi_params { Enodes in the input problem have generation 0. Some combinations of m_qi_cost and m_qi_new_gen will prevent Z3 from breaking matching loops. - For example, the "Weight 0" peformace bug was triggered by the following combination: + For example, the "Weight 0" performance bug was triggered by the following combination: - m_qi_cost: (+ weight generation) - m_qi_new_gen: cost If a quantifier has weight 0, then the cost of instantiating it with a term in the input problem has cost 0. The new enodes created during the instantiation will be tagged with generation = const = 0. So, every enode will have generation 0, and consequently every quantifier instantiation will have cost 0. - Although dangerous, this feature was requested by the Boogie team. In their case, the patterns are carefully constructred, + Although dangerous, this feature was requested by the Boogie team. In their case, the patterns are carefully constructed, and there are no matching loops. Moreover, the tag some quantifiers with weight 0 to instruct Z3 to never block their instances. An example is the select-store axiom. They need this feature to be able to analyze code that contains very long execution paths. diff --git a/src/smt/params/smt_params_helper.pyg b/src/smt/params/smt_params_helper.pyg index 76e9f03b1..6b4aee1c3 100644 --- a/src/smt/params/smt_params_helper.pyg +++ b/src/smt/params/smt_params_helper.pyg @@ -12,7 +12,7 @@ def_module_params(module_name='smt', ('ematching', BOOL, True, 'E-Matching based quantifier instantiation'), ('phase_selection', UINT, 3, 'phase selection heuristic: 0 - always false, 1 - always true, 2 - phase caching, 3 - phase caching conservative, 4 - phase caching conservative 2, 5 - random, 6 - number of occurrences'), ('restart_strategy', UINT, 1, '0 - geometric, 1 - inner-outer-geometric, 2 - luby, 3 - fixed, 4 - arithmetic'), - ('restart_factor', DOUBLE, 1.1, 'when using geometric (or inner-outer-geometric) progression of restarts, it specifies the constant used to multiply the currect restart threshold'), + ('restart_factor', DOUBLE, 1.1, 'when using geometric (or inner-outer-geometric) progression of restarts, it specifies the constant used to multiply the current restart threshold'), ('case_split', UINT, 1, '0 - case split based on variable activity, 1 - similar to 0, but delay case splits created during the search, 2 - similar to 0, but cache the relevancy, 3 - case split based on relevancy (structural splitting), 4 - case split on relevancy and activity, 5 - case split on relevancy and current goal, 6 - activity-based case split with theory-aware branching activity'), ('delay_units', BOOL, False, 'if true then z3 will not restart when a unit clause is learned'), ('delay_units_threshold', UINT, 32, 'maximum number of learned unit clauses before restarting, ignored if delay_units is false'), @@ -95,5 +95,7 @@ def_module_params(module_name='smt', ('core.extend_patterns.max_distance', UINT, UINT_MAX, 'limits the distance of a pattern-extended unsat core'), ('core.extend_nonlocal_patterns', BOOL, False, 'extend unsat cores with literals that have quantifiers with patterns that contain symbols which are not in the quantifier\'s body'), ('lemma_gc_strategy', UINT, 0, 'lemma garbage collection strategy: 0 - fixed, 1 - geometric, 2 - at restart, 3 - none'), - ('dt_lazy_splits', UINT, 1, 'How lazy datatype splits are performed: 0- eager, 1- lazy for infinite types, 2- lazy') + ('dt_lazy_splits', UINT, 1, 'How lazy datatype splits are performed: 0- eager, 1- lazy for infinite types, 2- lazy'), + ('recfun.native', BOOL, True, 'use native rec-fun solver'), + ('recfun.depth', UINT, 2, 'initial depth for maxrec expansion') )) diff --git a/src/smt/proto_model/array_factory.cpp b/src/smt/proto_model/array_factory.cpp index dc3e0f89c..141021006 100644 --- a/src/smt/proto_model/array_factory.cpp +++ b/src/smt/proto_model/array_factory.cpp @@ -104,7 +104,7 @@ bool array_factory::mk_two_diff_values_for(sort * s) { bool array_factory::get_some_values(sort * s, expr_ref & v1, expr_ref & v2) { value_set * set = nullptr; - if (!m_sort2value_set.find(s, set) || set->size() == 0) { + if (!m_sort2value_set.find(s, set) || set->empty()) { if (!mk_two_diff_values_for(s)) return false; } diff --git a/src/smt/qi_queue.cpp b/src/smt/qi_queue.cpp index 94868ef6e..d621a9f50 100644 --- a/src/smt/qi_queue.cpp +++ b/src/smt/qi_queue.cpp @@ -175,7 +175,7 @@ namespace smt { } } m_new_entries.reset(); - TRACE("new_entries_bug", tout << "[qi:instatiate]\n";); + TRACE("new_entries_bug", tout << "[qi:instantiate]\n";); } void qi_queue::display_instance_profile(fingerprint * f, quantifier * q, unsigned num_bindings, enode * const * bindings, unsigned proof_id, unsigned generation) { diff --git a/src/smt/smt_arith_value.cpp b/src/smt/smt_arith_value.cpp new file mode 100644 index 000000000..8dfca3ebb --- /dev/null +++ b/src/smt/smt_arith_value.cpp @@ -0,0 +1,126 @@ +/*++ +Copyright (c) 2018 Microsoft Corporation + +Module Name: + + smt_arith_value.cpp + +Abstract: + + Utility to extract arithmetic values from context. + +Author: + + Nikolaj Bjorner (nbjorner) 2018-12-08. + +Revision History: + +--*/ + +#include "smt/smt_arith_value.h" + +namespace smt { + + arith_value::arith_value(ast_manager& m): + m_ctx(nullptr), m(m), a(m) {} + + void arith_value::init(context* ctx) { + m_ctx = ctx; + family_id afid = a.get_family_id(); + theory* th = m_ctx->get_theory(afid); + m_tha = dynamic_cast(th); + m_thi = dynamic_cast(th); + m_thr = dynamic_cast(th); + } + + bool arith_value::get_lo_equiv(expr* e, rational& lo, bool& is_strict) { + if (!m_ctx->e_internalized(e)) return false; + is_strict = false; + enode* next = m_ctx->get_enode(e), *n = next; + bool found = false; + bool is_strict1; + rational lo1; + do { + if ((m_tha && m_tha->get_lower(next, lo1, is_strict1)) || + (m_thi && m_thi->get_lower(next, lo1, is_strict1)) || + (m_thr && m_thr->get_lower(next, lo1, is_strict1))) { + if (!found || lo1 > lo || (lo == lo1 && is_strict1)) lo = lo1, is_strict = is_strict1; + found = true; + } + next = next->get_next(); + } + while (n != next); + return found; + } + + bool arith_value::get_up_equiv(expr* e, rational& up, bool& is_strict) { + if (!m_ctx->e_internalized(e)) return false; + is_strict = false; + enode* next = m_ctx->get_enode(e), *n = next; + bool found = false, is_strict1; + rational up1; + do { + if ((m_tha && m_tha->get_upper(next, up1, is_strict1)) || + (m_thi && m_thi->get_upper(next, up1, is_strict1)) || + (m_thr && m_thr->get_upper(next, up1, is_strict1))) { + if (!found || up1 < up || (up1 == up && is_strict1)) up = up1, is_strict = is_strict1; + found = true; + } + next = next->get_next(); + } + while (n != next); + return found; + } + + bool arith_value::get_up(expr* e, rational& up, bool& is_strict) const { + if (!m_ctx->e_internalized(e)) return false; + is_strict = false; + enode* n = m_ctx->get_enode(e); + if (m_tha) return m_tha->get_upper(n, up, is_strict); + if (m_thi) return m_thi->get_upper(n, up, is_strict); + if (m_thr) return m_thr->get_upper(n, up, is_strict); + return false; + } + + bool arith_value::get_lo(expr* e, rational& up, bool& is_strict) const { + if (!m_ctx->e_internalized(e)) return false; + is_strict = false; + enode* n = m_ctx->get_enode(e); + if (m_tha) return m_tha->get_lower(n, up, is_strict); + if (m_thi) return m_thi->get_lower(n, up, is_strict); + if (m_thr) return m_thr->get_lower(n, up, is_strict); + return false; + } + + bool arith_value::get_value(expr* e, rational& val) const { + if (!m_ctx->e_internalized(e)) return false; + expr_ref _val(m); + enode* n = m_ctx->get_enode(e); + if (m_tha && m_tha->get_value(n, _val) && a.is_numeral(_val, val)) return true; + if (m_thi && m_thi->get_value(n, _val) && a.is_numeral(_val, val)) return true; + if (m_thr && m_thr->get_value(n, val)) return true; + return false; + } + + + bool arith_value::get_value_equiv(expr* e, rational& val) const { + if (!m_ctx->e_internalized(e)) return false; + expr_ref _val(m); + enode* next = m_ctx->get_enode(e), *n = next; + do { + e = next->get_owner(); + if (m_tha && m_tha->get_value(next, _val) && a.is_numeral(_val, val)) return true; + if (m_thi && m_thi->get_value(next, _val) && a.is_numeral(_val, val)) return true; + if (m_thr && m_thr->get_value(next, val)) return true; + next = next->get_next(); + } + while (next != n); + return false; + } + + final_check_status arith_value::final_check() { + family_id afid = a.get_family_id(); + theory * th = m_ctx->get_theory(afid); + return th->final_check_eh(); + } +}; diff --git a/src/smt/smt_arith_value.h b/src/smt/smt_arith_value.h new file mode 100644 index 000000000..7fa1ecc31 --- /dev/null +++ b/src/smt/smt_arith_value.h @@ -0,0 +1,48 @@ + +/*++ +Copyright (c) 2018 Microsoft Corporation + +Module Name: + + smt_arith_value.h + +Abstract: + + Utility to extract arithmetic values from context. + +Author: + + Nikolaj Bjorner (nbjorner) 2018-12-08. + +Revision History: + +--*/ +#pragma once + +#include "ast/arith_decl_plugin.h" +#include "smt/smt_context.h" +#include "smt/theory_lra.h" +#include "smt/theory_arith.h" + + +namespace smt { + class arith_value { + context* m_ctx; + ast_manager& m; + arith_util a; + theory_mi_arith* m_tha; + theory_i_arith* m_thi; + theory_lra* m_thr; + public: + arith_value(ast_manager& m); + void init(context* ctx); + bool get_lo_equiv(expr* e, rational& lo, bool& strict); + bool get_up_equiv(expr* e, rational& up, bool& strict); + bool get_value_equiv(expr* e, rational& value) const; + bool get_lo(expr* e, rational& lo, bool& strict) const; + bool get_up(expr* e, rational& up, bool& strict) const; + bool get_value(expr* e, rational& value) const; + bool get_fixed(expr* e, rational& value) const; + final_check_status final_check(); + }; +}; diff --git a/src/smt/smt_case_split_queue.cpp b/src/smt/smt_case_split_queue.cpp index 5c51b906f..6290ed14d 100644 --- a/src/smt/smt_case_split_queue.cpp +++ b/src/smt/smt_case_split_queue.cpp @@ -281,7 +281,7 @@ namespace smt { } } if (order == 1) { - if (undef_children.size() == 0) { + if (undef_children.empty()) { // a bug? } else if (undef_children.size() == 1) { undef_child = undef_children[0]; diff --git a/src/smt/smt_conflict_resolution.cpp b/src/smt/smt_conflict_resolution.cpp index f7bc60051..93c172bf1 100644 --- a/src/smt/smt_conflict_resolution.cpp +++ b/src/smt/smt_conflict_resolution.cpp @@ -51,7 +51,7 @@ namespace smt { } /** - \brief Mark all enodes in a 'proof' tree brach starting at n + \brief Mark all enodes in a 'proof' tree branch starting at n n -> ... -> root */ template diff --git a/src/smt/smt_context.cpp b/src/smt/smt_context.cpp index f275b0ebf..3c601f400 100644 --- a/src/smt/smt_context.cpp +++ b/src/smt/smt_context.cpp @@ -37,6 +37,7 @@ Revision History: #include "model/model_pp.h" #include "ast/ast_smt2_pp.h" #include "ast/ast_translation.h" +#include "ast/recfun_decl_plugin.h" namespace smt { @@ -494,7 +495,7 @@ namespace smt { try { TRACE("add_eq", tout << "assigning: #" << n1->get_owner_id() << " = #" << n2->get_owner_id() << "\n";); - TRACE("add_eq_detail", tout << "assigning\n" << mk_pp(n1->get_owner(), m_manager) << "\n" << mk_pp(n2->get_owner(), m_manager) << "\n"; + TRACE("add_eq_detail", tout << "assigning\n" << enode_pp(n1, *this) << "\n" << enode_pp(n2, *this) << "\n"; tout << "kind: " << js.get_kind() << "\n";); m_stats.m_num_add_eq++; @@ -518,7 +519,7 @@ namespace smt { // 2. r1 is interpreted but r2 is not. // // The second condition is used to enforce the invariant that if a class contain - // an interepreted enode then the root is also interpreted. + // an interpreted enode then the root is also interpreted. if ((r1->get_class_size() > r2->get_class_size() && !r2->is_interpreted()) || r1->is_interpreted()) { SASSERT(!r2->is_interpreted()); std::swap(n1, n2); @@ -529,7 +530,7 @@ namespace smt { " n1: #" << n1->get_owner_id() << "\n";); // It is necessary to propagate relevancy to other elements of - // the equivalence class. This is nessary to enforce the invariant + // the equivalence class. This is necessary to enforce the invariant // in the field m_parent of the enode class. if (is_relevant(r1)) { // && !m_manager.is_eq(r1->get_owner())) !is_eq HACK // NOTE for !is_eq HACK... the !is_eq HACK does not propagate relevancy when two @@ -562,7 +563,7 @@ namespace smt { invert_trans(n1); n1->m_trans.m_target = n2; n1->m_trans.m_justification = js; - n1->m_proof_logged_status = smt::logged_status::NOT_LOGGED; + n1->m_proof_is_logged = false; SASSERT(r1->trans_reaches(n1)); // --------------- // r1 -> .. -> n1 -> n2 -> ... -> r2 @@ -742,14 +743,14 @@ namespace smt { eq_justification js = n->m_trans.m_justification; prev->m_trans.m_target = nullptr; prev->m_trans.m_justification = null_eq_justification; - prev->m_proof_logged_status = smt::logged_status::NOT_LOGGED; + prev->m_proof_is_logged = false; while (curr != nullptr) { SASSERT(prev->trans_reaches(n)); enode * new_curr = curr->m_trans.m_target; eq_justification new_js = curr->m_trans.m_justification; curr->m_trans.m_target = prev; curr->m_trans.m_justification = js; - curr->m_proof_logged_status = smt::logged_status::NOT_LOGGED; + curr->m_proof_is_logged = false; prev = curr; js = new_js; curr = new_curr; @@ -1043,7 +1044,7 @@ namespace smt { SASSERT(r1->trans_reaches(n1)); n1->m_trans.m_target = nullptr; n1->m_trans.m_justification = null_eq_justification; - n1->m_proof_logged_status = smt::logged_status::NOT_LOGGED; + n1->m_proof_is_logged = false; invert_trans(r1); // --------------- // n1 -> ... -> r1 @@ -1232,7 +1233,7 @@ namespace smt { if (depth == 0) return false; if (r1->get_num_parents() < SMALL_NUM_PARENTS) { - TRACE("is_ext_diseq", tout << mk_bounded_pp(n1->get_owner(), m_manager) << " " << mk_bounded_pp(n2->get_owner(), m_manager) << " " << depth << "\n";); + TRACE("is_ext_diseq", tout << enode_pp(n1, *this) << " " << enode_pp(n2, *this) << " " << depth << "\n";); for (enode * p1 : enode::parents(r1)) { if (!is_relevant(p1)) continue; @@ -1241,7 +1242,7 @@ namespace smt { if (!p1->is_cgr()) continue; func_decl * f = p1->get_decl(); - TRACE("is_ext_diseq", tout << "p1: " << mk_bounded_pp(p1->get_owner(), m_manager) << "\n";); + TRACE("is_ext_diseq", tout << "p1: " << enode_pp(p1, *this) << "\n";); unsigned num_args = p1->get_num_args(); for (enode * p2 : enode::parents(r2)) { if (!is_relevant(p2)) @@ -1250,7 +1251,7 @@ namespace smt { continue; if (!p2->is_cgr()) continue; - TRACE("is_ext_diseq", tout << "p2: " << mk_bounded_pp(p2->get_owner(), m_manager) << "\n";); + TRACE("is_ext_diseq", tout << "p2: " << enode_pp(p2, *this) << "\n";); if (p1->get_root() != p2->get_root() && p2->get_decl() == f && p2->get_num_args() == num_args) { unsigned j = 0; for (j = 0; j < num_args; j++) { @@ -1264,7 +1265,7 @@ namespace smt { break; } if (j == num_args) { - TRACE("is_ext_diseq", tout << "found parents: " << mk_bounded_pp(p1->get_owner(), m_manager) << " " << mk_bounded_pp(p2->get_owner(), m_manager) << "\n";); + TRACE("is_ext_diseq", tout << "found parents: " << enode_pp(p1, *this) << " " << enode_pp(p2, *this) << "\n";); if (is_ext_diseq(p1, p2, depth - 1)) return true; } @@ -1384,7 +1385,10 @@ namespace smt { SASSERT(m_manager.is_eq(n)); expr * lhs = n->get_arg(0); expr * rhs = n->get_arg(1); - if (val == l_true) { + if (m_manager.is_bool(lhs)) { + // no-op + } + else if (val == l_true) { add_eq(get_enode(lhs), get_enode(rhs), eq_justification(l)); } else { @@ -1770,7 +1774,7 @@ namespace smt { void context::set_conflict(const b_justification & js, literal not_l) { if (!inconsistent()) { - TRACE("set_conflict", display_literal_verbose(tout, not_l); display(tout, js); ); + TRACE("set_conflict", display_literal_verbose(tout, not_l); display(tout << " ", js); ); m_conflict = js; m_not_l = not_l; } @@ -1809,7 +1813,7 @@ namespace smt { } /** - \brief Execute next clase split, return false if there are no + \brief Execute next case split, return false if there are no more case splits to be performed. */ bool context::decide() { @@ -1854,7 +1858,7 @@ namespace smt { if (is_quantifier(m_bool_var2expr[var])) { // Overriding any decision on how to assign the quantifier. - // assigining a quantifier to false is equivalent to make it irrelevant. + // assigning a quantifier to false is equivalent to make it irrelevant. phase = l_false; } @@ -2130,7 +2134,7 @@ namespace smt { \brief When a clause is reinitialized (see reinit_clauses) enodes and literals may need to be recreated. When an enode is recreated, I want to use the same generation number it had before being deleted. Otherwise the generation will be 0, and will affect - the loop prevetion heuristics used to control quantifier instantiation. + the loop prevention heuristics used to control quantifier instantiation. Thus, I cache the generation number of enodes that will be deleted during backtracking and recreated by reinit_clauses. */ @@ -3207,7 +3211,7 @@ namespace smt { } else { set_conflict(b_justification(tmp_clause.first), null_literal); - } + } VERIFY(!resolve_conflict()); return l_false; next_clause: @@ -3266,6 +3270,18 @@ namespace smt { m_assumptions.reset(); } + bool context::should_research(lbool r) { + if (r != l_false || m_unsat_core.empty()) { + return false; + } + for (theory* th : m_theory_set) { + if (th->should_research(m_unsat_core)) { + return true; + } + } + return false; + } + lbool context::mk_unsat_core(lbool r) { if (r != l_false) return r; SASSERT(inconsistent()); @@ -3353,7 +3369,7 @@ namespace smt { add_theory_assumptions(theory_assumptions); if (!theory_assumptions.empty()) { TRACE("search", tout << "Adding theory assumptions to context" << std::endl;); - return check(theory_assumptions.size(), theory_assumptions.c_ptr(), reset_cancel, true); + return check(0, nullptr, reset_cancel); } internalize_assertions(); @@ -3407,19 +3423,24 @@ namespace smt { } } - lbool context::check(unsigned num_assumptions, expr * const * assumptions, bool reset_cancel, bool already_did_theory_assumptions) { + lbool context::check(unsigned num_assumptions, expr * const * assumptions, bool reset_cancel) { if (!check_preamble(reset_cancel)) return l_undef; SASSERT(at_base_level()); setup_context(false); - expr_ref_vector asms(m_manager, num_assumptions, assumptions); - if (!already_did_theory_assumptions) add_theory_assumptions(asms); - // introducing proxies: if (!validate_assumptions(asms)) return l_undef; - TRACE("unsat_core_bug", tout << asms << "\n";); - internalize_assertions(); - init_assumptions(asms); - TRACE("before_search", display(tout);); - lbool r = search(); - r = mk_unsat_core(r); + lbool r; + do { + pop_to_base_lvl(); + expr_ref_vector asms(m_manager, num_assumptions, assumptions); + add_theory_assumptions(asms); + // introducing proxies: if (!validate_assumptions(asms)) return l_undef; + TRACE("unsat_core_bug", tout << asms << "\n";); + internalize_assertions(); + init_assumptions(asms); + TRACE("before_search", display(tout);); + r = search(); + r = mk_unsat_core(r); + } + while (should_research(r)); r = check_finalize(r); return r; } @@ -3428,15 +3449,20 @@ namespace smt { if (!check_preamble(true)) return l_undef; TRACE("before_search", display(tout);); setup_context(false); - expr_ref_vector asms(cube); - add_theory_assumptions(asms); - // introducing proxies: if (!validate_assumptions(asms)) return l_undef; - for (auto const& clause : clauses) if (!validate_assumptions(clause)) return l_undef; - internalize_assertions(); - init_assumptions(asms); - for (auto const& clause : clauses) init_clause(clause); - lbool r = search(); - r = mk_unsat_core(r); + lbool r; + do { + pop_to_base_lvl(); + expr_ref_vector asms(cube); + add_theory_assumptions(asms); + // introducing proxies: if (!validate_assumptions(asms)) return l_undef; + for (auto const& clause : clauses) if (!validate_assumptions(clause)) return l_undef; + internalize_assertions(); + init_assumptions(asms); + for (auto const& clause : clauses) init_clause(clause); + r = search(); + r = mk_unsat_core(r); + } + while (should_research(r)); r = check_finalize(r); return r; } @@ -3770,7 +3796,7 @@ namespace smt { } m_stats.m_num_final_checks++; - TRACE("final_check_stats", tout << "m_stats.m_num_final_checks = " << m_stats.m_num_final_checks << "\n";); + TRACE("final_check_stats", tout << "m_stats.m_num_final_checks = " << m_stats.m_num_final_checks << "\n";); final_check_status ok = m_qmanager->final_check_eh(false); if (ok != FC_DONE) @@ -3846,7 +3872,7 @@ namespace smt { for (unsigned i = head; i < sz; i++) { literal l = m_assigned_literals[i]; bool_var v = l.var(); - TRACE("forget_phase", tout << "forgeting phase of l: " << l << "\n";); + TRACE("forget_phase", tout << "forgetting phase of l: " << l << "\n";); m_bdata[v].m_phase_available = false; } } @@ -4067,7 +4093,7 @@ namespace smt { A literal may have been marked relevant within the scope that gets popped during conflict resolution. In this case, the literal is no longer marked as relevant after the pop. This can cause quantifier instantiation to miss relevant triggers and thereby - cause incmpleteness. + cause incompleteness. */ void context::record_relevancy(unsigned n, literal const* lits) { m_relevant_conflict_literals.reset(); @@ -4281,7 +4307,7 @@ namespace smt { return true; } - // the variabe is shared if the equivalence class of n + // the variable is shared if the equivalence class of n // contains a parent application. theory_var_list * l = n->get_th_var_list(); @@ -4290,7 +4316,7 @@ namespace smt { for (enode * parent : enode::parents(n)) { family_id fid = parent->get_owner()->get_family_id(); if (fid != th_id && fid != m_manager.get_basic_family_id()) { - TRACE("is_shared", tout << mk_pp(n->get_owner(), m_manager) << "\nis shared because of:\n" << mk_pp(parent->get_owner(), m_manager) << "\n";); + TRACE("is_shared", tout << enode_pp(n, *this) << "\nis shared because of:\n" << enode_pp(parent, *this) << "\n";); return true; } } @@ -4428,6 +4454,29 @@ namespace smt { m_model->register_decl(f, fi); } } + recfun::util u(m); + func_decl_ref_vector recfuns = u.get_rec_funs(); + for (func_decl* f : recfuns) { + auto& def = u.get_def(f); + expr* rhs = def.get_rhs(); + if (!rhs) continue; + if (f->get_arity() == 0) { + m_model->register_decl(f, rhs); + continue; + } + + func_interp* fi = alloc(func_interp, m, f->get_arity()); + // reverse argument order so that variable 0 starts at the beginning. + expr_ref_vector subst(m); + for (unsigned i = 0; i < f->get_arity(); ++i) { + subst.push_back(m.mk_var(i, f->get_domain(i))); + } + var_subst sub(m, true); + expr_ref bodyr = sub(rhs, subst.size(), subst.c_ptr()); + + fi->set_else(bodyr); + m_model->register_decl(f, fi); + } } }; diff --git a/src/smt/smt_context.h b/src/smt/smt_context.h index ff92f6f95..6f382a5f6 100644 --- a/src/smt/smt_context.h +++ b/src/smt/smt_context.h @@ -565,7 +565,7 @@ namespace smt { return m_asserted_formulas.has_quantifiers(); } - fingerprint * add_fingerprint(void * data, unsigned data_hash, unsigned num_args, enode * const * args, expr* def = 0) { + fingerprint * add_fingerprint(void * data, unsigned data_hash, unsigned num_args, enode * const * args, expr* def = nullptr) { return m_fingerprints.insert(data, data_hash, num_args, args, def); } @@ -859,6 +859,10 @@ namespace smt { void mk_th_axiom(theory_id tid, literal l1, literal l2, literal l3, unsigned num_params = 0, parameter * params = nullptr); + void mk_th_axiom(theory_id tid, literal_vector const& ls, unsigned num_params = 0, parameter * params = nullptr) { + mk_th_axiom(tid, ls.size(), ls.c_ptr(), num_params, params); + } + /* * Provide a hint to the core solver that the specified literals form a "theory case split". * The core solver will enforce the condition that exactly one of these literals can be @@ -1010,9 +1014,9 @@ namespace smt { void restore_theory_vars(enode * r2, enode * r1); void push_eq(enode * lhs, enode * rhs, eq_justification const & js) { - SASSERT(lhs != rhs); - SASSERT(lhs->get_root() != rhs->get_root()); - m_eq_propagation_queue.push_back(new_eq(lhs, rhs, js)); + if (lhs->get_root() != rhs->get_root()) { + m_eq_propagation_queue.push_back(new_eq(lhs, rhs, js)); + } } void push_new_congruence(enode * n1, enode * n2, bool used_commutativity) { @@ -1133,6 +1137,8 @@ namespace smt { void add_theory_assumptions(expr_ref_vector & theory_assumptions); lbool mk_unsat_core(lbool result); + + bool should_research(lbool result); void validate_unsat_core(); @@ -1243,6 +1249,11 @@ namespace smt { public: bool can_propagate() const; + // Retrieve arithmetic values. + bool get_arith_lo(expr* e, rational& lo, bool& strict); + bool get_arith_up(expr* e, rational& up, bool& strict); + bool get_arith_value(expr* e, rational& value); + // ----------------------------------- // // Model checking... (must be improved) @@ -1515,7 +1526,7 @@ namespace smt { void pop(unsigned num_scopes); - lbool check(unsigned num_assumptions = 0, expr * const * assumptions = nullptr, bool reset_cancel = true, bool already_did_theory_assumptions = false); + lbool check(unsigned num_assumptions = 0, expr * const * assumptions = nullptr, bool reset_cancel = true); lbool check(expr_ref_vector const& cube, vector const& clauses); @@ -1609,6 +1620,50 @@ namespace smt { void insert_macro(func_decl * f, quantifier * m, proof * pr, expr_dependency * dep) { m_asserted_formulas.insert_macro(f, m, pr, dep); } }; + struct pp_lit { + context & ctx; + literal lit; + pp_lit(context & ctx, literal lit) : ctx(ctx), lit(lit) {} + }; + + inline std::ostream & operator<<(std::ostream & out, pp_lit const & pp) { + return pp.ctx.display_detailed_literal(out, pp.lit); + } + + struct pp_lits { + context & ctx; + literal const *lits; + unsigned len; + pp_lits(context & ctx, unsigned len, literal const *lits) : ctx(ctx), lits(lits), len(len) {} + pp_lits(context & ctx, literal_vector const& ls) : ctx(ctx), lits(ls.c_ptr()), len(ls.size()) {} + }; + + inline std::ostream & operator<<(std::ostream & out, pp_lits const & pp) { + out << "{"; + bool first = true; + for (unsigned i = 0; i < pp.len; ++i) { + if (first) { first = false; } else { out << " or\n"; } + pp.ctx.display_detailed_literal(out, pp.lits[i]); + } + return out << "}"; + + } + struct enode_eq_pp { + context const& ctx; + enode_pair const& p; + enode_eq_pp(enode_pair const& p, context const& ctx): ctx(ctx), p(p) {} + }; + + std::ostream& operator<<(std::ostream& out, enode_eq_pp const& p); + + struct enode_pp { + context const& ctx; + enode* n; + enode_pp(enode* n, context const& ctx): ctx(ctx), n(n) {} + }; + + std::ostream& operator<<(std::ostream& out, enode_pp const& p); + }; #endif /* SMT_CONTEXT_H_ */ diff --git a/src/smt/smt_context_inv.cpp b/src/smt/smt_context_inv.cpp index 7f409622b..a6c4f49b4 100644 --- a/src/smt/smt_context_inv.cpp +++ b/src/smt/smt_context_inv.cpp @@ -303,7 +303,7 @@ namespace smt { for (bool_var v = 0; v < num; v++) { if (has_enode(v)) { enode * n = bool_var2enode(v); - if (n->is_eq() && is_relevant(n) && get_assignment(v) == l_false) { + if (n->is_eq() && is_relevant(n) && get_assignment(v) == l_false && !m_manager.is_iff(n->get_owner())) { TRACE("check_th_diseq_propagation", tout << "checking: #" << n->get_owner_id() << " " << mk_bounded_pp(n->get_owner(), m_manager) << "\n";); enode * lhs = n->get_arg(0)->get_root(); enode * rhs = n->get_arg(1)->get_root(); diff --git a/src/smt/smt_context_pp.cpp b/src/smt/smt_context_pp.cpp index 2a46fd07f..5dea80f5e 100644 --- a/src/smt/smt_context_pp.cpp +++ b/src/smt/smt_context_pp.cpp @@ -426,6 +426,7 @@ namespace smt { std::stringstream strm; strm << "lemma_" << (++m_lemma_id) << ".smt2"; std::ofstream out(strm.str()); + TRACE("lemma", tout << strm.str() << "\n";); display_lemma_as_smt_problem(out, num_antecedents, antecedents, consequent, logic); out.close(); return m_lemma_id; @@ -466,6 +467,7 @@ namespace smt { std::stringstream strm; strm << "lemma_" << (++m_lemma_id) << ".smt2"; std::ofstream out(strm.str()); + TRACE("lemma", tout << strm.str() << "\n";); display_lemma_as_smt_problem(out, num_antecedents, antecedents, num_eq_antecedents, eq_antecedents, consequent, logic); out.close(); return m_lemma_id; @@ -601,5 +603,17 @@ namespace smt { display(out, j); } + std::ostream& operator<<(std::ostream& out, enode_pp const& p) { + ast_manager& m = p.ctx.get_manager(); + enode* n = p.n; + return out << "[#" << n->get_owner_id() << " " << mk_bounded_pp(n->get_owner(), m) << "]"; + } + + std::ostream& operator<<(std::ostream& out, enode_eq_pp const& p) { + return out << enode_pp(p.p.first, p.ctx) << " = " << enode_pp(p.p.second, p.ctx) << "\n"; + } + + + }; diff --git a/src/smt/smt_enode.cpp b/src/smt/smt_enode.cpp index ca646974d..d9477e95d 100644 --- a/src/smt/smt_enode.cpp +++ b/src/smt/smt_enode.cpp @@ -47,7 +47,7 @@ namespace smt { n->m_cgc_enabled = cgc_enabled; n->m_iscope_lvl = iscope_lvl; n->m_lbl_hash = -1; - n->m_proof_logged_status = smt::logged_status::NOT_LOGGED; + n->m_proof_is_logged = false; unsigned num_args = n->get_num_args(); for (unsigned i = 0; i < num_args; i++) { enode * arg = app2enode[owner->get_arg(i)->get_id()]; diff --git a/src/smt/smt_enode.h b/src/smt/smt_enode.h index 61fed786b..f7dfda83b 100644 --- a/src/smt/smt_enode.h +++ b/src/smt/smt_enode.h @@ -38,15 +38,6 @@ namespace smt { } }; - /** - \brief Indicates whether the proof for membership in an equivalence class is already logged. - */ - enum logged_status { - NOT_LOGGED, //!< Proof is not logged or logged information is not up-to-date. - BEING_LOGGED, //!< We are currently in the process of logging all relevant information. This is used to prevent looping when logging congruence steps. - LOGGED //!< Proof is logged and logged information is still up-to-date. - }; - /** \ brief Use sparse maps in SMT solver. Define this to use hash maps rather than vectors over ast @@ -73,7 +64,7 @@ namespace smt { class tmp_enode; /** - \brief Aditional data-structure for implementing congruence closure, + \brief Additional data-structure for implementing congruence closure, equality propagation, and the theory central bus of equalities. */ class enode { @@ -114,7 +105,7 @@ namespace smt { enode_vector m_parents; //!< Parent enodes of the equivalence class. theory_var_list m_th_var_list; //!< List of theories that 'care' about this enode. trans_justification m_trans; //!< A justification for the enode being equal to its root. - logged_status m_proof_logged_status; //!< Indicates that the proof for the enode being equal to its root is in the log. + bool m_proof_is_logged; //!< Indicates that the proof for the enode being equal to its root is in the log. signed char m_lbl_hash; //!< It is different from -1, if enode is used in a pattern approx_set m_lbls; approx_set m_plbls; diff --git a/src/smt/smt_farkas_util.cpp b/src/smt/smt_farkas_util.cpp index ff415ad0c..f7aaea61b 100644 --- a/src/smt/smt_farkas_util.cpp +++ b/src/smt/smt_farkas_util.cpp @@ -312,6 +312,13 @@ namespace smt { } expr_ref farkas_util::get() { + TRACE("arith", + for (unsigned i = 0; i < m_coeffs.size(); ++i) { + tout << m_coeffs[i] << " * (" << mk_pp(m_ineqs[i].get(), m) << ") "; + } + tout << "\n"; + ); + m_normalize_factor = rational::one(); expr_ref res(m); if (m_coeffs.empty()) { @@ -330,13 +337,12 @@ namespace smt { partition_ineqs(); expr_ref_vector lits(m); unsigned lo = 0; - for (unsigned i = 0; i < m_his.size(); ++i) { - unsigned hi = m_his[i]; + for (unsigned hi : m_his) { lits.push_back(extract_consequence(lo, hi)); lo = hi; } bool_rewriter(m).mk_or(lits.size(), lits.c_ptr(), res); - IF_VERBOSE(2, { if (lits.size() > 1) { verbose_stream() << "combined lemma: " << mk_pp(res, m) << "\n"; } }); + IF_VERBOSE(2, { if (lits.size() > 1) { verbose_stream() << "combined lemma: " << res << "\n"; } }); } else { res = extract_consequence(0, m_coeffs.size()); diff --git a/src/smt/smt_internalizer.cpp b/src/smt/smt_internalizer.cpp index 1414cb522..4a6cd086c 100644 --- a/src/smt/smt_internalizer.cpp +++ b/src/smt/smt_internalizer.cpp @@ -216,13 +216,17 @@ namespace smt { SASSERT(m_manager.is_bool(n)); if (is_gate(m_manager, n)) { switch(to_app(n)->get_decl_kind()) { - case OP_AND: - UNREACHABLE(); + case OP_AND: { + for (expr * arg : *to_app(n)) { + internalize(arg, true); + literal lit = get_literal(arg); + mk_root_clause(1, &lit, pr); + } + break; + } case OP_OR: { literal_buffer lits; - unsigned num = to_app(n)->get_num_args(); - for (unsigned i = 0; i < num; i++) { - expr * arg = to_app(n)->get_arg(i); + for (expr * arg : *to_app(n)) { internalize(arg, true); lits.push_back(get_literal(arg)); } @@ -294,8 +298,7 @@ namespace smt { sort * s = m_manager.get_sort(n->get_arg(0)); sort_ref u(m_manager.mk_fresh_sort("distinct-elems"), m_manager); func_decl_ref f(m_manager.mk_fresh_func_decl("distinct-aux-f", "", 1, &s, u), m_manager); - for (unsigned i = 0; i < num_args; i++) { - expr * arg = n->get_arg(i); + for (expr * arg : *n) { app_ref fapp(m_manager.mk_app(f, arg), m_manager); app_ref val(m_manager.mk_fresh_const("unique-value", u), m_manager); enode * e = mk_enode(val, false, false, true); @@ -826,9 +829,7 @@ namespace smt { void context::internalize_uninterpreted(app * n) { SASSERT(!e_internalized(n)); // process args - unsigned num = n->get_num_args(); - for (unsigned i = 0; i < num; i++) { - expr * arg = n->get_arg(i); + for (expr * arg : *n) { internalize(arg, false); SASSERT(e_internalized(arg)); } @@ -1017,8 +1018,17 @@ namespace smt { void context::apply_sort_cnstr(app * term, enode * e) { sort * s = term->get_decl()->get_range(); theory * th = m_theories.get_plugin(s->get_family_id()); - if (th) + if (th) { + if (m_manager.has_trace_stream()) { + m_manager.trace_stream() << "[theory-constraints] " << m_manager.get_family_name(s->get_family_id()) << "\n"; + } + th->apply_sort_cnstr(e, s); + + if (m_manager.has_trace_stream()) { + m_manager.trace_stream() << "[end-theory-constraints]\n"; + } + } } /** @@ -1542,10 +1552,9 @@ namespace smt { void context::add_and_rel_watches(app * n) { if (relevancy()) { relevancy_eh * eh = m_relevancy_propagator->mk_and_relevancy_eh(n); - unsigned num = n->get_num_args(); - for (unsigned i = 0; i < num; i++) { + for (expr * arg : *n) { // if one child is assigned to false, the and-parent must be notified - literal l = get_literal(n->get_arg(i)); + literal l = get_literal(arg); add_rel_watch(~l, eh); } } @@ -1554,10 +1563,9 @@ namespace smt { void context::add_or_rel_watches(app * n) { if (relevancy()) { relevancy_eh * eh = m_relevancy_propagator->mk_or_relevancy_eh(n); - unsigned num = n->get_num_args(); - for (unsigned i = 0; i < num; i++) { + for (expr * arg : *n) { // if one child is assigned to true, the or-parent must be notified - literal l = get_literal(n->get_arg(i)); + literal l = get_literal(arg); add_rel_watch(l, eh); } } @@ -1588,9 +1596,8 @@ namespace smt { TRACE("mk_and_cnstr", tout << "l: "; display_literal(tout, l); tout << "\n";); literal_buffer buffer; buffer.push_back(l); - unsigned num_args = n->get_num_args(); - for (unsigned i = 0; i < num_args; i++) { - literal l_arg = get_literal(n->get_arg(i)); + for (expr * arg : *n) { + literal l_arg = get_literal(arg); TRACE("mk_and_cnstr", tout << "l_arg: "; display_literal(tout, l_arg); tout << "\n";); mk_gate_clause(~l, l_arg); buffer.push_back(~l_arg); @@ -1602,9 +1609,8 @@ namespace smt { literal l = get_literal(n); literal_buffer buffer; buffer.push_back(~l); - unsigned num_args = n->get_num_args(); - for (unsigned i = 0; i < num_args; i++) { - literal l_arg = get_literal(n->get_arg(i)); + for (expr * arg : *n) { + literal l_arg = get_literal(arg); mk_gate_clause(l, ~l_arg); buffer.push_back(l_arg); } diff --git a/src/smt/smt_model_checker.cpp b/src/smt/smt_model_checker.cpp index 0fea4d13d..58158ec06 100644 --- a/src/smt/smt_model_checker.cpp +++ b/src/smt/smt_model_checker.cpp @@ -47,6 +47,7 @@ namespace smt { m_model_finder(mf), m_max_cexs(1), m_iteration_idx(0), + m_has_rec_fun(false), m_curr_model(nullptr), m_pinned_exprs(m) { } @@ -260,7 +261,7 @@ namespace smt { try { for_each_expr(*this, m_visited, n); } - catch (is_model_value) { + catch (const is_model_value &) { return true; } return false; @@ -351,9 +352,7 @@ namespace smt { bool model_checker::check_rec_fun(quantifier* q, bool strict_rec_fun) { TRACE("model_checker", tout << mk_pp(q, m) << "\n";); SASSERT(q->get_num_patterns() == 2); // first pattern is the function, second is the body. - expr* fn = to_app(q->get_pattern(0))->get_arg(0); - SASSERT(is_app(fn)); - func_decl* f = to_app(fn)->get_decl(); + func_decl* f = m.get_rec_fun_decl(q); expr_ref_vector args(m); unsigned num_decls = q->get_num_decls(); @@ -433,7 +432,7 @@ namespace smt { TRACE("model_checker", tout << "model checker result: " << (num_failures == 0) << "\n";); m_max_cexs += m_params.m_mbqi_max_cexs; - if (num_failures == 0 && !m_context->validate_model()) { + if (num_failures == 0 && (!m_context->validate_model() || has_rec_under_quantifiers())) { num_failures = 1; // this time force expanding recursive function definitions // that are not forced true in the current model. @@ -450,6 +449,43 @@ namespace smt { return num_failures == 0; } + struct has_rec_fun_proc { + obj_hashtable& m_rec_funs; + bool m_has_rec_fun; + + bool has_rec_fun() const { return m_has_rec_fun; } + + has_rec_fun_proc(obj_hashtable& rec_funs): + m_rec_funs(rec_funs), + m_has_rec_fun(false) {} + + void operator()(app* fn) { + m_has_rec_fun |= m_rec_funs.contains(fn->get_decl()); + } + void operator()(expr*) {} + }; + + bool model_checker::has_rec_under_quantifiers() { + if (!m_has_rec_fun) { + return false; + } + obj_hashtable rec_funs; + for (quantifier * q : *m_qm) { + if (m.is_rec_fun_def(q)) { + rec_funs.insert(m.get_rec_fun_decl(q)); + } + } + expr_fast_mark1 visited; + has_rec_fun_proc proc(rec_funs); + for (quantifier * q : *m_qm) { + if (!m.is_rec_fun_def(q)) { + quick_for_each_expr(proc, visited, q); + if (proc.has_rec_fun()) return true; + } + } + return false; + } + // // (repeated from defined_names.cpp) // NB. The pattern for lambdas is incomplete. @@ -479,6 +515,7 @@ namespace smt { } found_relevant = true; if (m.is_rec_fun_def(q)) { + m_has_rec_fun = true; if (!check_rec_fun(q, strict_rec_fun)) { TRACE("model_checker", tout << "checking recursive function failed\n";); num_failures++; @@ -540,7 +577,7 @@ namespace smt { } if (inst.m_def) { - m_context->internalize_assertion(inst.m_def, 0, gen); + m_context->internalize_assertion(inst.m_def, nullptr, gen); } TRACE("model_checker_bug_detail", tout << "instantiating... q:\n" << mk_pp(q, m) << "\n"; diff --git a/src/smt/smt_model_checker.h b/src/smt/smt_model_checker.h index 40a58efea..57edf3034 100644 --- a/src/smt/smt_model_checker.h +++ b/src/smt/smt_model_checker.h @@ -51,8 +51,10 @@ namespace smt { scoped_ptr m_aux_context; // Auxiliary context used for model checking quantifiers. unsigned m_max_cexs; unsigned m_iteration_idx; + bool m_has_rec_fun; proto_model * m_curr_model; obj_map m_value2expr; + friend class instantiation_set; void init_aux_context(); @@ -64,6 +66,7 @@ namespace smt { bool add_blocking_clause(model * cex, expr_ref_vector & sks); bool check(quantifier * q); bool check_rec_fun(quantifier* q, bool strict_rec_fun); + bool has_rec_under_quantifiers(); void check_quantifiers(bool strict_rec_fun, bool& found_relevant, unsigned& num_failures); struct instance { diff --git a/src/smt/smt_model_finder.cpp b/src/smt/smt_model_finder.cpp index b8b22b067..111b9a0c0 100644 --- a/src/smt/smt_model_finder.cpp +++ b/src/smt/smt_model_finder.cpp @@ -177,7 +177,7 @@ namespace smt { try { for_each_expr(*this, m_visited, n); } - catch (is_model_value) { + catch (const is_model_value &) { return true; } return false; @@ -1703,7 +1703,7 @@ namespace smt { friend class quantifier_analyzer; void checkpoint() { - m_mf.checkpoint("quantifer_info"); + m_mf.checkpoint("quantifier_info"); } void insert_qinfo(qinfo * qi) { @@ -2892,7 +2892,7 @@ namespace smt { try { for_each_expr(oc, m_visited, def); } - catch (occurs) { + catch (const occurs &) { return false; } return true; @@ -2981,7 +2981,7 @@ namespace smt { try { process(f); } - catch (found_satisfied_subset) { + catch (const found_satisfied_subset &) { set_interp(); copy_non_satisfied(qcandidates, new_qs); return true; diff --git a/src/smt/smt_model_generator.cpp b/src/smt/smt_model_generator.cpp index a4b3029e2..c27845ff6 100644 --- a/src/smt/smt_model_generator.cpp +++ b/src/smt/smt_model_generator.cpp @@ -402,7 +402,10 @@ namespace smt { enode * n = m_context->get_enode(t); unsigned num_args = n->get_num_args(); func_decl * f = n->get_decl(); - if (num_args > 0 && n->get_cg() == n && include_func_interp(f)) { + if (num_args == 0 && include_func_interp(f)) { + m_model->register_decl(f, get_value(n)); + } + else if (num_args > 0 && n->get_cg() == n && include_func_interp(f)) { ptr_buffer args; expr * result = get_value(n); SASSERT(result); diff --git a/src/smt/smt_model_generator.h b/src/smt/smt_model_generator.h index 1f69eb324..a26113a16 100644 --- a/src/smt/smt_model_generator.h +++ b/src/smt/smt_model_generator.h @@ -96,7 +96,7 @@ namespace smt { class model_value_dependency { bool m_fresh; //!< True if the dependency is a new fresh value; union { - enode * m_enode; //!< When m_fresh == false, contains an enode depedency. + enode * m_enode; //!< When m_fresh == false, contains an enode dependency. extra_fresh_value * m_value; //!< When m_fresh == true, contains the sort of the fresh value }; public: diff --git a/src/smt/smt_quantifier.cpp b/src/smt/smt_quantifier.cpp index 885157ab3..ce621144e 100644 --- a/src/smt/smt_quantifier.cpp +++ b/src/smt/smt_quantifier.cpp @@ -26,6 +26,7 @@ Revision History: #include "smt/smt_quick_checker.h" #include "smt/mam.h" #include "smt/qi_queue.h" +#include "util/obj_hashtable.h" namespace smt { @@ -108,30 +109,33 @@ namespace smt { \brief Ensures that all relevant proof steps to explain why the enode is equal to the root of its equivalence class are in the log and up-to-date. */ - void log_justification_to_root(std::ostream & log, enode *en) { - enode *root = en->get_root(); - for (enode *it = en; it != root; it = it->get_trans_justification().m_target) { - if (it->m_proof_logged_status == smt::logged_status::NOT_LOGGED) { - it->m_proof_logged_status = smt::logged_status::BEING_LOGGED; - log_single_justification(log, it); - it->m_proof_logged_status = smt::logged_status::LOGGED; - } else if (it->m_proof_logged_status != smt::logged_status::BEING_LOGGED && it->get_trans_justification().m_justification.get_kind() == smt::eq_justification::kind::CONGRUENCE) { + void log_justification_to_root(std::ostream & out, enode *en, obj_hashtable &visited) { + enode* root = en->get_root(); + for (enode *it = en; it != root && !visited.contains(it); it = it->get_trans_justification().m_target) { - // When the justification of an argument changes m_proof_logged_status is not reset => We need to check if the proofs of all arguments are logged. - it->m_proof_logged_status = smt::logged_status::BEING_LOGGED; + visited.insert(it); + + if (!it->m_proof_is_logged) { + log_single_justification(out, it, visited); + it->m_proof_is_logged = true; + } + else if (it->get_trans_justification().m_justification.get_kind() == smt::eq_justification::kind::CONGRUENCE) { + + // When the justification of an argument changes m_proof_is_logged + // is not reset => We need to check if the proofs of all arguments are logged. const unsigned num_args = it->get_num_args(); enode *target = it->get_trans_justification().m_target; for (unsigned i = 0; i < num_args; ++i) { - log_justification_to_root(log, it->get_arg(i)); - log_justification_to_root(log, target->get_arg(i)); + log_justification_to_root(out, it->get_arg(i), visited); + log_justification_to_root(out, target->get_arg(i), visited); } - it->m_proof_logged_status = smt::logged_status::LOGGED; + SASSERT(it->m_proof_is_logged); } } - if (root->m_proof_logged_status == smt::logged_status::NOT_LOGGED) { - log << "[eq-expl] #" << root->get_owner_id() << " root\n"; - root->m_proof_logged_status = smt::logged_status::LOGGED; + if (!root->m_proof_is_logged) { + out << "[eq-expl] #" << root->get_owner_id() << " root\n"; + root->m_proof_is_logged = true; } } @@ -139,7 +143,7 @@ namespace smt { \brief Logs a single equality explanation step and, if necessary, recursively calls log_justification_to_root to log equalities needed by the step (e.g. argument equalities for congruence steps). */ - void log_single_justification(std::ostream & out, enode *en) { + void log_single_justification(std::ostream & out, enode *en, obj_hashtable &visited) { smt::literal lit; unsigned num_args; enode *target = en->get_trans_justification().m_target; @@ -158,8 +162,8 @@ namespace smt { num_args = en->get_num_args(); for (unsigned i = 0; i < num_args; ++i) { - log_justification_to_root(out, en->get_arg(i)); - log_justification_to_root(out, target->get_arg(i)); + log_justification_to_root(out, en->get_arg(i), visited); + log_justification_to_root(out, target->get_arg(i), visited); } out << "[eq-expl] #" << en->get_owner_id() << " cg"; @@ -188,6 +192,53 @@ namespace smt { } } + void log_add_instance( + fingerprint* f, + quantifier * q, app * pat, + unsigned num_bindings, + enode * const * bindings, + vector> & used_enodes) { + + std::ostream & out = trace_stream(); + + obj_hashtable visited; + + // In the term produced by the quantifier instantiation the root of + // the equivalence class of the terms bound to the quantified variables + // is used. We need to make sure that all of these equalities appear in the log. + for (unsigned i = 0; i < num_bindings; ++i) { + log_justification_to_root(out, bindings[i], visited); + } + + for (auto n : used_enodes) { + enode *orig = std::get<0>(n); + enode *substituted = std::get<1>(n); + if (orig != nullptr) { + log_justification_to_root(out, orig, visited); + log_justification_to_root(out, substituted, visited); + } + } + + // At this point all relevant equalities for the match are logged. + out << "[new-match] " << static_cast(f) << " #" << q->get_id() << " #" << pat->get_id(); + for (unsigned i = 0; i < num_bindings; i++) { + // I don't want to use mk_pp because it creates expressions for pretty printing. + // This nasty side-effect may change the behavior of Z3. + out << " #" << bindings[i]->get_owner_id(); + } + out << " ;"; + for (auto n : used_enodes) { + enode *orig = std::get<0>(n); + enode *substituted = std::get<1>(n); + if (orig == nullptr) + out << " #" << substituted->get_owner_id(); + else { + out << " (#" << orig->get_owner_id() << " #" << substituted->get_owner_id() << ")"; + } + } + out << "\n"; + } + bool add_instance(quantifier * q, app * pat, unsigned num_bindings, enode * const * bindings, @@ -204,41 +255,7 @@ namespace smt { fingerprint * f = m_context.add_fingerprint(q, q->get_id(), num_bindings, bindings, def); if (f) { if (has_trace_stream()) { - std::ostream & out = trace_stream(); - - // In the term produced by the quantifier instantiation the root of the equivalence class of the terms bound to the quantified variables - // is used. We need to make sure that all of these equalities appear in the log. - for (unsigned i = 0; i < num_bindings; ++i) { - log_justification_to_root(out, bindings[i]); - } - - for (auto n : used_enodes) { - enode *orig = std::get<0>(n); - enode *substituted = std::get<1>(n); - if (orig != nullptr) { - log_justification_to_root(out, orig); - log_justification_to_root(out, substituted); - } - } - - // At this point all relevant equalities for the match are logged. - out << "[new-match] " << static_cast(f) << " #" << q->get_id() << " #" << pat->get_id(); - for (unsigned i = 0; i < num_bindings; i++) { - // I don't want to use mk_pp because it creates expressions for pretty printing. - // This nasty side-effect may change the behavior of Z3. - out << " #" << bindings[i]->get_owner_id(); - } - out << " ;"; - for (auto n : used_enodes) { - enode *orig = std::get<0>(n); - enode *substituted = std::get<1>(n); - if (orig == nullptr) - out << " #" << substituted->get_owner_id(); - else { - out << " (#" << orig->get_owner_id() << " #" << substituted->get_owner_id() << ")"; - } - } - out << "\n"; + log_add_instance(f, q, pat, num_bindings, bindings, used_enodes); } m_qi_queue.insert(f, pat, max_generation, min_top_generation, max_top_generation); // TODO m_num_instances++; @@ -249,7 +266,7 @@ namespace smt { tout << mk_pp(bindings[i]->get_owner(), m()) << " "; } tout << "\n"; - tout << "inserted: " << (f != 0) << "\n"; + tout << "inserted: " << (f != nullptr) << "\n"; ); return f != nullptr; diff --git a/src/smt/smt_setup.cpp b/src/smt/smt_setup.cpp index 9e38fef69..a6b27784f 100644 --- a/src/smt/smt_setup.cpp +++ b/src/smt/smt_setup.cpp @@ -28,6 +28,7 @@ Revision History: #include "smt/theory_array_full.h" #include "smt/theory_bv.h" #include "smt/theory_datatype.h" +#include "smt/theory_recfun.h" #include "smt/theory_dummy.h" #include "smt/theory_dl.h" #include "smt/theory_seq_empty.h" @@ -35,6 +36,7 @@ Revision History: #include "smt/theory_pb.h" #include "smt/theory_fpa.h" #include "smt/theory_str.h" +#include "smt/theory_jobscheduler.h" namespace smt { @@ -119,6 +121,8 @@ namespace smt { setup_UFLRA(); else if (m_logic == "LRA") setup_LRA(); + else if (m_logic == "CSP") + setup_CSP(); else if (m_logic == "QF_FP") setup_QF_FP(); else if (m_logic == "QF_FPBV" || m_logic == "QF_BVFP") @@ -196,6 +200,8 @@ namespace smt { setup_QF_DT(); else if (m_logic == "LRA") setup_LRA(); + else if (m_logic == "CSP") + setup_CSP(); else setup_unknown(st); } @@ -203,7 +209,7 @@ namespace smt { static void check_no_arithmetic(static_features const & st, char const * logic) { if (st.m_num_arith_ineqs > 0 || st.m_num_arith_terms > 0 || st.m_num_arith_eqs > 0) - throw default_exception("Benchmark constains arithmetic, but specified loging does not support it."); + throw default_exception("Benchmark constrains arithmetic, but specified logic does not support it."); } void setup::setup_QF_UF() { @@ -217,6 +223,7 @@ namespace smt { void setup::setup_QF_DT() { setup_QF_UF(); setup_datatypes(); + setup_recfuns(); } void setup::setup_QF_BVRE() { @@ -519,7 +526,7 @@ namespace smt { m_params.m_arith_eq2ineq = true; m_params.m_eliminate_term_ite = true; // if (st.m_num_exprs < 5000 && st.m_num_ite_terms < 50) { // safeguard to avoid high memory consumption - // TODO: implement analsysis function to decide where lift ite is too expensive. + // TODO: implement analysis function to decide where lift ite is too expensive. // m_params.m_lift_ite = LI_FULL; // } } @@ -873,6 +880,12 @@ namespace smt { m_context.register_plugin(alloc(theory_datatype, m_manager, m_params)); } + void setup::setup_recfuns() { + TRACE("recfun", tout << "registering theory recfun...\n";); + theory_recfun * th = alloc(theory_recfun, m_manager); + m_context.register_plugin(th); + } + void setup::setup_dl() { m_context.register_plugin(mk_theory_dl(m_manager)); } @@ -916,6 +929,11 @@ namespace smt { m_context.register_plugin(alloc(smt::theory_seq, m_manager, m_params)); } + void setup::setup_CSP() { + setup_unknown(); + m_context.register_plugin(alloc(smt::theory_jobscheduler, m_manager)); + } + void setup::setup_unknown() { static_features st(m_manager); ptr_vector fmls; @@ -926,6 +944,7 @@ namespace smt { setup_arrays(); setup_bv(); setup_datatypes(); + setup_recfuns(); setup_dl(); setup_seq_str(st); setup_card(); @@ -945,6 +964,7 @@ namespace smt { setup_seq_str(st); setup_card(); setup_fpa(); + setup_recfuns(); return; } diff --git a/src/smt/smt_setup.h b/src/smt/smt_setup.h index ed0ab066d..01a143301 100644 --- a/src/smt/smt_setup.h +++ b/src/smt/smt_setup.h @@ -81,6 +81,7 @@ namespace smt { void setup_QF_FPBV(); void setup_QF_S(); void setup_LRA(); + void setup_CSP(); void setup_AUFLIA(bool simple_array = true); void setup_AUFLIA(static_features const & st); void setup_AUFLIRA(bool simple_array = true); @@ -93,6 +94,7 @@ namespace smt { void setup_unknown(static_features & st); void setup_arrays(); void setup_datatypes(); + void setup_recfuns(); void setup_bv(); void setup_arith(); void setup_dl(); diff --git a/src/smt/smt_theory.h b/src/smt/smt_theory.h index 9d5a4f49f..66bb3e14b 100644 --- a/src/smt/smt_theory.h +++ b/src/smt/smt_theory.h @@ -36,6 +36,7 @@ namespace smt { unsigned_vector m_var2enode_lim; friend class context; + friend class arith_value; protected: virtual void init(context * ctx); @@ -67,7 +68,7 @@ namespace smt { public: /** - \brief Return ture if the given enode is attached to a + \brief Return true if the given enode is attached to a variable of the theory. \remark The result is not equivalent to @@ -193,6 +194,15 @@ namespace smt { return l_false; } + /** + \brief This method is called from the smt_context when an unsat core is generated. + The theory may tell the solver to perform iterative deepening by invalidating + this unsat core and increasing some resource constraints. + */ + virtual bool should_research(expr_ref_vector & unsat_core) { + return false; + } + /** \brief This method is invoked before the search starts. */ @@ -293,6 +303,8 @@ namespace smt { SASSERT(m_context); return *m_context; } + + context & ctx() const { return get_context(); } ast_manager & get_manager() const { SASSERT(m_manager); @@ -388,7 +400,7 @@ namespace smt { \brief When an eq atom n is created during the search, the default behavior is to make sure that the n->get_arg(0)->get_id() < n->get_arg(1)->get_id(). This may create some redundant atoms, since some theories/families use different - convetions in their simplifiers. For example, arithmetic always force a numeral + conventions in their simplifiers. For example, arithmetic always force a numeral to be in the right hand side. So, this method should be redefined if the default behavior conflicts with a convention used by the theory/family. */ diff --git a/src/smt/tactic/smt_tactic.cpp b/src/smt/tactic/smt_tactic.cpp index 50fe47985..2d894d3ee 100644 --- a/src/smt/tactic/smt_tactic.cpp +++ b/src/smt/tactic/smt_tactic.cpp @@ -217,7 +217,7 @@ public: model_ref md; m_ctx->get_model(md); buffer r; - m_ctx->get_relevant_labels(0, r); + m_ctx->get_relevant_labels(nullptr, r); labels_vec rv; rv.append(r.size(), r.c_ptr()); model_converter_ref mc; @@ -270,7 +270,7 @@ public: model_ref md; m_ctx->get_model(md); buffer r; - m_ctx->get_relevant_labels(0, r); + m_ctx->get_relevant_labels(nullptr, r); labels_vec rv; rv.append(r.size(), r.c_ptr()); in->add(model_and_labels2model_converter(md.get(), rv)); @@ -289,30 +289,24 @@ public: } }; -tactic * mk_smt_tactic(params_ref const & p) { +static tactic * mk_seq_smt_tactic(params_ref const & p) { return alloc(smt_tactic, p); } -tactic * mk_smt_tactic_using(bool auto_config, params_ref const & _p) { - params_ref p = _p; - p.set_bool("auto_config", auto_config); - tactic * r = mk_smt_tactic(p); - TRACE("smt_tactic", tout << "auto_config: " << auto_config << "\nr: " << r << "\np: " << p << "\n";); - return using_params(r, p); -} - -tactic * mk_psmt_tactic(ast_manager& m, params_ref const& p, symbol const& logic) { - parallel_params pp(p); - return pp.enable() ? mk_parallel_tactic(mk_smt_solver(m, p, logic), p) : mk_smt_tactic(p); -} - -tactic * mk_psmt_tactic_using(ast_manager& m, bool auto_config, params_ref const& _p, symbol const& logic) { - parallel_params pp(_p); - params_ref p = _p; - p.set_bool("auto_config", auto_config); - return using_params(pp.enable() ? mk_parallel_tactic(mk_smt_solver(m, p, logic), p) : mk_smt_tactic(p), p); -} tactic * mk_parallel_smt_tactic(ast_manager& m, params_ref const& p) { return mk_parallel_tactic(mk_smt_solver(m, p, symbol::null), p); } + +tactic * mk_smt_tactic(ast_manager& m, params_ref const& p, symbol const& logic) { + parallel_params pp(p); + return pp.enable() ? mk_parallel_tactic(mk_smt_solver(m, p, logic), p) : mk_seq_smt_tactic(p); +} + +tactic * mk_smt_tactic_using(ast_manager& m, bool auto_config, params_ref const& _p) { + parallel_params pp(_p); + params_ref p = _p; + p.set_bool("auto_config", auto_config); + return using_params(pp.enable() ? mk_parallel_smt_tactic(m, p) : mk_seq_smt_tactic(p), p); +} + diff --git a/src/smt/tactic/smt_tactic.h b/src/smt/tactic/smt_tactic.h index fbee950c2..733413bb2 100644 --- a/src/smt/tactic/smt_tactic.h +++ b/src/smt/tactic/smt_tactic.h @@ -27,17 +27,15 @@ Notes: class tactic; class filter_model_converter; -tactic * mk_smt_tactic(params_ref const & p = params_ref()); +tactic * mk_smt_tactic(ast_manager& m, params_ref const & p = params_ref(), symbol const& logic = symbol::null); // syntax sugar for using_params(mk_smt_tactic(), p) where p = (:auto_config, auto_config) -tactic * mk_smt_tactic_using(bool auto_config = true, params_ref const & p = params_ref()); +tactic * mk_smt_tactic_using(ast_manager& m, bool auto_config = true, params_ref const & p = params_ref()); -tactic * mk_psmt_tactic(ast_manager& m, params_ref const& p, symbol const& logic = symbol::null); -tactic * mk_psmt_tactic_using(ast_manager& m, bool auto_config, params_ref const& p, symbol const& logic = symbol::null); tactic * mk_parallel_smt_tactic(ast_manager& m, params_ref const& p); /* - ADD_TACTIC("smt", "apply a SAT based SMT solver.", "mk_smt_tactic(p)") + ADD_TACTIC("smt", "apply a SAT based SMT solver.", "mk_smt_tactic(m, p)") ADD_TACTIC("psmt", "builtin strategy for SMT tactic in parallel.", "mk_parallel_smt_tactic(m, p)") */ #endif diff --git a/src/smt/theory_arith.h b/src/smt/theory_arith.h index 4b3ee52f6..384b44de7 100644 --- a/src/smt/theory_arith.h +++ b/src/smt/theory_arith.h @@ -156,9 +156,9 @@ namespace smt { row_entry & operator[](unsigned idx) { return m_entries[idx]; } row_entry const & operator[](unsigned idx) const { return m_entries[idx]; } typename vector::iterator begin_entries() { return m_entries.begin(); } - const typename vector::const_iterator begin_entries() const { return m_entries.begin(); } + typename vector::const_iterator begin_entries() const { return m_entries.begin(); } typename vector::iterator end_entries() { return m_entries.end(); } - const typename vector::const_iterator end_entries() const { return m_entries.end(); } + typename vector::const_iterator end_entries() const { return m_entries.end(); } row_entry & add_row_entry(int & pos_idx); void del_row_entry(unsigned idx); void compress(vector & cols); @@ -195,9 +195,9 @@ namespace smt { col_entry & operator[](unsigned idx) { return m_entries[idx]; } col_entry const & operator[](unsigned idx) const { return m_entries[idx]; } typename svector::iterator begin_entries() { return m_entries.begin(); } - const typename svector::const_iterator begin_entries() const { return m_entries.begin(); } + typename svector::const_iterator begin_entries() const { return m_entries.begin(); } typename svector::iterator end_entries() { return m_entries.end(); } - const typename svector::const_iterator end_entries() const { return m_entries.end(); } + typename svector::const_iterator end_entries() const { return m_entries.end(); } col_entry & add_col_entry(int & pos_idx); void del_col_entry(unsigned idx); }; @@ -541,9 +541,9 @@ namespace smt { bool process_atoms() const; unsigned get_num_conflicts() const { return m_num_conflicts; } var_kind get_var_kind(theory_var v) const { return m_data[v].kind(); } - bool is_base(theory_var v) const { return get_var_kind(v) == BASE; } - bool is_quasi_base(theory_var v) const { return get_var_kind(v) == QUASI_BASE; } - bool is_non_base(theory_var v) const { return get_var_kind(v) == NON_BASE; } + bool is_base(theory_var v) const { return v != null_theory_var && get_var_kind(v) == BASE; } + bool is_quasi_base(theory_var v) const { return v != null_theory_var && get_var_kind(v) == QUASI_BASE; } + bool is_non_base(theory_var v) const { return v != null_theory_var && get_var_kind(v) == NON_BASE; } void set_var_kind(theory_var v, var_kind k) { m_data[v].m_kind = k; } unsigned get_var_row(theory_var v) const { SASSERT(!is_non_base(v)); return m_data[v].m_row_id; } void set_var_row(theory_var v, unsigned r_id) { m_data[v].m_row_id = r_id; } @@ -1071,6 +1071,8 @@ namespace smt { bool get_lower(enode* n, expr_ref& r); bool get_upper(enode* n, expr_ref& r); + bool get_lower(enode* n, rational& r, bool &is_strict); + bool get_upper(enode* n, rational& r, bool &is_strict); bool to_expr(inf_numeral const& val, bool is_int, expr_ref& r); diff --git a/src/smt/theory_arith_aux.h b/src/smt/theory_arith_aux.h index 9526637e9..ae0286c59 100644 --- a/src/smt/theory_arith_aux.h +++ b/src/smt/theory_arith_aux.h @@ -491,13 +491,21 @@ namespace smt { if (!it->is_dead()) { unsigned rid = it->m_row_id; row & r = m_rows[rid]; - if (is_base(r.get_base_var())) + theory_var v = r.get_base_var(); + if (v == null_theory_var) { + // skip + } + else if (is_base(v)) { return it; + } else if (quasi_base_rid == -1) quasi_base_rid = rid; } } - SASSERT(quasi_base_rid != -1); // since c.size() != 0 + if (quasi_base_rid == -1) { + return nullptr; + } + quasi_base_row2base_row(quasi_base_rid); // There is no guarantee that v is still a variable of row quasi_base_rid. @@ -540,7 +548,7 @@ namespace smt { if (!it->is_dead()) { row const & r = m_rows[it->m_row_id]; theory_var s = r.get_base_var(); - if (is_quasi_base(s) && m_var_occs[s].size() == 0) + if (is_quasi_base(s) && m_var_occs[s].empty()) continue; if (is_int(v)) { numeral const & c = r[it->m_row_idx].m_coeff; @@ -566,7 +574,7 @@ namespace smt { TRACE("move_unconstrained_to_base", tout << "before...\n"; display(tout);); int num = get_num_vars(); for (theory_var v = 0; v < num; v++) { - if (m_var_occs[v].size() == 0 && is_free(v)) { + if (m_var_occs[v].empty() && is_free(v)) { switch (get_var_kind(v)) { case QUASI_BASE: break; @@ -1073,7 +1081,7 @@ namespace smt { /** \brief: Create an atom that enforces the inequality v > val The arithmetical expression encoding the inequality suffices - for the theory of aritmetic. + for the theory of arithmetic. */ template expr_ref theory_arith::mk_gt(theory_var v) { @@ -1103,6 +1111,7 @@ namespace smt { e = m_util.mk_gt(obj, e); } } + TRACE("opt", tout << e << "\n";); return e; } @@ -1119,6 +1128,8 @@ namespace smt { std::ostringstream strm; strm << val << " <= " << mk_pp(get_enode(v)->get_owner(), get_manager()); app* b = m.mk_const(symbol(strm.str().c_str()), m.mk_bool_sort()); + expr_ref result(b, m); + TRACE("opt", tout << result << "\n";); if (!ctx.b_internalized(b)) { fm.hide(b->get_decl()); bool_var bv = ctx.mk_bool_var(b); @@ -1133,7 +1144,7 @@ namespace smt { TRACE("arith", tout << mk_pp(b, m) << "\n"; display_atom(tout, a, false);); } - return expr_ref(b, m); + return result; } @@ -1143,7 +1154,7 @@ namespace smt { template void theory_arith::enable_record_conflict(expr* bound) { m_params.m_arith_bound_prop = BP_NONE; - SASSERT(propagation_mode() == BP_NONE); // bound propagtion rules are not (yet) handled. + SASSERT(propagation_mode() == BP_NONE); // bound propagation rules are not (yet) handled. if (bound) { context& ctx = get_context(); m_bound_watch = ctx.get_bool_var(bound); diff --git a/src/smt/theory_arith_core.h b/src/smt/theory_arith_core.h index f96b6228b..f3a3e9238 100644 --- a/src/smt/theory_arith_core.h +++ b/src/smt/theory_arith_core.h @@ -484,7 +484,6 @@ namespace smt { void theory_arith::mk_idiv_mod_axioms(expr * dividend, expr * divisor) { if (!m_util.is_zero(divisor)) { ast_manager & m = get_manager(); - bool is_numeral = m_util.is_numeral(divisor); // if divisor is zero, then idiv and mod are uninterpreted functions. expr_ref div(m), mod(m), zero(m), abs_divisor(m), one(m); expr_ref eqz(m), eq(m), lower(m), upper(m); @@ -504,7 +503,7 @@ namespace smt { tout << "lower: " << lower << "\n"; tout << "upper: " << upper << "\n";); - mk_axiom(eqz, eq, true); + mk_axiom(eqz, eq, false); mk_axiom(eqz, lower, false); mk_axiom(eqz, upper, !m_util.is_numeral(abs_divisor)); rational k; @@ -3129,7 +3128,7 @@ namespace smt { // // 1) Handling inequalities: (n1, k1) <= (n2, k2) // - // The only intersting case is n1 < n2 and k1 > k2. + // The only interesting case is n1 < n2 and k1 > k2. // Using the definition of infinitesimal numbers // we have: // n1 + k1 * epsilon <= n2 + k2 - epsilon @@ -3303,6 +3302,20 @@ namespace smt { return b && to_expr(b->get_value(), is_int(v), r); } + template + bool theory_arith::get_lower(enode * n, rational& r, bool& is_strict) { + theory_var v = n->get_th_var(get_id()); + bound* b = (v == null_theory_var) ? nullptr : lower(v); + return b && (r = b->get_value().get_rational().to_rational(), is_strict = b->get_value().get_infinitesimal().is_pos(), true); + } + + template + bool theory_arith::get_upper(enode * n, rational& r, bool& is_strict) { + theory_var v = n->get_th_var(get_id()); + bound* b = (v == null_theory_var) ? nullptr : upper(v); + return b && (r = b->get_value().get_rational().to_rational(), is_strict = b->get_value().get_infinitesimal().is_neg(), true); + } + // ----------------------------------- // // Backtracking @@ -3519,7 +3532,7 @@ namespace smt { } /** - \brief reset and retrieve built-in explanation hints for arithmetic lemmmas. + \brief reset and retrieve built-in explanation hints for arithmetic lemmas. */ template diff --git a/src/smt/theory_arith_int.h b/src/smt/theory_arith_int.h index ee3bd5e2e..afe527a98 100644 --- a/src/smt/theory_arith_int.h +++ b/src/smt/theory_arith_int.h @@ -396,7 +396,9 @@ namespace smt { for (; it != end; ++it) { if (!it->is_dead() && it->m_var != b && is_free(it->m_var)) { theory_var v = it->m_var; - expr * bound = m_util.mk_ge(get_enode(v)->get_owner(), m_util.mk_numeral(rational::zero(), is_int(v))); + expr* e = get_enode(v)->get_owner(); + bool _is_int = m_util.is_int(e); + expr * bound = m_util.mk_ge(e, m_util.mk_numeral(rational::zero(), _is_int)); context & ctx = get_context(); ctx.internalize(bound, true); ctx.mark_as_relevant(bound); diff --git a/src/smt/theory_arith_nl.h b/src/smt/theory_arith_nl.h index c27d3b44a..24e1020fd 100644 --- a/src/smt/theory_arith_nl.h +++ b/src/smt/theory_arith_nl.h @@ -1337,7 +1337,7 @@ namespace smt { } /** - \brief Diplay a nested form expression + \brief Display a nested form expression */ template void theory_arith::display_nested_form(std::ostream & out, expr * p) { @@ -1682,7 +1682,7 @@ namespace smt { if (!get_manager().int_real_coercions() && is_mixed_real_integer(r)) return true; // giving up... see comment above - TRACE("cross_nested", tout << "cheking problematic row...\n";); + TRACE("cross_nested", tout << "checking problematic row...\n";); rational c = rational::one(); if (is_integer(r)) @@ -1764,7 +1764,7 @@ namespace smt { updated with the fixed variables in m. A variable is only added to dep if it is not already in already_found. - Return null if the monomial was simplied to 0. + Return null if the monomial was simplified to 0. */ template grobner::monomial * theory_arith::mk_gb_monomial(rational const & _coeff, expr * m, grobner & gb, v_dependency * & dep, var_set & already_found) { diff --git a/src/smt/theory_array_full.cpp b/src/smt/theory_array_full.cpp index d872997c4..3e474df81 100644 --- a/src/smt/theory_array_full.cpp +++ b/src/smt/theory_array_full.cpp @@ -65,10 +65,14 @@ namespace smt { bool result = false; var_data * d = m_var_data[v]; var_data_full * d_full = m_var_data_full[v]; - for (enode* pm : d_full->m_parent_maps) - for (enode* ps : d->m_parent_selects) + for (unsigned i = 0; i < d_full->m_parent_maps.size(); ++i) { + enode* pm = d_full->m_parent_maps[i]; + for (unsigned j = 0; j < d->m_parent_selects.size(); ++j) { + enode* ps = d->m_parent_selects[j]; if (instantiate_select_map_axiom(ps, pm)) - result = true; + result = true; + } + } return result; } @@ -137,7 +141,7 @@ namespace smt { } void theory_array_full::set_prop_upward(theory_var v, var_data* d) { - if (m_params.m_array_always_prop_upward || d->m_stores.size() >= 1) { + if (m_params.m_array_always_prop_upward || !d->m_stores.empty()) { theory_array::set_prop_upward(v, d); } else { @@ -339,18 +343,14 @@ namespace smt { SASSERT(v != null_theory_var); v = find(v); var_data* d = m_var_data[v]; + TRACE("array", tout << "v" << v << " " << d->m_prop_upward << " " << m_params.m_array_delay_exp_axiom << "\n";); for (enode * store : d->m_stores) { SASSERT(is_store(store)); instantiate_default_store_axiom(store); } if (!m_params.m_array_weak && !m_params.m_array_delay_exp_axiom && d->m_prop_upward) { - for (enode * store : d->m_parent_stores) { - SASSERT(is_store(store)); - if (!m_params.m_array_cg || store->is_cgr()) { - instantiate_default_store_axiom(store); - } - } + instantiate_parent_stores_default(v); } } @@ -381,14 +381,13 @@ namespace smt { } void theory_array_full::relevant_eh(app* n) { - TRACE("array", tout << mk_pp(n, get_manager()) << "\n";); + TRACE("array", tout << mk_pp(n, get_manager()) << "\n";); theory_array::relevant_eh(n); - if (!is_default(n) && !is_select(n) && !is_map(n) && !is_const(n) && !is_as_array(n)) { + if (!is_default(n) && !is_select(n) && !is_map(n) && !is_const(n) && !is_as_array(n)){ return; } context & ctx = get_context(); enode* node = ctx.get_enode(n); - if (is_select(n)) { enode * arg = ctx.get_enode(n->get_arg(0)); theory_var v = arg->get_th_var(get_id()); @@ -399,14 +398,18 @@ namespace smt { enode * arg = ctx.get_enode(n->get_arg(0)); theory_var v = arg->get_th_var(get_id()); SASSERT(v != null_theory_var); + set_prop_upward(v); add_parent_default(find(v)); } else if (is_const(n)) { instantiate_default_const_axiom(node); + theory_var v = node->get_th_var(get_id()); + set_prop_upward(v); + add_parent_default(find(v)); } else if (is_map(n)) { - for (unsigned i = 0; i < n->get_num_args(); ++i) { - enode* arg = ctx.get_enode(n->get_arg(i)); + for (expr * e : *n) { + enode* arg = ctx.get_enode(e); theory_var v_arg = find(arg->get_th_var(get_id())); add_parent_map(v_arg, node); set_prop_upward(v_arg); @@ -496,7 +499,7 @@ namespace smt { app* map = mp->get_owner(); ast_manager& m = get_manager(); context& ctx = get_context(); - if (!ctx.add_fingerprint(this, 0, 1, &mp)) { + if (!ctx.add_fingerprint(this, m_default_map_fingerprint, 1, &mp)) { return false; } TRACE("array", tout << mk_bounded_pp(map, get_manager()) << "\n";); @@ -521,7 +524,7 @@ namespace smt { bool theory_array_full::instantiate_default_const_axiom(enode* cnst) { context& ctx = get_context(); - if (!ctx.add_fingerprint(this, 0, 1, &cnst)) { + if (!ctx.add_fingerprint(this, m_default_const_fingerprint, 1, &cnst)) { return false; } m_stats.m_num_default_const_axiom++; @@ -542,7 +545,7 @@ namespace smt { return false; #if 0 context& ctx = get_context(); - if (!ctx.add_fingerprint(this, 0, 1, &arr)) { + if (!ctx.add_fingerprint(this, m_default_as_array_fingerprint, 1, &arr)) { return false; } m_stats.m_num_default_as_array_axiom++; @@ -659,7 +662,7 @@ namespace smt { app* store_app = store->get_owner(); context& ctx = get_context(); ast_manager& m = get_manager(); - if (!ctx.add_fingerprint(this, 0, 1, &store)) { + if (!ctx.add_fingerprint(this, m_default_store_fingerprint, 1, &store)) { return false; } @@ -732,6 +735,10 @@ namespace smt { var_data * d = m_var_data[v]; if (d->m_prop_upward && instantiate_axiom_map_for(v)) r = FC_CONTINUE; + if (d->m_prop_upward && !m_params.m_array_weak) { + if (instantiate_parent_stores_default(v)) + r = FC_CONTINUE; + } } } while (!m_eqsv.empty()) { @@ -746,6 +753,22 @@ namespace smt { return r; } + bool theory_array_full::instantiate_parent_stores_default(theory_var v) { + SASSERT(v != null_theory_var); + TRACE("array", tout << "v" << v << "\n";); + v = find(v); + var_data* d = m_var_data[v]; + bool result = false; + for (enode * store : d->m_parent_stores) { + TRACE("array", tout << expr_ref(store->get_owner(), get_manager()) << "\n";); + SASSERT(is_store(store)); + if (!m_params.m_array_cg || store->is_cgr()) { + if (instantiate_default_store_axiom(store)) + result = true; + } + } + return result; + } bool theory_array_full::try_assign_eq(expr* v1, expr* v2) { TRACE("array", diff --git a/src/smt/theory_array_full.h b/src/smt/theory_array_full.h index 3216b4286..b249ec0b4 100644 --- a/src/smt/theory_array_full.h +++ b/src/smt/theory_array_full.h @@ -38,6 +38,11 @@ namespace smt { ast2ast_trailmap m_sort2epsilon; obj_pair_map m_eqs; svector m_eqsv; + + static unsigned const m_default_map_fingerprint = UINT_MAX - 112; + static unsigned const m_default_store_fingerprint = UINT_MAX - 113; + static unsigned const m_default_const_fingerprint = UINT_MAX - 115; + static unsigned const m_default_as_array_fingerprint = UINT_MAX - 116; protected: @@ -70,6 +75,7 @@ namespace smt { bool instantiate_default_store_axiom(enode* store); bool instantiate_default_map_axiom(enode* map); bool instantiate_default_as_array_axiom(enode* arr); + bool instantiate_parent_stores_default(theory_var v); bool has_large_domain(app* array_term); app* mk_epsilon(sort* s); diff --git a/src/smt/theory_bv.cpp b/src/smt/theory_bv.cpp index 33207d15a..6e1626cc1 100644 --- a/src/smt/theory_bv.cpp +++ b/src/smt/theory_bv.cpp @@ -20,6 +20,7 @@ Revision History: #include "smt/theory_bv.h" #include "ast/ast_ll_pp.h" #include "ast/ast_pp.h" +#include "ast/bv_decl_plugin.h" #include "smt/smt_model_generator.h" #include "util/stats.h" @@ -1083,7 +1084,6 @@ namespace smt { for (unsigned i = 0; i <= num_args; i++) { expr* arg = (i == num_args)?n:n->get_arg(i); sort* s = get_manager().get_sort(arg); - s = get_manager().get_sort(arg); if (m_util.is_bv_sort(s) && m_util.get_bv_size(arg) > m_params.m_bv_blast_max_size) { if (!m_approximates_large_bvs) { TRACE("bv", tout << "found large size bit-vector:\n" << mk_pp(n, get_manager()) << "\n";); diff --git a/src/smt/theory_datatype.cpp b/src/smt/theory_datatype.cpp index 049555297..6aa49efae 100644 --- a/src/smt/theory_datatype.cpp +++ b/src/smt/theory_datatype.cpp @@ -365,7 +365,7 @@ namespace smt { if (!is_recognizer(n)) return; TRACE("datatype", tout << "assigning recognizer: #" << n->get_owner_id() << " is_true: " << is_true << "\n" - << mk_bounded_pp(n->get_owner(), get_manager()) << "\n";); + << enode_pp(n, ctx) << "\n";); SASSERT(n->get_num_args() == 1); enode * arg = n->get_arg(0); theory_var tv = arg->get_th_var(get_id()); @@ -393,11 +393,10 @@ namespace smt { } void theory_datatype::relevant_eh(app * n) { - TRACE("datatype", tout << "relevant_eh: " << mk_bounded_pp(n, get_manager()) << "\n";); context & ctx = get_context(); + TRACE("datatype", tout << "relevant_eh: " << mk_pp(n, get_manager()) << "\n";); SASSERT(ctx.relevancy()); if (is_recognizer(n)) { - TRACE("datatype", tout << "relevant_eh: #" << n->get_id() << "\n" << mk_bounded_pp(n, get_manager()) << "\n";); SASSERT(ctx.e_internalized(n)); enode * e = ctx.get_enode(n); theory_var v = e->get_arg(0)->get_th_var(get_id()); @@ -483,31 +482,41 @@ namespace smt { SASSERT(app->get_root() == root->get_root()); if (app != root) m_used_eqs.push_back(enode_pair(app, root)); + + TRACE("datatype", + tout << "occurs_check\n"; + for (enode_pair const& p : m_used_eqs) { + tout << enode_eq_pp(p, get_context()); + }); } // start exploring subgraph below `app` bool theory_datatype::occurs_check_enter(enode * app) { - oc_mark_on_stack(app); - theory_var v = app->get_root()->get_th_var(get_id()); - if (v != null_theory_var) { - v = m_find.find(v); - var_data * d = m_var_data[v]; - if (d->m_constructor) { - for (enode * arg : enode::args(d->m_constructor)) { - if (oc_cycle_free(arg)) { - continue; - } - if (oc_on_stack(arg)) { - // arg was explored before app, and is still on the stack: cycle - occurs_check_explain(app, arg); - return true; - } - // explore `arg` (with parent `app`) - if (m_util.is_datatype(get_manager().get_sort(arg->get_owner()))) { - m_parent.insert(arg->get_root(), app); - oc_push_stack(arg); - } - } + app = app->get_root(); + theory_var v = app->get_th_var(get_id()); + if (v == null_theory_var) { + return false; + } + v = m_find.find(v); + var_data * d = m_var_data[v]; + if (!d->m_constructor) { + return false; + } + enode * parent = d->m_constructor; + oc_mark_on_stack(parent); + for (enode * arg : enode::args(parent)) { + if (oc_cycle_free(arg)) { + continue; + } + if (oc_on_stack(arg)) { + // arg was explored before app, and is still on the stack: cycle + occurs_check_explain(parent, arg); + return true; + } + // explore `arg` (with paren) + if (m_util.is_datatype(get_manager().get_sort(arg->get_owner()))) { + m_parent.insert(arg->get_root(), parent); + oc_push_stack(arg); } } return false; @@ -521,7 +530,7 @@ namespace smt { a3 = cons(v3, a1) */ bool theory_datatype::occurs_check(enode * n) { - TRACE("datatype", tout << "occurs check: #" << n->get_owner_id() << " " << mk_bounded_pp(n->get_owner(), get_manager()) << "\n";); + TRACE("datatype", tout << "occurs check: " << enode_pp(n, get_context()) << "\n";); m_stats.m_occurs_check++; bool res = false; @@ -535,7 +544,7 @@ namespace smt { if (oc_cycle_free(app)) continue; - TRACE("datatype", tout << "occurs check loop: #" << app->get_owner_id() << " " << mk_bounded_pp(app->get_owner(), get_manager()) << (op==ENTER?" enter":" exit")<< "\n";); + TRACE("datatype", tout << "occurs check loop: " << enode_pp(app, get_context()) << (op==ENTER?" enter":" exit")<< "\n";); switch (op) { case ENTER: @@ -553,12 +562,6 @@ namespace smt { context & ctx = get_context(); region & r = ctx.get_region(); ctx.set_conflict(ctx.mk_justification(ext_theory_conflict_justification(get_id(), r, 0, nullptr, m_used_eqs.size(), m_used_eqs.c_ptr()))); - TRACE("datatype", - tout << "occurs_check: true\n"; - for (enode_pair const& p : m_used_eqs) { - tout << "eq: #" << p.first->get_owner_id() << " #" << p.second->get_owner_id() << "\n"; - tout << mk_bounded_pp(p.first->get_owner(), get_manager()) << " " << mk_bounded_pp(p.second->get_owner(), get_manager()) << "\n"; - }); } return res; } @@ -613,7 +616,7 @@ namespace smt { var_data * d = m_var_data[v]; out << "v" << v << " #" << get_enode(v)->get_owner_id() << " -> v" << m_find.find(v) << " "; if (d->m_constructor) - out << mk_bounded_pp(d->m_constructor->get_owner(), get_manager()); + out << enode_pp(d->m_constructor, get_context()); else out << "(null)"; out << "\n"; @@ -778,11 +781,11 @@ namespace smt { SASSERT(!lits.empty()); region & reg = ctx.get_region(); TRACE("datatype_conflict", tout << mk_ismt2_pp(recognizer->get_owner(), get_manager()) << "\n"; - for (unsigned i = 0; i < lits.size(); i++) { - ctx.display_detailed_literal(tout, lits[i]); tout << "\n"; + for (literal l : lits) { + ctx.display_detailed_literal(tout, l); tout << "\n"; } - for (unsigned i = 0; i < eqs.size(); i++) { - tout << mk_ismt2_pp(eqs[i].first->get_owner(), get_manager()) << " = " << mk_ismt2_pp(eqs[i].second->get_owner(), get_manager()) << "\n"; + for (auto const& p : eqs) { + tout << enode_eq_pp(p, ctx); }); ctx.set_conflict(ctx.mk_justification(ext_theory_conflict_justification(get_id(), reg, lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr()))); } diff --git a/src/smt/theory_dense_diff_logic_def.h b/src/smt/theory_dense_diff_logic_def.h index 3dfba6b1b..369209e49 100644 --- a/src/smt/theory_dense_diff_logic_def.h +++ b/src/smt/theory_dense_diff_logic_def.h @@ -756,7 +756,7 @@ namespace smt { (n_x, k_x) <= (n_y + n_c, k_y + k_c) - The only intersting case is n_x < n_y + n_c and k_x > k_y + k_c. + The only interesting case is n_x < n_y + n_c and k_x > k_y + k_c. Using the definition of infinitesimal numbers we have: diff --git a/src/smt/theory_jobscheduler.cpp b/src/smt/theory_jobscheduler.cpp new file mode 100644 index 000000000..1499c102d --- /dev/null +++ b/src/smt/theory_jobscheduler.cpp @@ -0,0 +1,1074 @@ +/*++ +Copyright (c) 2018 Microsoft Corporation + +Module Name: + + theory_jobscheduler.cpp + +Abstract: + + +Author: + + Nikolaj Bjorner (nbjorner) 2018-09-08. + +Revision History: + +TODO: + +- arithmetic interface + +- propagation queue: + - register bounds on start times to propagate energy constraints + - more general registration mechanism for arithmetic theory. +- interact with opt +- jobs without resources + - complain or add dummy resource? At which level. + +Features: +- properties +- priority + - try mss based from outside +- job-goal + - try optimization based on arithmetic solver. + - earliest start, latest start +- constraint level + - add constraints gradually +- resource groups + - resource groups like a resource + - resources bound to resource groups within time intervals + - job can require to use K resources from a resource group simultaneously. + +--*/ + +#include "ast/ast_pp.h" +#include "smt/theory_jobscheduler.h" +#include "smt/smt_context.h" +#include "smt/smt_arith_value.h" +#include "smt/smt_model_generator.h" + +namespace smt { + + theory_var theory_jobscheduler::mk_var(enode * n) { + theory_var v = theory::mk_var(n); + return v; + } + + bool theory_jobscheduler::internalize_term(app * term) { + context & ctx = get_context(); + if (ctx.e_internalized(term)) + return true; + for (expr* arg : *term) { + if (!ctx.e_internalized(arg)) + ctx.internalize(arg, false); + } + enode* e = ctx.mk_enode(term, false, false, true); + theory_var v = mk_var(e); + ctx.attach_th_var(e, this, v); + ctx.mark_as_relevant(e); + return true; + } + + bool theory_jobscheduler::internalize_atom(app * atom, bool gate_ctx) { + TRACE("csp", tout << mk_pp(atom, m) << "\n";); + context & ctx = get_context(); + SASSERT(u.is_model(atom)); + for (expr* arg : *atom) { + if (!ctx.e_internalized(arg)) ctx.internalize(arg, false); + internalize_cmd(arg); + } + add_done(); + bool_var bv = ctx.mk_bool_var(atom); + ctx.set_var_theory(bv, get_id()); + return true; + } + + struct symbol_cmp { + bool operator()(symbol const& s1, symbol const& s2) const { + return lt(s1, s2); + } + }; + + // TBD: stronger parameter validation + void theory_jobscheduler::internalize_cmd(expr* cmd) { + symbol key, val; + rational r; + expr* job, *resource; + unsigned j = 0, res = 0, cap = 0, loadpct = 100, level = 0; + time_t start = 0, end = std::numeric_limits::max(), capacity = 0; + js_job_goal goal; + js_optimization_objective obj; + properties ps; + if (u.is_set_preemptable(cmd, job) && u.is_job(job, j)) { + set_preemptable(j, true); + } + else if (u.is_add_resource_available(cmd, resource, loadpct, cap, start, end, ps) && u.is_resource(resource, res)) { + std::sort(ps.begin(), ps.end(), symbol_cmp()); + (void) cap; // TBD + add_resource_available(res, loadpct, start, end, ps); + } + else if (u.is_add_job_resource(cmd, job, resource, loadpct, capacity, end, ps) && u.is_job(job, j) && u.is_resource(resource, res)) { + std::sort(ps.begin(), ps.end(), symbol_cmp()); + add_job_resource(j, res, loadpct, capacity, end, ps); + } + else if (u.is_job_goal(cmd, goal, level, job) && u.is_job(job, j)) { + // skip + } + else if (u.is_objective(cmd, obj)) { + // skip + } + else { + invalid_argument("command not recognized ", cmd); + } + } + + void theory_jobscheduler::invalid_argument(char const* msg, expr* arg) { + std::ostringstream strm; + strm << msg << mk_pp(arg, m); + throw default_exception(strm.str()); + } + + void theory_jobscheduler::new_eq_eh(theory_var v1, theory_var v2) { + enode* e1 = get_enode(v1); + enode* root = e1->get_root(); + unsigned r; + if (u.is_resource(root->get_owner(), r)) { + enode* next = e1; + do { + unsigned j; + if (u.is_job2resource(next->get_owner(), j) && !m_jobs[j].m_is_bound) { + m_bound_jobs.push_back(j); + m_jobs[j].m_is_bound = true; + } + next = next->get_next(); + } + while (e1 != next); + } + } + + + void theory_jobscheduler::new_diseq_eh(theory_var v1, theory_var v2) { + + } + + void theory_jobscheduler::push_scope_eh() { + scope s; + s.m_bound_jobs_lim = m_bound_jobs.size(); + s.m_bound_qhead = m_bound_qhead; + m_scopes.push_back(s); + } + + void theory_jobscheduler::pop_scope_eh(unsigned num_scopes) { + unsigned new_lvl = m_scopes.size() - num_scopes; + scope const& s = m_scopes[new_lvl]; + for (unsigned i = s.m_bound_jobs_lim; i < m_bound_jobs.size(); ++i) { + unsigned j = m_bound_jobs[i]; + m_jobs[j].m_is_bound = false; + } + m_bound_jobs.shrink(s.m_bound_jobs_lim); + m_bound_qhead = s.m_bound_qhead; + m_scopes.shrink(new_lvl); + } + + final_check_status theory_jobscheduler::final_check_eh() { + TRACE("csp", tout << "\n";); + bool blocked = false; + for (unsigned j = 0; j < m_jobs.size(); ++j) { + if (split_job2resource(j)) { + return FC_CONTINUE; + } + } + for (unsigned r = 0; r < m_resources.size(); ++r) { + if (constrain_resource_energy(r)) { + blocked = true; + } + } + for (unsigned j = 0; j < m_jobs.size(); ++j) { + if (constrain_end_time_interval(j, resource(j))) { + blocked = true; + } + } + + if (blocked) return FC_CONTINUE; + return FC_DONE; + } + + bool theory_jobscheduler::can_propagate() { + return m_bound_qhead < m_bound_jobs.size(); + } + + literal theory_jobscheduler::mk_literal(expr * e) { + expr_ref _e(e, m); + context& ctx = get_context(); + if (!ctx.e_internalized(e)) { + ctx.internalize(e, false); + } + ctx.mark_as_relevant(ctx.get_enode(e)); + return ctx.get_literal(e); + } + + literal theory_jobscheduler::mk_ge(expr* e, time_t t) { + return mk_literal(mk_ge_expr(e, t)); + } + + expr* theory_jobscheduler::mk_ge_expr(expr* e, time_t t) { + return a.mk_ge(e, a.mk_int(rational(t, rational::ui64()))); + } + + literal theory_jobscheduler::mk_ge(enode* e, time_t t) { + return mk_ge(e->get_owner(), t); + } + + literal theory_jobscheduler::mk_le(expr* e, time_t t) { + return mk_literal(mk_le_expr(e, t)); + } + + expr* theory_jobscheduler::mk_le_expr(expr* e, time_t t) { + return a.mk_le(e, a.mk_int(rational(t, rational::ui64()))); + } + + literal theory_jobscheduler::mk_le(enode* l, enode* r) { + context& ctx = get_context(); + expr_ref le(a.mk_le(l->get_owner(), r->get_owner()), m); + ctx.get_rewriter()(le); + return mk_literal(le); + } + + literal theory_jobscheduler::mk_le(enode* e, time_t t) { + return mk_le(e->get_owner(), t); + } + + literal theory_jobscheduler::mk_eq_lit(expr * l, expr * r) { + literal lit = mk_eq(l, r, false); + get_context().mark_as_relevant(lit); + return lit; + } + + + /** + * iterator of job overlaps. + */ + theory_jobscheduler::job_overlap::job_overlap(vector& starts, vector& ends): + m_start(0), m_starts(starts), m_ends(ends), s_idx(0), e_idx(0) { + job_time::compare cmp; + std::sort(starts.begin(), starts.end(), cmp); + std::sort(ends.begin(), ends.end(), cmp); + } + + bool theory_jobscheduler::job_overlap::next() { + if (s_idx == m_starts.size()) { + return false; + } + do { + m_start = std::max(m_start, m_starts[s_idx].m_time); + + // add jobs that start before or at m_start + while (s_idx < m_starts.size() && m_starts[s_idx].m_time <= m_start) { + m_jobs.insert(m_starts[s_idx].m_job); + ++s_idx; + } + // remove jobs that end before m_start. + while (e_idx < m_ends.size() && m_ends[e_idx].m_time < m_start) { + m_jobs.remove(m_ends[e_idx].m_job); + ++e_idx; + } + } + // as long as set of jobs increments, add to m_start + while (s_idx < m_starts.size() && e_idx < m_ends.size() && + m_starts[s_idx].m_time <= m_ends[e_idx].m_time); + + return true; + } + + + /** + * r = resource(j) & start(j) >= slb => end(j) >= ect(j, r, slb) + * + * note: not used so far + * note: subsumed by constrain_end_time_interval used in final-check + */ + void theory_jobscheduler::propagate_end_time(unsigned j, unsigned r) { + time_t slb = est(j); + time_t clb = ect(j, r, slb); + context& ctx = get_context(); + + if (clb > end(j)) { + job_info const& ji = m_jobs[j]; + literal start_ge_lo = mk_ge(ji.m_start, slb); + if (ctx.get_assignment(start_ge_lo) != l_true) { + return; + } + enode_pair eq(ji.m_job2resource, m_resources[r].m_resource); + if (eq.first->get_root() != eq.second->get_root()) { + return; + } + + literal end_ge_lo = mk_ge(ji.m_end, clb); + // Initialization ensures that satisfiable states have completion time below end. + VERIFY(clb <= get_job_resource(j, r).m_end); + region& r = ctx.get_region(); + ctx.assign(end_ge_lo, + ctx.mk_justification( + ext_theory_propagation_justification(get_id(), r, 1, &start_ge_lo, 1, &eq, end_ge_lo, 0, nullptr))); + } + } + + /** + * For time interval [t0, t1] the end-time can be computed as a function + * of start time based on resource load availability. + * + * r = resource(j) & t1 >= start(j) >= t0 => end(j) = start(j) + ect(j, r, t0) - t0 + */ + bool theory_jobscheduler::constrain_end_time_interval(unsigned j, unsigned r) { + unsigned idx1 = 0, idx2 = 0; + time_t s = start(j); + job_resource const& jr = get_job_resource(j, r); + TRACE("csp", tout << "job: " << j << " resource: " << r << " start: " << s << "\n";); + vector& available = m_resources[r].m_available; + if (!resource_available(r, s, idx1)) return false; + if (!resource_available(jr, available[idx1])) return false; + time_t e = ect(j, r, s); + TRACE("csp", tout << "job: " << j << " resource: " << r << " ect: " << e << "\n";); + if (!resource_available(r, e, idx2)) return false; // infeasible.. + if (!resource_available(jr, available[idx2])) return false; + time_t start1 = available[idx1].m_start; + time_t end1 = available[idx1].m_end; + unsigned cap1 = available[idx1].m_loadpct; + time_t start2 = available[idx2].m_start; + time_t end2 = available[idx2].m_end; + unsigned cap2 = available[idx2].m_loadpct; + // calculate minimal start1 <= t0 <= s, such that ect(j, r, t0) >= start2 + // calculate maximal s <= t1 <= end1, such that ect(j, r, t1) <= end2 + time_t delta1 = (s - start1)*cap1; + time_t delta2 = (e - start2)*cap2; + time_t t0, t1; + if (delta1 <= delta2) { + t0 = start1; + } + else { + // solve for t0: + // (s - t0)*cap1 = (e - start2)*cap2; + t0 = s - (delta2 / cap1); + } + delta1 = (end1 - s)*cap1; + delta2 = (end2 - e)*cap2; + if (delta1 <= delta2) { + t1 = end1; + } + else { + // solve for t1: + // (t1 - s)*cap1 = (end2 - e)*cap2 + t1 = s + (delta2 / cap1); + } + + time_t delta = ect(j, r, t0) - t0; + if (end(j) == start(j) + delta) { + return false; + } + TRACE("csp", tout << "job: " << j << " resource " << r << " t0: " << t0 << " t1: " << t1 << " delta: " << delta << "\n";); + literal_vector lits; + enode* start_e = m_jobs[j].m_start; + enode* end_e = m_jobs[j].m_end; + lits.push_back(~mk_eq_lit(m_jobs[j].m_job2resource, m_resources[r].m_resource)); + lits.push_back(~mk_ge(start_e, t0)); + lits.push_back(~mk_le(start_e, t1)); + expr_ref rhs(a.mk_add(start_e->get_owner(), a.mk_int(rational(delta, rational::ui64()))), m); + lits.push_back(mk_eq_lit(end_e->get_owner(), rhs)); + context& ctx = get_context(); + ctx.mk_clause(lits.size(), lits.c_ptr(), nullptr, CLS_AUX_LEMMA, nullptr); + return true; + } + + + /** + * Ensure that job overlaps don't exceed available energy + */ + bool theory_jobscheduler::constrain_resource_energy(unsigned r) { + bool blocked = false; + vector starts, ends; + res_info const& ri = m_resources[r]; + for (unsigned j : ri.m_jobs) { + if (resource(j) == r) { + starts.push_back(job_time(j, start(j))); + ends.push_back(job_time(j, end(j))); + } + } + job_overlap overlap(starts, ends); + while (overlap.next()) { + unsigned cap = 0; + auto const& jobs = overlap.jobs(); + for (auto j : jobs) { + cap += get_job_resource(j, r).m_loadpct; + if (cap > 100) { + block_job_overlap(r, jobs, j); + blocked = true; + goto try_next_overlap; + } + } + try_next_overlap: + ; + } + return blocked; + } + + void theory_jobscheduler::block_job_overlap(unsigned r, uint_set const& jobs, unsigned last_job) { + // + // block the following case: + // each job is assigned to r. + // max { start(j) | j0..last_job } <= min { end(j) | j0..last_job } + // joint capacity of jobs exceeds availability of resource. + // + time_t max_start = 0; + unsigned max_j = last_job; + for (auto j : jobs) { + if (max_start < start(j)) { + max_start = start(j); + max_j = j; + } + if (j == last_job) break; + } + literal_vector lits; + for (auto j : jobs) { + // create literals for: + // resource(j) == r + // m_jobs[j].m_start <= m_jobs[max_j].m_start; + // m_jobs[max_j].m_start <= m_jobs[j].m_end; + lits.push_back(~mk_eq_lit(m_jobs[j].m_job2resource, m_resources[r].m_resource)); + if (j != max_j) { + lits.push_back(~mk_le(m_jobs[j].m_start, m_jobs[max_j].m_start)); + lits.push_back(~mk_le(m_jobs[max_j].m_start, m_jobs[j].m_end)); + } + if (j == last_job) break; + } + context& ctx = get_context(); + ctx.mk_clause(lits.size(), lits.c_ptr(), nullptr, CLS_AUX_LEMMA, nullptr); + } + + void theory_jobscheduler::propagate() { + while (m_bound_qhead < m_bound_jobs.size()) { + unsigned j = m_bound_jobs[m_bound_qhead++]; + unsigned r = 0; + job_info const& ji = m_jobs[j]; + VERIFY(u.is_resource(ji.m_job2resource->get_root()->get_owner(), r)); + TRACE("csp", tout << "job: " << j << " resource: " << r << "\n";); + propagate_job2resource(j, r); + } + } + + void theory_jobscheduler::propagate_job2resource(unsigned j, unsigned r) { + job_info const& ji = m_jobs[j]; + res_info const& ri = m_resources[r]; + job_resource const& jr = get_job_resource(j, r); + literal eq = mk_eq_lit(ji.m_job2resource, ri.m_resource); + assert_last_end_time(j, r, jr, eq); + assert_last_start_time(j, r, eq); + assert_first_start_time(j, r, eq); + vector const& available = ri.m_available; + // TBD: needs to take properties into account + + unsigned i = 0; + if (!first_available(jr, ri, i)) return; + while (true) { + unsigned next = i + 1; + if (!first_available(jr, ri, next)) return; + SASSERT(available[i].m_end < available[next].m_start); + assert_job_not_in_gap(j, r, i, next, eq); + if (!ji.m_is_preemptable && available[i].m_end + 1 < available[i+1].m_start) { + assert_job_non_preemptable(j, r, i, next, eq); + } + i = next; + } + } + + theory_jobscheduler::theory_jobscheduler(ast_manager& m): + theory(m.get_family_id("csp")), + m(m), + u(m), + a(m), + m_bound_qhead(0) { + } + + std::ostream& theory_jobscheduler::display(std::ostream & out, job_resource const& jr) const { + return out << "r:" << jr.m_resource_id << " cap:" << jr.m_capacity << " load:" << jr.m_loadpct << " end:" << jr.m_end; + for (auto const& s : jr.m_properties) out << " " << s; out << "\n"; + } + + std::ostream& theory_jobscheduler::display(std::ostream & out, job_info const& j) const { + for (job_resource const& jr : j.m_resources) { + display(out << " ", jr) << "\n"; + } + return out; + } + + std::ostream& theory_jobscheduler::display(std::ostream & out, res_available const& r) const { + return out << "[" << r.m_start << ":" << r.m_end << "] @ " << r.m_loadpct << "%"; + for (auto const& s : r.m_properties) out << " " << s; out << "\n"; + } + + std::ostream& theory_jobscheduler::display(std::ostream & out, res_info const& r) const { + for (res_available const& ra : r.m_available) { + display(out << " ", ra); + } + return out; + } + + void theory_jobscheduler::display(std::ostream & out) const { + out << "jobscheduler:\n"; + for (unsigned j = 0; j < m_jobs.size(); ++j) { + display(out << "job " << j << ":\n", m_jobs[j]) << "\n"; + } + for (unsigned r = 0; r < m_resources.size(); ++r) { + display(out << "resource " << r << ":\n", m_resources[r]) << "\n"; + } + } + + void theory_jobscheduler::collect_statistics(::statistics & st) const { + + } + + bool theory_jobscheduler::include_func_interp(func_decl* f) { + return + f->get_decl_kind() == OP_JS_START || + f->get_decl_kind() == OP_JS_END || + f->get_decl_kind() == OP_JS_JOB2RESOURCE; + } + + void theory_jobscheduler::init_model(model_generator & m) { + + } + + model_value_proc * theory_jobscheduler::mk_value(enode * n, model_generator & mg) { + return alloc(expr_wrapper_proc, n->get_root()->get_owner()); + } + + bool theory_jobscheduler::get_value(enode * n, expr_ref & r) { + std::cout << mk_pp(n->get_owner(), m) << "\n"; + return false; + } + + theory * theory_jobscheduler::mk_fresh(context * new_ctx) { + return alloc(theory_jobscheduler, new_ctx->get_manager()); + } + + time_t theory_jobscheduler::get_lo(expr* e) { + arith_value av(m); + av.init(&get_context()); + rational val; + bool is_strict; + if (av.get_lo(e, val, is_strict) && !is_strict && val.is_uint64()) { + return val.get_uint64(); + } + return 0; + } + + time_t theory_jobscheduler::get_up(expr* e) { + arith_value av(m); + av.init(&get_context()); + rational val; + bool is_strict; + if (av.get_up(e, val, is_strict) && !is_strict && val.is_uint64()) { + return val.get_uint64(); + } + return std::numeric_limits::max(); + } + + time_t theory_jobscheduler::get_value(expr* e) { + arith_value av(get_manager()); + av.init(&get_context()); + rational val; + if (av.get_value_equiv(e, val) && val.is_uint64()) { + return val.get_uint64(); + } + return 0; + } + + time_t theory_jobscheduler::est(unsigned j) { + return get_lo(m_jobs[j].m_start->get_owner()); + } + + time_t theory_jobscheduler::lst(unsigned j) { + return get_up(m_jobs[j].m_start->get_owner()); + } + + time_t theory_jobscheduler::ect(unsigned j) { + return get_lo(m_jobs[j].m_end->get_owner()); + } + + time_t theory_jobscheduler::lct(unsigned j) { + return get_up(m_jobs[j].m_end->get_owner()); + } + + time_t theory_jobscheduler::start(unsigned j) { + return get_value(m_jobs[j].m_start->get_owner()); + } + + time_t theory_jobscheduler::end(unsigned j) { + return get_value(m_jobs[j].m_end->get_owner()); + } + + unsigned theory_jobscheduler::resource(unsigned j) { + unsigned r; + enode* next = m_jobs[j].m_job2resource, *n = next; + do { + if (u.is_resource(next->get_owner(), r)) { + return r; + } + next = next->get_next(); + } + while (next != n); + return 0; + } + + void theory_jobscheduler::set_preemptable(unsigned j, bool is_preemptable) { + m_jobs.reserve(j + 1); + m_jobs[j].m_is_preemptable = is_preemptable; + } + + void theory_jobscheduler::add_job_resource(unsigned j, unsigned r, unsigned loadpct, uint64_t cap, time_t end, properties const& ps) { + SASSERT(get_context().at_base_level()); + SASSERT(0 <= loadpct && loadpct <= 100); + SASSERT(0 <= cap); + m_jobs.reserve(j + 1); + m_resources.reserve(r + 1); + job_info& ji = m_jobs[j]; + if (ji.m_resource2index.contains(r)) { + throw default_exception("resource already bound to job"); + } + if (!ji.m_start) { + context& ctx = get_context(); + app_ref job(u.mk_job(j), m); + app_ref start(u.mk_start(j), m); + app_ref end(u.mk_end(j), m); + app_ref res(u.mk_job2resource(j), m); + if (!ctx.e_internalized(job)) ctx.internalize(job, false); + if (!ctx.e_internalized(start)) ctx.internalize(start, false); + if (!ctx.e_internalized(end)) ctx.internalize(end, false); + if (!ctx.e_internalized(res)) ctx.internalize(res, false); + ji.m_job = ctx.get_enode(job); + ji.m_start = ctx.get_enode(start); + ji.m_end = ctx.get_enode(end); + ji.m_job2resource = ctx.get_enode(res); + } + ji.m_resource2index.insert(r, ji.m_resources.size()); + ji.m_resources.push_back(job_resource(r, cap, loadpct, end, ps)); + SASSERT(!m_resources[r].m_jobs.contains(j)); + m_resources[r].m_jobs.push_back(j); + } + + + void theory_jobscheduler::add_resource_available(unsigned r, unsigned max_loadpct, time_t start, time_t end, properties const& ps) { + SASSERT(get_context().at_base_level()); + SASSERT(1 <= max_loadpct && max_loadpct <= 100); + SASSERT(start <= end); + m_resources.reserve(r + 1); + res_info& ri = m_resources[r]; + if (!ri.m_resource) { + context& ctx = get_context(); + app_ref res(u.mk_resource(r), m); + if (!ctx.e_internalized(res)) ctx.internalize(res, false); + ri.m_resource = ctx.get_enode(res); + app_ref ms(u.mk_makespan(r), m); + if (!ctx.e_internalized(ms)) ctx.internalize(ms, false); + ri.m_makespan = ctx.get_enode(ms); + } + ri.m_available.push_back(res_available(max_loadpct, start, end, ps)); + } + + /* + * Initialize the state based on the set of jobs and resources added. + * Ensure that the availability slots for each resource is sorted by time. + * + * For each resource j: + * est(j) <= start(j) <= end(j) <= lct(j) + * + * possible strengthenings: + * - start(j) <= lst(j) + * - start(j) + min_completion_time(j) <= end(j) + * - start(j) + max_completion_time(j) >= end(j) + * + * makespan constraints? + * + */ + void theory_jobscheduler::add_done() { + TRACE("csp", tout << "add-done begin\n";); + context & ctx = get_context(); + + // sort availability intervals + for (res_info& ri : m_resources) { + vector& available = ri.m_available; + res_available::compare cmp; + std::sort(available.begin(), available.end(), cmp); + } + + literal lit; + unsigned job_id = 0; + + for (job_info const& ji : m_jobs) { + if (ji.m_resources.empty()) { + throw default_exception("every job should be associated with at least one resource"); + } + + // start(j) <= end(j) + lit = mk_le(ji.m_start, ji.m_end); + ctx.mk_th_axiom(get_id(), 1, &lit); + + time_t start_lb = std::numeric_limits::max(); + time_t runtime_lb = std::numeric_limits::max(); + time_t end_ub = 0; // , runtime_ub = 0; + for (job_resource const& jr : ji.m_resources) { + unsigned r = jr.m_resource_id; + res_info const& ri = m_resources[r]; + if (ri.m_available.empty()) continue; + unsigned idx = 0; + if (first_available(jr, ri, idx)) { + start_lb = std::min(start_lb, ri.m_available[idx].m_start); + } + idx = ri.m_available.size(); + if (last_available(jr, ri, idx)) { + end_ub = std::max(end_ub, ri.m_available[idx].m_end); + } + runtime_lb = std::min(runtime_lb, jr.m_capacity); + // TBD: more accurate estimates for runtime_lb based on gaps + // TBD: correct estimate of runtime_ub taking gaps into account. + } + CTRACE("csp", (start_lb > end_ub), tout << "there is no associated resource working time\n";); + if (start_lb > end_ub) { + warning_msg("Job %d has no associated resource working time", job_id); + } + + // start(j) >= start_lb + lit = mk_ge(ji.m_start, start_lb); + ctx.mk_th_axiom(get_id(), 1, &lit); + + // end(j) <= end_ub + lit = mk_le(ji.m_end, end_ub); + ctx.mk_th_axiom(get_id(), 1, &lit); + + // start(j) + runtime_lb <= end(j) + // end(j) <= start(j) + runtime_ub + + ++job_id; + } + + TRACE("csp", tout << "add-done end\n";); + } + + // resource(j) = r => end(j) <= end(j, r) + void theory_jobscheduler::assert_last_end_time(unsigned j, unsigned r, job_resource const& jr, literal eq) { + job_info const& ji = m_jobs[j]; + literal l2 = mk_le(ji.m_end, jr.m_end); + get_context().mk_th_axiom(get_id(), ~eq, l2); + } + + // resource(j) = r => start(j) <= lst(j, r, end(j, r)) + void theory_jobscheduler::assert_last_start_time(unsigned j, unsigned r, literal eq) { + context& ctx = get_context(); + time_t t; + if (lst(j, r, t)) { + ctx.mk_th_axiom(get_id(), ~eq, mk_le(m_jobs[j].m_start, t)); + } + else { + eq.neg(); + ctx.mk_th_axiom(get_id(), 1, &eq); + } + } + + // resource(j) = r => start(j) >= available[0].m_start + void theory_jobscheduler::assert_first_start_time(unsigned j, unsigned r, literal eq) { + job_resource const& jr = get_job_resource(j, r); + unsigned idx = 0; + if (!first_available(jr, m_resources[r], idx)) return; + vector& available = m_resources[r].m_available; + literal l2 = mk_ge(m_jobs[j].m_start, available[idx].m_start); + get_context().mk_th_axiom(get_id(), ~eq, l2); + } + + // resource(j) = r => start(j) <= end[idx] || start[idx+1] <= start(j); + void theory_jobscheduler::assert_job_not_in_gap(unsigned j, unsigned r, unsigned idx, unsigned idx1, literal eq) { + job_resource const& jr = get_job_resource(j, r); + (void) jr; + vector& available = m_resources[r].m_available; + SASSERT(resource_available(jr, available[idx])); + literal l2 = mk_ge(m_jobs[j].m_start, available[idx1].m_start); + literal l3 = mk_le(m_jobs[j].m_start, available[idx].m_end); + get_context().mk_th_axiom(get_id(), ~eq, l2, l3); + } + + // resource(j) = r => end(j) <= end[idx] || start[idx+1] <= start(j); + void theory_jobscheduler::assert_job_non_preemptable(unsigned j, unsigned r, unsigned idx, unsigned idx1, literal eq) { + vector& available = m_resources[r].m_available; + job_resource const& jr = get_job_resource(j, r); + (void) jr; + SASSERT(resource_available(jr, available[idx])); + literal l2 = mk_le(m_jobs[j].m_end, available[idx].m_end); + literal l3 = mk_ge(m_jobs[j].m_start, available[idx1].m_start); + get_context().mk_th_axiom(get_id(), ~eq, l2, l3); + } + + /** + * bind a job to one of the resources it can run on. + */ + bool theory_jobscheduler::split_job2resource(unsigned j) { + job_info const& ji = m_jobs[j]; + context& ctx = get_context(); + if (ji.m_is_bound) return false; + auto const& jrs = ji.m_resources; + for (job_resource const& jr : jrs) { + unsigned r = jr.m_resource_id; + res_info const& ri = m_resources[r]; + enode* e1 = ji.m_job2resource; + enode* e2 = ri.m_resource; + if (ctx.is_diseq(e1, e2)) + continue; + literal eq = mk_eq_lit(e1, e2); + if (ctx.get_assignment(eq) != l_false) { + ctx.mark_as_relevant(eq); + if (assume_eq(e1, e2)) { + return true; + } + } + } + literal_vector lits; + for (job_resource const& jr : jrs) { + unsigned r = jr.m_resource_id; + res_info const& ri = m_resources[r]; + enode* e1 = ji.m_job2resource; + enode* e2 = ri.m_resource; + lits.push_back(mk_eq_lit(e1, e2)); + } + ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr()); + return true; + } + + /** + * check that each job is run on some resource according to + * requested capacity. + * + * Check that the sum of jobs run in each time instance + * does not exceed capacity. + */ + void theory_jobscheduler::validate_assignment() { + vector> start_times, end_times; + start_times.reserve(m_resources.size()); + end_times.reserve(m_resources.size()); + for (unsigned j = 0; j < m_jobs.size(); ++j) { + unsigned r = resource(j); + start_times[r].push_back(job_time(j, start(j))); + end_times[r].push_back(job_time(j, end(j))); + if (ect(j, r, start(j)) > end(j)) { + throw default_exception("job not assigned full capacity"); + } + unsigned idx; + if (!resource_available(r, start(j), idx)) { + throw default_exception("resource is not available at job start time"); + } + } + for (unsigned r = 0; r < m_resources.size(); ++r) { + // order jobs running on r by start, end-time intervals + // then consume ordered list to find jobs in scope. + job_overlap overlap(start_times[r], end_times[r]); + while (overlap.next()) { + // check that sum of job loads does not exceed 100% + unsigned cap = 0; + for (auto j : overlap.jobs()) { + cap += get_job_resource(j, r).m_loadpct; + } + if (cap > 100) { + throw default_exception("capacity on resource exceeded"); + } + } + } + } + + theory_jobscheduler::job_resource const& theory_jobscheduler::get_job_resource(unsigned j, unsigned r) const { + job_info const& ji = m_jobs[j]; + return ji.m_resources[ji.m_resource2index[r]]; + } + + /** + * find idx, if any, such that t is within the time interval of available[idx] + */ + bool theory_jobscheduler::resource_available(unsigned r, time_t t, unsigned& idx) { + vector& available = m_resources[r].m_available; + unsigned lo = 0, hi = available.size(), mid = hi / 2; + while (lo < hi) { + SASSERT(lo <= mid && mid < hi); + res_available const& ra = available[mid]; + if (ra.m_start <= t && t <= ra.m_end) { + idx = mid; + return true; + } + else if (ra.m_start > t && mid > 0) { + hi = mid; + mid = lo + (mid - lo) / 2; + } + else if (ra.m_end < t) { + lo = mid + 1; + mid += (hi - mid) / 2; + } + else { + break; + } + } + return false; + } + + /** + * compute earliest completion time for job j on resource r starting at time start. + */ + time_t theory_jobscheduler::ect(unsigned j, unsigned r, time_t start) { + job_resource const& jr = get_job_resource(j, r); + vector& available = m_resources[r].m_available; + + unsigned j_load_pct = jr.m_loadpct; + time_t cap = jr.m_capacity; + unsigned idx = 0; + if (!resource_available(r, start, idx)) { + TRACE("csp", tout << "resource is not available for " << j << " " << r << "\n";); + return std::numeric_limits::max(); + } + SASSERT(cap > 0); + + for (; idx < available.size(); ++idx) { + if (!resource_available(jr, available[idx])) continue; + start = std::max(start, available[idx].m_start); + time_t end = available[idx].m_end; + unsigned load_pct = available[idx].m_loadpct; + time_t delta = solve_for_capacity(load_pct, j_load_pct, start, end); + TRACE("csp", tout << "delta: " << delta << " capacity: " << cap << " load " + << load_pct << " jload: " << j_load_pct << " start: " << start << " end " << end << "\n";); + if (delta > cap) { + end = solve_for_end(load_pct, j_load_pct, start, cap); + cap = 0; + } + else { + cap -= delta; + } + if (cap == 0) { + return end; + } + } + return std::numeric_limits::max(); + } + + /** + * find end, such that cap = (load / job_load_pct) * (end - start + 1) + */ + time_t theory_jobscheduler::solve_for_end(unsigned load_pct, unsigned job_load_pct, time_t start, time_t cap) { + SASSERT(load_pct > 0); + SASSERT(job_load_pct > 0); + // cap = (load / job_load_pct) * (end - start + 1) + // <=> + // end - start + 1 = (cap * job_load_pct) / load + // <=> + // end = start - 1 + (cap * job_load_pct) / load + // <=> + // end = (load * (start - 1) + cap * job_load_pct) / load + unsigned load = std::min(load_pct, job_load_pct); + return (load * (start - 1) + cap * job_load_pct) / load; + } + + /** + * find start, such that cap = (load / job_load_pct) * (end - start + 1) + */ + time_t theory_jobscheduler::solve_for_start(unsigned load_pct, unsigned job_load_pct, time_t end, time_t cap) { + SASSERT(load_pct > 0); + SASSERT(job_load_pct > 0); + // cap = (load / job_load_pct) * (end - start + 1) + // <=> + // end - start + 1 = (cap * job_load_pct) / load + // <=> + // start = end + 1 - (cap * job_load_pct) / load + // <=> + // start = (load * (end + 1) - cap * job_load_pct) / load + unsigned load = std::min(load_pct, job_load_pct); + return (load * (end + 1) - cap * job_load_pct) / load; + } + + /** + * find cap, such that cap = (load / job_load_pct) * (end - start + 1) + */ + time_t theory_jobscheduler::solve_for_capacity(unsigned load_pct, unsigned job_load_pct, time_t start, time_t end) { + SASSERT(job_load_pct > 0); + unsigned load = std::min(load_pct, job_load_pct); + return (load * (end - start + 1)) / job_load_pct; + } + + /** + * Compute last start time for job on resource r. + */ + bool theory_jobscheduler::lst(unsigned j, unsigned r, time_t& start) { + start = 0; + job_resource const& jr = get_job_resource(j, r); + vector& available = m_resources[r].m_available; + unsigned j_load_pct = jr.m_loadpct; + time_t cap = jr.m_capacity; + for (unsigned idx = available.size(); idx-- > 0; ) { + if (!resource_available(jr, available[idx])) continue; + start = available[idx].m_start; + time_t end = available[idx].m_end; + unsigned load_pct = available[idx].m_loadpct; + time_t delta = solve_for_capacity(load_pct, j_load_pct, start, end); + if (delta > cap) { + start = solve_for_start(load_pct, j_load_pct, end, cap); + cap = 0; + } + else { + cap -= delta; + } + if (cap == 0) { + return true; + } + } + return false; + } + + /** + * \brief check that job properties is a subset of resource properties. + * It assumes that both vectors are sorted. + */ + + bool theory_jobscheduler::resource_available(job_resource const& jr, res_available const& ra) const { + auto const& jps = jr.m_properties; + auto const& rps = ra.m_properties; + if (jps.size() > rps.size()) return false; + unsigned j = 0, i = 0; + for (; i < jps.size() && j < rps.size(); ) { + if (jps[i] == rps[j]) { + ++i; ++j; + } + else if (lt(rps[j], jps[i])) { + ++j; + } + else { + break; + } + } + return i == jps.size(); + } + + /** + * \brief minimal current resource available for job resource, includes idx. + */ + bool theory_jobscheduler::first_available(job_resource const& jr, res_info const& ri, unsigned& idx) const { + for (; idx < ri.m_available.size(); ++idx) { + if (resource_available(jr, ri.m_available[idx])) + return true; + } + return false; + } + + /** + * \brief maximal previous resource available for job resource, excludes idx. + */ + bool theory_jobscheduler::last_available(job_resource const& jr, res_info const& ri, unsigned& idx) const { + while (idx-- > 0) { + if (resource_available(jr, ri.m_available[idx])) + return true; + } + return false; + } + + +}; + diff --git a/src/smt/theory_jobscheduler.h b/src/smt/theory_jobscheduler.h new file mode 100644 index 000000000..3b9a42595 --- /dev/null +++ b/src/smt/theory_jobscheduler.h @@ -0,0 +1,244 @@ +/*++ +Copyright (c) 2018 Microsoft Corporation + +Module Name: + + theory_jobscheduling.h + +Abstract: + + Propagation solver for jobscheduling problems. + It relies on an external module to tighten bounds of + job variables. + +Author: + + Nikolaj Bjorner (nbjorner) 2018-09-08. + +Revision History: + +--*/ +#pragma once + +#include "util/uint_set.h" +#include "ast/csp_decl_plugin.h" +#include "ast/arith_decl_plugin.h" +#include "smt/smt_theory.h" + +namespace smt { + + typedef uint64_t time_t; + + class theory_jobscheduler : public theory { + public: + typedef svector properties; + protected: + + struct job_resource { + unsigned m_resource_id; // id of resource + time_t m_capacity; // amount of resource to use + unsigned m_loadpct; // assuming loadpct + time_t m_end; // must run before + properties m_properties; + job_resource(unsigned r, time_t cap, unsigned loadpct, time_t end, properties const& ps): + m_resource_id(r), m_capacity(cap), m_loadpct(loadpct), m_end(end), m_properties(ps) {} + }; + + struct job_time { + unsigned m_job; + time_t m_time; + job_time(unsigned j, time_t time): m_job(j), m_time(time) {} + + struct compare { + bool operator()(job_time const& jt1, job_time const& jt2) const { + return jt1.m_time < jt2.m_time; + } + }; + }; + + struct job_info { + bool m_is_preemptable; // can job be pre-empted + vector m_resources; // resources allowed to run job. + u_map m_resource2index; // resource to index into vector + enode* m_job; + enode* m_start; + enode* m_end; + enode* m_job2resource; + bool m_is_bound; + job_info(): m_is_preemptable(false), m_job(nullptr), m_start(nullptr), m_end(nullptr), m_job2resource(nullptr), m_is_bound(false) {} + }; + + struct res_available { + unsigned m_loadpct; + time_t m_start; + time_t m_end; + properties m_properties; + res_available(unsigned load_pct, time_t start, time_t end, properties const& ps): + m_loadpct(load_pct), + m_start(start), + m_end(end), + m_properties(ps) + {} + struct compare { + bool operator()(res_available const& ra1, res_available const& ra2) const { + return ra1.m_start < ra2.m_start; + } + }; + }; + + struct res_info { + unsigned_vector m_jobs; // jobs allocated to run on resource + vector m_available; // time intervals where resource is available + time_t m_end; // can't run after + enode* m_resource; + enode* m_makespan; + res_info(): m_end(std::numeric_limits::max()), m_resource(nullptr), m_makespan(nullptr) {} + }; + + ast_manager& m; + csp_util u; + arith_util a; + vector m_jobs; + vector m_resources; + unsigned_vector m_bound_jobs; + unsigned m_bound_qhead; + struct scope { + unsigned m_bound_jobs_lim; + unsigned m_bound_qhead; + }; + svector m_scopes; + + protected: + + theory_var mk_var(enode * n) override; + + bool internalize_atom(app * atom, bool gate_ctx) override; + + bool internalize_term(app * term) override; + + void assign_eh(bool_var v, bool is_true) override {} + + void new_eq_eh(theory_var v1, theory_var v2) override; + + void new_diseq_eh(theory_var v1, theory_var v2) override; + + void push_scope_eh() override; + + void pop_scope_eh(unsigned num_scopes) override; + + final_check_status final_check_eh() override; + + bool can_propagate() override; + + void propagate() override; + + public: + + theory_jobscheduler(ast_manager& m); + + ~theory_jobscheduler() override {} + + void display(std::ostream & out) const override; + + void collect_statistics(::statistics & st) const override; + + bool include_func_interp(func_decl* f) override; + + void init_model(model_generator & m) override; + + model_value_proc * mk_value(enode * n, model_generator & mg) override; + + bool get_value(enode * n, expr_ref & r) override; + + theory * mk_fresh(context * new_ctx) override; + + public: + // set up job/resource global constraints + void set_preemptable(unsigned j, bool is_preemptable); + void add_job_resource(unsigned j, unsigned r, unsigned loadpct, time_t cap, time_t end, properties const& ps); + void add_resource_available(unsigned r, unsigned max_loadpct, time_t start, time_t end, properties const& ps); + void add_done(); + + // assignments + time_t est(unsigned j); // earliest start time of job j + time_t lst(unsigned j); // last start time + time_t ect(unsigned j); // earliest completion time + time_t lct(unsigned j); // last completion time + time_t start(unsigned j); // start time of job j + time_t end(unsigned j); // end time of job j + time_t get_lo(expr* e); + time_t get_up(expr* e); + time_t get_value(expr* e); + unsigned resource(unsigned j); // resource of job j + + // derived bounds + time_t ect(unsigned j, unsigned r, time_t start); + bool lst(unsigned j, unsigned r, time_t& t); + + bool resource_available(job_resource const& jr, res_available const& ra) const; + bool first_available(job_resource const& jr, res_info const& ri, unsigned& idx) const; + bool last_available(job_resource const& jr, res_info const& ri, unsigned& idx) const; + + time_t solve_for_start(unsigned load_pct, unsigned job_load_pct, time_t end, time_t cap); + time_t solve_for_end(unsigned load_pct, unsigned job_load_pct, time_t start, time_t cap); + time_t solve_for_capacity(unsigned load_pct, unsigned job_load_pct, time_t start, time_t end); + + // validate assignment + void validate_assignment(); + bool resource_available(unsigned r, time_t t, unsigned& idx); // load available on resource r at time t. + time_t capacity_used(unsigned j, unsigned r, time_t start, time_t end); // capacity used between start and end + + job_resource const& get_job_resource(unsigned j, unsigned r) const; + + // propagation + void propagate_end_time(unsigned j, unsigned r); + void propagate_job2resource(unsigned j, unsigned r); + + // final check constraints + bool constrain_end_time_interval(unsigned j, unsigned r); + bool constrain_resource_energy(unsigned r); + bool split_job2resource(unsigned j); + + void assert_last_end_time(unsigned j, unsigned r, job_resource const& jr, literal eq); + void assert_last_start_time(unsigned j, unsigned r, literal eq); + void assert_first_start_time(unsigned j, unsigned r, literal eq); + void assert_job_not_in_gap(unsigned j, unsigned r, unsigned idx, unsigned idx1, literal eq); + void assert_job_non_preemptable(unsigned j, unsigned r, unsigned idx, unsigned idx1, literal eq); + + void block_job_overlap(unsigned r, uint_set const& jobs, unsigned last_job); + + class job_overlap { + time_t m_start; + vector & m_starts, &m_ends; + unsigned s_idx, e_idx; // index into starts/ends + uint_set m_jobs; + public: + job_overlap(vector& starts, vector& ends); + bool next(); + uint_set const& jobs() const { return m_jobs; } + }; + + // term builders + literal mk_ge(expr* e, time_t t); + expr* mk_ge_expr(expr* e, time_t t); + literal mk_ge(enode* e, time_t t); + literal mk_le(expr* e, time_t t); + expr* mk_le_expr(expr* e, time_t t); + literal mk_le(enode* e, time_t t); + literal mk_le(enode* l, enode* r); + literal mk_literal(expr* e); + literal mk_eq_lit(enode * l, enode * r) { return mk_eq_lit(l->get_owner(), r->get_owner()); } + literal mk_eq_lit(expr * l, expr * r); + + void internalize_cmd(expr* cmd); + void unrecognized_argument(expr* arg) { invalid_argument("unrecognized argument ", arg); } + void invalid_argument(char const* msg, expr* arg); + + std::ostream& display(std::ostream & out, res_info const& r) const; + std::ostream& display(std::ostream & out, res_available const& r) const; + std::ostream& display(std::ostream & out, job_info const& r) const; + std::ostream& display(std::ostream & out, job_resource const& r) const; + + }; +}; + diff --git a/src/smt/theory_lra.cpp b/src/smt/theory_lra.cpp index 267412da6..c9db3f6b0 100644 --- a/src/smt/theory_lra.cpp +++ b/src/smt/theory_lra.cpp @@ -55,7 +55,7 @@ std::ostream& operator<<(std::ostream& out, bound_kind const& k) { } class bound { - smt::bool_var m_bv; + smt::bool_var m_bv; smt::theory_var m_var; bool m_is_int; rational m_value; @@ -129,6 +129,7 @@ class theory_lra::imp { struct scope { unsigned m_bounds_lim; + unsigned m_idiv_lim; unsigned m_asserted_qhead; unsigned m_asserted_atoms_lim; unsigned m_underspecified_lim; @@ -146,7 +147,7 @@ class theory_lra::imp { imp& m_imp; public: resource_limit(imp& i): m_imp(i) { } - virtual bool get_cancel_flag() { return m_imp.m.canceled(); } + bool get_cancel_flag() override { return m_imp.m.canceled(); } }; @@ -154,6 +155,7 @@ class theory_lra::imp { ast_manager& m; theory_arith_params& m_arith_params; arith_util a; + bool m_has_int; arith_eq_adapter m_arith_eq_adapter; vector m_columns; @@ -163,13 +165,13 @@ class theory_lra::imp { expr_ref_vector m_terms; vector m_coeffs; svector m_vars; - rational m_coeff; + rational m_offset; ptr_vector m_terms_to_internalize; internalize_state(ast_manager& m): m_terms(m) {} void reset() { m_terms.reset(); m_coeffs.reset(); - m_coeff.reset(); + m_offset.reset(); m_vars.reset(); m_terms_to_internalize.reset(); } @@ -195,7 +197,7 @@ class theory_lra::imp { expr_ref_vector& terms() { return m_st.m_terms; } vector& coeffs() { return m_st.m_coeffs; } svector& vars() { return m_st.m_vars; } - rational& coeff() { return m_st.m_coeff; } + rational& offset() { return m_st.m_offset; } ptr_vector& terms_to_internalize() { return m_st.m_terms_to_internalize; } void push(expr* e, rational c) { m_st.m_terms.push_back(e); m_st.m_coeffs.push_back(c); } void set_back(unsigned i) { @@ -214,6 +216,10 @@ class theory_lra::imp { svector m_term_index2theory_var; // reverse map from lp_solver variables to theory variables var_coeffs m_left_side; // constraint left side mutable std::unordered_map m_variable_values; // current model + lp::var_index m_one_var; + lp::var_index m_zero_var; + lp::var_index m_rone_var; + lp::var_index m_rzero_var; enum constraint_source { inequality_source, @@ -229,6 +235,7 @@ class theory_lra::imp { svector m_asserted_atoms; expr* m_not_handled; ptr_vector m_underspecified; + ptr_vector m_idiv_terms; unsigned_vector m_var_trail; vector > m_use_list; // bounds where variables are used. @@ -316,6 +323,10 @@ class theory_lra::imp { m_solver->settings().m_int_run_gcd_test = ctx().get_fparams().m_arith_gcd_test; m_solver->settings().set_random_seed(ctx().get_fparams().m_random_seed); m_lia = alloc(lp::int_solver, m_solver.get()); + get_one(true); + get_zero(true); + get_one(false); + get_zero(false); } void ensure_nra() { @@ -328,6 +339,31 @@ class theory_lra::imp { } } + lp::var_index add_const(int c, lp::var_index& var, bool is_int) { + if (var != UINT_MAX) { + return var; + } + app_ref cnst(a.mk_numeral(rational(c), is_int), m); + TRACE("arith", tout << "add " << cnst << "\n";); + mk_enode(cnst); + theory_var v = mk_var(cnst); + var = m_solver->add_var(v, true); + m_theory_var2var_index.setx(v, var, UINT_MAX); + m_var_index2theory_var.setx(var, v, UINT_MAX); + m_var_trail.push_back(v); + add_def_constraint(m_solver->add_var_bound(var, lp::GE, rational(c))); + add_def_constraint(m_solver->add_var_bound(var, lp::LE, rational(c))); + return var; + } + + lp::var_index get_one(bool is_int) { + return add_const(1, is_int ? m_one_var : m_rone_var, is_int); + } + + lp::var_index get_zero(bool is_int) { + return add_const(0, is_int ? m_zero_var : m_rzero_var, is_int); + } + void found_not_handled(expr* n) { m_not_handled = n; @@ -372,7 +408,7 @@ class theory_lra::imp { expr_ref_vector & terms = st.terms(); svector& vars = st.vars(); vector& coeffs = st.coeffs(); - rational& coeff = st.coeff(); + rational& offset = st.offset(); rational r; expr* n1, *n2; unsigned index = 0; @@ -412,7 +448,7 @@ class theory_lra::imp { ++index; } else if (a.is_numeral(n, r)) { - coeff += coeffs[index]*r; + offset += coeffs[index]*r; ++index; } else if (a.is_uminus(n, n1)) { @@ -424,7 +460,6 @@ class theory_lra::imp { app* t = to_app(n); internalize_args(t); mk_enode(t); - theory_var v = mk_var(n); coeffs[vars.size()] = coeffs[index]; vars.push_back(v); @@ -442,6 +477,7 @@ class theory_lra::imp { } else if (a.is_idiv(n, n1, n2)) { if (!a.is_numeral(n2, r) || r.is_zero()) found_not_handled(n); + m_idiv_terms.push_back(n); app * mod = a.mk_mod(n1, n2); ctx().internalize(mod, false); if (ctx().relevancy()) ctx().add_relevancy_dependency(n, mod); @@ -451,6 +487,7 @@ class theory_lra::imp { if (!is_num) { found_not_handled(n); } +#if 0 else { app_ref div(a.mk_idiv(n1, n2), m); mk_enode(div); @@ -461,7 +498,8 @@ class theory_lra::imp { // abs(r) > v >= 0 assert_idiv_mod_axioms(u, v, w, r); } - if (!ctx().relevancy() && !is_num) mk_idiv_mod_axioms(n1, n2); +#endif + if (!ctx().relevancy()) mk_idiv_mod_axioms(n1, n2); } else if (a.is_rem(n, n1, n2)) { if (!a.is_numeral(n2, r) || r.is_zero()) found_not_handled(n); @@ -544,6 +582,7 @@ class theory_lra::imp { } enode * mk_enode(app * n) { + TRACE("arith", tout << expr_ref(n, m) << "\n";); if (ctx().e_internalized(n)) { return get_enode(n); } @@ -624,6 +663,7 @@ class theory_lra::imp { } if (result == UINT_MAX) { result = m_solver->add_var(v, is_int(v)); + m_has_int |= is_int(v); m_theory_var2var_index.setx(v, result, UINT_MAX); m_var_index2theory_var.setx(result, v, UINT_MAX); m_var_trail.push_back(v); @@ -677,7 +717,7 @@ class theory_lra::imp { m_constraint_sources.setx(index, inequality_source, null_source); m_inequalities.setx(index, lit, null_literal); ++m_stats.m_add_rows; - TRACE("arith", m_solver->print_constraint(index, tout); tout << "\n";); + TRACE("arith", m_solver->print_constraint(index, tout) << "\n";); } void add_def_constraint(lp::constraint_index index) { @@ -692,9 +732,7 @@ class theory_lra::imp { ++m_stats.m_add_rows; } - void internalize_eq(theory_var v1, theory_var v2) { - enode* n1 = get_enode(v1); - enode* n2 = get_enode(v2); + void internalize_eq(theory_var v1, theory_var v2) { app_ref term(m.mk_fresh_const("eq", a.mk_real()), m); scoped_internalize_state st(*this); st.vars().push_back(v1); @@ -707,8 +745,8 @@ class theory_lra::imp { add_def_constraint(m_solver->add_var_bound(vi, lp::GE, rational::zero())); TRACE("arith", { - expr* o1 = n1->get_owner(); - expr* o2 = n2->get_owner(); + expr* o1 = get_enode(v1)->get_owner(); + expr* o2 = get_enode(v2)->get_owner(); tout << "v" << v1 << " = " << "v" << v2 << ": " << mk_pp(o1, m) << " = " << mk_pp(o2, m) << "\n"; }); @@ -733,10 +771,19 @@ class theory_lra::imp { } bool is_unit_var(scoped_internalize_state& st) { - return st.coeff().is_zero() && st.vars().size() == 1 && st.coeffs()[0].is_one(); + return st.offset().is_zero() && st.vars().size() == 1 && st.coeffs()[0].is_one(); + } + + bool is_one(scoped_internalize_state& st) { + return st.offset().is_one() && st.vars().empty(); + } + + bool is_zero(scoped_internalize_state& st) { + return st.offset().is_zero() && st.vars().empty(); } theory_var internalize_def(app* term, scoped_internalize_state& st) { + TRACE("arith", tout << expr_ref(term, m) << "\n";); if (ctx().e_internalized(term)) { IF_VERBOSE(0, verbose_stream() << "repeated term\n";); return mk_var(term, false); @@ -766,13 +813,24 @@ class theory_lra::imp { if (is_unit_var(st)) { return st.vars()[0]; } + else if (is_one(st)) { + return get_one(a.is_int(term)); + } + else if (is_zero(st)) { + return get_zero(a.is_int(term)); + } else { init_left_side(st); theory_var v = mk_var(term); lp::var_index vi = m_theory_var2var_index.get(v, UINT_MAX); - TRACE("arith", tout << mk_pp(term, m) << " " << v << " " << vi << "\n";); + TRACE("arith", tout << mk_pp(term, m) << " v" << v << "\n";); if (vi == UINT_MAX) { - vi = m_solver->add_term(m_left_side, st.coeff()); + rational const& offset = st.offset(); + if (!offset.is_zero()) { + m_left_side.push_back(std::make_pair(offset, get_one(a.is_int(term)))); + } + SASSERT(!m_left_side.empty()); + vi = m_solver->add_term(m_left_side); m_theory_var2var_index.setx(v, vi, UINT_MAX); if (m_solver->is_term(vi)) { m_term_index2theory_var.setx(m_solver->adjust_term_index(vi), v, UINT_MAX); @@ -782,7 +840,7 @@ class theory_lra::imp { } m_var_trail.push_back(v); TRACE("arith_verbose", tout << "v" << v << " := " << mk_pp(term, m) << " slack: " << vi << " scopes: " << m_scopes.size() << "\n"; - m_solver->print_term(m_solver->get_term(vi), tout); tout << "\n";); + m_solver->print_term(m_solver->get_term(vi), tout) << "\n";); } rational val; if (a.is_numeral(term, val)) { @@ -798,9 +856,14 @@ public: th(th), m(m), m_arith_params(ap), a(m), + m_has_int(false), m_arith_eq_adapter(th, ap, a), m_internalize_head(0), - m_not_handled(0), + m_one_var(UINT_MAX), + m_zero_var(UINT_MAX), + m_rone_var(UINT_MAX), + m_rzero_var(UINT_MAX), + m_not_handled(nullptr), m_asserted_qhead(0), m_assume_eq_head(0), m_num_conflicts(0), @@ -871,16 +934,18 @@ public: } return true; } + + bool is_arith(enode* n) { + return n && n->get_th_var(get_id()) != null_theory_var; + } void internalize_eq_eh(app * atom, bool_var) { - expr* lhs = 0, *rhs = 0; + TRACE("arith_verbose", tout << mk_pp(atom, m) << "\n";); + expr* lhs = nullptr, *rhs = nullptr; VERIFY(m.is_eq(atom, lhs, rhs)); enode * n1 = get_enode(lhs); enode * n2 = get_enode(rhs); - if (n1->get_th_var(get_id()) != null_theory_var && - n2->get_th_var(get_id()) != null_theory_var && - n1 != n2) { - TRACE("arith_verbose", tout << mk_pp(atom, m) << "\n";); + if (is_arith(n1) && is_arith(n2) && n1 != n2) { m_arith_eq_adapter.mk_axioms(n1, n2); } } @@ -910,6 +975,7 @@ public: scope& s = m_scopes.back(); s.m_bounds_lim = m_bounds_trail.size(); s.m_asserted_qhead = m_asserted_qhead; + s.m_idiv_lim = m_idiv_terms.size(); s.m_asserted_atoms_lim = m_asserted_atoms.size(); s.m_not_handled = m_not_handled; s.m_underspecified_lim = m_underspecified.size(); @@ -935,6 +1001,7 @@ public: } m_theory_var2var_index[m_var_trail[i]] = UINT_MAX; } + m_idiv_terms.shrink(m_scopes[old_size].m_idiv_lim); m_asserted_atoms.shrink(m_scopes[old_size].m_asserted_atoms_lim); m_asserted_qhead = m_scopes[old_size].m_asserted_qhead; m_underspecified.shrink(m_scopes[old_size].m_underspecified_lim); @@ -991,7 +1058,7 @@ public: // to_int (to_real x) = x // to_real(to_int(x)) <= x < to_real(to_int(x)) + 1 void mk_to_int_axiom(app* n) { - expr* x = 0, *y = 0; + expr* x = nullptr, *y = nullptr; VERIFY (a.is_to_int(n, x)); if (a.is_to_real(x, y)) { mk_axiom(th.mk_eq(y, n, false)); @@ -1007,7 +1074,7 @@ public: // is_int(x) <=> to_real(to_int(x)) = x void mk_is_int_axiom(app* n) { - expr* x = 0; + expr* x = nullptr; VERIFY(a.is_is_int(n, x)); literal eq = th.mk_eq(a.mk_to_real(a.mk_to_int(x)), x, false); literal is_int = ctx().get_literal(n); @@ -1030,37 +1097,74 @@ public: add_def_constraint(m_solver->add_var_bound(vi, lp::LE, rational::zero())); add_def_constraint(m_solver->add_var_bound(get_var_index(v), lp::GE, rational::zero())); add_def_constraint(m_solver->add_var_bound(get_var_index(v), lp::LT, abs(r))); + TRACE("arith", m_solver->print_constraints(tout << term << "\n");); } void mk_idiv_mod_axioms(expr * p, expr * q) { if (a.is_zero(q)) { return; } + TRACE("arith", tout << expr_ref(p, m) << " " << expr_ref(q, m) << "\n";); // if q is zero, then idiv and mod are uninterpreted functions. expr_ref div(a.mk_idiv(p, q), m); expr_ref mod(a.mk_mod(p, q), m); expr_ref zero(a.mk_int(0), m); - literal q_ge_0 = mk_literal(a.mk_ge(q, zero)); - literal q_le_0 = mk_literal(a.mk_le(q, zero)); - // literal eqz = th.mk_eq(q, zero, false); literal eq = th.mk_eq(a.mk_add(a.mk_mul(q, div), mod), p, false); literal mod_ge_0 = mk_literal(a.mk_ge(mod, zero)); - // q >= 0 or p = (p mod q) + q * (p div q) - // q <= 0 or p = (p mod q) + q * (p div q) - // q >= 0 or (p mod q) >= 0 - // q <= 0 or (p mod q) >= 0 - // q <= 0 or (p mod q) < q - // q >= 0 or (p mod q) < -q - // enable_trace("mk_bool_var"); - mk_axiom(q_ge_0, eq); - mk_axiom(q_le_0, eq); - mk_axiom(q_ge_0, mod_ge_0); - mk_axiom(q_le_0, mod_ge_0); - mk_axiom(q_le_0, ~mk_literal(a.mk_ge(a.mk_sub(mod, q), zero))); - mk_axiom(q_ge_0, ~mk_literal(a.mk_ge(a.mk_add(mod, q), zero))); - rational k; - if (m_arith_params.m_arith_enum_const_mod && a.is_numeral(q, k) && - k.is_pos() && k < rational(8)) { + literal div_ge_0 = mk_literal(a.mk_ge(div, zero)); + literal div_le_0 = mk_literal(a.mk_le(div, zero)); + literal p_ge_0 = mk_literal(a.mk_ge(p, zero)); + literal p_le_0 = mk_literal(a.mk_le(p, zero)); + + rational k(0); + expr_ref upper(m); + + if (a.is_numeral(q, k)) { + if (k.is_pos()) { + upper = a.mk_numeral(k - 1, true); + } + else if (k.is_neg()) { + upper = a.mk_numeral(-k - 1, true); + } + } + else { + k = rational::zero(); + } + + if (!k.is_zero()) { + mk_axiom(eq); + mk_axiom(mod_ge_0); + mk_axiom(mk_literal(a.mk_le(mod, upper))); + if (k.is_pos()) { + mk_axiom(~p_ge_0, div_ge_0); + mk_axiom(~p_le_0, div_le_0); + } + else { + mk_axiom(~p_ge_0, div_le_0); + mk_axiom(~p_le_0, div_ge_0); + } + } + else { + // q >= 0 or p = (p mod q) + q * (p div q) + // q <= 0 or p = (p mod q) + q * (p div q) + // q >= 0 or (p mod q) >= 0 + // q <= 0 or (p mod q) >= 0 + // q <= 0 or (p mod q) < q + // q >= 0 or (p mod q) < -q + literal q_ge_0 = mk_literal(a.mk_ge(q, zero)); + literal q_le_0 = mk_literal(a.mk_le(q, zero)); + mk_axiom(q_ge_0, eq); + mk_axiom(q_le_0, eq); + mk_axiom(q_ge_0, mod_ge_0); + mk_axiom(q_le_0, mod_ge_0); + mk_axiom(q_le_0, ~mk_literal(a.mk_ge(a.mk_sub(mod, q), zero))); + mk_axiom(q_ge_0, ~mk_literal(a.mk_ge(a.mk_add(mod, q), zero))); + mk_axiom(q_le_0, ~p_ge_0, div_ge_0); + mk_axiom(q_le_0, ~p_le_0, div_le_0); + mk_axiom(q_ge_0, ~p_ge_0, div_le_0); + mk_axiom(q_ge_0, ~p_le_0, div_ge_0); + } + if (m_arith_params.m_arith_enum_const_mod && k.is_pos() && k < rational(8)) { unsigned _k = k.get_unsigned(); literal_buffer lits; for (unsigned j = 0; j < _k; ++j) { @@ -1152,7 +1256,6 @@ public: m_todo_terms.pop_back(); if (m_solver->is_term(vi)) { const lp::lar_term& term = m_solver->get_term(vi); - result += term.m_v * coeff; for (const auto & i: term) { m_todo_terms.push_back(std::make_pair(i.var(), coeff * i.coeff())); } @@ -1189,7 +1292,6 @@ public: m_todo_terms.pop_back(); if (m_solver->is_term(wi)) { const lp::lar_term& term = m_solver->get_term(wi); - result += term.m_v * coeff; for (const auto & i : term) { if (m_variable_values.count(i.var()) > 0) { result += m_variable_values[i.var()] * coeff * i.coeff(); @@ -1208,10 +1310,10 @@ public: } void init_variable_values() { + reset_variable_values(); if (!m.canceled() && m_solver.get() && th.get_num_vars() > 0) { - reset_variable_values(); + TRACE("arith", tout << "update variable values\n";); m_solver->get_model(m_variable_values); - TRACE("arith", display(tout);); } } @@ -1263,8 +1365,7 @@ public: } enode* n2 = get_enode(other); if (n1->get_root() != n2->get_root()) { - TRACE("arith", tout << mk_pp(n1->get_owner(), m) << " = " << mk_pp(n2->get_owner(), m) << "\n"; - tout << mk_pp(n1->get_owner(), m) << " = " << mk_pp(n2->get_owner(), m) << "\n"; + TRACE("arith", tout << enode_eq_pp(enode_pair(n1, n2), ctx()); tout << "v" << v << " = " << "v" << other << "\n";); m_assume_eq_candidates.push_back(std::make_pair(v, other)); result = true; @@ -1314,6 +1415,7 @@ public: } final_check_status final_check_eh() { + IF_VERBOSE(2, verbose_stream() << "final-check " << m_solver->get_status() << "\n"); m_use_nra_model = false; lbool is_sat = l_true; if (m_solver->get_status() != lp::lp_status::OPTIMAL) { @@ -1328,7 +1430,7 @@ public: } if (assume_eqs()) { return FC_CONTINUE; - } + } switch (check_lia()) { case l_true: @@ -1340,7 +1442,7 @@ public: st = FC_CONTINUE; break; } - + switch (check_nra()) { case l_true: break; @@ -1351,7 +1453,7 @@ public: st = FC_GIVEUP; break; } - if (m_not_handled != 0) { + if (m_not_handled != nullptr) { TRACE("arith", tout << "unhandled operator " << mk_pp(m_not_handled, m) << "\n";); st = FC_GIVEUP; } @@ -1378,6 +1480,18 @@ public: u_map coeffs; term2coeffs(term, coeffs, rational::one(), offset); offset.neg(); + TRACE("arith", + m_solver->print_term(term, tout << "term: ") << "\n"; + for (auto const& kv : coeffs) { + tout << "v" << kv.m_key << " * " << kv.m_value << "\n"; + } + tout << offset << "\n"; + rational g(0); + for (auto const& kv : coeffs) { + g = gcd(g, kv.m_value); + } + tout << "gcd: " << g << "\n"; + ); if (is_int) { // 3x + 6y >= 5 -> x + 3y >= 5/3, then x + 3y >= 2 // 3x + 6y <= 5 -> x + 3y <= 1 @@ -1385,10 +1499,12 @@ public: rational g = gcd_reduce(coeffs); if (!g.is_one()) { if (lower_bound) { - offset = div(offset + g - rational::one(), g); + TRACE("arith", tout << "lower: " << offset << " / " << g << " = " << offset / g << " >= " << ceil(offset / g) << "\n";); + offset = ceil(offset / g); } else { - offset = div(offset, g); + TRACE("arith", tout << "upper: " << offset << " / " << g << " = " << offset / g << " <= " << floor(offset / g) << "\n";); + offset = floor(offset / g); } } } @@ -1408,27 +1524,246 @@ public: } TRACE("arith", tout << t << ": " << atom << "\n"; - m_solver->print_term(term, tout << "bound atom: "); tout << (lower_bound?" >= ":" <= ") << k << "\n";); + m_solver->print_term(term, tout << "bound atom: ") << (lower_bound?" >= ":" <= ") << k << "\n";); ctx().internalize(atom, true); ctx().mark_as_relevant(atom.get()); return atom; } + bool make_sure_all_vars_have_bounds() { + if (!m_has_int) { + return true; + } + unsigned nv = std::min(th.get_num_vars(), m_theory_var2var_index.size()); + bool all_bounded = true; + for (unsigned v = 0; v < nv; ++v) { + lp::var_index vi = m_theory_var2var_index[v]; + if (vi == UINT_MAX) + continue; + if (!m_solver->is_term(vi) && !var_has_bound(vi, true) && !var_has_bound(vi, false)) { + lp::lar_term term; + term.add_monomial(rational::one(), vi); + app_ref b = mk_bound(term, rational::zero(), true); + TRACE("arith", tout << "added bound " << b << "\n";); + IF_VERBOSE(2, verbose_stream() << "bound: " << b << "\n"); + all_bounded = false; + } + } + return all_bounded; + } + + /** + * n = (div p q) + * + * (div p q) * q + (mod p q) = p, (mod p q) >= 0 + * + * 0 < q => (p/q <= v(p)/v(q) => n <= floor(v(p)/v(q))) + * 0 < q => (v(p)/v(q) <= p/q => v(p)/v(q) - 1 < n) + * + */ + bool check_idiv_bounds() { + if (m_idiv_terms.empty()) { + return true; + } + bool all_divs_valid = true; + init_variable_values(); + for (expr* n : m_idiv_terms) { + expr* p = nullptr, *q = nullptr; + VERIFY(a.is_idiv(n, p, q)); + theory_var v = mk_var(n); + theory_var v1 = mk_var(p); + rational r1 = get_value(v1); + rational r2; + + if (!r1.is_int() || r1.is_neg()) { + // TBD + // r1 = 223/4, r2 = 2, r = 219/8 + // take ceil(r1), floor(r1), ceil(r2), floor(r2), for floor(r2) > 0 + // then + // p/q <= ceil(r1)/floor(r2) => n <= div(ceil(r1), floor(r2)) + // p/q >= floor(r1)/ceil(r2) => n >= div(floor(r1), ceil(r2)) + continue; + } + + if (a.is_numeral(q, r2) && r2.is_pos()) { + if (get_value(v) == div(r1, r2)) continue; + + rational div_r = div(r1, r2); + // p <= q * div(r1, q) + q - 1 => div(p, q) <= div(r1, r2) + // p >= q * div(r1, q) => div(r1, q) <= div(p, q) + rational mul(1); + rational hi = r2 * div_r + r2 - 1; + rational lo = r2 * div_r; + + // used to normalize inequalities so they + // don't appear as 8*x >= 15, but x >= 2 + expr *n1 = nullptr, *n2 = nullptr; + if (a.is_mul(p, n1, n2) && is_numeral(n1, mul) && mul.is_pos()) { + p = n2; + hi = floor(hi/mul); + lo = ceil(lo/mul); + } + literal p_le_r1 = mk_literal(a.mk_le(p, a.mk_numeral(hi, true))); + literal p_ge_r1 = mk_literal(a.mk_ge(p, a.mk_numeral(lo, true))); + literal n_le_div = mk_literal(a.mk_le(n, a.mk_numeral(div_r, true))); + literal n_ge_div = mk_literal(a.mk_ge(n, a.mk_numeral(div_r, true))); + mk_axiom(~p_le_r1, n_le_div); + mk_axiom(~p_ge_r1, n_ge_div); + + all_divs_valid = false; + + TRACE("arith", + tout << r1 << " div " << r2 << "\n"; + literal_vector lits; + lits.push_back(~p_le_r1); + lits.push_back(n_le_div); + ctx().display_literals_verbose(tout, lits) << "\n\n"; + lits[0] = ~p_ge_r1; + lits[1] = n_ge_div; + ctx().display_literals_verbose(tout, lits) << "\n";); + continue; + } +#if 0 + + // TBD similar for non-linear division. + // better to deal with in nla_solver: + + all_divs_valid = false; + + + // + // p/q <= r1/r2 => n <= div(r1, r2) + // <=> + // p*r2 <= q*r1 => n <= div(r1, r2) + // + // p/q >= r1/r2 => n >= div(r1, r2) + // <=> + // p*r2 >= r1*q => n >= div(r1, r2) + // + expr_ref zero(a.mk_int(0), m); + expr_ref divc(a.mk_numeral(div(r1, r2), true), m); + expr_ref pqr(a.mk_sub(a.mk_mul(a.mk_numeral(r2, true), p), a.mk_mul(a.mk_numeral(r1, true), q)), m); + literal pq_lhs = ~mk_literal(a.mk_le(pqr, zero)); + literal pq_rhs = ~mk_literal(a.mk_ge(pqr, zero)); + literal n_le_div = mk_literal(a.mk_le(n, divc)); + literal n_ge_div = mk_literal(a.mk_ge(n, divc)); + mk_axiom(pq_lhs, n_le_div); + mk_axiom(pq_rhs, n_ge_div); + TRACE("arith", + literal_vector lits; + lits.push_back(pq_lhs); + lits.push_back(n_le_div); + ctx().display_literals_verbose(tout, lits) << "\n"; + lits[0] = pq_rhs; + lits[1] = n_ge_div; + ctx().display_literals_verbose(tout, lits) << "\n";); +#endif + } + + return all_divs_valid; + } + + expr_ref var2expr(lp::var_index v) { + std::ostringstream name; + name << "v" << m_solver->local2external(v); + return expr_ref(m.mk_const(symbol(name.str().c_str()), a.mk_int()), m); + } + + expr_ref multerm(rational const& r, expr* e) { + if (r.is_one()) return expr_ref(e, m); + return expr_ref(a.mk_mul(a.mk_numeral(r, true), e), m); + } + + expr_ref term2expr(lp::lar_term const& term) { + expr_ref t(m); + expr_ref_vector ts(m); + for (auto const& p : term) { + lp::var_index wi = p.var(); + if (m_solver->is_term(wi)) { + ts.push_back(multerm(p.coeff(), term2expr(m_solver->get_term(wi)))); + } + else { + ts.push_back(multerm(p.coeff(), var2expr(wi))); + } + } + if (ts.size() == 1) { + t = ts.back(); + } + else { + t = a.mk_add(ts.size(), ts.c_ptr()); + } + return t; + } + + expr_ref constraint2fml(lp::constraint_index ci) { + lp::lar_base_constraint const& c = *m_solver->constraints()[ci]; + expr_ref fml(m); + expr_ref_vector ts(m); + rational rhs = c.m_right_side; + for (auto cv : c.get_left_side_coefficients()) { + ts.push_back(multerm(cv.first, var2expr(cv.second))); + } + switch (c.m_kind) { + case lp::LE: fml = a.mk_le(a.mk_add(ts.size(), ts.c_ptr()), a.mk_numeral(rhs, true)); break; + case lp::LT: fml = a.mk_lt(a.mk_add(ts.size(), ts.c_ptr()), a.mk_numeral(rhs, true)); break; + case lp::GE: fml = a.mk_ge(a.mk_add(ts.size(), ts.c_ptr()), a.mk_numeral(rhs, true)); break; + case lp::GT: fml = a.mk_gt(a.mk_add(ts.size(), ts.c_ptr()), a.mk_numeral(rhs, true)); break; + case lp::EQ: fml = m.mk_eq(a.mk_add(ts.size(), ts.c_ptr()), a.mk_numeral(rhs, true)); break; + } + return fml; + } + + void dump_cut_lemma(std::ostream& out, lp::lar_term const& term, lp::mpq const& k, lp::explanation const& ex, bool upper) { + m_solver->print_term(term, out << "bound: "); + out << (upper?" <= ":" >= ") << k << "\n"; + for (auto const& p : term) { + lp::var_index wi = p.var(); + out << p.coeff() << " * "; + if (m_solver->is_term(wi)) { + m_solver->print_term(m_solver->get_term(wi), out) << "\n"; + } + else { + out << "v" << m_solver->local2external(wi) << "\n"; + } + } + for (auto const& ev : ex.m_explanation) { + m_solver->print_constraint(ev.second, out << ev.first << ": "); + } + expr_ref_vector fmls(m); + for (auto const& ev : ex.m_explanation) { + fmls.push_back(constraint2fml(ev.second)); + } + expr_ref t(term2expr(term), m); + if (upper) { + fmls.push_back(m.mk_not(a.mk_ge(t, a.mk_numeral(k, true)))); + } + else { + fmls.push_back(m.mk_not(a.mk_le(t, a.mk_numeral(k, true)))); + } + ast_pp_util visitor(m); + visitor.collect(fmls); + visitor.display_decls(out); + visitor.display_asserts(out, fmls, true); + out << "(check-sat)\n"; + } + lbool check_lia() { if (m.canceled()) { TRACE("arith", tout << "canceled\n";); return l_undef; } - lp::lar_term term; - lp::mpq k; - lp::explanation ex; // TBD, this should be streamlined accross different explanations - bool upper; - switch(m_lia->check(term, k, ex, upper)) { + if (!check_idiv_bounds()) { + TRACE("arith", tout << "idiv bounds check\n";); + return l_false; + } + m_explanation.reset(); + switch (m_lia->check()) { case lp::lia_move::sat: return l_true; case lp::lia_move::branch: { TRACE("arith", tout << "branch\n";); - app_ref b = mk_bound(term, k, !upper); + app_ref b = mk_bound(m_lia->get_term(), m_lia->get_offset(), !m_lia->is_upper()); + IF_VERBOSE(2, verbose_stream() << "branch " << b << "\n";); // branch on term >= k + 1 // branch on term <= k // TBD: ctx().force_phase(ctx().get_literal(b)); @@ -1440,11 +1775,13 @@ public: TRACE("arith", tout << "cut\n";); ++m_stats.m_gomory_cuts; // m_explanation implies term <= k - app_ref b = mk_bound(term, k, !upper); + app_ref b = mk_bound(m_lia->get_term(), m_lia->get_offset(), !m_lia->is_upper()); + IF_VERBOSE(2, verbose_stream() << "cut " << b << "\n"); + TRACE("arith", dump_cut_lemma(tout, m_lia->get_term(), m_lia->get_offset(), m_lia->get_explanation(), m_lia->is_upper());); m_eqs.reset(); m_core.reset(); m_params.reset(); - for (auto const& ev : ex.m_explanation) { + for (auto const& ev : m_lia->get_explanation().m_explanation) { if (!ev.first.is_zero()) { set_evidence(ev.second); } @@ -1457,8 +1794,9 @@ public: return l_false; } case lp::lia_move::conflict: + TRACE("arith", tout << "conflict\n";); // ex contains unsat core - m_explanation = ex.m_explanation; + m_explanation = m_lia->get_explanation().m_explanation; set_conflict1(); return l_false; case lp::lia_move::undef: @@ -1744,12 +2082,12 @@ public: m_core2.push_back(~c); } m_core2.push_back(lit); - justification * js = 0; + justification * js = nullptr; if (proofs_enabled()) { js = alloc(theory_lemma_justification, get_id(), ctx(), m_core2.size(), m_core2.c_ptr(), m_params.size(), m_params.c_ptr()); } - ctx().mk_clause(m_core2.size(), m_core2.c_ptr(), js, CLS_AUX_LEMMA, 0); + ctx().mk_clause(m_core2.size(), m_core2.c_ptr(), js, CLS_AUX_LEMMA, nullptr); } else { ctx().assign( @@ -1804,7 +2142,7 @@ public: rational const& k1 = b.get_value(); lp_bounds & bounds = m_bounds[v]; - lp_api::bound* end = 0; + lp_api::bound* end = nullptr; lp_api::bound* lo_inf = end, *lo_sup = end; lp_api::bound* hi_inf = end, *hi_sup = end; @@ -1945,16 +2283,14 @@ public: iterator lo_inf = begin1, lo_sup = begin1; iterator hi_inf = begin2, hi_sup = begin2; - iterator lo_inf1 = begin1, lo_sup1 = begin1; - iterator hi_inf1 = begin2, hi_sup1 = begin2; bool flo_inf, fhi_inf, flo_sup, fhi_sup; ptr_addr_hashtable visited; for (unsigned i = 0; i < atoms.size(); ++i) { lp_api::bound* a1 = atoms[i]; - lo_inf1 = next_inf(a1, lp_api::lower_t, lo_inf, end, flo_inf); - hi_inf1 = next_inf(a1, lp_api::upper_t, hi_inf, end, fhi_inf); - lo_sup1 = next_sup(a1, lp_api::lower_t, lo_sup, end, flo_sup); - hi_sup1 = next_sup(a1, lp_api::upper_t, hi_sup, end, fhi_sup); + iterator lo_inf1 = next_inf(a1, lp_api::lower_t, lo_inf, end, flo_inf); + iterator hi_inf1 = next_inf(a1, lp_api::upper_t, hi_inf, end, fhi_inf); + iterator lo_sup1 = next_sup(a1, lp_api::lower_t, lo_sup, end, flo_sup); + iterator hi_sup1 = next_sup(a1, lp_api::upper_t, hi_sup, end, fhi_sup); if (lo_inf1 != end) lo_inf = lo_inf1; if (lo_sup1 != end) lo_sup = lo_sup1; if (hi_inf1 != end) hi_inf = hi_inf1; @@ -2062,18 +2398,18 @@ public: SASSERT(!bounds.empty()); if (bounds.size() == 1) return; if (m_unassigned_bounds[v] == 0) return; - + bool v_is_int = is_int(v); literal lit1(bv, !is_true); literal lit2 = null_literal; bool find_glb = (is_true == (k == lp_api::lower_t)); + TRACE("arith", tout << "find_glb: " << find_glb << " is_true: " << is_true << " k: " << k << " is_lower: " << (k == lp_api::lower_t) << "\n";); if (find_glb) { rational glb; - lp_api::bound* lb = 0; - for (unsigned i = 0; i < bounds.size(); ++i) { - lp_api::bound* b2 = bounds[i]; + lp_api::bound* lb = nullptr; + for (lp_api::bound* b2 : bounds) { if (b2 == &b) continue; rational const& val2 = b2->get_value(); - if ((is_true ? val2 < val : val2 <= val) && (!lb || glb < val2)) { + if (((is_true || v_is_int) ? val2 < val : val2 <= val) && (!lb || glb < val2)) { lb = b2; glb = val2; } @@ -2084,12 +2420,11 @@ public: } else { rational lub; - lp_api::bound* ub = 0; - for (unsigned i = 0; i < bounds.size(); ++i) { - lp_api::bound* b2 = bounds[i]; + lp_api::bound* ub = nullptr; + for (lp_api::bound* b2 : bounds) { if (b2 == &b) continue; rational const& val2 = b2->get_value(); - if ((is_true ? val < val2 : val <= val2) && (!ub || val2 < lub)) { + if (((is_true || v_is_int) ? val < val2 : val <= val2) && (!ub || val2 < lub)) { ub = b2; lub = val2; } @@ -2107,7 +2442,7 @@ public: m_params.reset(); m_core.reset(); m_eqs.reset(); - m_core.push_back(lit2); + m_core.push_back(lit1); m_params.push_back(parameter(symbol("farkas"))); m_params.push_back(parameter(rational(1))); m_params.push_back(parameter(rational(1))); @@ -2335,14 +2670,12 @@ public: if (propagate_eqs()) { rational const& value = b.get_value(); if (k == lp::GE) { - set_lower_bound(vi, ci, value); - if (has_upper_bound(vi, ci, value)) { + if (set_lower_bound(vi, ci, value) && has_upper_bound(vi, ci, value)) { fixed_var_eh(b.get_var(), value); } } else if (k == lp::LE) { - set_upper_bound(vi, ci, value); - if (has_lower_bound(vi, ci, value)) { + if (set_upper_bound(vi, ci, value) && has_lower_bound(vi, ci, value)) { fixed_var_eh(b.get_var(), value); } } @@ -2361,26 +2694,52 @@ public: bool use_tableau() const { return lp_params(ctx().get_params()).simplex_strategy() < 2; } - void set_upper_bound(lp::var_index vi, lp::constraint_index ci, rational const& v) { set_bound(vi, ci, v, false); } + bool set_upper_bound(lp::var_index vi, lp::constraint_index ci, rational const& v) { return set_bound(vi, ci, v, false); } - void set_lower_bound(lp::var_index vi, lp::constraint_index ci, rational const& v) { set_bound(vi, ci, v, true); } + bool set_lower_bound(lp::var_index vi, lp::constraint_index ci, rational const& v) { return set_bound(vi, ci, v, true); } - void set_bound(lp::var_index vi, lp::constraint_index ci, rational const& v, bool is_lower) { - if (!m_solver->is_term(vi)) { + bool set_bound(lp::var_index vi, lp::constraint_index ci, rational const& v, bool is_lower) { + + if (m_solver->is_term(vi)) { + lp::var_index ti = m_solver->adjust_term_index(vi); + auto& vec = is_lower ? m_lower_terms : m_upper_terms; + if (vec.size() <= ti) { + vec.resize(ti + 1, constraint_bound(UINT_MAX, rational())); + } + constraint_bound& b = vec[ti]; + if (b.first == UINT_MAX || (is_lower? b.second < v : b.second > v)) { + TRACE("arith", tout << "tighter bound " << vi << "\n";); + ctx().push_trail(vector_value_trail(vec, ti)); + b.first = ci; + b.second = v; + } + return true; + } + else { + TRACE("arith", tout << "not a term " << vi << "\n";); // m_solver already tracks bounds on proper variables, but not on terms. - return; + bool is_strict = false; + rational b; + if (is_lower) { + return m_solver->has_lower_bound(vi, ci, b, is_strict) && !is_strict && b == v; + } + else { + return m_solver->has_upper_bound(vi, ci, b, is_strict) && !is_strict && b == v; + } + } - lp::var_index ti = m_solver->adjust_term_index(vi); - auto& vec = is_lower ? m_lower_terms : m_upper_terms; - if (vec.size() <= ti) { - vec.resize(ti + 1, constraint_bound(UINT_MAX, rational())); - } - constraint_bound& b = vec[ti]; - if (b.first == UINT_MAX || (is_lower? b.second < v : b.second > v)) { - ctx().push_trail(vector_value_trail(vec, ti)); - b.first = ci; - b.second = v; + } + + bool var_has_bound(lp::var_index vi, bool is_lower) { + bool is_strict = false; + rational b; + lp::constraint_index ci; + if (is_lower) { + return m_solver->has_lower_bound(vi, ci, b, is_strict); } + else { + return m_solver->has_upper_bound(vi, ci, b, is_strict); + } } bool has_upper_bound(lp::var_index vi, lp::constraint_index& ci, rational const& bound) { return has_bound(vi, ci, bound, false); } @@ -2451,18 +2810,18 @@ public: justification* js = ctx().mk_justification( ext_theory_eq_propagation_justification( - get_id(), ctx().get_region(), m_core.size(), m_core.c_ptr(), m_eqs.size(), m_eqs.c_ptr(), x, y, 0, 0)); + get_id(), ctx().get_region(), m_core.size(), m_core.c_ptr(), m_eqs.size(), m_eqs.c_ptr(), x, y, 0, nullptr)); TRACE("arith", - for (unsigned i = 0; i < m_core.size(); ++i) { - ctx().display_detailed_literal(tout, m_core[i]); + for (literal c : m_core) { + ctx().display_detailed_literal(tout, c); tout << "\n"; } - for (unsigned i = 0; i < m_eqs.size(); ++i) { - tout << mk_pp(m_eqs[i].first->get_owner(), m) << " = " << mk_pp(m_eqs[i].second->get_owner(), m) << "\n"; + for (enode_pair const& p : m_eqs) { + tout << enode_eq_pp(p, ctx()); } tout << " ==> "; - tout << mk_pp(x->get_owner(), m) << " = " << mk_pp(y->get_owner(), m) << "\n"; + tout << enode_pp(x, ctx()) << " = " << enode_pp(y, ctx()) << "\n"; ); // parameters are TBD. @@ -2606,7 +2965,7 @@ public: m_todo_terms.push_back(std::make_pair(vi, rational::one())); TRACE("arith", tout << "v" << v << " := w" << vi << "\n"; - m_solver->print_term(m_solver->get_term(vi), tout); tout << "\n";); + m_solver->print_term(m_solver->get_term(vi), tout) << "\n";); m_nra->am().set(r, 0); while (!m_todo_terms.empty()) { @@ -2614,13 +2973,13 @@ public: vi = m_todo_terms.back().first; m_todo_terms.pop_back(); lp::lar_term const& term = m_solver->get_term(vi); - TRACE("arith", m_solver->print_term(term, tout); tout << "\n";); + TRACE("arith", m_solver->print_term(term, tout) << "\n";); scoped_anum r1(m_nra->am()); - rational c1 = term.m_v * wcoeff; + rational c1(0); m_nra->am().set(r1, c1.to_mpq()); m_nra->am().add(r, r1, r); for (auto const & arg : term) { - lp::var_index wi = m_solver->local2external(arg.var()); + lp::var_index wi = arg.var(); c1 = arg.coeff() * wcoeff; if (m_solver->is_term(wi)) { m_todo_terms.push_back(std::make_pair(wi, c1)); @@ -2658,13 +3017,23 @@ public: } } - bool get_value(enode* n, expr_ref& r) { + bool get_value(enode* n, rational& val) { theory_var v = n->get_th_var(get_id()); if (!can_get_bound(v)) return false; lp::var_index vi = m_theory_var2var_index[v]; - rational val; if (m_solver->has_value(vi, val)) { + TRACE("arith", tout << expr_ref(n->get_owner(), m) << " := " << val << "\n";); if (is_int(n) && !val.is_int()) return false; + return true; + } + else { + return false; + } + } + + bool get_value(enode* n, expr_ref& r) { + rational val; + if (get_value(n, val)) { r = a.mk_numeral(val, is_int(n)); return true; } @@ -2673,7 +3042,7 @@ public: } } - bool get_lower(enode* n, expr_ref& r) { + bool get_lower(enode* n, rational& val, bool& is_strict) { theory_var v = n->get_th_var(get_id()); if (!can_get_bound(v)) { TRACE("arith", tout << "cannot get lower for " << v << "\n";); @@ -2681,29 +3050,36 @@ public: } lp::var_index vi = m_theory_var2var_index[v]; lp::constraint_index ci; - rational val; + return m_solver->has_lower_bound(vi, ci, val, is_strict); + } + + bool get_lower(enode* n, expr_ref& r) { bool is_strict; - if (m_solver->has_lower_bound(vi, ci, val, is_strict)) { + rational val; + if (get_lower(n, val, is_strict) && !is_strict) { r = a.mk_numeral(val, is_int(n)); return true; } - TRACE("arith", m_solver->print_constraints(tout << "does not have lower bound " << vi << "\n");); return false; } - bool get_upper(enode* n, expr_ref& r) { + bool get_upper(enode* n, rational& val, bool& is_strict) { theory_var v = n->get_th_var(get_id()); if (!can_get_bound(v)) return false; lp::var_index vi = m_theory_var2var_index[v]; lp::constraint_index ci; - rational val; + return m_solver->has_upper_bound(vi, ci, val, is_strict); + + } + + bool get_upper(enode* n, expr_ref& r) { bool is_strict; - if (m_solver->has_upper_bound(vi, ci, val, is_strict)) { + rational val; + if (get_upper(n, val, is_strict) && !is_strict) { r = a.mk_numeral(val, is_int(n)); return true; } - TRACE("arith", m_solver->print_constraints(tout << "does not have upper bound " << vi << "\n");); return false; } @@ -2862,7 +3238,7 @@ public: theory_var w; if (m_solver->is_term(ti.var())) { //w = m_term_index2theory_var.get(m_solver->adjust_term_index(ti.var()), null_theory_var); - //if (w == null_theory_var) // if extracing expressions directly from nested term + //if (w == null_theory_var) // if extracting expressions directly from nested term lp::lar_term const& term1 = m_solver->get_term(ti.var()); rational coeff2 = coeff * ti.coeff(); term2coeffs(term1, coeffs, coeff2, offset); @@ -2875,7 +3251,6 @@ public: coeffs.find(w, c0); coeffs.insert(w, c0 + ti.coeff() * coeff); } - offset += coeff * term.m_v; } app_ref coeffs2app(u_map const& coeffs, rational const& offset, bool is_int) { @@ -2915,15 +3290,17 @@ public: rational gcd_reduce(u_map& coeffs) { rational g(0); - for (auto const& kv : coeffs) { - g = gcd(g, kv.m_value); - } - if (!g.is_one() && !g.is_zero()) { - for (auto& kv : coeffs) { - kv.m_value /= g; - } - } - return g; + for (auto const& kv : coeffs) { + g = gcd(g, kv.m_value); + } + if (g.is_zero()) + return rational::one(); + if (!g.is_one()) { + for (auto& kv : coeffs) { + kv.m_value /= g; + } + } + return g; } app_ref mk_obj(theory_var v) { @@ -2951,7 +3328,7 @@ public: } if (!ctx().b_internalized(b)) { fm.hide(b->get_decl()); - bool_var bv = ctx().mk_bool_var(b); + bool_var bv = ctx().mk_bool_var(b); ctx().set_var_theory(bv, get_id()); // ctx().set_enode_flag(bv, true); lp_api::bound_kind bkind = lp_api::bound_kind::lower_t; @@ -3007,8 +3384,7 @@ public: break; } case equality_source: - out << mk_pp(m_equalities[idx].first->get_owner(), m) << " = " - << mk_pp(m_equalities[idx].second->get_owner(), m) << "\n"; + out << enode_eq_pp(m_equalities[idx], ctx()); break; case definition_source: { theory_var v = m_definitions[idx]; @@ -3132,6 +3508,9 @@ void theory_lra::init_model(model_generator & m) { model_value_proc * theory_lra::mk_value(enode * n, model_generator & mg) { return m_imp->mk_value(n, mg); } +bool theory_lra::get_value(enode* n, rational& r) { + return m_imp->get_value(n, r); +} bool theory_lra::get_value(enode* n, expr_ref& r) { return m_imp->get_value(n, r); } @@ -3141,6 +3520,12 @@ bool theory_lra::get_lower(enode* n, expr_ref& r) { bool theory_lra::get_upper(enode* n, expr_ref& r) { return m_imp->get_upper(n, r); } +bool theory_lra::get_lower(enode* n, rational& r, bool& is_strict) { + return m_imp->get_lower(n, r, is_strict); +} +bool theory_lra::get_upper(enode* n, rational& r, bool& is_strict) { + return m_imp->get_upper(n, r, is_strict); +} bool theory_lra::validate_eq_in_model(theory_var v1, theory_var v2, bool is_true) const { return m_imp->validate_eq_in_model(v1, v2, is_true); diff --git a/src/smt/theory_lra.h b/src/smt/theory_lra.h index 074b11ba7..23adaa557 100644 --- a/src/smt/theory_lra.h +++ b/src/smt/theory_lra.h @@ -78,8 +78,11 @@ namespace smt { model_value_proc * mk_value(enode * n, model_generator & mg) override; bool get_value(enode* n, expr_ref& r) override; + bool get_value(enode* n, rational& r); bool get_lower(enode* n, expr_ref& r); bool get_upper(enode* n, expr_ref& r); + bool get_lower(enode* n, rational& r, bool& is_strict); + bool get_upper(enode* n, rational& r, bool& is_strict); bool validate_eq_in_model(theory_var v1, theory_var v2, bool is_true) const override; diff --git a/src/smt/theory_pb.cpp b/src/smt/theory_pb.cpp index e389c819e..de86ef7e3 100644 --- a/src/smt/theory_pb.cpp +++ b/src/smt/theory_pb.cpp @@ -465,7 +465,9 @@ namespace smt { bool theory_pb::internalize_atom(app * atom, bool gate_ctx) { context& ctx = get_context(); - TRACE("pb", tout << mk_pp(atom, get_manager()) << "\n";); + ast_manager& m = get_manager(); + + TRACE("pb", tout << mk_pp(atom, m) << "\n";); if (ctx.b_internalized(atom)) { return true; } @@ -490,12 +492,37 @@ namespace smt { unsigned num_args = atom->get_num_args(); bool_var abv = ctx.mk_bool_var(atom); ctx.set_var_theory(abv, get_id()); + literal lit(abv); + + + if (pb.is_eq(atom)) { + expr_ref_vector args(m); + vector coeffs; + unsigned n = atom->get_num_args(); + for (unsigned i = 0; i < n; ++i) { + args.push_back(atom->get_arg(i)); + coeffs.push_back(pb.get_coeff(atom, i)); + } + expr_ref le(pb.mk_le(n, coeffs.c_ptr(), args.c_ptr(), pb.get_k(atom)), m); + expr_ref ge(pb.mk_ge(n, coeffs.c_ptr(), args.c_ptr(), pb.get_k(atom)), m); + ctx.internalize(le, false); + ctx.internalize(ge, false); + literal le_lit = ctx.get_literal(le); + literal ge_lit = ctx.get_literal(ge); + ctx.mark_as_relevant(le_lit); + ctx.mark_as_relevant(ge_lit); + ctx.mk_th_axiom(get_id(), ~lit, le_lit); + ctx.mk_th_axiom(get_id(), ~lit, ge_lit); + ctx.mk_th_axiom(get_id(), ~le_lit, ~ge_lit, lit); + return true; + } ineq* c = alloc(ineq, m_mpz_mgr, literal(abv), pb.is_eq(atom)); c->m_args[0].m_k = pb.get_k(atom); numeral& k = c->m_args[0].m_k; arg_t& args = c->m_args[0]; + // extract literals and coefficients. for (unsigned i = 0; i < num_args; ++i) { expr* arg = atom->get_arg(i); @@ -523,21 +550,14 @@ namespace smt { SASSERT(pb.is_at_least_k(atom) || pb.is_ge(atom) || pb.is_eq(atom)); } TRACE("pb", display(tout, *c, true);); - //app_ref fml1(m), fml2(m); - //fml1 = c->to_expr(ctx, m); c->unique(); lbool is_true = c->normalize(); c->prune(); c->post_prune(); - //fml2 = c->to_expr(ctx, m); - //expr_ref validate_pb = pb_rewriter(m).mk_validate_rewrite(fml1, fml2); - //pb_rewriter(m).dump_pb_rewrite(validate_pb); - - literal lit(abv); TRACE("pb", display(tout, *c); tout << " := " << lit << "\n";); - switch(is_true) { + switch (is_true) { case l_false: lit = ~lit; // fall-through @@ -590,14 +610,11 @@ namespace smt { else { c->m_compilation_threshold = UINT_MAX; } - init_watch_var(*c); + init_watch_ineq(*c); init_watch(abv); m_var_infos[abv].m_ineq = c; m_ineqs_trail.push_back(abv); - - TRACE("pb", display(tout, *c);); - return true; } @@ -699,7 +716,6 @@ namespace smt { } } - void theory_pb::watch_literal(literal lit, ineq* c) { init_watch(lit.var()); ptr_vector* ineqs = m_var_infos[lit.var()].m_lit_watch[lit.sign()]; @@ -707,27 +723,13 @@ namespace smt { ineqs = alloc(ptr_vector); m_var_infos[lit.var()].m_lit_watch[lit.sign()] = ineqs; } - ineqs->push_back(c); - } - - - void theory_pb::watch_var(bool_var v, ineq* c) { - init_watch(v); - ptr_vector* ineqs = m_var_infos[v].m_var_watch; - if (ineqs == nullptr) { - ineqs = alloc(ptr_vector); - m_var_infos[v].m_var_watch = ineqs; + for (auto* c1 : *ineqs) { + //if (c1 == c) return; + SASSERT (c1 != c); } ineqs->push_back(c); } - void theory_pb::unwatch_var(bool_var v, ineq* c) { - ptr_vector* ineqs = m_var_infos[v].m_var_watch; - if (ineqs) { - remove(*ineqs, c); - } - } - void theory_pb::unwatch_literal(literal lit, ineq* c) { ptr_vector* ineqs = m_var_infos[lit.var()].m_lit_watch[lit.sign()]; if (ineqs) { @@ -736,13 +738,14 @@ namespace smt { } void theory_pb::remove(ptr_vector& ineqs, ineq* c) { - for (unsigned j = 0; j < ineqs.size(); ++j) { + unsigned sz = ineqs.size(); + for (unsigned j = 0; j < sz; ++j) { if (ineqs[j] == c) { - std::swap(ineqs[j], ineqs[ineqs.size()-1]); + std::swap(ineqs[j], ineqs[sz-1]); ineqs.pop_back(); - break; + return; } - } + } } // ---------------------------- @@ -759,18 +762,18 @@ namespace smt { card& get_card() { return m_card; } - virtual void get_antecedents(conflict_resolution& cr) { + void get_antecedents(conflict_resolution& cr) override { cr.mark_literal(m_card.lit()); for (unsigned i = m_card.k(); i < m_card.size(); ++i) { cr.mark_literal(~m_card.lit(i)); } } - virtual theory_id get_from_theory() const { + theory_id get_from_theory() const override { return m_fid; } - virtual proof* mk_proof(smt::conflict_resolution& cr) { + proof* mk_proof(smt::conflict_resolution& cr) override { ptr_buffer prs; ast_manager& m = cr.get_context().get_manager(); expr_ref fact(m); @@ -792,8 +795,6 @@ namespace smt { return m.mk_th_lemma(m_fid, fact, prs.size(), prs.c_ptr()); } } - - }; @@ -897,7 +898,7 @@ namespace smt { void theory_pb::watch_literal(literal lit, card* c) { init_watch(lit.var()); ptr_vector* cards = m_var_infos[lit.var()].m_lit_cwatch[lit.sign()]; - if (cards == 0) { + if (cards == nullptr) { cards = alloc(ptr_vector); m_var_infos[lit.var()].m_lit_cwatch[lit.sign()] = cards; } @@ -961,13 +962,13 @@ namespace smt { void theory_pb::add_clause(card& c, literal_vector const& lits) { m_stats.m_num_conflicts++; context& ctx = get_context(); - justification* js = 0; + justification* js = nullptr; c.inc_propagations(*this); if (!resolve_conflict(c, lits)) { if (proofs_enabled()) { js = alloc(theory_lemma_justification, get_id(), ctx, lits.size(), lits.c_ptr()); } - ctx.mk_clause(lits.size(), lits.c_ptr(), js, CLS_AUX_LEMMA, 0); + ctx.mk_clause(lits.size(), lits.c_ptr(), js, CLS_AUX_LEMMA, nullptr); } SASSERT(ctx.inconsistent()); } @@ -1027,7 +1028,7 @@ namespace smt { } void theory_pb::assign_eh(bool_var v, bool is_true) { - ptr_vector* ineqs = 0; + ptr_vector* ineqs = nullptr; context& ctx = get_context(); literal nlit(v, is_true); init_watch(v); @@ -1042,13 +1043,6 @@ namespace smt { } } } - ineqs = m_var_infos[v].m_var_watch; - if (ineqs != nullptr) { - for (unsigned i = 0; i < ineqs->size(); ++i) { - ineq* c = (*ineqs)[i]; - assign_watch(v, is_true, *c); - } - } ineq* c = m_var_infos[v].m_ineq; if (c != nullptr) { if (c->is_ge()) { @@ -1060,7 +1054,7 @@ namespace smt { } ptr_vector* cards = m_var_infos[v].m_lit_cwatch[nlit.sign()]; - if (cards != 0 && !cards->empty() && !ctx.inconsistent()) { + if (cards != nullptr && !cards->empty() && !ctx.inconsistent()) { ptr_vector::iterator it = cards->begin(), it2 = it, end = cards->end(); for (; it != end; ++it) { if (ctx.get_assignment((*it)->lit()) != l_true) { @@ -1088,7 +1082,7 @@ namespace smt { } card* crd = m_var_infos[v].m_card; - if (crd != 0 && !ctx.inconsistent()) { + if (crd != nullptr && !ctx.inconsistent()) { crd->init_watch(*this, is_true); } @@ -1143,19 +1137,6 @@ namespace smt { return lits; } - class theory_pb::rewatch_vars : public trail { - theory_pb& pb; - ineq& c; - public: - rewatch_vars(theory_pb& p, ineq& c): pb(p), c(c) {} - void undo(context& ctx) override { - for (unsigned i = 0; i < c.size(); ++i) { - pb.watch_var(c.lit(i).var(), &c); - } - } - }; - - class theory_pb::negate_ineq : public trail { ineq& c; public: @@ -1176,7 +1157,6 @@ namespace smt { ctx.push_trail(value_trail(c.m_max_sum)); ctx.push_trail(value_trail(c.m_min_sum)); ctx.push_trail(value_trail(c.m_nfixed)); - ctx.push_trail(rewatch_vars(*this, c)); SASSERT(c.is_ge()); unsigned sz = c.size(); @@ -1230,103 +1210,6 @@ namespace smt { } - /** - Propagation rules: - - nfixed = N & minsum = k -> T - nfixed = N & minsum != k -> F - - minsum > k or maxsum < k -> F - minsum = k & = -> fix 0 variables - nfixed+1 = N & = -> fix unassigned variable or conflict - nfixed+1 = N & != -> maybe forced unassigned to ensure disequal - minsum >= k -> T - maxsum < k -> F - */ - - void theory_pb::assign_watch(bool_var v, bool is_true, ineq& c) { - - context& ctx = get_context(); - unsigned i; - literal l = c.lit(); - lbool asgn = ctx.get_assignment(l); - - if (c.max_sum() < c.mpz_k() && asgn == l_false) { - return; - } - if (c.is_ge() && c.min_sum() >= c.mpz_k() && asgn == l_true) { - return; - } - for (i = 0; i < c.size(); ++i) { - if (c.lit(i).var() == v) { - break; - } - } - - TRACE("pb", display(tout << "assign watch " << literal(v,!is_true) << " ", c, true);); - - SASSERT(i < c.size()); - if (c.lit(i).sign() == is_true) { - ctx.push_trail(value_trail(c.m_max_sum)); - c.m_max_sum -= c.ncoeff(i); - } - else { - ctx.push_trail(value_trail(c.m_min_sum)); - c.m_min_sum += c.ncoeff(i); - } - DEBUG_CODE( - scoped_mpz sum(m_mpz_mgr); - scoped_mpz maxs(m_mpz_mgr); - for (unsigned i = 0; i < c.size(); ++i) { - if (ctx.get_assignment(c.lit(i)) == l_true) sum += c.ncoeff(i); - if (ctx.get_assignment(c.lit(i)) != l_false) maxs += c.ncoeff(i); - } - CTRACE("pb", (maxs > c.max_sum()), display(tout, c, true);); - SASSERT(c.min_sum() <= sum); - SASSERT(sum <= maxs); - SASSERT(maxs <= c.max_sum()); - ); - SASSERT(c.min_sum() <= c.max_sum()); - SASSERT(!m_mpz_mgr.is_neg(c.min_sum())); - ctx.push_trail(value_trail(c.m_nfixed)); - ++c.m_nfixed; - SASSERT(c.nfixed() <= c.size()); - if (c.is_ge() && c.min_sum() >= c.mpz_k() && asgn != l_true) { - TRACE("pb", display(tout << "Set " << l << "\n", c, true);); - add_assign(c, get_helpful_literals(c, false), l); - } - else if (c.max_sum() < c.mpz_k() && asgn != l_false) { - TRACE("pb", display(tout << "Set " << ~l << "\n", c, true);); - add_assign(c, get_unhelpful_literals(c, true), ~l); - } - else if (c.is_eq() && c.nfixed() == c.size() && c.min_sum() == c.mpz_k() && asgn != l_true) { - TRACE("pb", display(tout << "Set " << l << "\n", c, true);); - add_assign(c, get_all_literals(c, false), l); - } - else if (c.is_eq() && c.nfixed() == c.size() && c.min_sum() != c.mpz_k() && asgn != l_false) { - TRACE("pb", display(tout << "Set " << ~l << "\n", c, true);); - add_assign(c, get_all_literals(c, false), ~l); - } -#if 0 - else if (c.is_eq() && c.min_sum() > c.mpz_k() && asgn != l_false) { - TRACE("pb", display(tout << "Set " << ~l << "\n", c, true);); - add_assign(c, get_all_literals(c, false), ~l); - } - else if (c.is_eq() && asgn == l_true && c.min_sum() == c.mpz_k() && c.max_sum() > c.mpz_k()) { - literal_vector& lits = get_all_literals(c, false); - lits.push_back(c.lit()); - for (unsigned i = 0; i < c.size(); ++i) { - if (ctx.get_assignment(c.lit(i)) == l_undef) { - add_assign(c, lits, ~c.lit(i)); - } - } - } -#endif - else { - IF_VERBOSE(14, display(verbose_stream() << "no propagation ", c, true);); - } - } - /** \brief v is assigned in inequality c. Update current bounds and watch list. @@ -1527,7 +1410,7 @@ namespace smt { else { z++; clear_watch(*c); - m_var_infos[v].m_card = 0; + m_var_infos[v].m_card = nullptr; dealloc(c); m_card_trail[i] = null_bool_var; ctx.remove_watch(v); @@ -1553,7 +1436,7 @@ namespace smt { } } - std::cout << "zs: " << z << " nzs: " << nz << " lemmas: " << ctx.get_lemmas().size() << " trail: " << m_card_trail.size() << "\n"; + //std::cout << "zs: " << z << " nzs: " << nz << " lemmas: " << ctx.get_lemmas().size() << " trail: " << m_card_trail.size() << "\n"; return z*10 >= nz; m_occs.reset(); @@ -1671,7 +1554,7 @@ namespace smt { if (v != null_bool_var) { card* c = m_var_infos[v].m_card; clear_watch(*c); - m_var_infos[v].m_card = 0; + m_var_infos[v].m_card = nullptr; dealloc(c); } } @@ -1682,7 +1565,6 @@ namespace smt { void theory_pb::clear_watch(ineq& c) { for (unsigned i = 0; i < c.size(); ++i) { literal w = c.lit(i); - unwatch_var(w.var(), &c); unwatch_literal(w, &c); } c.m_watch_sum.reset(); @@ -1728,7 +1610,7 @@ namespace smt { ctx.push_trail(unwatch_ge(*this, c)); } - void theory_pb::init_watch_var(ineq& c) { + void theory_pb::init_watch_ineq(ineq& c) { c.m_min_sum.reset(); c.m_max_sum.reset(); c.m_nfixed = 0; @@ -1736,7 +1618,6 @@ namespace smt { c.m_max_watch.reset(); c.m_watch_sz = 0; for (unsigned i = 0; i < c.size(); ++i) { - watch_var(c.lit(i).var(), &c); c.m_max_sum += c.ncoeff(i); } } @@ -1774,11 +1655,11 @@ namespace smt { context& ctx = get_context(); TRACE("pb", tout << "#prop:" << c.m_num_propagations << " - " << lits << "\n"; display(tout, c, true);); - justification* js = 0; + justification* js = nullptr; if (proofs_enabled()) { js = alloc(theory_lemma_justification, get_id(), ctx, lits.size(), lits.c_ptr()); } - ctx.mk_clause(lits.size(), lits.c_ptr(), js, CLS_AUX_LEMMA, 0); + ctx.mk_clause(lits.size(), lits.c_ptr(), js, CLS_AUX_LEMMA, nullptr); } @@ -1858,7 +1739,7 @@ namespace smt { k.assert_expr(notB); lbool is_sat = k.check(); validating = false; - std::cout << is_sat << "\n"; + // std::cout << is_sat << "\n"; if (is_sat == l_true) { std::cout << A << "\n"; std::cout << B << "\n"; @@ -1894,11 +1775,11 @@ namespace smt { break; case b_justification::JUSTIFICATION: { justification* j = js.get_justification(); - card_justification* pbj = 0; + card_justification* pbj = nullptr; if (j->get_from_theory() == get_id()) { pbj = dynamic_cast(j); } - if (pbj != 0) { + if (pbj != nullptr) { card& c2 = pbj->get_card(); result = card2expr(c2); } @@ -2129,7 +2010,6 @@ namespace smt { m_coeffs[m_active_vars[i]] /= g; } m_bound = (m_bound + g - 1) / g; - std::cout << "CUT " << g << "\n"; TRACE("pb", display_resolved_lemma(tout << "cut\n");); } } @@ -2151,7 +2031,7 @@ namespace smt { for (unsigned i = 0; i < m_antecedent_exprs.size(); ++i) { expr* a = m_antecedent_exprs[i].get(); if (!ctx.b_internalized(a)) { - std::cout << "not internalized " << mk_pp(a, m) << "\n"; + // std::cout << "not internalized " << mk_pp(a, m) << "\n"; return; } m_antecedents.push_back(~literal(ctx.get_bool_var(a), m_antecedent_signs[i])); @@ -2159,7 +2039,7 @@ namespace smt { for (unsigned i = 0; i < m_cardinality_exprs.size(); ++i) { expr* a = m_cardinality_exprs[i].get(); if (!ctx.b_internalized(a)) { - std::cout << "not internalized " << mk_pp(a, m) << "\n"; + // std::cout << "not internalized " << mk_pp(a, m) << "\n"; return; } if (m_cardinality_signs[i]) { @@ -2170,11 +2050,11 @@ namespace smt { VERIFY(internalize_card(atl, false)); bool_var abv = ctx.get_bool_var(atl); m_antecedents.push_back(literal(abv)); - justification* js = 0; + justification* js = nullptr; if (proofs_enabled()) { - js = 0; // + js = nullptr; } - ctx.mk_clause(m_antecedents.size(), m_antecedents.c_ptr(), js, CLS_AUX_LEMMA, 0); + ctx.mk_clause(m_antecedents.size(), m_antecedents.c_ptr(), js, CLS_AUX_LEMMA, nullptr); } bool theory_pb::resolve_conflict(card& c, literal_vector const& confl) { @@ -2403,7 +2283,7 @@ namespace smt { } #endif SASSERT(validate_antecedents(m_antecedents)); - ctx.assign(alit, ctx.mk_justification(theory_propagation_justification(get_id(), ctx.get_region(), m_antecedents.size(), m_antecedents.c_ptr(), alit, 0, 0))); + ctx.assign(alit, ctx.mk_justification(theory_propagation_justification(get_id(), ctx.get_region(), m_antecedents.size(), m_antecedents.c_ptr(), alit, 0, nullptr))); DEBUG_CODE( m_antecedents.push_back(~alit); @@ -2757,16 +2637,6 @@ namespace smt { display_watch(out, vi, false); display_watch(out, vi, true); } - for (unsigned vi = 0; vi < m_var_infos.size(); ++vi) { - ineq_watch const* w = m_var_infos[vi].m_var_watch; - if (!w) continue; - out << "watch (v): " << literal(vi) << " |-> "; - ineq_watch const& wl = *w; - for (unsigned i = 0; i < wl.size(); ++i) { - out << wl[i]->lit() << " "; - } - out << "\n"; - } for (unsigned vi = 0; vi < m_var_infos.size(); ++vi) { ineq* c = m_var_infos[vi].m_ineq; if (c) { diff --git a/src/smt/theory_pb.h b/src/smt/theory_pb.h index 7e9c55a12..e7b95bf94 100644 --- a/src/smt/theory_pb.h +++ b/src/smt/theory_pb.h @@ -107,7 +107,7 @@ namespace smt { struct ineq { unsynch_mpz_manager& m_mpz; // mpz manager. - literal m_lit; // literal repesenting predicate + literal m_lit; // literal representing predicate bool m_is_eq; // is this an = or >=. arg_t m_args[2]; // encode args[0]*coeffs[0]+...+args[n-1]*coeffs[n-1] >= k(); // Watch the first few positions until the sum satisfies: @@ -192,7 +192,7 @@ namespace smt { // If none are available, then perform unit propagation. // class card { - literal m_lit; // literal repesenting predicate + literal m_lit; // literal representing predicate literal_vector m_args; unsigned m_bound; unsigned m_num_propagations; @@ -252,13 +252,12 @@ namespace smt { struct var_info { ineq_watch* m_lit_watch[2]; - ineq_watch* m_var_watch; ineq* m_ineq; card_watch* m_lit_cwatch[2]; card* m_card; - var_info(): m_var_watch(0), m_ineq(0), m_card(0) + var_info(): m_ineq(nullptr), m_card(nullptr) { m_lit_watch[0] = nullptr; m_lit_watch[1] = nullptr; @@ -269,7 +268,6 @@ namespace smt { void reset() { dealloc(m_lit_watch[0]); dealloc(m_lit_watch[1]); - dealloc(m_var_watch); dealloc(m_ineq); dealloc(m_lit_cwatch[0]); dealloc(m_lit_cwatch[1]); @@ -305,16 +303,13 @@ namespace smt { void add_watch(ineq& c, unsigned index); void del_watch(ineq_watch& watch, unsigned index, ineq& c, unsigned ineq_index); void init_watch_literal(ineq& c); - void init_watch_var(ineq& c); + void init_watch_ineq(ineq& c); void clear_watch(ineq& c); void watch_literal(literal lit, ineq* c); - void watch_var(bool_var v, ineq* c); void unwatch_literal(literal w, ineq* c); - void unwatch_var(bool_var v, ineq* c); void remove(ptr_vector& ineqs, ineq* c); bool assign_watch_ge(bool_var v, bool is_true, ineq_watch& watch, unsigned index); - void assign_watch(bool_var v, bool is_true, ineq& c); void assign_ineq(ineq& c, bool is_true); void assign_eq(ineq& c, bool is_true); diff --git a/src/smt/theory_recfun.cpp b/src/smt/theory_recfun.cpp new file mode 100644 index 000000000..303bf5155 --- /dev/null +++ b/src/smt/theory_recfun.cpp @@ -0,0 +1,452 @@ +/*++ +Copyright (c) 2018 Microsoft Corporation, Simon Cuares + +Module Name: + + theory_recfun.cpp + +Abstract: + + Theory responsible for unrolling recursive functions + +Author: + + Simon Cuares December 2017 + +Revision History: + +--*/ + +#include "util/stats.h" +#include "ast/ast_util.h" +#include "ast/for_each_expr.h" +#include "smt/theory_recfun.h" +#include "smt/params/smt_params_helper.hpp" + + +#define TRACEFN(x) TRACE("recfun", tout << x << '\n';) + +namespace smt { + + theory_recfun::theory_recfun(ast_manager & m) + : theory(m.mk_family_id("recfun")), + m(m), + m_plugin(*reinterpret_cast(m.get_plugin(get_family_id()))), + m_util(m_plugin.u()), + m_preds(m), + m_max_depth(0), + m_q_case_expand(), + m_q_body_expand() + { + } + + theory_recfun::~theory_recfun() { + reset_queues(); + } + + char const * theory_recfun::get_name() const { return "recfun"; } + + theory* theory_recfun::mk_fresh(context* new_ctx) { + return alloc(theory_recfun, new_ctx->get_manager()); + } + + void theory_recfun::init(context* ctx) { + theory::init(ctx); + smt_params_helper p(ctx->get_params()); + m_max_depth = p.recfun_depth(); + if (m_max_depth < 2) m_max_depth = 2; + } + + void theory_recfun::init_search_eh() { + } + + bool theory_recfun::internalize_atom(app * atom, bool gate_ctx) { + TRACEFN(mk_pp(atom, m)); + if (!u().has_defs()) { + return false; + } + for (expr * arg : *atom) { + ctx().internalize(arg, false); + } + if (!ctx().e_internalized(atom)) { + ctx().mk_enode(atom, false, true, false); + } + if (!ctx().b_internalized(atom)) { + bool_var v = ctx().mk_bool_var(atom); + ctx().set_var_theory(v, get_id()); + } + return true; + } + + bool theory_recfun::internalize_term(app * term) { + if (!u().has_defs()) { + return false; + } + for (expr* e : *term) { + ctx().internalize(e, false); + } + // the internalization of the arguments may have triggered the internalization of term. + if (!ctx().e_internalized(term)) { + ctx().mk_enode(term, false, false, true); + } + return true; + } + + void theory_recfun::reset_queues() { + for (auto* e : m_q_case_expand) { + dealloc(e); + } + m_q_case_expand.reset(); + for (auto* e : m_q_body_expand) { + dealloc(e); + } + m_q_body_expand.reset(); + m_q_clauses.clear(); + } + + void theory_recfun::reset_eh() { + reset_queues(); + m_stats.reset(); + theory::reset_eh(); + } + + /* + * when `n` becomes relevant, if it's `f(t1...tn)` with `f` defined, + * then case-expand `n`. If it's a macro we can also immediately + * body-expand it. + */ + void theory_recfun::relevant_eh(app * n) { + SASSERT(ctx().relevancy()); + if (u().is_defined(n) && u().has_defs()) { + TRACEFN("relevant_eh: (defined) " << mk_pp(n, m)); + push_case_expand(alloc(case_expansion, u(), n)); + } + } + + void theory_recfun::push_scope_eh() { + theory::push_scope_eh(); + m_preds_lim.push_back(m_preds.size()); + } + + void theory_recfun::pop_scope_eh(unsigned num_scopes) { + theory::pop_scope_eh(num_scopes); + reset_queues(); + + // restore depth book-keeping + unsigned new_lim = m_preds_lim.size()-num_scopes; +#if 0 + // depth tracking of recursive unfolding is + // turned off when enabling this code: + unsigned start = m_preds_lim[new_lim]; + for (unsigned i = start; i < m_preds.size(); ++i) { + m_pred_depth.remove(m_preds.get(i)); + } + m_preds.resize(start); +#endif + m_preds_lim.shrink(new_lim); + } + + void theory_recfun::restart_eh() { + TRACEFN("restart"); + reset_queues(); + theory::restart_eh(); + } + + bool theory_recfun::can_propagate() { + return ! (m_q_case_expand.empty() && + m_q_body_expand.empty() && + m_q_clauses.empty()); + } + + void theory_recfun::propagate() { + + for (literal_vector & c : m_q_clauses) { + TRACEFN("add axiom " << pp_lits(ctx(), c)); + ctx().mk_th_axiom(get_id(), c); + } + m_q_clauses.clear(); + + for (unsigned i = 0; i < m_q_case_expand.size(); ++i) { + case_expansion* e = m_q_case_expand[i]; + if (e->m_def->is_fun_macro()) { + // body expand immediately + assert_macro_axiom(*e); + } + else { + // case expand + SASSERT(e->m_def->is_fun_defined()); + assert_case_axioms(*e); + } + dealloc(e); + m_q_case_expand[i] = nullptr; + } + m_stats.m_case_expansions += m_q_case_expand.size(); + m_q_case_expand.reset(); + + for (unsigned i = 0; i < m_q_body_expand.size(); ++i) { + assert_body_axiom(*m_q_body_expand[i]); + dealloc(m_q_body_expand[i]); + m_q_body_expand[i] = nullptr; + } + m_stats.m_body_expansions += m_q_body_expand.size(); + m_q_body_expand.reset(); + } + + /** + * make clause `depth_limit => ~guard` + * the guard appears at a depth below the current cutoff. + */ + void theory_recfun::assert_max_depth_limit(expr* guard) { + literal_vector c; + app_ref dlimit = m_util.mk_depth_limit_pred(m_max_depth); + c.push_back(~mk_literal(dlimit)); + c.push_back(~mk_literal(guard)); + TRACEFN("max-depth limit: add clause " << pp_lits(ctx(), c)); + m_q_clauses.push_back(std::move(c)); + } + + /** + * retrieve depth associated with predicate or expression. + */ + unsigned theory_recfun::get_depth(expr* e) { + SASSERT(u().is_defined(e) || u().is_case_pred(e)); + unsigned d = 0; + m_pred_depth.find(e, d); + TRACEFN("depth " << d << " " << mk_pp(e, m)); + return d; + } + + /** + * Update depth of subterms of e with respect to d. + */ + void theory_recfun::set_depth_rec(unsigned d, expr* e) { + struct insert_c { + theory_recfun& th; + unsigned m_depth; + insert_c(theory_recfun& th, unsigned d): th(th), m_depth(d) {} + void operator()(app* e) { th.set_depth(m_depth, e); } + void operator()(quantifier*) {} + void operator()(var*) {} + }; + insert_c proc(*this, d); + for_each_expr(proc, e); + } + + void theory_recfun::set_depth(unsigned depth, expr* e) { + if ((u().is_defined(e) || u().is_case_pred(e)) && !m_pred_depth.contains(e)) { + m_pred_depth.insert(e, depth); + m_preds.push_back(e); + TRACEFN("depth " << depth << " : " << mk_pp(e, m)); + } + } + + /** + * if `is_true` and `v = C_f_i(t1...tn)`, + * then body-expand i-th case of `f(t1...tn)` + */ + void theory_recfun::assign_eh(bool_var v, bool is_true) { + expr* e = ctx().bool_var2expr(v); + if (is_true && u().is_case_pred(e)) { + TRACEFN("assign_case_pred_true " << mk_pp(e, m)); + // body-expand + push_body_expand(alloc(body_expansion, u(), to_app(e))); + } + } + + // replace `vars` by `args` in `e` + expr_ref theory_recfun::apply_args( + unsigned depth, + recfun::vars const & vars, + ptr_vector const & args, + expr * e) { + SASSERT(is_standard_order(vars)); + var_subst subst(m, true); + expr_ref new_body(m); + new_body = subst(e, args.size(), args.c_ptr()); + ctx().get_rewriter()(new_body); // simplify + set_depth_rec(depth + 1, new_body); + return new_body; + } + + literal theory_recfun::mk_literal(expr* e) { + ctx().internalize(e, false); + literal lit = ctx().get_literal(e); + ctx().mark_as_relevant(lit); + return lit; + } + + literal theory_recfun::mk_eq_lit(expr* l, expr* r) { + literal lit; + if (m.is_true(r) || m.is_false(r)) { + std::swap(l, r); + } + if (m.is_true(l)) { + lit = mk_literal(r); + } + else if (m.is_false(l)) { + lit = ~mk_literal(r); + } + else { + lit = mk_eq(l, r, false); + } + ctx().mark_as_relevant(lit); + return lit; + } + + /** + * For functions f(args) that are given as macros f(vs) = rhs + * + * 1. substitute `e.args` for `vs` into the macro rhs + * 2. add unit clause `f(args) = rhs` + */ + void theory_recfun::assert_macro_axiom(case_expansion & e) { + m_stats.m_macro_expansions++; + TRACEFN("case expansion " << pp_case_expansion(e, m) << "\n"); + SASSERT(e.m_def->is_fun_macro()); + auto & vars = e.m_def->get_vars(); + expr_ref lhs(e.m_lhs, m); + unsigned depth = get_depth(e.m_lhs); + expr_ref rhs(apply_args(depth, vars, e.m_args, e.m_def->get_rhs()), m); + literal lit = mk_eq_lit(lhs, rhs); + ctx().mk_th_axiom(get_id(), 1, &lit); + TRACEFN("macro expansion yields " << mk_pp(rhs, m) << "\n" << + "literal " << pp_lit(ctx(), lit)); + } + + /** + * Add case axioms for every case expansion path. + * + * assert `p(args) <=> And(guards)` (with CNF on the fly) + * + * also body-expand paths that do not depend on any defined fun + */ + void theory_recfun::assert_case_axioms(case_expansion & e) { + TRACEFN("assert_case_axioms "<< pp_case_expansion(e,m) + << " with " << e.m_def->get_cases().size() << " cases"); + SASSERT(e.m_def->is_fun_defined()); + // add case-axioms for all case-paths + auto & vars = e.m_def->get_vars(); + literal_vector preds; + for (recfun::case_def const & c : e.m_def->get_cases()) { + // applied predicate to `args` + app_ref pred_applied = c.apply_case_predicate(e.m_args); + + // cut off cases below max-depth + unsigned depth = get_depth(e.m_lhs); + set_depth(depth, pred_applied); + SASSERT(u().owns_app(pred_applied)); + literal concl = mk_literal(pred_applied); + preds.push_back(concl); + + if (c.is_immediate()) { + body_expansion be(pred_applied, c, e.m_args); + assert_body_axiom(be); + } + else if (depth >= m_max_depth) { + assert_max_depth_limit(pred_applied); + continue; + } + + literal_vector guards; + guards.push_back(concl); + for (auto & g : c.get_guards()) { + expr_ref ga = apply_args(depth, vars, e.m_args, g); + literal guard = mk_literal(ga); + guards.push_back(~guard); + literal c[2] = {~concl, guard}; + ctx().mk_th_axiom(get_id(), 2, c); + } + ctx().mk_th_axiom(get_id(), guards); + + } + // the disjunction of branches is asserted + // to close the available cases. + ctx().mk_th_axiom(get_id(), preds); + } + + /** + * For a guarded definition guards => f(vars) = rhs + * and occurrence f(args) + * + * substitute `args` for `vars` in guards, and rhs + * add axiom guards[args/vars] => f(args) = rhs[args/vars] + * + */ + void theory_recfun::assert_body_axiom(body_expansion & e) { + recfun::def & d = *e.m_cdef->get_def(); + auto & vars = d.get_vars(); + auto & args = e.m_args; + SASSERT(is_standard_order(vars)); + unsigned depth = get_depth(e.m_pred); + expr_ref lhs(u().mk_fun_defined(d, args), m); + expr_ref rhs = apply_args(depth, vars, args, e.m_cdef->get_rhs()); + + literal_vector clause; + for (auto & g : e.m_cdef->get_guards()) { + expr_ref guard = apply_args(depth, vars, args, g); + clause.push_back(~mk_literal(guard)); + if (clause.back() == true_literal) { + TRACEFN("body " << pp_body_expansion(e,m) << "\n" << clause << "\n" << guard); + return; + } + if (clause.back() == false_literal) { + clause.pop_back(); + } + } + clause.push_back(mk_eq_lit(lhs, rhs)); + ctx().mk_th_axiom(get_id(), clause); + TRACEFN("body " << pp_body_expansion(e,m)); + TRACEFN(pp_lits(ctx(), clause)); + } + + final_check_status theory_recfun::final_check_eh() { + TRACEFN("final\n"); + if (can_propagate()) { + propagate(); + return FC_CONTINUE; + } + return FC_DONE; + } + + void theory_recfun::add_theory_assumptions(expr_ref_vector & assumptions) { + if (u().has_defs()) { + app_ref dlimit = m_util.mk_depth_limit_pred(m_max_depth); + TRACEFN("add_theory_assumption " << mk_pp(dlimit.get(), m)); + assumptions.push_back(dlimit); + } + } + + // if `dlimit` occurs in unsat core, return 'true' + bool theory_recfun::should_research(expr_ref_vector & unsat_core) { + for (auto & e : unsat_core) { + if (u().is_depth_limit(e)) { + m_max_depth = (3 * m_max_depth) / 2; + IF_VERBOSE(1, verbose_stream() << "(smt.recfun :increase-depth " << m_max_depth << ")\n"); + return true; + } + } + return false; + } + + void theory_recfun::display(std::ostream & out) const { + out << "recfun{}"; + } + + void theory_recfun::collect_statistics(::statistics & st) const { + st.update("recfun macro expansion", m_stats.m_macro_expansions); + st.update("recfun case expansion", m_stats.m_case_expansions); + st.update("recfun body expansion", m_stats.m_body_expansions); + } + + std::ostream& operator<<(std::ostream & out, theory_recfun::pp_case_expansion const & e) { + return out << "case_exp(" << mk_pp(e.e.m_lhs, e.m) << ")"; + } + + std::ostream& operator<<(std::ostream & out, theory_recfun::pp_body_expansion const & e) { + out << "body_exp(" << e.e.m_cdef->get_decl()->get_name(); + for (auto* t : e.e.m_args) { + out << " " << mk_pp(t,e.m); + } + return out << ")"; + } +} diff --git a/src/smt/theory_recfun.h b/src/smt/theory_recfun.h new file mode 100644 index 000000000..c233da059 --- /dev/null +++ b/src/smt/theory_recfun.h @@ -0,0 +1,163 @@ +/*++ +Copyright (c) 2018 Microsoft Corporation + +Module Name: + + theory_recfun.h + +Abstract: + + Theory responsible for unrolling recursive functions + +Author: + + Simon Cuares December 2017 + +Revision History: + +--*/ +#ifndef THEORY_RECFUN_H_ +#define THEORY_RECFUN_H_ + +#include "smt/smt_theory.h" +#include "smt/smt_context.h" +#include "ast/ast_pp.h" +#include "ast/recfun_decl_plugin.h" + +namespace smt { + + class theory_recfun : public theory { + struct stats { + unsigned m_case_expansions, m_body_expansions, m_macro_expansions; + void reset() { memset(this, 0, sizeof(stats)); } + stats() { reset(); } + }; + + // one case-expansion of `f(t1...tn)` + struct case_expansion { + app * m_lhs; // the term to expand + recfun::def * m_def; + ptr_vector m_args; + case_expansion(recfun::util& u, app * n) : + m_lhs(n), m_def(nullptr), m_args() { + SASSERT(u.is_defined(n)); + func_decl * d = n->get_decl(); + m_def = &u.get_def(d); + m_args.append(n->get_num_args(), n->get_args()); + } + case_expansion(case_expansion const & from) + : m_lhs(from.m_lhs), + m_def(from.m_def), + m_args(from.m_args) {} + case_expansion(case_expansion && from) + : m_lhs(from.m_lhs), + m_def(from.m_def), + m_args(std::move(from.m_args)) {} + }; + + struct pp_case_expansion { + case_expansion & e; + ast_manager & m; + pp_case_expansion(case_expansion & e, ast_manager & m) : e(e), m(m) {} + }; + + friend std::ostream& operator<<(std::ostream&, pp_case_expansion const &); + + // one body-expansion of `f(t1...tn)` using a `C_f_i(t1...tn)` + struct body_expansion { + app* m_pred; + recfun::case_def const * m_cdef; + ptr_vector m_args; + + body_expansion(recfun::util& u, app * n) : m_pred(n), m_cdef(nullptr), m_args() { + m_cdef = &u.get_case_def(n); + m_args.append(n->get_num_args(), n->get_args()); + } + body_expansion(app* pred, recfun::case_def const & d, ptr_vector & args) : + m_pred(pred), m_cdef(&d), m_args(args) {} + body_expansion(body_expansion const & from): + m_pred(from.m_pred), m_cdef(from.m_cdef), m_args(from.m_args) {} + body_expansion(body_expansion && from) : + m_pred(from.m_pred), m_cdef(from.m_cdef), m_args(std::move(from.m_args)) {} + }; + + struct pp_body_expansion { + body_expansion & e; + ast_manager & m; + pp_body_expansion(body_expansion & e, ast_manager & m) : e(e), m(m) {} + }; + + friend std::ostream& operator<<(std::ostream&, pp_body_expansion const &); + + ast_manager& m; + recfun::decl::plugin& m_plugin; + recfun::util& m_util; + stats m_stats; + + // book-keeping for depth of predicates + obj_map m_pred_depth; + expr_ref_vector m_preds; + unsigned_vector m_preds_lim; + unsigned m_max_depth; // for fairness and termination + + ptr_vector m_q_case_expand; + ptr_vector m_q_body_expand; + vector m_q_clauses; + + recfun::util & u() const { return m_util; } + bool is_defined(app * f) const { return u().is_defined(f); } + bool is_case_pred(app * f) const { return u().is_case_pred(f); } + + bool is_defined(enode * e) const { return is_defined(e->get_owner()); } + bool is_case_pred(enode * e) const { return is_case_pred(e->get_owner()); } + + void reset_queues(); + expr_ref apply_args(unsigned depth, recfun::vars const & vars, ptr_vector const & args, expr * e); //!< substitute variables by args + void assert_macro_axiom(case_expansion & e); + void assert_case_axioms(case_expansion & e); + void assert_body_axiom(body_expansion & e); + literal mk_literal(expr* e); + + void assert_max_depth_limit(expr* guard); + unsigned get_depth(expr* e); + void set_depth(unsigned d, expr* e); + void set_depth_rec(unsigned d, expr* e); + + literal mk_eq_lit(expr* l, expr* r); + bool is_standard_order(recfun::vars const& vars) const { + return vars.empty() || vars[vars.size()-1]->get_idx() == 0; + } + protected: + void push_case_expand(case_expansion* e) { m_q_case_expand.push_back(e); } + void push_body_expand(body_expansion* e) { m_q_body_expand.push_back(e); } + + bool internalize_atom(app * atom, bool gate_ctx) override; + bool internalize_term(app * term) override; + void reset_eh() override; + void relevant_eh(app * n) override; + char const * get_name() const override; + final_check_status final_check_eh() override; + void assign_eh(bool_var v, bool is_true) override; + void push_scope_eh() override; + void pop_scope_eh(unsigned num_scopes) override; + void restart_eh() override; + bool can_propagate() override; + void propagate() override; + bool should_research(expr_ref_vector &) override; + + void new_eq_eh(theory_var v1, theory_var v2) override {} + void new_diseq_eh(theory_var v1, theory_var v2) override {} + void add_theory_assumptions(expr_ref_vector & assumptions) override; + void init(context* ctx) override; + + public: + theory_recfun(ast_manager & m); + ~theory_recfun() override; + theory * mk_fresh(context * new_ctx) override; + void init_search_eh() override; + void display(std::ostream & out) const override; + void collect_statistics(::statistics & st) const override; + }; +} + +#endif diff --git a/src/smt/theory_seq.cpp b/src/smt/theory_seq.cpp index b00c1565c..283bd4e57 100644 --- a/src/smt/theory_seq.cpp +++ b/src/smt/theory_seq.cpp @@ -51,6 +51,7 @@ public: m_kernel.assert_expr(e); lbool r = m_kernel.check(); m_kernel.pop(1); + IF_VERBOSE(11, verbose_stream() << "is " << r << " " << mk_pp(e, m_kernel.m()) << "\n"); return r; } }; @@ -208,23 +209,25 @@ theory_seq::theory_seq(ast_manager& m, theory_seq_params const & params): m_axioms(m), m_axioms_head(0), m_int_string(m), + m_length(m), m_mg(nullptr), m_rewrite(m), m_seq_rewrite(m), m_util(m), m_autil(m), + m_arith_value(m), m_trail_stack(*this), m_ls(m), m_rs(m), m_lhs(m), m_rhs(m), m_res(m), - m_atoms_qhead(0), + m_max_unfolding_depth(1), + m_max_unfolding_lit(null_literal), m_new_solution(false), m_new_propagation(false), m_mk_aut(m) { m_prefix = "seq.p.suffix"; m_suffix = "seq.s.prefix"; m_accept = "aut.accept"; - m_reject = "aut.reject"; m_tail = "seq.tail"; m_nth = "seq.nth"; m_seq_first = "seq.first"; @@ -245,8 +248,12 @@ theory_seq::~theory_seq() { void theory_seq::init(context* ctx) { theory::init(ctx); + m_arith_value.init(ctx); } +#define TRACEFIN(s) { TRACE("seq", tout << ">>" << s << "\n";); IF_VERBOSE(10, verbose_stream() << s << "\n"); } + + final_check_status theory_seq::final_check_eh() { if (m_reset_cache) { m_rep.reset_cache(); @@ -257,84 +264,74 @@ final_check_status theory_seq::final_check_eh() { TRACE("seq_verbose", get_context().display(tout);); if (simplify_and_solve_eqs()) { ++m_stats.m_solve_eqs; - TRACE("seq", tout << ">>solve_eqs\n";); + TRACEFIN("solve_eqs"); return FC_CONTINUE; } if (check_contains()) { ++m_stats.m_propagate_contains; - TRACE("seq", tout << ">>propagate_contains\n";); + TRACEFIN("propagate_contains"); return FC_CONTINUE; } if (solve_nqs(0)) { ++m_stats.m_solve_nqs; - TRACE("seq", tout << ">>solve_nqs\n";); + TRACEFIN("solve_nqs"); return FC_CONTINUE; } if (fixed_length(true)) { ++m_stats.m_fixed_length; - TRACE("seq", tout << ">>zero_length\n";); + TRACEFIN("zero_length"); return FC_CONTINUE; } if (m_params.m_split_w_len && len_based_split()) { ++m_stats.m_branch_variable; - TRACE("seq", tout << ">>split_based_on_length\n";); + TRACEFIN("split_based_on_length"); return FC_CONTINUE; } if (fixed_length()) { ++m_stats.m_fixed_length; - TRACE("seq", tout << ">>fixed_length\n";); + TRACEFIN("fixed_length"); return FC_CONTINUE; } if (check_int_string()) { ++m_stats.m_int_string; - TRACE("seq", tout << ">>int_string\n";); + TRACEFIN("int_string"); return FC_CONTINUE; } if (reduce_length_eq()) { ++m_stats.m_branch_variable; - TRACE("seq", tout << ">>reduce length\n";); + TRACEFIN("reduce_length"); return FC_CONTINUE; } if (branch_unit_variable()) { ++m_stats.m_branch_variable; - TRACE("seq", tout << ">>branch_unit_variable\n";); + TRACEFIN("ranch_unit_variable"); return FC_CONTINUE; } if (branch_binary_variable()) { ++m_stats.m_branch_variable; - TRACE("seq", tout << ">>branch_binary_variable\n";); + TRACEFIN("branch_binary_variable"); return FC_CONTINUE; } - if (branch_ternary_variable1() || branch_ternary_variable2() || branch_quat_variable()) { + if (branch_variable()) { ++m_stats.m_branch_variable; - TRACE("seq", tout << ">>split_based_on_alignment\n";); - return FC_CONTINUE; - } - if (branch_variable_mb() || branch_variable()) { - ++m_stats.m_branch_variable; - TRACE("seq", tout << ">>branch_variable\n";); + TRACEFIN("branch_variable"); return FC_CONTINUE; } if (check_length_coherence()) { ++m_stats.m_check_length_coherence; - TRACE("seq", tout << ">>check_length_coherence\n";); + TRACEFIN("check_length_coherence"); return FC_CONTINUE; } if (!check_extensionality()) { ++m_stats.m_extensionality; - TRACE("seq", tout << ">>extensionality\n";); - return FC_CONTINUE; - } - if (propagate_automata()) { - ++m_stats.m_propagate_automata; - TRACE("seq", tout << ">>propagate_automata\n";); + TRACEFIN("extensionality"); return FC_CONTINUE; } if (is_solved()) { - TRACE("seq", tout << ">>is_solved\n";); + TRACEFIN("is_solved"); return FC_DONE; } - TRACE("seq", tout << ">>give_up\n";); + TRACEFIN("give_up"); return FC_GIVEUP; } @@ -385,20 +382,20 @@ bool theory_seq::branch_binary_variable(eq const& e) { rational lenX, lenY; context& ctx = get_context(); - if (branch_variable(e)) { + if (branch_variable_eq(e)) { return true; } if (!get_length(x, lenX)) { - enforce_length(ensure_enode(x)); + enforce_length(x); return true; } if (!get_length(y, lenY)) { - enforce_length(ensure_enode(y)); + enforce_length(y); return true; } if (lenX + rational(xs.size()) != lenY + rational(ys.size())) { // |x| - |y| = |ys| - |xs| - expr_ref a(mk_sub(m_util.str.mk_length(x), m_util.str.mk_length(y)), m); + expr_ref a(mk_sub(mk_len(x), mk_len(y)), m); expr_ref b(m_autil.mk_int(ys.size()-xs.size()), m); propagate_lit(e.dep(), 0, nullptr, mk_eq(a, b, false)); return true; @@ -409,7 +406,7 @@ bool theory_seq::branch_binary_variable(eq const& e) { branch_unit_variable(e.dep(), x, Ys); return true; } - expr_ref le(m_autil.mk_le(m_util.str.mk_length(x), m_autil.mk_int(ys.size())), m); + expr_ref le(m_autil.mk_le(mk_len(x), m_autil.mk_int(ys.size())), m); literal lit = mk_literal(le); if (l_false == ctx.get_assignment(lit)) { // |x| > |ys| => x = ys ++ y1, y = y1 ++ y2, y2 = xs @@ -455,6 +452,9 @@ bool theory_seq::is_unit_eq(expr_ref_vector const& ls, expr_ref_vector const& rs if (ls.empty() || !is_var(ls[0])) { return false; } + //std::function is_unit = [&](expr* elem) { return m_util.str.is_unit(elem); } + //return rs.forall(is_unit); + for (auto const& elem : rs) { if (!m_util.str.is_unit(elem)) { return false; @@ -469,11 +469,11 @@ void theory_seq::branch_unit_variable(dependency* dep, expr* X, expr_ref_vector rational lenX; if (!get_length(X, lenX)) { TRACE("seq", tout << "enforce length on " << mk_pp(X, m) << "\n";); - enforce_length(ensure_enode(X)); + enforce_length(X); return; } if (lenX > rational(units.size())) { - expr_ref le(m_autil.mk_le(m_util.str.mk_length(X), m_autil.mk_int(units.size())), m); + expr_ref le(m_autil.mk_le(mk_len(X), m_autil.mk_int(units.size())), m); TRACE("seq", tout << "propagate length on " << mk_pp(X, m) << "\n";); propagate_lit(dep, 0, nullptr, mk_literal(le)); return; @@ -485,7 +485,7 @@ void theory_seq::branch_unit_variable(dependency* dep, expr* X, expr_ref_vector set_empty(X); } else { - literal lit = mk_eq(m_autil.mk_int(lX), m_util.str.mk_length(X), false); + literal lit = mk_eq(m_autil.mk_int(lX), mk_len(X), false); if (l_true == ctx.get_assignment(lit)) { expr_ref R(m_util.str.mk_concat(lX, units.c_ptr()), m); propagate_eq(dep, lit, X, R); @@ -500,7 +500,9 @@ void theory_seq::branch_unit_variable(dependency* dep, expr* X, expr_ref_vector } bool theory_seq::branch_ternary_variable1() { - for (auto const& e : m_eqs) { + int start = get_context().get_random_value(); + for (unsigned i = 0; i < m_eqs.size(); ++i) { + eq const& e = m_eqs[(i + start) % m_eqs.size()]; if (branch_ternary_variable(e) || branch_ternary_variable2(e)) { return true; } @@ -509,7 +511,9 @@ bool theory_seq::branch_ternary_variable1() { } bool theory_seq::branch_ternary_variable2() { - for (auto const& e : m_eqs) { + int start = get_context().get_random_value(); + for (unsigned i = 0; i < m_eqs.size(); ++i) { + eq const& e = m_eqs[(i + start) % m_eqs.size()]; if (branch_ternary_variable(e, true)) { return true; } @@ -591,7 +595,7 @@ bool theory_seq::branch_ternary_variable_base( else { xs2E = m_util.str.mk_empty(m.get_sort(x)); } - literal lit1 = mk_literal(m_autil.mk_le(m_util.str.mk_length(y2), m_autil.mk_int(xs.size()-ind))); + literal lit1 = mk_literal(m_autil.mk_le(mk_len(y2), m_autil.mk_int(xs.size()-ind))); if (ctx.get_assignment(lit1) == l_undef) { TRACE("seq", tout << "base case init\n";); ctx.mark_as_relevant(lit1); @@ -642,13 +646,13 @@ bool theory_seq::branch_ternary_variable(eq const& e, bool flag1) { rational lenX, lenY1, lenY2; context& ctx = get_context(); if (!get_length(x, lenX)) { - enforce_length(ensure_enode(x)); + enforce_length(x); } if (!get_length(y1, lenY1)) { - enforce_length(ensure_enode(y1)); + enforce_length(y1); } if (!get_length(y2, lenY2)) { - enforce_length(ensure_enode(y2)); + enforce_length(y2); } SASSERT(!xs.empty() && !ys.empty()); @@ -672,7 +676,7 @@ bool theory_seq::branch_ternary_variable(eq const& e, bool flag1) { propagate_eq(dep, lits, y2, ZxsE, true); } else { - expr_ref ge(m_autil.mk_ge(m_util.str.mk_length(y2), m_autil.mk_int(xs.size())), m); + expr_ref ge(m_autil.mk_ge(mk_len(y2), m_autil.mk_int(xs.size())), m); literal lit2 = mk_literal(ge); if (ctx.get_assignment(lit2) == l_undef) { TRACE("seq", tout << "rec case init\n";); @@ -707,7 +711,7 @@ bool theory_seq::branch_ternary_variable_base2(dependency* dep, unsigned_vector else { xs1E = m_util.str.mk_empty(m.get_sort(x)); } - literal lit1 = mk_literal(m_autil.mk_le(m_util.str.mk_length(y1), m_autil.mk_int(ind))); + literal lit1 = mk_literal(m_autil.mk_le(mk_len(y1), m_autil.mk_int(ind))); if (ctx.get_assignment(lit1) == l_undef) { TRACE("seq", tout << "base case init\n";); ctx.mark_as_relevant(lit1); @@ -758,13 +762,13 @@ bool theory_seq::branch_ternary_variable2(eq const& e, bool flag1) { rational lenX, lenY1, lenY2; context& ctx = get_context(); if (!get_length(x, lenX)) { - enforce_length(ensure_enode(x)); + enforce_length(x); } if (!get_length(y1, lenY1)) { - enforce_length(ensure_enode(y1)); + enforce_length(y1); } if (!get_length(y2, lenY2)) { - enforce_length(ensure_enode(y2)); + enforce_length(y2); } SASSERT(!xs.empty() && !ys.empty()); unsigned_vector indexes = overlap2(xs, ys); @@ -787,7 +791,7 @@ bool theory_seq::branch_ternary_variable2(eq const& e, bool flag1) { propagate_eq(dep, lits, y1, xsZ, true); } else { - expr_ref ge(m_autil.mk_ge(m_util.str.mk_length(y1), m_autil.mk_int(xs.size())), m); + expr_ref ge(m_autil.mk_ge(mk_len(y1), m_autil.mk_int(xs.size())), m); literal lit2 = mk_literal(ge); if (ctx.get_assignment(lit2) == l_undef) { TRACE("seq", tout << "rec case init\n";); @@ -832,16 +836,16 @@ bool theory_seq::branch_quat_variable(eq const& e) { rational lenX1, lenX2, lenY1, lenY2; context& ctx = get_context(); if (!get_length(x1_l, lenX1)) { - enforce_length(ensure_enode(x1_l)); + enforce_length(x1_l); } if (!get_length(y1_l, lenY1)) { - enforce_length(ensure_enode(y1_l)); + enforce_length(y1_l); } if (!get_length(x2, lenX2)) { - enforce_length(ensure_enode(x2)); + enforce_length(x2); } if (!get_length(y2, lenY2)) { - enforce_length(ensure_enode(y2)); + enforce_length(y2); } SASSERT(!xs.empty() && !ys.empty()); @@ -851,7 +855,7 @@ bool theory_seq::branch_quat_variable(eq const& e) { expr_ref ysy2 = mk_concat(ys); expr_ref x1(x1_l, m); expr_ref y1(y1_l, m); - expr_ref sub(mk_sub(m_util.str.mk_length(x1_l), m_util.str.mk_length(y1_l)), m); + expr_ref sub(mk_sub(mk_len(x1_l), mk_len(y1_l)), m); expr_ref le(m_autil.mk_le(sub, m_autil.mk_int(0)), m); literal lit2 = mk_literal(le); if (ctx.get_assignment(lit2) == l_undef) { @@ -896,8 +900,8 @@ void theory_seq::len_offset(expr* e, rational val) { if (m_autil.is_add(e, l1, l2) && m_autil.is_mul(l2, l21, l22) && m_autil.is_numeral(l21, fact) && fact.is_minus_one()) { if (ctx.e_internalized(l1) && ctx.e_internalized(l22)) { - enode* r1 = ctx.get_enode(l1)->get_root(), *n1 = r1; - enode* r2 = ctx.get_enode(l22)->get_root(), *n2 = r2; + enode* r1 = get_root(l1), *n1 = r1; + enode* r2 = get_root(l22), *n2 = r2; expr *e1 = nullptr, *e2 = nullptr; do { if (m_util.str.is_length(n1->get_owner(), e1)) @@ -952,7 +956,7 @@ int theory_seq::find_fst_non_empty_idx(expr_ref_vector const& xs) const { for (unsigned i = 0; i < xs.size(); ++i) { expr* x = xs[i]; if (!is_var(x)) return -1; - expr_ref e(m_util.str.mk_length(x), m); + expr_ref e = mk_len(x); if (ctx.e_internalized(e)) { enode* root = ctx.get_enode(e)->get_root(); rational val; @@ -993,8 +997,9 @@ void theory_seq::find_max_eq_len(expr_ref_vector const& ls, expr_ref_vector cons hi = 1; } else { - lower_bound(ls.get(j), lo); - upper_bound(ls.get(j), hi); + expr_ref len_s = mk_len(ls.get(j)); + lower_bound(len_s, lo); + upper_bound(len_s, hi); } if (!lo.is_minus_one()) { if (lo1.is_minus_one()) @@ -1011,7 +1016,7 @@ void theory_seq::find_max_eq_len(expr_ref_vector const& ls, expr_ref_vector cons else { hi1 = rational(-2); } - len1 = mk_add(len1, m_util.str.mk_length(ls.get(j))); + len1 = mk_add(len1, mk_len(ls.get(j))); j++; } j = 2 + r_fst; @@ -1026,8 +1031,9 @@ void theory_seq::find_max_eq_len(expr_ref_vector const& ls, expr_ref_vector cons hi = 1; } else { - lower_bound(rs.get(j), lo); - upper_bound(rs.get(j), hi); + expr_ref len_s = mk_len(rs.get(j)); + lower_bound(len_s, lo); + upper_bound(len_s, hi); } if (!lo.is_minus_one()) { if (lo2.is_minus_one()) @@ -1044,7 +1050,7 @@ void theory_seq::find_max_eq_len(expr_ref_vector const& ls, expr_ref_vector cons else { hi2 = rational(-2); } - len2 = mk_add(len2, m_util.str.mk_length(rs.get(j))); + len2 = mk_add(len2, mk_len(rs.get(j))); j++; } if (m_autil.is_numeral(len1) && m_autil.is_numeral(len2)) @@ -1089,74 +1095,54 @@ bool theory_seq::find_better_rep(expr_ref_vector const& ls, expr_ref_vector cons expr* l_fst = find_fst_non_empty_var(ls); expr* r_fst = find_fst_non_empty_var(rs); if (!r_fst) return false; - expr_ref len_r_fst(m_util.str.mk_length(r_fst), m); + expr_ref len_r_fst = mk_len(r_fst); + expr_ref len_l_fst(m); enode * root2; - if (!ctx.e_internalized(len_r_fst)) + if (!ctx.e_internalized(len_r_fst)) { return false; - else - root2 = ctx.get_enode(len_r_fst)->get_root(); + } + if (l_fst) { + len_l_fst = mk_len(l_fst); + } + + root2 = get_root(len_r_fst); // Offset = 0, No change - if (l_fst) { - expr_ref len_l_fst(m_util.str.mk_length(l_fst), m); - if (ctx.e_internalized(len_l_fst)) { - enode * root1 = ctx.get_enode(len_l_fst)->get_root(); - if (root1 == root2) { - TRACE("seq", tout << "(" << mk_pp(l_fst, m) << ", " << mk_pp(r_fst,m) << ")\n";); - return false; - } - } + if (l_fst && get_root(len_l_fst) == root2) { + TRACE("seq", tout << "(" << mk_pp(l_fst, m) << ", " << mk_pp(r_fst,m) << ")\n";); + return false; } // Offset = 0, Changed - { - for (unsigned i = 0; i < idx; ++i) { - eq const& e = m_eqs[i]; - if (e.ls().size() == ls.size()) { - bool flag = true; - for (unsigned j = 0; j < ls.size(); ++j) - if (e.ls().get(j) != ls.get(j)) { - flag = false; - break; - } - if (flag) { - expr* nl_fst = 0; - if (e.rs().size()>1 && is_var(e.rs().get(0))) - nl_fst = e.rs().get(0); - if (nl_fst && nl_fst != r_fst) { - expr_ref len_nl_fst(m_util.str.mk_length(nl_fst), m); - if (ctx.e_internalized(len_nl_fst)) { - enode * root1 = ctx.get_enode(len_nl_fst)->get_root(); - if (root1 == root2) { - res.reset(); - res.append(e.rs().size(), e.rs().c_ptr()); - deps = m_dm.mk_join(e.dep(), deps); - return true; - } - } - } - } - } + + for (unsigned i = 0; i < idx; ++i) { + eq const& e = m_eqs[i]; + if (e.ls() != ls) continue; + expr* nl_fst = nullptr; + if (e.rs().size() > 1 && is_var(e.rs().get(0))) + nl_fst = e.rs().get(0); + if (nl_fst && nl_fst != r_fst && root2 == get_root(mk_len(nl_fst))) { + res.reset(); + res.append(e.rs().size(), e.rs().c_ptr()); + deps = m_dm.mk_join(e.dep(), deps); + return true; } } // Offset != 0, No change - if (l_fst) { - expr_ref len_l_fst(m_util.str.mk_length(l_fst), m); - if (ctx.e_internalized(len_l_fst)) { - enode * root1 = ctx.get_enode(len_l_fst)->get_root(); - obj_map tmp; - int offset; - if (!m_autil.is_numeral(root1->get_owner()) && !m_autil.is_numeral(root2->get_owner())) { - if (m_len_offset.find(root1, tmp) && tmp.find(root2, offset)) { - TRACE("seq", tout << "(" << mk_pp(l_fst, m) << ", " << mk_pp(r_fst,m) << ")\n";); - find_max_eq_len(ls, rs); - return false; - } - else if (m_len_offset.find(root2, tmp) && tmp.find(root1, offset)) { - TRACE("seq", tout << "(" << mk_pp(r_fst, m) << ", " << mk_pp(l_fst,m) << ")\n";); - find_max_eq_len(ls ,rs); - return false; - } + if (l_fst && ctx.e_internalized(len_l_fst)) { + enode * root1 = get_root(len_l_fst); + obj_map tmp; + int offset; + if (!m_autil.is_numeral(root1->get_owner()) && !m_autil.is_numeral(root2->get_owner())) { + if (m_len_offset.find(root1, tmp) && tmp.find(root2, offset)) { + TRACE("seq", tout << "(" << mk_pp(l_fst, m) << ", " << mk_pp(r_fst,m) << ")\n";); + find_max_eq_len(ls, rs); + return false; + } + else if (m_len_offset.find(root2, tmp) && tmp.find(root1, offset)) { + TRACE("seq", tout << "(" << mk_pp(r_fst, m) << ", " << mk_pp(l_fst,m) << ")\n";); + find_max_eq_len(ls ,rs); + return false; } } } @@ -1165,30 +1151,21 @@ bool theory_seq::find_better_rep(expr_ref_vector const& ls, expr_ref_vector cons if (!m_autil.is_numeral(root2->get_owner()) && m_len_offset.find(root2, tmp)) { for (unsigned i = 0; i < idx; ++i) { eq const& e = m_eqs[i]; - if (e.ls().size() == ls.size()) { - bool flag = true; - for (unsigned j = 0; j < ls.size(); ++j) - if (e.ls().get(j) != ls.get(j)) { - flag = false; - break; - } - if (flag) { - expr* nl_fst = 0; - if (e.rs().size()>1 && is_var(e.rs().get(0))) - nl_fst = e.rs().get(0); - if (nl_fst && nl_fst != r_fst) { - int offset; - expr_ref len_nl_fst(m_util.str.mk_length(nl_fst), m); - if (ctx.e_internalized(len_nl_fst)) { - enode * root1 = ctx.get_enode(len_nl_fst)->get_root(); - if (!m_autil.is_numeral(root1->get_owner()) && tmp.find(root1, offset)) { - res.reset(); - res.append(e.rs().size(), e.rs().c_ptr()); - deps = m_dm.mk_join(e.dep(), deps); - find_max_eq_len(res, rs); - return true; - } - } + if (e.ls() != ls) continue; + expr* nl_fst = nullptr; + if (e.rs().size()>1 && is_var(e.rs().get(0))) + nl_fst = e.rs().get(0); + if (nl_fst && nl_fst != r_fst) { + int offset; + expr_ref len_nl_fst = mk_len(nl_fst); + if (ctx.e_internalized(len_nl_fst)) { + enode * root1 = ctx.get_enode(len_nl_fst)->get_root(); + if (!m_autil.is_numeral(root1->get_owner()) && tmp.find(root1, offset)) { + res.reset(); + res.append(e.rs().size(), e.rs().c_ptr()); + deps = m_dm.mk_join(e.dep(), deps); + find_max_eq_len(res, rs); + return true; } } } @@ -1200,40 +1177,41 @@ bool theory_seq::find_better_rep(expr_ref_vector const& ls, expr_ref_vector cons bool theory_seq::has_len_offset(expr_ref_vector const& ls, expr_ref_vector const& rs, int & offset) { context& ctx = get_context(); - if (ls.size() == 0 || rs.size() == 0) + if (ls.empty() || rs.empty()) return false; expr* l_fst = ls[0]; expr* r_fst = rs[0]; if (!is_var(l_fst) || !is_var(r_fst)) return false; - expr_ref len_r_fst(m_util.str.mk_length(r_fst), m); - enode * root2; + expr_ref len_l_fst = mk_len(l_fst); + if (!ctx.e_internalized(len_l_fst)) + return false; + enode * root1 = ctx.get_enode(len_l_fst)->get_root(); + + expr_ref len_r_fst = mk_len(r_fst); if (!ctx.e_internalized(len_r_fst)) return false; - else - root2 = ctx.get_enode(len_r_fst)->get_root(); + enode* root2 = ctx.get_enode(len_r_fst)->get_root(); - expr_ref len_l_fst(m_util.str.mk_length(l_fst), m); - if (ctx.e_internalized(len_l_fst)) { - enode * root1 = ctx.get_enode(len_l_fst)->get_root(); - if (root1 == root2) { - TRACE("seq", tout << "(" << mk_pp(l_fst, m) << ", " << mk_pp(r_fst,m) << ")\n";); - offset = 0; - return true; - } - obj_map tmp; - if (!m_autil.is_numeral(root1->get_owner()) && !m_autil.is_numeral(root2->get_owner())) { - if (m_len_offset.find(root1, tmp) && tmp.find(root2, offset)) { - TRACE("seq", tout << "(" << mk_pp(l_fst, m) << ", " << mk_pp(r_fst,m) << ")\n";); - return true; - } - else if (m_len_offset.find(root2, tmp) && tmp.find(root1, offset)) { - offset = -offset; - TRACE("seq", tout << "(" << mk_pp(r_fst, m) << ", " << mk_pp(l_fst,m) << ")\n";); - return true; - } - } + if (root1 == root2) { + TRACE("seq", tout << "(" << mk_pp(l_fst, m) << ", " << mk_pp(r_fst,m) << ")\n";); + offset = 0; + return true; + } + + if (m_autil.is_numeral(root1->get_owner()) || m_autil.is_numeral(root2->get_owner())) + return false; + + obj_map tmp; + if (m_len_offset.find(root1, tmp) && tmp.find(root2, offset)) { + TRACE("seq", tout << "(" << mk_pp(l_fst, m) << ", " << mk_pp(r_fst,m) << ")\n";); + return true; + } + if (m_len_offset.find(root2, tmp) && tmp.find(root1, offset)) { + offset = -offset; + TRACE("seq", tout << "(" << mk_pp(r_fst, m) << ", " << mk_pp(l_fst,m) << ")\n";); + return true; } return false; } @@ -1285,12 +1263,12 @@ bool theory_seq::len_based_split(eq const& e) { expr_ref y11(m_util.str.mk_concat(1, rs.c_ptr()), m); expr_ref y12(m_util.str.mk_concat(rs.size()-1, rs.c_ptr()+1), m); - expr_ref lenX11(m_util.str.mk_length(x11),m); + expr_ref lenX11 = mk_len(x11); expr_ref lenY11(m); expr_ref Z(m); int offset = 0; if (offset_orig != 0) { - lenY11 = m_autil.mk_add(m_util.str.mk_length(y11), m_autil.mk_int(offset_orig)); + lenY11 = m_autil.mk_add(mk_len(y11), m_autil.mk_int(offset_orig)); if (offset_orig > 0) { offset = offset_orig; Z = mk_skolem(m_seq_align, y12, x12, x11, y11); @@ -1304,31 +1282,33 @@ bool theory_seq::len_based_split(eq const& e) { y12 = mk_concat(Z, y12); } } - else { - lenY11 = m_util.str.mk_length(y11); - } + else { + lenY11 = mk_len(y11); + } dependency* dep = e.dep(); literal_vector lits; literal lit1 = mk_eq(lenX11, lenY11, false); - if (ctx.get_assignment(lit1) != l_true) { - return false; - } + if (ctx.get_assignment(lit1) != l_true) { + return false; + } lits.push_back(lit1); if (ls.size() >= 2 && rs.size() >= 2 && (ls.size() > 2 || rs.size() > 2)) { expr_ref len1(m_autil.mk_int(0),m), len2(m_autil.mk_int(0),m); - for (unsigned i = 2; i < ls.size(); ++i) - len1 = mk_add(len1, m_util.str.mk_length(ls[i])); - for (unsigned i = 2; i < rs.size(); ++i) - len2 = mk_add(len2, m_util.str.mk_length(rs[i])); - literal lit2; + for (unsigned i = 2; i < ls.size(); ++i) { + len1 = mk_add(len1, mk_len(ls[i])); + } + for (unsigned i = 2; i < rs.size(); ++i) { + len2 = mk_add(len2, mk_len(rs[i])); + } + literal lit2; if (!m_autil.is_numeral(len1) && !m_autil.is_numeral(len2)) { lit2 = mk_eq(len1, len2, false); } else { expr_ref eq_len(m.mk_eq(len1, len2), m); - lit2 = mk_literal(eq_len); + lit2 = mk_literal(eq_len); } if (ctx.get_assignment(lit2) == l_true) { @@ -1349,7 +1329,7 @@ bool theory_seq::len_based_split(eq const& e) { } if (offset != 0) { - expr_ref lenZ(m_util.str.mk_length(Z), m); + expr_ref lenZ = mk_len(Z); propagate_eq(dep, lits, lenZ, m_autil.mk_int(offset), false); } propagate_eq(dep, lits, y11, x11, true); @@ -1358,6 +1338,20 @@ bool theory_seq::len_based_split(eq const& e) { return true; } +/** + \brief select branching on variable equality. + preference mb > eq > ternary > quat + this performs much better on #1628 +*/ +bool theory_seq::branch_variable() { + if (branch_variable_mb()) return true; + if (branch_variable_eq()) return true; + if (branch_ternary_variable1()) return true; + if (branch_ternary_variable2()) return true; + if (branch_quat_variable()) return true; + return false; +} + bool theory_seq::branch_variable_mb() { bool change = false; for (auto const& e : m_eqs) { @@ -1375,13 +1369,13 @@ bool theory_seq::branch_variable_mb() { continue; } rational l1, l2; - for (auto elem : len1) l1 += elem; - for (auto elem : len2) l2 += elem; + for (const auto& elem : len1) l1 += elem; + for (const auto& elem : len2) l2 += elem; if (l1 != l2) { TRACE("seq", tout << "lengths are not compatible\n";); expr_ref l = mk_concat(e.ls()); expr_ref r = mk_concat(e.rs()); - expr_ref lnl(m_util.str.mk_length(l), m), lnr(m_util.str.mk_length(r), m); + expr_ref lnl = mk_len(l), lnr = mk_len(r); propagate_eq(e.dep(), lnl, lnr, false); change = true; continue; @@ -1412,7 +1406,7 @@ bool theory_seq::is_complex(eq const& e) { \brief Decompose ls = rs into Xa = bYc, such that 1. - X != Y - - |b| <= |X| <= |bY| in currrent model + - |b| <= |X| <= |bY| in current model - b is non-empty. 2. X != Y - b is empty @@ -1471,9 +1465,9 @@ bool theory_seq::split_lengths(dependency* dep, // |b| < |X| <= |b| + |Y| => x = bY1, Y = Y1Y2 - expr_ref lenXE(m_util.str.mk_length(X), m); - expr_ref lenYE(m_util.str.mk_length(Y), m); - expr_ref lenb(m_util.str.mk_length(b), m); + expr_ref lenXE = mk_len(X); + expr_ref lenYE = mk_len(Y); + expr_ref lenb = mk_len(b); expr_ref le1(m_autil.mk_le(mk_sub(lenXE, lenb), m_autil.mk_int(0)), m); expr_ref le2(m_autil.mk_le(mk_sub(mk_sub(lenXE, lenb), lenYE), m_autil.mk_int(0)), m); @@ -1507,7 +1501,7 @@ bool theory_seq::split_lengths(dependency* dep, } bool theory_seq::set_empty(expr* x) { - add_axiom(~mk_eq(m_autil.mk_int(0), m_util.str.mk_length(x), false), mk_eq_empty(x)); + add_axiom(~mk_eq(m_autil.mk_int(0), mk_len(x), false), mk_eq_empty(x)); return true; } @@ -1515,8 +1509,7 @@ bool theory_seq::enforce_length(expr_ref_vector const& es, vector & le bool all_have_length = true; rational val; zstring s; - for (unsigned i = 0; i < es.size(); ++i) { - expr* e = es[i]; + for (expr* e : es) { if (m_util.str.is_unit(e)) { len.push_back(rational(1)); } @@ -1530,14 +1523,14 @@ bool theory_seq::enforce_length(expr_ref_vector const& es, vector & le len.push_back(val); } else { - enforce_length(ensure_enode(e)); + enforce_length(e); all_have_length = false; } } return all_have_length; } -bool theory_seq::branch_variable() { +bool theory_seq::branch_variable_eq() { context& ctx = get_context(); unsigned sz = m_eqs.size(); int start = ctx.get_random_value(); @@ -1546,24 +1539,15 @@ bool theory_seq::branch_variable() { unsigned k = (i + start) % sz; eq const& e = m_eqs[k]; - if (branch_variable(e)) { + if (branch_variable_eq(e)) { TRACE("seq", tout << "branch variable\n";); return true; } - -#if 0 - if (!has_length(e.ls())) { - enforce_length(ensure_enode(e.ls())); - } - if (!has_length(e.rs())) { - enforce_length(ensure_enode(e.rs())); - } -#endif } return ctx.inconsistent(); } -bool theory_seq::branch_variable(eq const& e) { +bool theory_seq::branch_variable_eq(eq const& e) { unsigned id = e.id(); unsigned s = find_branch_start(2*id); TRACE("seq", tout << s << " " << id << ": " << e.ls() << " = " << e.rs() << "\n";); @@ -1677,10 +1661,8 @@ bool theory_seq::find_branch_candidate(unsigned& start, dependency* dep, expr_re TRACE("seq", tout << "start: " << start << "\n"; for (literal lit : lits) { - ctx.display_literal_verbose(tout << lit << ": ", lit); - tout << "\n"; - ctx.display(tout, ctx.get_justification(lit.var())); - tout << "\n"; + ctx.display_literal_verbose(tout << lit << ": ", lit) << "\n"; + ctx.display(tout, ctx.get_justification(lit.var())); tout << "\n"; }); return true; } @@ -1760,7 +1742,7 @@ bool theory_seq::propagate_length_coherence(expr* e) { } TRACE("seq", tout << "Unsolved " << mk_pp(e, m); if (!lower_bound2(e, lo)) lo = -rational::one(); - if (!upper_bound(e, hi)) hi = -rational::one(); + if (!upper_bound(mk_len(e), hi)) hi = -rational::one(); tout << " lo: " << lo << " hi: " << hi << "\n"; ); @@ -1776,16 +1758,17 @@ bool theory_seq::propagate_length_coherence(expr* e) { elems.push_back(seq); tail = mk_concat(elems.size(), elems.c_ptr()); // len(e) >= low => e = tail; - literal low(mk_literal(m_autil.mk_ge(m_util.str.mk_length(e), m_autil.mk_numeral(lo, true)))); + literal low(mk_literal(m_autil.mk_ge(mk_len(e), m_autil.mk_numeral(lo, true)))); add_axiom(~low, mk_seq_eq(e, tail)); - if (upper_bound(e, hi)) { + expr_ref len_e = mk_len(e); + if (upper_bound(len_e, hi)) { // len(e) <= hi => len(tail) <= hi - lo - expr_ref high1(m_autil.mk_le(m_util.str.mk_length(e), m_autil.mk_numeral(hi, true)), m); + expr_ref high1(m_autil.mk_le(len_e, m_autil.mk_numeral(hi, true)), m); if (hi == lo) { add_axiom(~mk_literal(high1), mk_seq_eq(seq, emp)); } else { - expr_ref high2(m_autil.mk_le(m_util.str.mk_length(seq), m_autil.mk_numeral(hi-lo, true)), m); + expr_ref high2(m_autil.mk_le(mk_len(seq), m_autil.mk_numeral(hi-lo, true)), m); add_axiom(~mk_literal(high1), mk_literal(high2)); } } @@ -1830,13 +1813,17 @@ bool theory_seq::check_length_coherence0(expr* e) { bool theory_seq::check_length_coherence() { #if 1 - for (auto e : m_length) { + for (expr* l : m_length) { + expr* e = nullptr; + VERIFY(m_util.str.is_length(l, e)); if (check_length_coherence0(e)) { return true; } } #endif - for (auto e : m_length) { + for (expr* l : m_length) { + expr* e = nullptr; + VERIFY(m_util.str.is_length(l, e)); if (check_length_coherence(e)) { return true; } @@ -1854,10 +1841,12 @@ bool theory_seq::fixed_length(bool is_zero) { return found; } -bool theory_seq::fixed_length(expr* e, bool is_zero) { +bool theory_seq::fixed_length(expr* len_e, bool is_zero) { rational lo, hi; - if (!(is_var(e) && lower_bound(e, lo) && upper_bound(e, hi) && lo == hi - && ((is_zero && lo.is_zero()) || (!is_zero && lo.is_unsigned())))) { + expr* e = nullptr; + VERIFY(m_util.str.is_length(len_e, e)); + if (!(is_var(e) && lower_bound(len_e, lo) && upper_bound(len_e, hi) && lo == hi + && ((is_zero && lo.is_zero()) || (!is_zero && lo.is_unsigned())))) { return false; } if (is_skolem(m_tail, e) || is_skolem(m_seq_first, e) || @@ -1889,9 +1878,9 @@ bool theory_seq::fixed_length(expr* e, bool is_zero) { seq = mk_concat(elems.size(), elems.c_ptr()); } TRACE("seq", tout << "Fixed: " << mk_pp(e, m) << " " << lo << "\n";); - add_axiom(~mk_eq(m_util.str.mk_length(e), m_autil.mk_numeral(lo, true), false), mk_seq_eq(seq, e)); + add_axiom(~mk_eq(len_e, m_autil.mk_numeral(lo, true), false), mk_seq_eq(seq, e)); if (!ctx.at_base_level()) { - m_trail_stack.push(push_replay(alloc(replay_fixed_length, m, e))); + m_trail_stack.push(push_replay(alloc(replay_fixed_length, m, len_e))); } return true; } @@ -1926,7 +1915,8 @@ bool theory_seq::is_unit_nth(expr* e) const { } bool theory_seq::is_nth(expr* e) const { - return is_skolem(m_nth, e); + return m_util.str.is_nth(e); +// return is_skolem(m_nth, e); } bool theory_seq::is_nth(expr* e, expr*& e1, expr*& e2) const { @@ -1964,9 +1954,7 @@ bool theory_seq::is_post(expr* e, expr*& s, expr*& i) { expr_ref theory_seq::mk_nth(expr* s, expr* idx) { - sort* char_sort = nullptr; - VERIFY(m_util.is_seq(m.get_sort(s), char_sort)); - return mk_skolem(m_nth, s, idx, nullptr, nullptr, char_sort); + return expr_ref(m_util.str.mk_nth(s, idx), m); } expr_ref theory_seq::mk_sk_ite(expr* c, expr* t, expr* e) { @@ -1995,6 +1983,7 @@ expr_ref theory_seq::mk_first(expr* s) { void theory_seq::mk_decompose(expr* e, expr_ref& head, expr_ref& tail) { expr* e1 = nullptr, *e2 = nullptr; zstring s; + rational r; if (m_util.str.is_empty(e)) { head = m_util.str.mk_unit(mk_nth(e, m_autil.mk_int(0))); tail = e; @@ -2011,11 +2000,9 @@ void theory_seq::mk_decompose(expr* e, expr_ref& head, expr_ref& tail) { head = e1; tail = e2; } - else if (is_skolem(m_tail, e)) { - rational r; + else if (is_skolem(m_tail, e) && m_autil.is_numeral(to_app(e)->get_arg(1), r)) { app* a = to_app(e); - expr* s = a->get_arg(0); - VERIFY (m_autil.is_numeral(a->get_arg(1), r)); + expr* s = a->get_arg(0); expr* idx = m_autil.mk_int(r.get_unsigned() + 1); head = m_util.str.mk_unit(mk_nth(s, idx)); tail = mk_skolem(m_tail, s, idx); @@ -2166,9 +2153,9 @@ void theory_seq::propagate_lit(dependency* dep, unsigned n, literal const* _lits if (!linearize(dep, eqs, lits)) return; TRACE("seq", - tout << "assert:"; - ctx.display_detailed_literal(tout, lit); - tout << " <- "; ctx.display_literals_verbose(tout, lits); + tout << "scope: " << ctx.get_scope_level() << "\n"; + ctx.display_detailed_literal(tout << "assert:", lit); + ctx.display_literals_verbose(tout << " <- ", lits); if (!lits.empty()) tout << "\n"; display_deps(tout, dep);); justification* js = ctx.mk_justification( @@ -2235,10 +2222,10 @@ void theory_seq::enforce_length_coherence(enode* n1, enode* n2) { return; } if (has_length(o1) && !has_length(o2)) { - enforce_length(n2); + enforce_length(o2); } else if (has_length(o2) && !has_length(o1)) { - enforce_length(n1); + enforce_length(o1); } } @@ -2292,6 +2279,42 @@ bool theory_seq::simplify_eq(expr_ref_vector& ls, expr_ref_vector& rs, dependenc return true; } +bool theory_seq::solve_itos(expr_ref_vector const& ls, expr_ref_vector const& rs, dependency* dep) { + expr* e = nullptr; + if (ls.size() == 1 && rs.empty() && m_util.str.is_itos(ls[0], e)) { + literal lit = mk_simplified_literal(m_autil.mk_le(e, m_autil.mk_int(-1))); + propagate_lit(dep, 0, nullptr, lit); + return true; + } + if (rs.size() == 1 && ls.empty() && m_util.str.is_itos(rs[0], e)) { + literal lit = mk_simplified_literal(m_autil.mk_le(e, m_autil.mk_int(-1))); + propagate_lit(dep, 0, nullptr, lit); + return true; + } + return false; +} + +bool theory_seq::solve_nth_eq(expr_ref_vector const& ls, expr_ref_vector const& rs, dependency* dep) { + if (ls.size() != 1 || rs.size() <= 1) { + return false; + } + expr* l = ls.get(0); + rational val; + if (!get_length(l, val) || val != rational(rs.size())) { + return false; + } + for (unsigned i = 0; i < rs.size(); ++i) { + unsigned k = 0; + expr* ru = nullptr, *r = nullptr; + if (m_util.str.is_unit(rs.get(i), ru) && m_util.str.is_nth(ru, r, k) && k == i && r == l) { + continue; + } + return false; + } + add_solution(l, mk_concat(rs, m.get_sort(l)), dep); + return true; +} + bool theory_seq::solve_unit_eq(expr_ref_vector const& l, expr_ref_vector const& r, dependency* deps) { if (l.size() == 1 && is_var(l[0]) && !occurs(l[0], r) && add_solution(l[0], mk_concat(r, m.get_sort(l[0])), deps)) { return true; @@ -2446,6 +2469,15 @@ bool theory_seq::solve_eq(expr_ref_vector const& l, expr_ref_vector const& r, de TRACE("seq", tout << "binary\n";); return true; } + if (!ctx.inconsistent() && solve_nth_eq(ls, rs, deps)) { + return true; + } + if (!ctx.inconsistent() && solve_nth_eq(rs, ls, deps)) { + return true; + } + if (!ctx.inconsistent() && solve_itos(rs, ls, deps)) { + return true; + } if (!ctx.inconsistent() && change) { // The propagation step from arithmetic state (e.g. length offset) to length constraints if (get_context().get_scope_level() == 0) { @@ -2481,7 +2513,7 @@ bool theory_seq::propagate_max_length(expr* l, expr* r, dependency* deps) { } rational hi; if (is_tail(l, s, idx) && has_length(s) && m_util.str.is_empty(r) && !upper_bound(s, hi)) { - propagate_lit(deps, 0, nullptr, mk_literal(m_autil.mk_le(m_util.str.mk_length(s), m_autil.mk_int(idx+1)))); + propagate_lit(deps, 0, nullptr, mk_literal(m_autil.mk_le(mk_len(s), m_autil.mk_int(idx+1)))); return true; } return false; @@ -2725,8 +2757,8 @@ bool theory_seq::reduce_length(unsigned i, unsigned j, bool front, expr_ref_vect SASSERT(0 < r1 && r1 < rs.size()); expr_ref l = mk_concat(l1, ls1); expr_ref r = mk_concat(r1, rs1); - expr_ref lenl(m_util.str.mk_length(l), m); - expr_ref lenr(m_util.str.mk_length(r), m); + expr_ref lenl = mk_len(l); + expr_ref lenr = mk_len(r); literal lit = mk_eq(lenl, lenr, false); if (ctx.get_assignment(lit) == l_true) { // expr_ref len_eq(m.mk_eq(lenl, lenr), m); @@ -2814,7 +2846,7 @@ bool theory_seq::get_length(expr* e, expr_ref& len, literal_vector& lits) { if (m_util.str.is_extract(e, s, i, l)) { // 0 <= i <= len(s), 0 <= l, i + l <= len(s) expr_ref zero(m_autil.mk_int(0), m); - expr_ref ls(m_util.str.mk_length(s), m); + expr_ref ls = mk_len(s); expr_ref ls_minus_i_l(mk_sub(mk_sub(ls, i),l), m); bool i_is_zero = m_autil.is_numeral(i, r) && r.is_zero(); literal i_ge_0 = i_is_zero?true_literal:mk_simplified_literal(m_autil.mk_ge(i, zero)); @@ -2838,7 +2870,7 @@ bool theory_seq::get_length(expr* e, expr_ref& len, literal_vector& lits) { expr_ref zero(m_autil.mk_int(0), m); bool i_is_zero = m_autil.is_numeral(i, r) && r.is_zero(); literal i_ge_0 = i_is_zero?true_literal:mk_simplified_literal(m_autil.mk_ge(i, zero)); - literal i_lt_len_s = ~mk_simplified_literal(m_autil.mk_ge(mk_sub(i, m_util.str.mk_length(s)), zero)); + literal i_lt_len_s = ~mk_simplified_literal(m_autil.mk_ge(mk_sub(i, mk_len(s)), zero)); literal _lits[2] = { i_ge_0, i_lt_len_s}; if (ctx.get_assignment(i_ge_0) == l_true && ctx.get_assignment(i_lt_len_s) == l_true) { @@ -2852,7 +2884,7 @@ bool theory_seq::get_length(expr* e, expr_ref& len, literal_vector& lits) { expr_ref zero(m_autil.mk_int(0), m); bool i_is_zero = m_autil.is_numeral(i, r) && r.is_zero(); literal i_ge_0 = i_is_zero?true_literal:mk_simplified_literal(m_autil.mk_ge(i, zero)); - literal i_lt_len_s = ~mk_simplified_literal(m_autil.mk_ge(mk_sub(i, m_util.str.mk_length(s)), zero)); + literal i_lt_len_s = ~mk_simplified_literal(m_autil.mk_ge(mk_sub(i, mk_len(s)), zero)); literal _lits[2] = { i_ge_0, i_lt_len_s }; if (ctx.get_assignment(i_ge_0) == l_true && ctx.get_assignment(i_lt_len_s) == l_true) { @@ -2865,7 +2897,7 @@ bool theory_seq::get_length(expr* e, expr_ref& len, literal_vector& lits) { else if (is_post(e, s, l)) { expr_ref zero(m_autil.mk_int(0), m); literal l_ge_0 = mk_simplified_literal(m_autil.mk_ge(l, zero)); - literal l_le_len_s = mk_simplified_literal(m_autil.mk_ge(mk_sub(m_util.str.mk_length(s), l), zero)); + literal l_le_len_s = mk_simplified_literal(m_autil.mk_ge(mk_sub(mk_len(s), l), zero)); literal _lits[2] = { l_ge_0, l_le_len_s }; if (ctx.get_assignment(l_ge_0) == l_true && ctx.get_assignment(l_le_len_s) == l_true) { @@ -2875,6 +2907,17 @@ bool theory_seq::get_length(expr* e, expr_ref& len, literal_vector& lits) { } TRACE("seq", ctx.display_literals_verbose(tout, 2, _lits); tout << "\n";); } + else if (is_skolem(m_tail, e)) { + s = to_app(e)->get_arg(0); + l = to_app(e)->get_arg(1); + expr_ref len_s = mk_len(s); + literal len_s_ge_l = mk_simplified_literal(m_autil.mk_ge(mk_sub(len_s, l), m_autil.mk_int(0))); + if (ctx.get_assignment(len_s_ge_l) == l_true) { + len = mk_sub(len_s, l); + lits.push_back(len_s_ge_l); + return true; + } + } else if (m_util.str.is_unit(e)) { len = m_autil.mk_int(1); return true; @@ -3059,41 +3102,73 @@ bool theory_seq::solve_ne(unsigned idx) { bool theory_seq::solve_nc(unsigned idx) { nc const& n = m_ncs[idx]; - dependency* deps = n.deps(); + literal len_gt = n.len_gt(); + context& ctx = get_context(); expr_ref c = canonize(n.contains(), deps); + expr* a = nullptr, *b = nullptr; CTRACE("seq", c != n.contains(), tout << n.contains() << " => " << c << "\n";); + if (m.is_true(c)) { literal_vector lits; set_conflict(deps, lits); return true; } + if (m.is_false(c)) { return true; } - if (c != n.contains()) { - m_ncs.push_back(nc(c, deps)); - m_new_propagation = true; + + if (ctx.get_assignment(len_gt) == l_true) { + TRACE("seq", tout << len_gt << " is true\n";); return true; } - expr* e1 = nullptr, *e2 = nullptr; - if (m.is_eq(c, e1, e2)) { - literal eq = mk_eq(e1, e2, false); + if (m.is_eq(c, a, b)) { + literal eq = mk_eq(a, b, false); propagate_lit(deps, 0, nullptr, ~eq); return true; } if (m.is_or(c)) { - for (unsigned i = 0; i < to_app(c)->get_num_args(); ++i) { - expr_ref ci(to_app(c)->get_arg(i), m); - m_ncs.push_back(nc(ci, deps)); + for (expr* arg : *to_app(c)) { + expr_ref ci(arg, m); + m_ncs.push_back(nc(ci, len_gt, deps)); } m_new_propagation = true; return true; } + + if (m.is_and(c)) { + enode_pair_vector eqs; + literal_vector lits; + if (!linearize(deps, eqs, lits)) { + return false; + } + for (enode_pair const& p : eqs) { + lits.push_back(~mk_eq(p.first->get_owner(), p.second->get_owner(), false)); + } + for (expr* arg : *to_app(c)) { + if (m.is_eq(arg, a, b)) { + lits.push_back(~mk_eq(a, b, false)); + } + else { + lits.push_back(~mk_literal(arg)); + } + } + TRACE("seq", ctx.display_literals_verbose(tout, lits.size(), lits.c_ptr()) << "\n";); + ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr()); + return true; + } + + if (c != n.contains()) { + m_ncs.push_back(nc(c, len_gt, deps)); + m_new_propagation = true; + return true; + } + return false; } @@ -3279,7 +3354,6 @@ bool theory_seq::internalize_term(app* term) { mk_var(e); return true; } - TRACE("seq_verbose", tout << mk_pp(term, m) << "\n";); for (auto arg : *term) { mk_var(ensure_enode(arg)); } @@ -3300,24 +3374,29 @@ bool theory_seq::internalize_term(app* term) { return true; } -void theory_seq::add_length(expr* e) { - SASSERT(!has_length(e)); - m_length.insert(e); - m_trail_stack.push(insert_obj_trail(m_length, e)); +void theory_seq::add_length(expr* l) { + expr* e = nullptr; + VERIFY(m_util.str.is_length(l, e)); + SASSERT(!m_length.contains(l)); + m_length.push_back(l); + m_has_length.insert(e); + m_trail_stack.push(insert_obj_trail(m_has_length, e)); + m_trail_stack.push(push_back_vector(m_length)); } /* ensure that all elements in equivalence class occur under an application of 'length' */ -void theory_seq::enforce_length(enode* n) { +void theory_seq::enforce_length(expr* e) { + enode* n = ensure_enode(e); enode* n1 = n; do { expr* o = n->get_owner(); if (!has_length(o)) { - expr_ref len(m_util.str.mk_length(o), m); + expr_ref len = mk_len(o); enque_axiom(len); - add_length(o); + add_length(len); } n = n->get_next(); } @@ -3333,17 +3412,21 @@ void theory_seq::add_int_string(expr* e) { bool theory_seq::check_int_string() { bool change = false; for (expr * e : m_int_string) { - expr* n = nullptr; - if (m_util.str.is_itos(e) && add_itos_val_axiom(e)) { - change = true; - } - else if (m_util.str.is_stoi(e, n) && add_stoi_val_axiom(e)) { + if (check_int_string(e)) { change = true; } } return change; } +bool theory_seq::check_int_string(expr* e) { + return + get_context().inconsistent() || + (m_util.str.is_itos(e) && add_itos_val_axiom(e)) || + (m_util.str.is_stoi(e) && add_stoi_val_axiom(e)); +} + + void theory_seq::add_stoi_axiom(expr* e) { TRACE("seq", tout << mk_pp(e, m) << "\n";); expr* s = nullptr; @@ -3352,101 +3435,9 @@ void theory_seq::add_stoi_axiom(expr* e) { // stoi(s) >= -1 literal l = mk_simplified_literal(m_autil.mk_ge(e, m_autil.mk_int(-1))); add_axiom(l); - - // stoi(s) >= 0 <=> s in (0-9)+ - expr_ref num_re(m); - num_re = m_util.re.mk_range(m_util.str.mk_string(symbol("0")), m_util.str.mk_string(symbol("9"))); - num_re = m_util.re.mk_plus(num_re); - app_ref in_re(m_util.re.mk_in_re(s, num_re), m); - literal ge0 = mk_simplified_literal(m_autil.mk_ge(e, m_autil.mk_int(0))); - add_axiom(~ge0, mk_literal(in_re)); - add_axiom(ge0, ~mk_literal(in_re)); -} -bool theory_seq::add_stoi_val_axiom(expr* e) { - context& ctx = get_context(); - expr* n = nullptr; - rational val; - TRACE("seq", tout << mk_pp(e, m) << "\n";); - VERIFY(m_util.str.is_stoi(e, n)); - if (!get_num_value(e, val)) { - return false; - } - if (!m_stoi_axioms.contains(val)) { - m_stoi_axioms.insert(val); - if (!val.is_minus_one()) { - app_ref e1(m_util.str.mk_string(symbol(val.to_string().c_str())), m); - expr_ref n1(arith_util(m).mk_numeral(val, true), m); - literal eq1 = mk_eq(e, n1, false); - literal eq2 = mk_eq(n, e1, false); - add_axiom(~eq1, eq2); - add_axiom(~eq2, eq1); - ctx.force_phase(eq1); - ctx.force_phase(eq2); - m_trail_stack.push(insert_map(m_stoi_axioms, val)); - m_trail_stack.push(push_replay(alloc(replay_axiom, m, e))); - return true; - } - } - if (upper_bound(n, val) && get_length(n, val) && val.is_pos() && !m_stoi_axioms.contains(val)) { - zstring s; - SASSERT(val.is_unsigned()); - unsigned sz = val.get_unsigned(); - expr_ref len1(m), len2(m), ith_char(m), num(m), coeff(m); - expr_ref_vector nums(m); - len1 = m_util.str.mk_length(n); - len2 = m_autil.mk_int(sz); - literal lit = mk_eq(len1, len2, false); - literal_vector lits; - lits.push_back(~lit); - for (unsigned i = 0; i < sz; ++i) { - ith_char = mk_nth(n, m_autil.mk_int(i)); - lits.push_back(~is_digit(ith_char)); - nums.push_back(digit2int(ith_char)); - } - rational c(1); - for (unsigned i = sz; i-- > 0; c *= rational(10)) { - coeff = m_autil.mk_numeral(c, true); - nums[i] = m_autil.mk_mul(coeff, nums[i].get()); - } - num = m_autil.mk_add(nums.size(), nums.c_ptr()); - ctx.get_rewriter()(num); - lits.push_back(mk_eq(e, num, false)); - ++m_stats.m_add_axiom; - m_new_propagation = true; - for (literal lit : lits) { - ctx.mark_as_relevant(lit); - } - TRACE("seq", ctx.display_literals_verbose(tout, lits); tout << "\n";); - ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr()); - m_stoi_axioms.insert(val); - m_trail_stack.push(insert_map(m_stoi_axioms, val)); - m_trail_stack.push(push_replay(alloc(replay_axiom, m, e))); - return true; - } - - return false; -} - -literal theory_seq::is_digit(expr* ch) { - bv_util bv(m); - literal isd = mk_literal(mk_skolem(symbol("seq.is_digit"), ch, nullptr, nullptr, nullptr, m.mk_bool_sort())); - expr_ref d2i = digit2int(ch); - expr_ref _lo(bv.mk_ule(bv.mk_numeral(rational('0'), bv.mk_sort(8)), ch), m); - expr_ref _hi(bv.mk_ule(ch, bv.mk_numeral(rational('9'), bv.mk_sort(8))), m); - literal lo = mk_literal(_lo); - literal hi = mk_literal(_hi); - add_axiom(~lo, ~hi, isd); - add_axiom(~isd, lo); - add_axiom(~isd, hi); - for (unsigned i = 0; i < 10; ++i) { - add_axiom(~mk_eq(ch, bv.mk_numeral(rational('0'+i), bv.mk_sort(8)), false), mk_eq(d2i, m_autil.mk_int(i), false)); - } - return isd; -} - -expr_ref theory_seq::digit2int(expr* ch) { - return expr_ref(mk_skolem(symbol("seq.digit2int"), ch, nullptr, nullptr, nullptr, m_autil.mk_int()), m); + // stoi("") = -1 + add_axiom(mk_eq(m_util.str.mk_stoi(m_util.str.mk_empty(m.get_sort(s))), m_autil.mk_int(-1), false)); } void theory_seq::add_itos_axiom(expr* e) { @@ -3456,9 +3447,8 @@ void theory_seq::add_itos_axiom(expr* e) { VERIFY(m_util.str.is_itos(e, n)); // itos(n) = "" <=> n < 0 - app_ref e1(m_util.str.mk_empty(m.get_sort(e)), m); - expr_ref zero(arith_util(m).mk_int(0), m); - literal eq1 = mk_eq(e1, e, false); + expr_ref zero(m_autil.mk_int(0), m); + literal eq1 = mk_literal(m_util.str.mk_is_empty(e)); literal ge0 = mk_literal(m_autil.mk_ge(n, zero)); // n >= 0 => itos(n) != "" // itos(n) = "" or n >= 0 @@ -3467,61 +3457,159 @@ void theory_seq::add_itos_axiom(expr* e) { // n >= 0 => stoi(itos(n)) = n app_ref stoi(m_util.str.mk_stoi(e), m); - add_axiom(~ge0, mk_eq(stoi, n, false)); + add_axiom(~ge0, mk_preferred_eq(stoi, n)); - // n >= 0 => itos(n) in (0-9)+ - expr_ref num_re(m); - num_re = m_util.re.mk_range(m_util.str.mk_string(symbol("0")), m_util.str.mk_string(symbol("9"))); - num_re = m_util.re.mk_plus(num_re); - app_ref in_re(m_util.re.mk_in_re(e, num_re), m); - add_axiom(~ge0, mk_literal(in_re)); +} + + +void theory_seq::ensure_digit_axiom() { + + if (m_si_axioms.empty()) { + for (unsigned i = 0; i < 10; ++i) { + expr_ref cnst(m_util.mk_char('0'+i), m); + add_axiom(mk_eq(digit2int(cnst), m_autil.mk_int(i), false)); + } + } } bool theory_seq::add_itos_val_axiom(expr* e) { - context& ctx = get_context(); - rational val; + rational val, val2; expr* n = nullptr; TRACE("seq", tout << mk_pp(e, m) << "\n";); VERIFY(m_util.str.is_itos(e, n)); - bool change = false; - if (get_num_value(n, val) && !val.is_neg() && !m_itos_axioms.contains(val)) { - m_itos_axioms.insert(val); - app_ref e1(m_util.str.mk_string(symbol(val.to_string().c_str())), m); - expr_ref n1(arith_util(m).mk_numeral(val, true), m); - - // itos(n) = "25" <=> n = 25 - literal eq1 = mk_eq(n1, n , false); - literal eq2 = mk_eq(e, e1, false); - add_axiom(~eq1, eq2); - add_axiom(~eq2, eq1); - ctx.force_phase(eq1); - ctx.force_phase(eq2); - - m_trail_stack.push(insert_map(m_itos_axioms, val)); - m_trail_stack.push(push_replay(alloc(replay_axiom, m, e))); - change = true; + if (m_util.str.is_stoi(n)) { + return false; } - return change; + enforce_length(e); + + if (get_length(e, val) && val.is_pos() && val.is_unsigned() && (!m_si_axioms.find(e, val2) || val != val2)) { + add_si_axiom(e, n, val.get_unsigned()); + m_si_axioms.insert(e, val); + m_trail_stack.push(push_replay(alloc(replay_is_axiom, m, e))); + m_trail_stack.push(insert_map, expr*>(m_si_axioms, e)); + return true; + } + + return false; } +bool theory_seq::add_stoi_val_axiom(expr* e) { + context& ctx = get_context(); + expr* n = nullptr; + rational val, val2; + VERIFY(m_util.str.is_stoi(e, n)); + + TRACE("seq", tout << mk_pp(e, m) << " " << ctx.get_scope_level () << " " << get_length(n, val) << " " << val << "\n";); + + if (m_util.str.is_itos(n)) { + return false; + } + enforce_length(n); + + if (get_length(n, val) && val.is_pos() && val.is_unsigned() && (!m_si_axioms.find(e, val2) || val2 != val)) { + add_si_axiom(n, e, val.get_unsigned()); + m_si_axioms.insert(e, val); + m_trail_stack.push(push_replay(alloc(replay_is_axiom, m, e))); + m_trail_stack.push(insert_map, expr*>(m_si_axioms, e)); + return true; + } + + return false; +} + +literal theory_seq::is_digit(expr* ch) { + literal isd = mk_literal(mk_skolem(symbol("seq.is_digit"), ch, nullptr, nullptr, nullptr, m.mk_bool_sort())); + expr_ref d2i = digit2int(ch); + expr_ref _lo(m_util.mk_le(m_util.mk_char('0'), ch), m); + expr_ref _hi(m_util.mk_le(ch, m_util.mk_char('9')), m); + literal lo = mk_literal(_lo); + literal hi = mk_literal(_hi); + add_axiom(~lo, ~hi, isd); + add_axiom(~isd, lo); + add_axiom(~isd, hi); + return isd; +} + +expr_ref theory_seq::digit2int(expr* ch) { + return expr_ref(mk_skolem(symbol("seq.digit2int"), ch, nullptr, nullptr, nullptr, m_autil.mk_int()), m); +} + + + +// n >= 0 & len(e) = k => is_digit(e_i) for i = 0..k-1 +// n >= 0 & len(e) = k => n = sum 10^i*digit(e_i) +// n < 0 & len(e) = k => \/_i ~is_digit(e_i) for i = 0..k-1 +// 10^k <= n < 10^{k+1}-1 => len(e) = k + +void theory_seq::add_si_axiom(expr* e, expr* n, unsigned k) { + context& ctx = get_context(); + zstring s; + expr_ref ith_char(m), num(m), coeff(m); + expr_ref_vector nums(m), chars(m); + expr_ref len = mk_len(e); + literal len_eq_k = mk_preferred_eq(len, m_autil.mk_int(k)); + literal ge0 = mk_literal(m_autil.mk_ge(n, m_autil.mk_int(0))); + literal_vector digits; + digits.push_back(~len_eq_k); + digits.push_back(ge0); + ensure_digit_axiom(); + for (unsigned i = 0; i < k; ++i) { + ith_char = mk_nth(e, m_autil.mk_int(i)); + literal isd = is_digit(ith_char); + add_axiom(~len_eq_k, ~ge0, isd); + chars.push_back(m_util.str.mk_unit(ith_char)); + nums.push_back(digit2int(ith_char)); + } + ++m_stats.m_add_axiom; + ctx.mk_th_axiom(get_id(), digits.size(), digits.c_ptr()); + rational c(1); + for (unsigned i = k; i-- > 0; c *= rational(10)) { + coeff = m_autil.mk_int(c); + nums[i] = m_autil.mk_mul(coeff, nums.get(i)); + } + num = m_autil.mk_add(nums.size(), nums.c_ptr()); + ctx.get_rewriter()(num); + m_new_propagation = true; + add_axiom(~len_eq_k, ~ge0, mk_preferred_eq(n, num)); + + add_axiom(~len_eq_k, ~ge0, mk_preferred_eq(e, m_util.str.mk_concat(chars))); + + SASSERT(k > 0); + rational lb = power(rational(10), k - 1); + rational ub = power(rational(10), k) - 1; + arith_util& a = m_autil; + literal lbl = mk_literal(a.mk_ge(n, a.mk_int(lb))); + literal ubl = mk_literal(a.mk_le(n, a.mk_int(ub))); + literal ge_k = mk_literal(a.mk_ge(len, a.mk_int(k))); + literal le_k = mk_literal(a.mk_le(len, a.mk_int(k))); + // n >= lb => len(s) >= k + // n >= 0 & len(s) >= k => n >= lb + // 0 <= n <= ub => len(s) <= k + add_axiom(~lbl, ge_k); + add_axiom(~ge0, lbl, ~ge_k); + add_axiom(~ge0, ~ubl, le_k); +} + + + void theory_seq::apply_sort_cnstr(enode* n, sort* s) { mk_var(n); } void theory_seq::display(std::ostream & out) const { - if (m_eqs.size() == 0 && - m_nqs.size() == 0 && + if (m_eqs.empty() && + m_nqs.empty() && m_rep.empty() && m_exclude.empty()) { return; } out << "Theory seq\n"; - if (m_eqs.size() > 0) { + if (!m_eqs.empty()) { out << "Equations:\n"; display_equations(out); } - if (m_nqs.size() > 0) { + if (!m_nqs.empty()) { display_disequations(out); } if (!m_re2aut.empty()) { @@ -3543,56 +3631,57 @@ void theory_seq::display(std::ostream & out) const { m_exclude.display(out); } - if (!m_length.empty()) { - for (auto e : m_length) { - rational lo(-1), hi(-1); - lower_bound(e, lo); - upper_bound(e, hi); - if (lo.is_pos() || !hi.is_minus_one()) { - out << mk_pp(e, m) << " [" << lo << ":" << hi << "]\n"; - } + for (auto e : m_length) { + rational lo(-1), hi(-1); + lower_bound(e, lo); + upper_bound(e, hi); + if (lo.is_pos() || !hi.is_minus_one()) { + out << mk_pp(e, m) << " [" << lo << ":" << hi << "]\n"; } } if (!m_ncs.empty()) { out << "Non contains:\n"; - for (unsigned i = 0; i < m_ncs.size(); ++i) { - display_nc(out, m_ncs[i]); + for (auto const& nc : m_ncs) { + display_nc(out, nc); } } } -void theory_seq::display_nc(std::ostream& out, nc const& nc) const { +std::ostream& theory_seq::display_nc(std::ostream& out, nc const& nc) const { out << "not " << mk_pp(nc.contains(), m) << "\n"; - display_deps(out << " <- ", nc.deps()); out << "\n"; + display_deps(out << " <- ", nc.deps()) << "\n"; + return out; } -void theory_seq::display_equations(std::ostream& out) const { +std::ostream& theory_seq::display_equations(std::ostream& out) const { for (auto const& e : m_eqs) { display_equation(out, e); } + return out; } -void theory_seq::display_equation(std::ostream& out, eq const& e) const { +std::ostream& theory_seq::display_equation(std::ostream& out, eq const& e) const { out << e.ls() << " = " << e.rs() << " <- \n"; - display_deps(out, e.dep()); + return display_deps(out, e.dep()); } -void theory_seq::display_disequations(std::ostream& out) const { +std::ostream& theory_seq::display_disequations(std::ostream& out) const { bool first = true; for (ne const& n : m_nqs) { if (first) out << "Disequations:\n"; first = false; display_disequation(out, n); } + return out; } -void theory_seq::display_disequation(std::ostream& out, ne const& e) const { +std::ostream& theory_seq::display_disequation(std::ostream& out, ne const& e) const { for (literal lit : e.lits()) { out << lit << " "; } - if (e.lits().size() > 0) { + if (!e.lits().empty()) { out << "\n"; } for (unsigned j = 0; j < e.ls().size(); ++j) { @@ -3601,21 +3690,21 @@ void theory_seq::display_disequation(std::ostream& out, ne const& e) const { if (e.dep()) { display_deps(out, e.dep()); } + return out; } -void theory_seq::display_deps(std::ostream& out, literal_vector const& lits, enode_pair_vector const& eqs) const { +std::ostream& theory_seq::display_deps(std::ostream& out, literal_vector const& lits, enode_pair_vector const& eqs) const { context& ctx = get_context(); smt2_pp_environment_dbg env(m); params_ref p; - for (unsigned i = 0; i < eqs.size(); ++i) { + for (auto const& eq : eqs) { out << " (= "; - ast_smt2_pp(out, eqs[i].first->get_owner(), env, p, 5); + ast_smt2_pp(out, eq.first->get_owner(), env, p, 5); out << "\n "; - ast_smt2_pp(out, eqs[i].second->get_owner(), env, p, 5); + ast_smt2_pp(out, eq.second->get_owner(), env, p, 5); out << ")\n"; } - for (unsigned i = 0; i < lits.size(); ++i) { - literal l = lits[i]; + for (literal l : lits) { if (l == true_literal) { out << " true"; } @@ -3634,19 +3723,20 @@ void theory_seq::display_deps(std::ostream& out, literal_vector const& lits, eno } out << "\n"; } + return out; } -void theory_seq::display_deps(std::ostream& out, dependency* dep) const { +std::ostream& theory_seq::display_deps(std::ostream& out, dependency* dep) const { literal_vector lits; enode_pair_vector eqs; linearize(dep, eqs, lits); display_deps(out, lits, eqs); + return out; } void theory_seq::collect_statistics(::statistics & st) const { st.update("seq num splits", m_stats.m_num_splits); st.update("seq num reductions", m_stats.m_num_reductions); - st.update("seq unfold def", m_stats.m_propagate_automata); st.update("seq length coherence", m_stats.m_check_length_coherence); st.update("seq branch", m_stats.m_branch_variable); st.update("seq solve !=", m_stats.m_solve_nqs); @@ -3655,6 +3745,7 @@ void theory_seq::collect_statistics(::statistics & st) const { st.update("seq extensionality", m_stats.m_extensionality); st.update("seq fixed length", m_stats.m_fixed_length); st.update("seq int.to.str", m_stats.m_int_string); + st.update("seq automata", m_stats.m_propagate_automata); } void theory_seq::init_search_eh() { @@ -3724,27 +3815,26 @@ public: } void add_buffer(svector& sbuffer, zstring const& zs) { - for (unsigned l = 0; l < zs.length(); ++l) { - sbuffer.push_back(zs[l]); - } + for (unsigned i = 0; i < zs.length(); ++i) { + sbuffer.push_back(zs[i]); + } } app * mk_value(model_generator & mg, ptr_vector & values) override { SASSERT(values.size() == m_dependencies.size()); expr_ref_vector args(th.m); unsigned j = 0, k = 0; + rational val; bool is_string = th.m_util.is_string(m_sort); expr_ref result(th.m); if (is_string) { unsigned_vector sbuffer; - bv_util bv(th.m); - rational val; - unsigned sz; + unsigned ch; for (source_t src : m_source) { switch (src) { case unit_source: { - VERIFY(bv.is_numeral(values[j++], val, sz)); - sbuffer.push_back(val.get_unsigned()); + VERIFY(th.m_util.is_const_char(values[j++], ch)); + sbuffer.push_back(ch); break; } case string_source: { @@ -3764,8 +3854,13 @@ public: std::ostringstream strm; arith_util arith(th.m); VERIFY(arith.is_numeral(values[j++], val)); - if (val.is_neg()) strm << "-"; - strm << abs(val); + + if (val.is_neg()) { + strm << ""; + } + else { + strm << val; + } zstring zs(strm.str().c_str()); add_buffer(sbuffer, zs); break; @@ -3793,28 +3888,35 @@ public: th.m_rewrite(result); } th.m_factory->add_trail(result); + TRACE("seq", tout << result << "\n";); return to_app(result); } }; +app* theory_seq::get_ite_value(expr* e) { + expr* e1, *e2, *e3; + while (m.is_ite(e, e1, e2, e3)) { + if (get_root(e2) == get_root(e)) { + e = e2; + } + else if (get_root(e3) == get_root(e)) { + e = e3; + } + else { + break; + } + } + return to_app(e); +} model_value_proc * theory_seq::mk_value(enode * n, model_generator & mg) { app* e = n->get_owner(); context& ctx = get_context(); - expr* e1, *e2, *e3; - if (m.is_ite(e, e1, e2, e3) && ctx.e_internalized(e2) && ctx.e_internalized(e3) && - (ctx.get_enode(e2)->get_root() == n->get_root() || - ctx.get_enode(e3)->get_root() == n->get_root())) { - if (ctx.get_enode(e2)->get_root() == n->get_root()) { - return mk_value(ctx.get_enode(e2), mg); - } - else { - return mk_value(ctx.get_enode(e3), mg); - } - } - else if (m_util.is_seq(e)) { + TRACE("seq", tout << mk_pp(n->get_owner(), m) << "\n";); + e = get_ite_value(e); + if (m_util.is_seq(e)) { ptr_vector concats; - get_concat(e, concats); + get_ite_concat(e, concats); sort* srt = m.get_sort(e); seq_value_proc* sv = alloc(seq_value_proc, *this, srt); @@ -3849,7 +3951,10 @@ model_value_proc * theory_seq::mk_value(enode * n, model_generator & mg) { app* theory_seq::mk_value(app* e) { expr_ref result(m); + context& ctx = get_context(); + e = get_ite_value(e); result = m_rep.find(e); + if (is_var(result)) { SASSERT(m_factory); expr_ref val(m); @@ -3922,9 +4027,9 @@ bool theory_seq::canonize(expr* e, expr_ref_vector& es, dependency*& eqs) { bool theory_seq::canonize(expr_ref_vector const& es, expr_ref_vector& result, dependency*& eqs) { bool change = false; - for (unsigned i = 0; i < es.size(); ++i) { - change = canonize(es[i], result, eqs) || change; - SASSERT(!m_util.str.is_concat(es[i]) || change); + for (expr* e : es) { + change = canonize(e, result, eqs) || change; + SASSERT(!m_util.str.is_concat(e) || change); } return change; } @@ -3950,9 +4055,6 @@ expr_ref theory_seq::try_expand(expr* e, dependency*& eqs){ } result = ed.first; } - else if (false && m_util.str.is_string(e)) { - result = add_elim_string_axiom(e); - } else { m_expand_todo.push_back(e); } @@ -4024,13 +4126,6 @@ expr_ref theory_seq::expand1(expr* e0, dependency*& eqs) { } else { literal lit(mk_literal(e1)); -#if 0 - expr_ref sk_ite = mk_sk_ite(e1, e2, e3); - add_axiom(~lit, mk_eq(e2, sk_ite, false)); - add_axiom( lit, mk_eq(e3, sk_ite, false)); - result = sk_ite; - -#else switch (ctx.get_assignment(lit)) { case l_true: deps = m_dm.mk_join(deps, m_dm.mk_leaf(assumption(lit))); @@ -4043,13 +4138,12 @@ expr_ref theory_seq::expand1(expr* e0, dependency*& eqs) { if (!result) return result; break; case l_undef: - result = e; + result = e; m_reset_cache = true; TRACE("seq", tout << "undef: " << result << "\n"; tout << lit << "@ level: " << ctx.get_scope_level() << "\n";); break; } -#endif } } else if (m_util.str.is_itos(e, e1)) { @@ -4075,9 +4169,12 @@ expr_ref theory_seq::expand1(expr* e0, dependency*& eqs) { deps = m_dm.mk_join(deps, m_dm.mk_leaf(assumption(n1, n2))); } else { - TRACE("seq", tout << "add axiom\n";); - add_axiom(~mk_eq(num, e1, false), mk_eq(e, res, false)); - add_axiom(mk_eq(num, e1, false), ~mk_eq(e, res, false)); + TRACE("seq", tout << "mk equalities\n";); + literal l1 = mk_preferred_eq(num, e1); + literal l2 = mk_preferred_eq(e, res); + TRACE("seq", tout << "add axiom " << l1 << " " << l2 << "\n";); + add_axiom(l1, ~l2); + add_axiom(~l1, l2); result = e; } #else @@ -4121,8 +4218,8 @@ void theory_seq::propagate() { ++m_axioms_head; } while (!m_replay.empty() && !ctx.inconsistent()) { - TRACE("seq", tout << "replay at level: " << ctx.get_scope_level() << "\n";); apply* app = m_replay[m_replay.size() - 1]; + TRACE("seq", tout << "replay at level: " << ctx.get_scope_level() << "\n";); (*app)(*this); m_replay.pop_back(); } @@ -4133,6 +4230,7 @@ void theory_seq::propagate() { } void theory_seq::enque_axiom(expr* e) { + TRACE("seq", tout << "enqueue_axiom " << mk_pp(e, m) << " " << m_axiom_set.contains(e) << "\n";); if (!m_axiom_set.contains(e)) { TRACE("seq", tout << "add axiom " << mk_pp(e, m) << "\n";); m_axioms.push_back(e); @@ -4147,9 +4245,8 @@ void theory_seq::deque_axiom(expr* n) { if (m_util.str.is_length(n)) { add_length_axiom(n); } - else if (m_util.str.is_empty(n) && !has_length(n) && !m_length.empty()) { - ensure_enode(n); - enforce_length(get_context().get_enode(n)); + else if (m_util.str.is_empty(n) && !has_length(n) && !m_has_length.empty()) { + enforce_length(n); } else if (m_util.str.is_index(n)) { add_indexof_axiom(n); @@ -4254,7 +4351,7 @@ void theory_seq::add_indexof_axiom(expr* i) { expr_ref x = mk_skolem(m_indexof_left, t, s); expr_ref y = mk_skolem(m_indexof_right, t, s); xsy = mk_concat(x, s, y); - expr_ref lenx(m_util.str.mk_length(x), m); + expr_ref lenx = mk_len(x); // |s| = 0 => indexof(t,s,0) = 0 // contains(t,s) & |s| != 0 => t = xsy & indexof(t,s,0) = |x| add_axiom(~s_eq_empty, i_eq_0); @@ -4267,9 +4364,9 @@ void theory_seq::add_indexof_axiom(expr* i) { // offset >= len(t) => |s| = 0 or indexof(t, s, offset) = -1 // offset > len(t) => indexof(t, s, offset) = -1 // offset = len(t) & |s| = 0 => indexof(t, s, offset) = offset - expr_ref len_t(m_util.str.mk_length(t), m); - literal offset_ge_len = mk_simplified_literal(m_autil.mk_ge(m_autil.mk_sub(offset, len_t), zero)); - literal offset_le_len = mk_simplified_literal(m_autil.mk_le(m_autil.mk_sub(offset, len_t), zero)); + expr_ref len_t = mk_len(t); + literal offset_ge_len = mk_simplified_literal(m_autil.mk_ge(mk_sub(offset, len_t), zero)); + literal offset_le_len = mk_simplified_literal(m_autil.mk_le(mk_sub(offset, len_t), zero)); literal i_eq_offset = mk_eq(i, offset, false); add_axiom(~offset_ge_len, s_eq_empty, i_eq_m1); add_axiom(offset_le_len, i_eq_m1); @@ -4288,7 +4385,7 @@ void theory_seq::add_indexof_axiom(expr* i) { // -1 = indexof(y,s,0) + offset = indexof(t, s, offset) add_axiom(~offset_ge_0, offset_ge_len, mk_seq_eq(t, mk_concat(x, y))); - add_axiom(~offset_ge_0, offset_ge_len, mk_eq(m_util.str.mk_length(x), offset, false)); + add_axiom(~offset_ge_0, offset_ge_len, mk_eq(mk_len(x), offset, false)); add_axiom(~offset_ge_0, offset_ge_len, ~mk_eq(indexof0, minus_one, false), i_eq_m1); add_axiom(~offset_ge_0, offset_ge_len, @@ -4374,7 +4471,7 @@ void theory_seq::add_length_axiom(expr* n) { } else if (m_util.str.is_itos(x)) { add_itos_length_axiom(n); - } + } else { add_axiom(mk_literal(m_autil.mk_ge(n, m_autil.mk_int(0)))); } @@ -4439,8 +4536,6 @@ void theory_seq::add_itos_length_axiom(expr* len) { void theory_seq::propagate_in_re(expr* n, bool is_true) { TRACE("seq", tout << mk_pp(n, m) << " <- " << (is_true?"true":"false") << "\n";); - expr* s = nullptr, *re = nullptr; - VERIFY(m_util.str.is_in_re(n, s, re)); expr_ref tmp(n, m); m_rewrite(tmp); @@ -4461,39 +4556,56 @@ void theory_seq::propagate_in_re(expr* n, bool is_true) { return; } - expr_ref e3(re, m); + expr* s = nullptr, *_re = nullptr; + VERIFY(m_util.str.is_in_re(n, s, _re)); + expr_ref re(_re, m); context& ctx = get_context(); literal lit = ctx.get_literal(n); if (!is_true) { - e3 = m_util.re.mk_complement(re); + re = m_util.re.mk_complement(re); lit.neg(); } - eautomaton* a = get_automaton(e3); + + literal_vector lits; + for (unsigned i = 0; i < m_s_in_re.size(); ++i) { + auto const& entry = m_s_in_re[i]; + if (entry.m_active && get_root(entry.m_s) == get_root(s) && entry.m_re != re) { + m_trail_stack.push(vector_value_trail(m_s_in_re, i)); + m_s_in_re[i].m_active = false; + IF_VERBOSE(11, verbose_stream() << "intersect " << re << " " << mk_pp(entry.m_re, m) << " " << mk_pp(s, m) << " " << mk_pp(entry.m_s, m) << "\n";); + re = m_util.re.mk_inter(entry.m_re, re); + m_rewrite(re); + lits.push_back(~entry.m_lit); + enode* n1 = ensure_enode(entry.m_s); + enode* n2 = ensure_enode(s); + if (n1 != n2) { + lits.push_back(~mk_eq(n1->get_owner(), n2->get_owner(), false)); + } + } + } + + IF_VERBOSE(11, verbose_stream() << mk_pp(s, m) << " in " << re << "\n"); + eautomaton* a = get_automaton(re); if (!a) return; + m_s_in_re.push_back(s_in_re(lit, s, re, a)); + m_trail_stack.push(push_back_vector>(m_s_in_re)); - expr_ref len(m_util.str.mk_length(s), m); - for (unsigned i = 0; i < a->num_states(); ++i) { - literal acc = mk_accept(s, len, e3, i); - literal rej = mk_reject(s, len, e3, i); - add_axiom(a->is_final_state(i)?acc:~acc); - add_axiom(a->is_final_state(i)?~rej:rej); - } + expr_ref len = mk_len(s); expr_ref zero(m_autil.mk_int(0), m); unsigned_vector states; a->get_epsilon_closure(a->init(), states); - literal_vector lits; lits.push_back(~lit); for (unsigned st : states) { - lits.push_back(mk_accept(s, zero, e3, st)); + lits.push_back(mk_accept(s, zero, re, st)); } if (lits.size() == 2) { propagate_lit(nullptr, 1, &lit, lits[1]); } else { - TRACE("seq", ctx.display_literals_verbose(tout, lits); tout << "\n";); + TRACE("seq", ctx.display_literals_verbose(tout, lits) << "\n";); ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr()); } } @@ -4532,66 +4644,40 @@ static T* get_th_arith(context& ctx, theory_id afid, expr* e) { } } -static bool get_arith_value(context& ctx, theory_id afid, expr* e, expr_ref& v) { - theory_mi_arith* tha = get_th_arith(ctx, afid, e); - if (tha) return tha->get_value(ctx.get_enode(e), v); - theory_i_arith* thi = get_th_arith(ctx, afid, e); - if (thi) return thi->get_value(ctx.get_enode(e), v); - theory_lra* thr = get_th_arith(ctx, afid, e); - if (thr) return thr->get_value(ctx.get_enode(e), v); - TRACE("seq", tout << "no arithmetic theory\n";); - return false; -} bool theory_seq::get_num_value(expr* e, rational& val) const { - context& ctx = get_context(); - expr_ref _val(m); - if (!ctx.e_internalized(e)) - return false; - enode* next = ctx.get_enode(e), *n = next; - do { - if (get_arith_value(ctx, m_autil.get_family_id(), next->get_owner(), _val) && m_autil.is_numeral(_val, val) && val.is_int()) { - return true; - } - next = next->get_next(); - } - while (next != n); - TRACE("seq", tout << "no value for " << mk_pp(e, m) << "\n";); - return false; + return m_arith_value.get_value_equiv(e, val) && val.is_int(); } -bool theory_seq::lower_bound(expr* _e, rational& lo) const { - context& ctx = get_context(); - expr_ref e(m_util.str.mk_length(_e), m); - expr_ref _lo(m); - family_id afid = m_autil.get_family_id(); - do { - theory_mi_arith* tha = get_th_arith(ctx, afid, e); - if (tha && tha->get_lower(ctx.get_enode(e), _lo)) break; - theory_i_arith* thi = get_th_arith(ctx, afid, e); - if (thi && thi->get_lower(ctx.get_enode(e), _lo)) break; - theory_lra* thr = get_th_arith(ctx, afid, e); - if (thr && thr->get_lower(ctx.get_enode(e), _lo)) break; - return false; - } - while (false); - return m_autil.is_numeral(_lo, lo) && lo.is_int(); +bool theory_seq::lower_bound(expr* e, rational& lo) const { + VERIFY(m_autil.is_int(e)); + bool is_strict = true; + return m_arith_value.get_lo(e, lo, is_strict) && !is_strict && lo.is_int(); + } +bool theory_seq::upper_bound(expr* e, rational& hi) const { + VERIFY(m_autil.is_int(e)); + bool is_strict = true; + return m_arith_value.get_up(e, hi, is_strict) && !is_strict && hi.is_int(); +} + + + // The difference with lower_bound function is that since in some cases, // the lower bound is not updated for all the enodes in the same eqc, // we have to traverse the eqc to query for the better lower bound. bool theory_seq::lower_bound2(expr* _e, rational& lo) { context& ctx = get_context(); - expr_ref e(m_util.str.mk_length(_e), m); + expr_ref e = mk_len(_e); expr_ref _lo(m); theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e); if (!tha) { theory_i_arith* thi = get_th_arith(ctx, m_autil.get_family_id(), e); - if (!thi || !thi->get_lower(ctx.get_enode(e), _lo)) return false; + if (!thi || !thi->get_lower(ctx.get_enode(e), _lo) || !m_autil.is_numeral(_lo, lo)) return false; } enode *ee = ctx.get_enode(e); - if (!tha->get_lower(ee, _lo) || m_autil.is_numeral(_lo, lo)) { + if (tha && (!tha->get_lower(ee, _lo) || m_autil.is_numeral(_lo, lo))) { enode *next = ee->get_next(); bool flag = false; while (next != ee) { @@ -4617,23 +4703,6 @@ bool theory_seq::lower_bound2(expr* _e, rational& lo) { return true; } -bool theory_seq::upper_bound(expr* _e, rational& hi) const { - context& ctx = get_context(); - expr_ref e(m_util.str.mk_length(_e), m); - family_id afid = m_autil.get_family_id(); - expr_ref _hi(m); - do { - theory_mi_arith* tha = get_th_arith(ctx, afid, e); - if (tha && tha->get_upper(ctx.get_enode(e), _hi)) break; - theory_i_arith* thi = get_th_arith(ctx, afid, e); - if (thi && thi->get_upper(ctx.get_enode(e), _hi)) break; - theory_lra* thr = get_th_arith(ctx, afid, e); - if (thr && thr->get_upper(ctx.get_enode(e), _hi)) break; - return false; - } - while (false); - return m_autil.is_numeral(_hi, hi) && hi.is_int(); -} bool theory_seq::get_length(expr* e, rational& val) const { context& ctx = get_context(); @@ -4665,10 +4734,8 @@ bool theory_seq::get_length(expr* e, rational& val) const { return false; } else { - len = m_util.str.mk_length(c); - if (ctx.e_internalized(len) && - get_arith_value(ctx, m_autil.get_family_id(), len, len_val) && - m_autil.is_numeral(len_val, val1)) { + len = mk_len(c); + if (m_arith_value.get_value(len, val1)) { val += val1; } else { @@ -4682,7 +4749,6 @@ bool theory_seq::get_length(expr* e, rational& val) const { } /* - TBD: check semantics of extract. let e = extract(s, i, l) @@ -4729,10 +4795,11 @@ void theory_seq::add_extract_axiom(expr* e) { add_extract_suffix_axiom(e, s, i); return; } + expr_ref x(mk_skolem(m_pre, s, i), m); - expr_ref ls(m_util.str.mk_length(s), m); - expr_ref lx(m_util.str.mk_length(x), m); - expr_ref le(m_util.str.mk_length(e), m); + expr_ref ls = mk_len(s); + expr_ref lx = mk_len(x); + expr_ref le = mk_len(e); expr_ref ls_minus_i_l(mk_sub(mk_sub(ls, i), l), m); expr_ref y(mk_skolem(m_post, s, ls_minus_i_l), m); expr_ref xe = mk_concat(x, e); @@ -4744,25 +4811,30 @@ void theory_seq::add_extract_axiom(expr* e) { literal li_ge_ls = mk_simplified_literal(m_autil.mk_ge(ls_minus_i_l, zero)); literal l_ge_zero = mk_simplified_literal(m_autil.mk_ge(l, zero)); literal ls_le_0 = mk_simplified_literal(m_autil.mk_le(ls, zero)); + literal le_is_0 = mk_eq(le, zero, false); add_axiom(~i_ge_0, ~ls_le_i, mk_seq_eq(xey, s)); add_axiom(~i_ge_0, ~ls_le_i, mk_eq(lx, i, false)); add_axiom(~i_ge_0, ~ls_le_i, ~l_ge_zero, ~li_ge_ls, mk_eq(le, l, false)); add_axiom(~i_ge_0, ~ls_le_i, li_ge_ls, mk_eq(le, mk_sub(ls, i), false)); add_axiom(~i_ge_0, ~ls_le_i, l_ge_zero, mk_eq(le, zero, false)); - add_axiom(i_ge_0, mk_eq(le, zero, false)); - add_axiom(ls_le_i, mk_eq(le, zero, false)); - add_axiom(~ls_le_0, mk_eq(le, zero, false)); + add_axiom(i_ge_0, le_is_0); + add_axiom(ls_le_i, le_is_0); + add_axiom(~ls_le_0, le_is_0); } void theory_seq::add_tail_axiom(expr* e, expr* s) { expr_ref head(m), tail(m); mk_decompose(s, head, tail); - add_axiom(mk_eq_empty(s), mk_seq_eq(s, mk_concat(head, e))); + literal emp = mk_eq_empty(s); + add_axiom(emp, mk_seq_eq(s, mk_concat(head, e))); + add_axiom(~emp, mk_eq_empty(e)); } void theory_seq::add_drop_last_axiom(expr* e, expr* s) { - add_axiom(mk_eq_empty(s), mk_seq_eq(s, mk_concat(e, m_util.str.mk_unit(mk_last(s))))); + literal emp = mk_eq_empty(s); + add_axiom(emp, mk_seq_eq(s, mk_concat(e, m_util.str.mk_unit(mk_last(s))))); + add_axiom(~emp, mk_eq_empty(e)); } bool theory_seq::is_drop_last(expr* s, expr* i, expr* l) { @@ -4771,7 +4843,7 @@ bool theory_seq::is_drop_last(expr* s, expr* i, expr* l) { return false; } expr_ref l2(m), l1(l, m); - l2 = m_autil.mk_sub(m_util.str.mk_length(s), m_autil.mk_int(1)); + l2 = mk_sub(mk_len(s), m_autil.mk_int(1)); m_rewrite(l1); m_rewrite(l2); return l1 == l2; @@ -4783,7 +4855,7 @@ bool theory_seq::is_tail(expr* s, expr* i, expr* l) { return false; } expr_ref l2(m), l1(l, m); - l2 = m_autil.mk_sub(m_util.str.mk_length(s), m_autil.mk_int(1)); + l2 = mk_sub(mk_len(s), m_autil.mk_int(1)); m_rewrite(l1); m_rewrite(l2); return l1 == l2; @@ -4803,11 +4875,12 @@ bool theory_seq::is_extract_suffix(expr* s, expr* i, expr* l) { /* 0 <= l <= len(s) => s = ey & l = len(e) len(s) < l => s = e + l < 0 => e = empty */ void theory_seq::add_extract_prefix_axiom(expr* e, expr* s, expr* l) { TRACE("seq", tout << mk_pp(e, m) << " " << mk_pp(s, m) << " " << mk_pp(l, m) << "\n";); - expr_ref le(m_util.str.mk_length(e), m); - expr_ref ls(m_util.str.mk_length(s), m); + expr_ref le = mk_len(e); + expr_ref ls = mk_len(s); expr_ref ls_minus_l(mk_sub(ls, l), m); expr_ref y(mk_skolem(m_post, s, ls_minus_l), m); expr_ref zero(m_autil.mk_int(0), m); @@ -4816,23 +4889,29 @@ void theory_seq::add_extract_prefix_axiom(expr* e, expr* s, expr* l) { literal l_le_s = mk_simplified_literal(m_autil.mk_le(mk_sub(l, ls), zero)); add_axiom(~l_ge_0, ~l_le_s, mk_seq_eq(s, ey)); add_axiom(~l_ge_0, ~l_le_s, mk_eq(l, le, false)); - add_axiom(~l_ge_0, ~l_le_s, mk_eq(ls_minus_l, m_util.str.mk_length(y), false)); + add_axiom(~l_ge_0, ~l_le_s, mk_eq(ls_minus_l, mk_len(y), false)); add_axiom(l_le_s, mk_eq(e, s, false)); + add_axiom(l_ge_0, mk_eq_empty(e)); } /* 0 <= i <= len(s) => s = xe & i = len(x) + i < 0 => e = empty + i > len(s) => e = empty */ void theory_seq::add_extract_suffix_axiom(expr* e, expr* s, expr* i) { expr_ref x(mk_skolem(m_pre, s, i), m); - expr_ref lx(m_util.str.mk_length(x), m); - expr_ref ls(m_util.str.mk_length(s), m); + expr_ref lx = mk_len(x); + expr_ref ls = mk_len(s); expr_ref zero(m_autil.mk_int(0), m); expr_ref xe = mk_concat(x, e); + literal le_is_0 = mk_eq_empty(e); literal i_ge_0 = mk_simplified_literal(m_autil.mk_ge(i, zero)); literal i_le_s = mk_simplified_literal(m_autil.mk_le(mk_sub(i, ls), zero)); add_axiom(~i_ge_0, ~i_le_s, mk_seq_eq(s, xe)); add_axiom(~i_ge_0, ~i_le_s, mk_eq(i, lx, false)); + add_axiom(i_ge_0, le_is_0); + add_axiom(i_le_s, le_is_0); } @@ -4846,47 +4925,41 @@ void theory_seq::add_extract_suffix_axiom(expr* e, expr* s, expr* i) { void theory_seq::add_at_axiom(expr* e) { expr* s = nullptr, *i = nullptr; VERIFY(m_util.str.is_at(e, s, i)); - expr_ref len_e(m_util.str.mk_length(e), m); - expr_ref len_s(m_util.str.mk_length(s), m); expr_ref zero(m_autil.mk_int(0), m); expr_ref one(m_autil.mk_int(1), m); - expr_ref x = mk_skolem(m_pre, s, i); - expr_ref y = mk_skolem(m_post, s, mk_sub(mk_sub(len_s, i), one)); - expr_ref xey = mk_concat(x, e, y); - expr_ref len_x(m_util.str.mk_length(x), m); expr_ref emp(m_util.str.mk_empty(m.get_sort(e)), m); - + expr_ref len_s = mk_len(s); literal i_ge_0 = mk_simplified_literal(m_autil.mk_ge(i, zero)); - literal i_ge_len_s = mk_simplified_literal(m_autil.mk_ge(mk_sub(i, m_util.str.mk_length(s)), zero)); + literal i_ge_len_s = mk_simplified_literal(m_autil.mk_ge(mk_sub(i, mk_len(s)), zero)); - - add_axiom(~i_ge_0, i_ge_len_s, mk_seq_eq(s, xey)); - add_axiom(~i_ge_0, i_ge_len_s, mk_eq(one, len_e, false)); - add_axiom(~i_ge_0, i_ge_len_s, mk_eq(i, len_x, false)); + rational iv; + if (m_autil.is_numeral(i, iv) && iv.is_int() && !iv.is_neg()) { + expr_ref_vector es(m); + expr_ref nth(m); + unsigned k = iv.get_unsigned(); + for (unsigned j = 0; j <= k; ++j) { + es.push_back(m_util.str.mk_unit(mk_nth(s, m_autil.mk_int(j)))); + } + nth = es.back(); + es.push_back(mk_skolem(m_tail, s, m_autil.mk_int(k))); + add_axiom(~i_ge_0, i_ge_len_s, mk_seq_eq(s, m_util.str.mk_concat(es))); + add_axiom(~i_ge_0, i_ge_len_s, mk_seq_eq(nth, e)); + } + else { + expr_ref len_e = mk_len(e); + expr_ref x = mk_skolem(m_pre, s, i); + expr_ref y = mk_skolem(m_tail, s, i); + expr_ref xey = mk_concat(x, e, y); + expr_ref len_x = mk_len(x); + add_axiom(~i_ge_0, i_ge_len_s, mk_seq_eq(s, xey)); + add_axiom(~i_ge_0, i_ge_len_s, mk_eq(one, len_e, false)); + add_axiom(~i_ge_0, i_ge_len_s, mk_eq(i, len_x, false)); + } add_axiom(i_ge_0, mk_eq(e, emp, false)); add_axiom(~i_ge_len_s, mk_eq(e, emp, false)); } -/** - step(s, idx, re, i, j, t) -> nth(s, idx) == t & len(s) > idx -*/ -void theory_seq::propagate_step(literal lit, expr* step) { - SASSERT(get_context().get_assignment(lit) == l_true); - expr* re = nullptr, *acc = nullptr, *s = nullptr, *idx = nullptr, *i = nullptr, *j = nullptr; - VERIFY(is_step(step, s, idx, re, i, j, acc)); - TRACE("seq", tout << mk_pp(step, m) << " -> " << mk_pp(acc, m) << "\n";); - propagate_lit(nullptr, 1, &lit, mk_simplified_literal(acc)); - rational lo; - rational _idx; - if (lower_bound(s, lo) && lo.is_unsigned() && m_autil.is_numeral(idx, _idx) && lo >= _idx) { - // skip - } - else { - propagate_lit(nullptr, 1, &lit, ~mk_literal(m_autil.mk_le(m_util.str.mk_length(s), idx))); - } - ensure_nth(lit, s, idx); -} /* lit => s = (nth s 0) ++ (nth s 1) ++ ... ++ (nth s idx) ++ (tail s idx) @@ -4903,8 +4976,8 @@ void theory_seq::ensure_nth(literal lit, expr* s, expr* idx) { for (unsigned j = 0; j <= _idx; ++j) { mk_decompose(s2, head, tail); elems.push_back(head); - len1 = m_util.str.mk_length(s2); - len2 = m_autil.mk_add(m_autil.mk_int(1), m_util.str.mk_length(tail)); + len1 = mk_len(s2); + len2 = m_autil.mk_add(m_autil.mk_int(1), mk_len(tail)); propagate_eq(lit, len1, len2, false); s2 = tail; } @@ -4926,12 +4999,19 @@ literal theory_seq::mk_literal(expr* _e) { return ctx.get_literal(e); } - literal theory_seq::mk_seq_eq(expr* a, expr* b) { SASSERT(m_util.is_seq(a)); return mk_literal(mk_skolem(m_eq, a, b, nullptr, nullptr, m.mk_bool_sort())); } +literal theory_seq::mk_preferred_eq(expr* a, expr* b) { + context& ctx = get_context(); + ctx.assume_eq(ensure_enode(a), ensure_enode(b)); + literal lit = mk_eq(a, b, false); + ctx.force_phase(lit); + return lit; +} + literal theory_seq::mk_eq_empty(expr* _e, bool phase) { context& ctx = get_context(); expr_ref e(_e, m); @@ -4968,19 +5048,20 @@ void theory_seq::add_axiom(literal l1, literal l2, literal l3, literal l4, liter if (l3 != null_literal && l3 != false_literal) { ctx.mark_as_relevant(l3); lits.push_back(l3); } if (l4 != null_literal && l4 != false_literal) { ctx.mark_as_relevant(l4); lits.push_back(l4); } if (l5 != null_literal && l5 != false_literal) { ctx.mark_as_relevant(l5); lits.push_back(l5); } - TRACE("seq", ctx.display_literals_verbose(tout << "assert:\n", lits); tout << "\n";); + TRACE("seq", ctx.display_literals_verbose(tout << "assert:\n", lits) << "\n";); m_new_propagation = true; ++m_stats.m_add_axiom; ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr()); } -expr* theory_seq::coalesce_chars(expr* const& e) { +expr_ref theory_seq::coalesce_chars(expr* const& e) { context& ctx = get_context(); expr* s; + unsigned ch; + expr_ref result(m); if (m_util.str.is_concat(e)) { - expr_ref_vector concats(m); + expr_ref_vector rs(m), concats(m); m_util.str.get_concat(e, concats); - expr_ref_vector result(m); for (unsigned i = 0; i < concats.size(); ++i) { expr_ref tmp(coalesce_chars(concats[i].get()), m); if (m_util.str.is_empty(tmp)) continue; @@ -5000,32 +5081,30 @@ expr* theory_seq::coalesce_chars(expr* const& e) { } } if (flag) { - result.push_back(m_util.str.mk_string(zs)); + rs.push_back(m_util.str.mk_string(zs)); if (i < concats.size()) - result.push_back(tmp); + rs.push_back(tmp); } else - result.push_back(tmp); + rs.push_back(tmp); } - SASSERT(result.size() > 0); - if (result.size() > 1) - return m_util.str.mk_concat(result.size(), result.c_ptr()); - else - return e; - } - else if (m_util.str.is_unit(e, s)) { - bv_util bvu(m); - if (bvu.is_bv(s)) { - expr_ref result(m); - expr * args[1] = {s}; - if (BR_FAILED != m_seq_rewrite.mk_app_core(to_app(e)->get_decl(), 1, args, result)) { - if (!ctx.e_internalized(result)) - ctx.internalize(result, false); - return result; - } + SASSERT(rs.size() > 0); + if (rs.size() > 1) { + return expr_ref(m_util.str.mk_concat(rs.size(), rs.c_ptr()), m); + } + else { + result = e; + return result; } } - return e; + else if (m_util.str.is_unit(e, s) && m_util.is_const_char(s, ch) && + BR_FAILED != m_seq_rewrite.mk_app_core(to_app(e)->get_decl(), 1, &s, result)) { + if (!ctx.e_internalized(result)) + ctx.internalize(result, false); + return result; + } + result = e; + return result; } expr_ref theory_seq::mk_skolem(symbol const& name, expr* e1, expr* e2, expr* e3, expr*e4, sort* range) { @@ -5035,10 +5114,12 @@ expr_ref theory_seq::mk_skolem(symbol const& name, expr* e1, expr* e2, expr* e3, if (!range) { range = m.get_sort(e1); } + expr_ref_vector pinned(m); if (name == m_seq_align) { for (unsigned i = 0; i < len; ++i) { - es[i] = coalesce_chars(es[i]); - TRACE("seq", tout << mk_pp(es[i], m) << "\n";); + pinned.push_back(coalesce_chars(es[i])); + es[i] = pinned.back(); + TRACE("seq", tout << mk_pp(es[i], m) << "\n";); } } return expr_ref(m_util.mk_skolem(name, len, es, range), m); @@ -5087,7 +5168,7 @@ void theory_seq::propagate_eq(dependency* deps, literal_vector const& _lits, exp } TRACE("seq", tout << "assert: " << mk_pp(e1, m) << " = " << mk_pp(e2, m) << " <- \n"; - if (!lits.empty()) { ctx.display_literals_verbose(tout, lits); tout << "\n"; }); + if (!lits.empty()) { ctx.display_literals_verbose(tout, lits) << "\n"; }); justification* js = ctx.mk_justification( ext_theory_eq_propagation_justification( @@ -5103,7 +5184,6 @@ void theory_seq::assign_eh(bool_var v, bool is_true) { expr* e = ctx.bool_var2expr(v); expr* e1 = nullptr, *e2 = nullptr; expr_ref f(m); - bool change = false; literal lit(v, !is_true); if (m_util.str.is_prefix(e, e1, e2)) { @@ -5111,16 +5191,11 @@ void theory_seq::assign_eh(bool_var v, bool is_true) { f = mk_skolem(m_prefix, e1, e2); f = mk_concat(e1, f); propagate_eq(lit, f, e2, true); + //literal len1_le_len2 = mk_simplified_literal(m_autil.mk_ge(mk_sub(mk_len(e2), mk_len(e1)), m_autil.mk_int(0))); + //add_axiom(~lit, len1_le_len2); } else { -#if 0 - propagate_not_prefix2(e); -#else - propagate_non_empty(lit, e1); - if (add_prefix2prefix(e, change)) { - add_atom(e); - } -#endif + propagate_not_prefix(e); } } else if (m_util.str.is_suffix(e, e1, e2)) { @@ -5128,26 +5203,11 @@ void theory_seq::assign_eh(bool_var v, bool is_true) { f = mk_skolem(m_suffix, e1, e2); f = mk_concat(f, e1); propagate_eq(lit, f, e2, true); + //literal len1_le_len2 = mk_simplified_literal(m_autil.mk_ge(mk_sub(mk_len(e2), mk_len(e1)), m_autil.mk_int(0))); + //add_axiom(~lit, len1_le_len2); } else { -#if 1 propagate_not_suffix(e); - -#else - // lit => e1 != empty - propagate_non_empty(lit, e1); - - // lit => e1 = first ++ (unit last) - expr_ref f1 = mk_first(e1); - expr_ref f2 = mk_last(e1); - f = mk_concat(f1, m_util.str.mk_unit(f2)); - propagate_eq(lit, e1, f, true); - - TRACE("seq", tout << "suffix: " << f << " = " << mk_pp(e1, m) << "\n";); - if (add_suffix2suffix(e, change)) { - add_atom(e); - } -#endif } } else if (m_util.str.is_contains(e, e1, e2)) { @@ -5171,40 +5231,26 @@ void theory_seq::assign_eh(bool_var v, bool is_true) { expr_ref f2 = mk_skolem(m_indexof_right, e1, e2); f = mk_concat(f1, e2, f2); propagate_eq(lit, f, e1, true); + //literal len2_le_len1 = mk_simplified_literal(m_autil.mk_ge(mk_sub(mk_len(e1), mk_len(e2)), m_autil.mk_int(0))); + //add_axiom(~lit, len2_le_len1); } else if (!canonizes(false, e)) { propagate_non_empty(lit, e2); -#if 1 dependency* dep = m_dm.mk_leaf(assumption(lit)); - m_ncs.push_back(nc(expr_ref(e, m), dep)); -#else - propagate_lit(0, 1, &lit, ~mk_literal(m_util.str.mk_prefix(e2, e1))); - if (add_contains2contains(e, change)) { - add_atom(e); - } -#endif + literal len_gt = mk_simplified_literal(m_autil.mk_le(mk_sub(mk_len(e1), mk_len(e2)), + m_autil.mk_int(-1))); + ctx.force_phase(len_gt); + m_ncs.push_back(nc(expr_ref(e, m), len_gt, dep)); } } else if (is_accept(e)) { if (is_true) { - propagate_acc_rej_length(lit, e); - if (add_accept2step(e, change)) { - add_atom(e); - } - } - } - else if (is_reject(e)) { - if (is_true) { - propagate_acc_rej_length(lit, e); - add_atom(e); + propagate_accept(lit, e); } } else if (is_step(e)) { if (is_true) { propagate_step(lit, e); - if (add_step2accept(e, change)) { - add_atom(e); - } } } else if (is_eq(e, e1, e2)) { @@ -5219,6 +5265,10 @@ void theory_seq::assign_eh(bool_var v, bool is_true) { // propagate equalities } else if (is_skolem(symbol("seq.is_digit"), e)) { + // no-op + } + else if (is_max_unfolding(e)) { + // no-op } else { TRACE("seq", tout << mk_pp(e, m) << "\n";); @@ -5226,11 +5276,6 @@ void theory_seq::assign_eh(bool_var v, bool is_true) { } } -void theory_seq::add_atom(expr* e) { - m_trail_stack.push(push_back_vector >(m_atoms)); - m_atoms.push_back(e); -} - void theory_seq::new_eq_eh(theory_var v1, theory_var v2) { enode* n1 = get_enode(v1); enode* n2 = get_enode(v2); @@ -5238,6 +5283,26 @@ void theory_seq::new_eq_eh(theory_var v1, theory_var v2) { new_eq_eh(deps, n1, n2); } +lbool theory_seq::regex_are_equal(expr* r1, expr* r2) { + if (r1 == r2) { + return l_true; + } + expr* d1 = m_util.re.mk_inter(r1, m_util.re.mk_complement(r2)); + expr* d2 = m_util.re.mk_inter(r2, m_util.re.mk_complement(r1)); + expr_ref diff(m_util.re.mk_union(d1, d2), m); + eautomaton* aut = get_automaton(diff); + if (!aut) { + return l_undef; + } + else if (aut->is_empty()) { + return l_true; + } + else { + return l_false; + } +} + + void theory_seq::new_eq_eh(dependency* deps, enode* n1, enode* n2) { TRACE("seq", tout << expr_ref(n1->get_owner(), m) << " = " << expr_ref(n2->get_owner(), m) << "\n";); if (n1 != n2 && m_util.is_seq(n1->get_owner())) { @@ -5255,13 +5320,26 @@ void theory_seq::new_eq_eh(dependency* deps, enode* n1, enode* n2) { enforce_length_coherence(n1, n2); } else if (n1 != n2 && m_util.is_re(n1->get_owner())) { - // ignore - // eautomaton* a1 = get_automaton(n1->get_owner()); - // eautomaton* a2 = get_automaton(n2->get_owner()); - // eautomaton* b1 = mk_difference(*a1, *a2); - // eautomaton* b2 = mk_difference(*a2, *a1); - // eautomaton* c = mk_union(*b1, *b2); - // then some emptiness check. + // create an expression for the symmetric difference and imply it is empty. + enode_pair_vector eqs; + literal_vector lits; + context& ctx = get_context(); + switch (regex_are_equal(n1->get_owner(), n2->get_owner())) { + case l_true: + break; + case l_false: + if (!linearize(deps, eqs, lits)) { + throw default_exception("could not linearlize assumptions"); + } + eqs.push_back(enode_pair(n1, n2)); + ctx.set_conflict( + ctx.mk_justification( + ext_theory_conflict_justification( + get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), 0, nullptr))); + break; + default: + throw default_exception("convert regular expressions into automata"); + } } } @@ -5271,6 +5349,26 @@ void theory_seq::new_diseq_eh(theory_var v1, theory_var v2) { expr_ref e1(n1->get_owner(), m); expr_ref e2(n2->get_owner(), m); SASSERT(n1->get_root() != n2->get_root()); + if (m_util.is_re(n1->get_owner())) { + enode_pair_vector eqs; + literal_vector lits; + context& ctx = get_context(); + switch (regex_are_equal(e1, e2)) { + case l_false: + return; + case l_true: { + literal lit = mk_eq(e1, e2, false); + lits.push_back(~lit); + ctx.set_conflict( + ctx.mk_justification( + ext_theory_conflict_justification( + get_id(), ctx.get_region(), lits.size(), lits.c_ptr(), eqs.size(), eqs.c_ptr(), 0, nullptr))); + return; + } + default: + throw default_exception("convert regular expressions into automata"); + } + } m_exclude.update(e1, e2); expr_ref eq(m.mk_eq(e1, e2), m); TRACE("seq", tout << "new disequality " << get_context().get_scope_level() << ": " << eq << "\n";); @@ -5298,7 +5396,6 @@ void theory_seq::push_scope_eh() { m_eqs.push_scope(); m_nqs.push_scope(); m_ncs.push_scope(); - m_atoms_lim.push_back(m_atoms.size()); } void theory_seq::pop_scope_eh(unsigned num_scopes) { @@ -5311,8 +5408,6 @@ void theory_seq::pop_scope_eh(unsigned num_scopes) { m_eqs.pop_scope(num_scopes); m_nqs.pop_scope(num_scopes); m_ncs.pop_scope(num_scopes); - m_atoms.resize(m_atoms_lim[m_atoms_lim.size()-num_scopes]); - m_atoms_lim.shrink(m_atoms_lim.size()-num_scopes); m_rewrite.reset(); if (ctx.get_base_level() > ctx.get_scope_level() - num_scopes) { m_replay.reset(); @@ -5345,7 +5440,7 @@ void theory_seq::relevant_eh(app* n) { expr* arg; if (m_util.str.is_length(n, arg) && !has_length(arg) && get_context().e_internalized(arg)) { - enforce_length(get_context().get_enode(arg)); + enforce_length(arg); } } @@ -5359,10 +5454,7 @@ eautomaton* theory_seq::get_automaton(expr* re) { m_mk_aut.set_solver(alloc(seq_expr_solver, m, get_context().get_fparams())); } result = m_mk_aut(re); - if (result) { - display_expr disp(m); - TRACE("seq", result->display(tout, disp);); - } + CTRACE("seq", result, { display_expr d(m); result->display(tout, d); }); m_automata.push_back(result); m_re2aut.insert(re, result); m_res.push_back(re); @@ -5374,14 +5466,9 @@ literal theory_seq::mk_accept(expr* s, expr* idx, expr* re, expr* state) { args.push_back(s).push_back(idx).push_back(re).push_back(state); return mk_literal(m_util.mk_skolem(m_accept, args.size(), args.c_ptr(), m.mk_bool_sort())); } -literal theory_seq::mk_reject(expr* s, expr* idx, expr* re, expr* state) { - expr_ref_vector args(m); - args.push_back(s).push_back(idx).push_back(re).push_back(state); - return mk_literal(m_util.mk_skolem(m_reject, args.size(), args.c_ptr(), m.mk_bool_sort())); -} -bool theory_seq::is_acc_rej(symbol const& ar, expr* e, expr*& s, expr*& idx, expr*& re, unsigned& i, eautomaton*& aut) { - if (is_skolem(ar, e)) { +bool theory_seq::is_accept(expr* e, expr*& s, expr*& idx, expr*& re, unsigned& i, eautomaton*& aut) { + if (is_accept(e)) { rational r; s = to_app(e)->get_arg(0); idx = to_app(e)->get_arg(1); @@ -5417,242 +5504,124 @@ bool theory_seq::is_step(expr* e, expr*& s, expr*& idx, expr*& re, expr*& i, exp } } -expr_ref theory_seq::mk_step(expr* s, expr* idx, expr* re, unsigned i, unsigned j, expr* acc) { - SASSERT(m.is_bool(acc)); +expr_ref theory_seq::mk_step(expr* s, expr* idx, expr* re, unsigned i, unsigned j, expr* t) { expr_ref_vector args(m); args.push_back(s).push_back(idx).push_back(re); args.push_back(m_autil.mk_int(i)); args.push_back(m_autil.mk_int(j)); - args.push_back(acc); + args.push_back(t); return expr_ref(m_util.mk_skolem(m_aut_step, args.size(), args.c_ptr(), m.mk_bool_sort()), m); } -/* - acc(s, idx, re, i) -> len(s) >= idx if i is final - rej(s, idx, re, i) -> len(s) >= idx if i is non-final - - acc(s, idx, re, i) -> len(s) > idx if i is non-final - rej(s, idx, re, i) -> len(s) > idx if i is final +/** + step(s, idx, re, i, j, t) -> nth(s, idx) == t & len(s) > idx + step(s, idx, re, i, j, t) -> accept(s, idx + 1, re, j) */ -void theory_seq::propagate_acc_rej_length(literal lit, expr* e) { - expr *s = nullptr, *idx = nullptr, *re = nullptr; - unsigned src; - eautomaton* aut = nullptr; - bool is_acc; - is_acc = is_accept(e, s, idx, re, src, aut); - if (!is_acc) { - VERIFY(is_reject(e, s, idx, re, src, aut)); - } - if (m_util.str.is_length(idx)) return; - SASSERT(m_autil.is_numeral(idx)); +void theory_seq::propagate_step(literal lit, expr* step) { SASSERT(get_context().get_assignment(lit) == l_true); - if (aut->is_sink_state(src)) { - propagate_lit(nullptr, 1, &lit, false_literal); - return; - } - bool is_final = aut->is_final_state(src); - if (is_final == is_acc) { - propagate_lit(nullptr, 1, &lit, mk_literal(m_autil.mk_ge(m_util.str.mk_length(s), idx))); + expr* re = nullptr, *s = nullptr, *t = nullptr, *idx = nullptr, *i = nullptr, *j = nullptr; + VERIFY(is_step(step, s, idx, re, i, j, t)); + + TRACE("seq", tout << mk_pp(step, m) << " -> " << mk_pp(t, m) << "\n";); + propagate_lit(nullptr, 1, &lit, mk_literal(t)); + + expr_ref len_s = mk_len(s); + rational lo; + rational _idx; + VERIFY(m_autil.is_numeral(idx, _idx)); + if (lower_bound(len_s, lo) && lo.is_unsigned() && lo >= _idx) { + // skip } else { - propagate_lit(nullptr, 1, &lit, ~mk_literal(m_autil.mk_le(m_util.str.mk_length(s), idx))); + propagate_lit(nullptr, 1, &lit, ~mk_literal(m_autil.mk_le(len_s, idx))); } + ensure_nth(lit, s, idx); + + expr_ref idx1(m_autil.mk_int(_idx + 1), m); + propagate_lit(nullptr, 1, &lit, mk_accept(s, idx1, re, j)); } /** acc(s, idx, re, i) -> \/ step(s, idx, re, i, j, t) if i is non-final - acc(s, idx, re, i) -> len(s) <= idx \/ step(s, idx, re, i, j, t) if i is final -*/ -bool theory_seq::add_accept2step(expr* acc, bool& change) { - context& ctx = get_context(); - - TRACE("seq", tout << mk_pp(acc, m) << "\n";); - SASSERT(ctx.get_assignment(acc) == l_true); + acc(s, idx, re, i) -> len(s) <= idx \/ step(s, idx, re, i, j, t) if i is final + acc(s, idx, re, i) -> len(s) >= idx if i is final + acc(s, idx, re, i) -> len(s) > idx if i is non-final + acc(s, idx, re, i) -> idx < max_unfolding + */ +void theory_seq::propagate_accept(literal lit, expr* acc) { + ++m_stats.m_propagate_automata; expr *e = nullptr, *idx = nullptr, *re = nullptr; - expr_ref step(m); - unsigned src; + unsigned src = 0; + context& ctx = get_context(); + rational _idx; eautomaton* aut = nullptr; VERIFY(is_accept(acc, e, idx, re, src, aut)); - if (!aut || m_util.str.is_length(idx)) { - return false; + VERIFY(m_autil.is_numeral(idx, _idx)); + VERIFY(aut); + if (aut->is_sink_state(src)) { + propagate_lit(nullptr, 1, &lit, false_literal); + return; + } + if (_idx.get_unsigned() > m_max_unfolding_depth && + m_max_unfolding_lit != null_literal && ctx.get_scope_level() > 0) { + propagate_lit(nullptr, 1, &lit, ~m_max_unfolding_lit); + return; } - SASSERT(m_autil.is_numeral(idx)); - eautomaton::moves mvs; - aut->get_moves_from(src, mvs); - expr_ref len(m_util.str.mk_length(e), m); + expr_ref len = mk_len(e); + literal_vector lits; - lits.push_back(~ctx.get_literal(acc)); + lits.push_back(~lit); if (aut->is_final_state(src)) { lits.push_back(mk_literal(m_autil.mk_le(len, idx))); - switch (ctx.get_assignment(lits.back())) { - case l_true: - return false; - case l_undef: - change = true; - ctx.force_phase(lits.back()); - return true; - default: - break; - } + propagate_lit(nullptr, 1, &lit, mk_literal(m_autil.mk_ge(len, idx))); } - bool has_undef = false; - int start = ctx.get_random_value(); - for (unsigned i = 0; i < mvs.size(); ++i) { - unsigned j = (i + start) % mvs.size(); - eautomaton::move mv = mvs[j]; - expr_ref nth = mk_nth(e, idx); - expr_ref acc = mv.t()->accept(nth); - step = mk_step(e, idx, re, src, mv.dst(), acc); - lits.push_back(mk_literal(step)); - switch (ctx.get_assignment(lits.back())) { - case l_true: - return false; - case l_undef: - //ctx.force_phase(lits.back()); - //return true; - has_undef = true; - break; - default: - break; - } + else { + propagate_lit(nullptr, 1, &lit, ~mk_literal(m_autil.mk_le(len, idx))); } - change = true; - if (has_undef && mvs.size() == 1) { - literal lit = lits.back(); - lits.pop_back(); - for (unsigned i = 0; i < lits.size(); ++i) { - lits[i].neg(); - } - propagate_lit(nullptr, lits.size(), lits.c_ptr(), lit); - return false; - } - if (has_undef) { - return true; - } - TRACE("seq", ctx.display_literals_verbose(tout, lits); tout << "\n";); - for (unsigned i = 0; i < lits.size(); ++i) { - SASSERT(ctx.get_assignment(lits[i]) == l_false); - lits[i].neg(); - } - set_conflict(nullptr, lits); - return false; -} - - -/** - acc(s, idx, re, i) & step(s, idx, re, i, j, t) => acc(s, idx + 1, re, j) -*/ - -bool theory_seq::add_step2accept(expr* step, bool& change) { - context& ctx = get_context(); - SASSERT(ctx.get_assignment(step) == l_true); - expr* re = nullptr, *_acc = nullptr, *s = nullptr, *idx = nullptr, *i = nullptr, *j = nullptr; - VERIFY(is_step(step, s, idx, re, i, j, _acc)); - literal acc1 = mk_accept(s, idx, re, i); - switch (ctx.get_assignment(acc1)) { - case l_false: - break; - case l_undef: - change = true; - return true; - case l_true: { - change = true; - rational r; - VERIFY(m_autil.is_numeral(idx, r) && r.is_unsigned()); - expr_ref idx1(m_autil.mk_int(r.get_unsigned() + 1), m); - literal acc2 = mk_accept(s, idx1, re, j); - literal_vector lits; - lits.push_back(acc1); - lits.push_back(ctx.get_literal(step)); - lits.push_back(~acc2); - switch (ctx.get_assignment(acc2)) { - case l_undef: - propagate_lit(nullptr, 2, lits.c_ptr(), acc2); - break; - case l_true: - break; - case l_false: - set_conflict(nullptr, lits); - break; - } - break; - } - } - return false; -} - - -/* - rej(s, idx, re, i) & nth(s, idx) = t & idx < len(s) => rej(s, idx + 1, re, j) - - len(s) > idx -> s = (nth 0 s) ++ .. ++ (nth idx s) ++ (tail idx s) - -Recall we also have: - rej(s, idx, re, i) -> len(s) >= idx if i is non-final - rej(s, idx, re, i) -> len(s) > idx if i is final - -*/ -bool theory_seq::add_reject2reject(expr* rej, bool& change) { - context& ctx = get_context(); - SASSERT(ctx.get_assignment(rej) == l_true); - expr* s = nullptr, *idx = nullptr, *re = nullptr; - unsigned src; - rational r; - eautomaton* aut = nullptr; - VERIFY(is_reject(rej, s, idx, re, src, aut)); - if (!aut || m_util.str.is_length(idx)) return false; - VERIFY(m_autil.is_numeral(idx, r) && r.is_unsigned()); - expr_ref idx1(m_autil.mk_int(r.get_unsigned() + 1), m); eautomaton::moves mvs; aut->get_moves_from(src, mvs); - literal rej1 = ctx.get_literal(rej); - expr_ref len(m_util.str.mk_length(s), m); - literal len_le_idx = mk_literal(m_autil.mk_le(len, idx)); - switch (ctx.get_assignment(len_le_idx)) { - case l_true: + TRACE("seq", tout << mvs.size() << "\n";); + for (auto const& mv : mvs) { + expr_ref nth = mk_nth(e, idx); + expr_ref t = mv.t()->accept(nth); + ctx.get_rewriter()(t); + literal step = mk_literal(mk_step(e, idx, re, src, mv.dst(), t)); + lits.push_back(step); + } + ctx.mk_th_axiom(get_id(), lits.size(), lits.c_ptr()); +} + +void theory_seq::add_theory_assumptions(expr_ref_vector & assumptions) { + TRACE("seq", tout << "add_theory_assumption " << m_util.has_re() << "\n";); + if (m_util.has_re()) { + expr_ref dlimit(m); + dlimit = mk_max_unfolding_depth(); + m_trail_stack.push(value_trail(m_max_unfolding_lit)); + m_max_unfolding_lit = mk_literal(dlimit); + assumptions.push_back(dlimit); + } +} + +bool theory_seq::should_research(expr_ref_vector & unsat_core) { + TRACE("seq", tout << unsat_core << " " << m_util.has_re() << "\n";); + if (!m_util.has_re()) { return false; - case l_undef: - ctx.force_phase(len_le_idx); - return true; - default: - break; } - expr_ref nth = mk_nth(s, idx); - ensure_nth(~len_le_idx, s, idx); - literal_vector eqs; - bool has_undef = false; - for (eautomaton::move const& mv : mvs) { - literal eq = mk_literal(mv.t()->accept(nth)); - switch (ctx.get_assignment(eq)) { - case l_false: - case l_true: - break; - case l_undef: - ctx.force_phase(~eq); - has_undef = true; - break; - } - eqs.push_back(eq); - } - change = true; - if (has_undef) { - return true; - } - for (unsigned i = 0; i < mvs.size(); ++i) { - eautomaton::move const& mv = mvs[i]; - literal eq = eqs[i]; - if (ctx.get_assignment(eq) == l_true) { - literal rej2 = mk_reject(s, idx1, re, m_autil.mk_int(mv.dst())); - add_axiom(~rej1, ~eq, len_le_idx, rej2); + for (auto & e : unsat_core) { + if (is_max_unfolding(e)) { + m_max_unfolding_depth = (3 * m_max_unfolding_depth) / 2 + 1; + IF_VERBOSE(1, verbose_stream() << "(smt.seq :increase-depth " << m_max_unfolding_depth << ")\n"); + return true; } } return false; } + /* !prefix(e1,e2) => e1 != "" - !prefix(e1,e2) => e2 = "" or e1 = xcy & (e2 = xdz & c != d or x = e2) + !prefix(e1,e2) => len(e1) > len(e2) or e1 = xcy & e2 = xdz & c != d */ void theory_seq::propagate_not_prefix(expr* e) { @@ -5665,8 +5634,7 @@ void theory_seq::propagate_not_prefix(expr* e) { return; } propagate_non_empty(~lit, e1); - expr_ref emp(m_util.str.mk_empty(m.get_sort(e1)), m); - literal e2_is_emp = mk_seq_eq(e2, emp); + literal e1_gt_e2 = mk_simplified_literal(m_autil.mk_ge(mk_sub(mk_len(e1), mk_len(e2)), m_autil.mk_int(1))); sort* char_sort = nullptr; VERIFY(m_util.is_seq(m.get_sort(e1), char_sort)); expr_ref x = mk_skolem(symbol("seq.prefix.x"), e1, e2); @@ -5674,42 +5642,16 @@ void theory_seq::propagate_not_prefix(expr* e) { expr_ref z = mk_skolem(symbol("seq.prefix.z"), e1, e2); expr_ref c = mk_skolem(symbol("seq.prefix.c"), e1, e2, nullptr, nullptr, char_sort); expr_ref d = mk_skolem(symbol("seq.prefix.d"), e1, e2, nullptr, nullptr, char_sort); - add_axiom(lit, e2_is_emp, mk_seq_eq(e1, mk_concat(x, m_util.str.mk_unit(c), y))); - add_axiom(lit, e2_is_emp, mk_seq_eq(e2, mk_concat(x, m_util.str.mk_unit(d), z)), mk_seq_eq(e2, x)); - add_axiom(lit, e2_is_emp, ~mk_eq(c, d, false), mk_seq_eq(e2, x)); + add_axiom(lit, e1_gt_e2, mk_seq_eq(e1, mk_concat(x, m_util.str.mk_unit(c), y))); + add_axiom(lit, e1_gt_e2, mk_seq_eq(e2, mk_concat(x, m_util.str.mk_unit(d), z)), mk_seq_eq(e2, x)); + add_axiom(lit, e1_gt_e2, ~mk_eq(c, d, false)); } -/* - !prefix(e1,e2) => len(e1) > 0 - !prefix(e1,e2) => len(e1) > len(e2) or e2 = pre(e2,len(e1))post(e2,len(e2)-len(e1)) & pre(e2, len(e1)) != e1 -*/ - -void theory_seq::propagate_not_prefix2(expr* e) { - context& ctx = get_context(); - expr* e1 = nullptr, *e2 = nullptr; - VERIFY(m_util.str.is_prefix(e, e1, e2)); - literal lit = ctx.get_literal(e); - SASSERT(ctx.get_assignment(lit) == l_false); - if (canonizes(false, e)) { - return; - } - propagate_non_empty(~lit, e1); - expr_ref len_e1(m_util.str.mk_length(e1), m); - expr_ref len_e2(m_util.str.mk_length(e2), m); - expr_ref len_e2_e1(mk_sub(len_e2, len_e1), m); - expr_ref x = mk_skolem(m_pre, e2, len_e1); - expr_ref y = mk_skolem(m_post, e2, len_e2_e1); - literal e2_ge_e1 = mk_literal(m_autil.mk_ge(len_e2_e1, m_autil.mk_int(0))); - add_axiom(lit, ~e2_ge_e1, mk_seq_eq(e2, mk_concat(x, y))); - add_axiom(lit, ~e2_ge_e1, mk_eq(m_util.str.mk_length(x), len_e1, false)); - add_axiom(lit, ~e2_ge_e1, ~mk_eq(e1, x, false)); -} /* !suffix(e1,e2) => e1 != "" - !suffix(e1,e2) => e2 = "" or e1 = ycx & (e2 = zdx & c != d or x = e2) - */ - + !suffix(e1,e2) => len(e1) > len(e2) or e1 = ycx & e2 = zdx & c != d +*/ void theory_seq::propagate_not_suffix(expr* e) { context& ctx = get_context(); @@ -5721,9 +5663,7 @@ void theory_seq::propagate_not_suffix(expr* e) { return; } propagate_non_empty(~lit, e1); - - expr_ref emp(m_util.str.mk_empty(m.get_sort(e1)), m); - literal e2_is_emp = mk_seq_eq(e2, emp); + literal e1_gt_e2 = mk_simplified_literal(m_autil.mk_ge(mk_sub(mk_len(e1), mk_len(e2)), m_autil.mk_int(1))); sort* char_sort = nullptr; VERIFY(m_util.is_seq(m.get_sort(e1), char_sort)); expr_ref x = mk_skolem(symbol("seq.suffix.x"), e1, e2); @@ -5731,147 +5671,12 @@ void theory_seq::propagate_not_suffix(expr* e) { expr_ref z = mk_skolem(symbol("seq.suffix.z"), e1, e2); expr_ref c = mk_skolem(symbol("seq.suffix.c"), e1, e2, nullptr, nullptr, char_sort); expr_ref d = mk_skolem(symbol("seq.suffix.d"), e1, e2, nullptr, nullptr, char_sort); - add_axiom(lit, e2_is_emp, mk_seq_eq(e1, mk_concat(y, m_util.str.mk_unit(c), x))); - add_axiom(lit, e2_is_emp, mk_seq_eq(e2, mk_concat(z, m_util.str.mk_unit(d), x)), mk_seq_eq(e2, x)); - add_axiom(lit, e2_is_emp, ~mk_eq(c, d, false), mk_seq_eq(e2, x)); + add_axiom(lit, e1_gt_e2, mk_seq_eq(e1, mk_concat(y, m_util.str.mk_unit(c), x))); + add_axiom(lit, e1_gt_e2, mk_seq_eq(e2, mk_concat(z, m_util.str.mk_unit(d), x))); + add_axiom(lit, e1_gt_e2, ~mk_eq(c, d, false)); } -/* - !prefix -> e2 = emp \/ nth(e1,0) != nth(e2,0) \/ !prefix(tail(e1),tail(e2)) -*/ -bool theory_seq::add_prefix2prefix(expr* e, bool& change) { - context& ctx = get_context(); - expr* e1 = nullptr, *e2 = nullptr; - VERIFY(m_util.str.is_prefix(e, e1, e2)); - SASSERT(ctx.get_assignment(e) == l_false); - if (canonizes(false, e)) { - TRACE("seq", tout << mk_pp(e, m) << " is false\n";); - return false; - } - expr_ref head1(m), tail1(m), head2(m), tail2(m), conc(m); - - literal e2_is_emp = mk_eq_empty(e2); - switch (ctx.get_assignment(e2_is_emp)) { - case l_true: - TRACE("seq", tout << mk_pp(e, m) << ": " << mk_pp(e2, m) << " = empty\n"; - ctx.display_literal_verbose(tout, e2_is_emp); tout << "\n"; ); - return false; // done - case l_undef: - // ctx.force_phase(e2_is_emp); - TRACE("seq", tout << mk_pp(e, m) << ": " << mk_pp(e2, m) << " ~ empty\n";); - return true; // retry - default: - break; - } - - mk_decompose(e2, head2, tail2); - conc = mk_concat(head2, tail2); - propagate_eq(~e2_is_emp, e2, conc, true); - - literal e1_is_emp = mk_eq_empty(e1, false); - switch (ctx.get_assignment(e1_is_emp)) { - case l_true: - TRACE("seq", tout << mk_pp(e, m) << ": " << mk_pp(e1, m) << " != empty\n";); - add_axiom(ctx.get_literal(e), ~e1_is_emp); - return false; // done - case l_undef: - TRACE("seq", tout << mk_pp(e, m) << ": " << mk_pp(e1, m) << " ~ empty\n";); - return true; // retry - default: - break; - } - - mk_decompose(e1, head1, tail1); - conc = mk_concat(head1, tail1); - propagate_eq(~e1_is_emp, e1, conc, true); - - - literal lit = mk_eq(head1, head2, false); - switch (ctx.get_assignment(lit)) { - case l_true: - break; - case l_false: - TRACE("seq", tout << mk_pp(e, m) << ": " << head1 << " != " << head2 << "\n";); - return false; - case l_undef: - ctx.force_phase(~lit); - TRACE("seq", tout << mk_pp(e, m) << ": " << head1 << " ~ " << head2 << "\n";); - return true; - } - change = true; - literal_vector lits; - lits.push_back(~ctx.get_literal(e)); - lits.push_back(~e2_is_emp); - lits.push_back(lit); - propagate_lit(nullptr, lits.size(), lits.c_ptr(), ~mk_literal(m_util.str.mk_prefix(tail1, tail2))); - TRACE("seq", tout << mk_pp(e, m) << " saturate: " << tail1 << " = " << tail2 << "\n";); - return false; -} - -/* - !suffix(e1, e2) -> e2 = emp \/ last(e1) != last(e2) \/ !suffix(first(e1), first(e2)) - */ -bool theory_seq::add_suffix2suffix(expr* e, bool& change) { - context& ctx = get_context(); - expr* e1 = nullptr, *e2 = nullptr; - VERIFY(m_util.str.is_suffix(e, e1, e2)); - SASSERT(ctx.get_assignment(e) == l_false); - if (canonizes(false, e)) { - return false; - } - - literal e2_is_emp = mk_eq_empty(e2); - switch (ctx.get_assignment(e2_is_emp)) { - case l_true: - return false; // done - case l_undef: - ctx.force_phase(e2_is_emp); - return true; // retry - case l_false: - break; - } - expr_ref first2 = mk_first(e2); - expr_ref last2 = mk_last(e2); - expr_ref conc2 = mk_concat(first2, m_util.str.mk_unit(last2)); - propagate_eq(~e2_is_emp, e2, conc2, true); - - literal e1_is_emp = mk_eq_empty(e1); - switch (ctx.get_assignment(e1_is_emp)) { - case l_true: - return false; // done - case l_undef: - ctx.force_phase(e1_is_emp); - return true; // retry - case l_false: - break; - } - expr_ref first1 = mk_first(e1); - expr_ref last1 = mk_last(e1); - expr_ref conc1 = mk_concat(first1, m_util.str.mk_unit(last1)); - propagate_eq(~e1_is_emp, e1, conc1, true); - - - literal last_eq = mk_eq(last1, last2, false); - switch (ctx.get_assignment(last_eq)) { - case l_false: - return false; // done - case l_undef: - ctx.force_phase(~last_eq); - return true; - case l_true: - break; - } - - change = true; - literal_vector lits; - lits.push_back(~ctx.get_literal(e)); - lits.push_back(~e2_is_emp); - lits.push_back(last_eq); - propagate_lit(nullptr, lits.size(), lits.c_ptr(), ~mk_literal(m_util.str.mk_suffix(first1, first2))); - TRACE("seq", tout << mk_pp(e, m) << " saturate\n";); - return false; -} bool theory_seq::canonizes(bool sign, expr* e) { context& ctx = get_context(); @@ -5893,91 +5698,17 @@ bool theory_seq::canonizes(bool sign, expr* e) { return false; } -/* - !contains(e1, e2) -> !prefix(e2, e1) - !contains(e1, e2) -> e1 = emp \/ !contains(tail(e1), e2) - */ -bool theory_seq::add_contains2contains(expr* e, bool& change) { - context& ctx = get_context(); - expr* e1 = nullptr, *e2 = nullptr; - VERIFY(m_util.str.is_contains(e, e1, e2)); - SASSERT(ctx.get_assignment(e) == l_false); - if (canonizes(false, e)) { - return false; - } - - literal e1_is_emp = mk_eq_empty(e1); - switch (ctx.get_assignment(e1_is_emp)) { - case l_true: - return false; // done - case l_undef: - ctx.force_phase(e1_is_emp); - return true; // retry - default: - break; - } - change = true; - expr_ref head(m), tail(m), conc(m); - mk_decompose(e1, head, tail); - - conc = mk_concat(head, tail); - propagate_eq(~e1_is_emp, e1, conc, true); - - literal lits[2] = { ~ctx.get_literal(e), ~e1_is_emp }; - propagate_lit(nullptr, 2, lits, ~mk_literal(m_util.str.mk_contains(tail, e2))); - return false; -} - -bool theory_seq::propagate_automata() { - context& ctx = get_context(); - if (m_atoms_qhead == m_atoms.size()) { - return false; - } - m_trail_stack.push(value_trail(m_atoms_qhead)); - ptr_vector re_add; - bool change = false; - while (m_atoms_qhead < m_atoms.size() && !ctx.inconsistent()) { - expr* e = m_atoms[m_atoms_qhead]; - TRACE("seq", tout << mk_pp(e, m) << "\n";); - bool reQ = false; - if (is_accept(e)) { - reQ = add_accept2step(e, change); - } - else if (is_reject(e)) { - reQ = add_reject2reject(e, change); - } - else if (is_step(e)) { - reQ = add_step2accept(e, change); - } - else if (m_util.str.is_prefix(e)) { - reQ = add_prefix2prefix(e, change); - } - else if (m_util.str.is_suffix(e)) { - reQ = add_suffix2suffix(e, change); - } - else if (m_util.str.is_contains(e)) { - reQ = add_contains2contains(e, change); - } - if (reQ) { - re_add.push_back(e); - change = true; - } - ++m_atoms_qhead; - } - m_atoms.append(re_add); - return change || get_context().inconsistent(); -} - -void theory_seq::get_concat(expr* e, ptr_vector& concats) { +void theory_seq::get_ite_concat(expr* e, ptr_vector& concats) { expr* e1 = nullptr, *e2 = nullptr; while (true) { e = m_rep.find(e); + e = get_ite_value(e); if (m_util.str.is_concat(e, e1, e2)) { - get_concat(e1, concats); + get_ite_concat(e1, concats); e = e2; continue; - } + } concats.push_back(e); return; } diff --git a/src/smt/theory_seq.h b/src/smt/theory_seq.h index fbefaede2..9925188b6 100644 --- a/src/smt/theory_seq.h +++ b/src/smt/theory_seq.h @@ -19,9 +19,7 @@ Revision History: #ifndef THEORY_SEQ_H_ #define THEORY_SEQ_H_ -#include "smt/smt_theory.h" #include "ast/seq_decl_plugin.h" -#include "smt/theory_seq_empty.h" #include "ast/rewriter/th_rewriter.h" #include "ast/ast_trail.h" #include "util/scoped_vector.h" @@ -30,6 +28,9 @@ Revision History: #include "ast/rewriter/seq_rewriter.h" #include "util/union_find.h" #include "util/obj_ref_hashtable.h" +#include "smt/smt_theory.h" +#include "smt/smt_arith_value.h" +#include "smt/theory_seq_empty.h" namespace smt { @@ -196,23 +197,28 @@ namespace smt { class nc { expr_ref m_contains; + literal m_len_gt; dependency* m_dep; public: - nc(expr_ref const& c, dependency* dep): + nc(expr_ref const& c, literal len_gt, dependency* dep): m_contains(c), + m_len_gt(len_gt), m_dep(dep) {} nc(nc const& other): m_contains(other.m_contains), + m_len_gt(other.m_len_gt), m_dep(other.m_dep) {} nc& operator=(nc const& other) { if (this != &other) { m_contains = other.m_contains; m_dep = other.m_dep; + m_len_gt = other.m_len_gt; } return *this; } dependency* deps() const { return m_dep; } expr_ref const& contains() const { return m_contains; } + literal len_gt() const { return m_len_gt; } }; class apply { @@ -254,6 +260,18 @@ namespace smt { } }; + + class replay_is_axiom : public apply { + expr_ref m_e; + public: + replay_is_axiom(ast_manager& m, expr* e) : m_e(e, m) {} + ~replay_is_axiom() override {} + void operator()(theory_seq& th) override { + th.check_int_string(m_e); + m_e.reset(); + } + }; + class push_replay : public trail { apply* m_apply; public: @@ -272,6 +290,16 @@ namespace smt { } }; + struct s_in_re { + literal m_lit; + expr* m_s; + expr* m_re; + eautomaton* m_aut; + bool m_active; + s_in_re(literal l, expr*s, expr* re, eautomaton* aut): + m_lit(l), m_s(s), m_re(re), m_aut(aut), m_active(true) {} + }; + void erase_index(unsigned idx, unsigned i); struct stats { @@ -316,15 +344,16 @@ namespace smt { unsigned m_axioms_head; // index of first axiom to add. bool m_incomplete; // is the solver (clearly) incomplete for the fragment. expr_ref_vector m_int_string; - rational_set m_itos_axioms; - rational_set m_stoi_axioms; - obj_hashtable m_length; // is length applied + obj_map m_si_axioms; + obj_hashtable m_has_length; // is length applied + expr_ref_vector m_length; // length applications themselves scoped_ptr_vector m_replay; // set of actions to replay model_generator* m_mg; th_rewriter m_rewrite; seq_rewriter m_seq_rewrite; seq_util m_util; arith_util m_autil; + arith_value m_arith_value; th_trail_stack m_trail_stack; stats m_stats; symbol m_prefix, m_suffix, m_accept, m_reject; @@ -337,11 +366,10 @@ namespace smt { scoped_ptr_vector m_automata; obj_map m_re2aut; expr_ref_vector m_res; + unsigned m_max_unfolding_depth; + literal m_max_unfolding_lit; + vector m_s_in_re; - // queue of asserted atoms - ptr_vector m_atoms; - unsigned_vector m_atoms_lim; - unsigned m_atoms_qhead; bool m_new_solution; // new solution added bool m_new_propagation; // new propagation to core re2automaton m_mk_aut; @@ -362,6 +390,8 @@ namespace smt { void pop_scope_eh(unsigned num_scopes) override; void restart_eh() override; void relevant_eh(app* n) override; + bool should_research(expr_ref_vector &) override; + void add_theory_assumptions(expr_ref_vector & assumptions) override; theory* mk_fresh(context* new_ctx) override { return alloc(theory_seq, new_ctx->get_manager(), m_params); } char const * get_name() const override { return "seq"; } theory_var mk_var(enode* n) override; @@ -374,6 +404,8 @@ namespace smt { void init_search_eh() override; void init_model(expr_ref_vector const& es); + app* get_ite_value(expr* a); + void get_ite_concat(expr* e, ptr_vector& concats); void len_offset(expr* e, rational val); void prop_arith_to_len_offset(); @@ -388,12 +420,13 @@ namespace smt { bool reduce_length_eq(); bool branch_unit_variable(); // branch on XYZ = abcdef bool branch_binary_variable(); // branch on abcX = Ydefg + bool branch_variable(); // branch on bool branch_ternary_variable1(); // branch on XabcY = Zdefg or XabcY = defgZ bool branch_ternary_variable2(); // branch on XabcY = defgZmnpq bool branch_quat_variable(); // branch on XabcY = ZdefgT bool len_based_split(); // split based on len offset bool branch_variable_mb(); // branch on a variable, model based on length - bool branch_variable(); // branch on a variable + bool branch_variable_eq(); // branch on a variable, by an alignment among variable boundaries. bool is_solved(); bool check_length_coherence(); bool check_length_coherence0(expr* e); @@ -401,7 +434,7 @@ namespace smt { bool fixed_length(bool is_zero = false); bool fixed_length(expr* e, bool is_zero); void branch_unit_variable(dependency* dep, expr* X, expr_ref_vector const& units); - bool branch_variable(eq const& e); + bool branch_variable_eq(eq const& e); bool branch_binary_variable(eq const& e); bool eq_unit(expr* const& l, expr* const &r) const; unsigned_vector overlap(expr_ref_vector const& ls, expr_ref_vector const& rs); @@ -419,6 +452,7 @@ namespace smt { vector const& ll, vector const& rl); bool set_empty(expr* x); bool is_complex(eq const& e); + lbool regex_are_equal(expr* r1, expr* r2); bool check_extensionality(); bool check_contains(); @@ -427,6 +461,8 @@ namespace smt { bool simplify_eq(expr_ref_vector& l, expr_ref_vector& r, dependency* dep); bool solve_unit_eq(expr* l, expr* r, dependency* dep); bool solve_unit_eq(expr_ref_vector const& l, expr_ref_vector const& r, dependency* dep); + bool solve_nth_eq(expr_ref_vector const& ls, expr_ref_vector const& rs, dependency* dep); + bool solve_itos(expr_ref_vector const& ls, expr_ref_vector const& rs, dependency* dep); bool is_binary_eq(expr_ref_vector const& l, expr_ref_vector const& r, expr_ref& x, ptr_vector& xunits, ptr_vector& yunits, expr_ref& y); bool is_quat_eq(expr_ref_vector const& ls, expr_ref_vector const& rs, expr_ref& x1, expr_ref_vector& xs, expr_ref& x2, expr_ref& y1, expr_ref_vector& ys, expr_ref& y2); bool is_ternary_eq(expr_ref_vector const& ls, expr_ref_vector const& rs, expr_ref& x, expr_ref_vector& xs, expr_ref& y1, expr_ref_vector& ys, expr_ref& y2, bool flag1); @@ -507,8 +543,6 @@ namespace smt { expr_ref expand1(expr* e, dependency*& eqs); expr_ref try_expand(expr* e, dependency*& eqs); void add_dependency(dependency*& dep, enode* a, enode* b); - - void get_concat(expr* e, ptr_vector& concats); // terms whose meaning are encoded using axioms. void enque_axiom(expr* e); @@ -528,15 +562,16 @@ namespace smt { bool is_extract_suffix(expr* s, expr* i, expr* l); - bool has_length(expr *e) const { return m_length.contains(e); } + bool has_length(expr *e) const { return m_has_length.contains(e); } void add_length(expr* e); - void enforce_length(enode* n); + void enforce_length(expr* n); bool enforce_length(expr_ref_vector const& es, vector& len); void enforce_length_coherence(enode* n1, enode* n2); // model-check the functions that convert integers to strings and the other way. void add_int_string(expr* e); bool check_int_string(); + bool check_int_string(expr* e); expr_ref add_elim_string_axiom(expr* n); void add_at_axiom(expr* n); @@ -545,6 +580,8 @@ namespace smt { void add_stoi_axiom(expr* n); bool add_stoi_val_axiom(expr* n); bool add_itos_val_axiom(expr* n); + void add_si_axiom(expr* s, expr* i, unsigned sz); + void ensure_digit_axiom(); literal is_digit(expr* ch); expr_ref digit2int(expr* ch); void add_itos_length_axiom(expr* n); @@ -552,11 +589,13 @@ namespace smt { literal mk_simplified_literal(expr* n); literal mk_eq_empty(expr* n, bool phase = true); literal mk_seq_eq(expr* a, expr* b); + literal mk_preferred_eq(expr* a, expr* b); void tightest_prefix(expr* s, expr* x); expr_ref mk_sub(expr* a, expr* b); expr_ref mk_add(expr* a, expr* b); + expr_ref mk_len(expr* s) const { return expr_ref(m_util.str.mk_length(s), m); } enode* ensure_enode(expr* a); - + enode* get_root(expr* a) { return ensure_enode(a)->get_root(); } dependency* mk_join(dependency* deps, literal lit); dependency* mk_join(dependency* deps, literal_vector const& lits); @@ -569,7 +608,7 @@ namespace smt { bool get_length(expr* s, rational& val) const; void mk_decompose(expr* e, expr_ref& head, expr_ref& tail); - expr* coalesce_chars(expr* const& str); + expr_ref coalesce_chars(expr* const& str); expr_ref mk_skolem(symbol const& s, expr* e1, expr* e2 = nullptr, expr* e3 = nullptr, expr* e4 = nullptr, sort* range = nullptr); bool is_skolem(symbol const& s, expr* e) const; @@ -581,46 +620,34 @@ namespace smt { literal mk_accept(expr* s, expr* idx, expr* re, expr* state); literal mk_accept(expr* s, expr* idx, expr* re, unsigned i) { return mk_accept(s, idx, re, m_autil.mk_int(i)); } bool is_accept(expr* acc) const { return is_skolem(m_accept, acc); } - bool is_accept(expr* acc, expr*& s, expr*& idx, expr*& re, unsigned& i, eautomaton*& aut) { - return is_acc_rej(m_accept, acc, s, idx, re, i, aut); - } - literal mk_reject(expr* s, expr* idx, expr* re, expr* state); - literal mk_reject(expr* s, expr* idx, expr* re, unsigned i) { return mk_reject(s, idx, re, m_autil.mk_int(i)); } - bool is_reject(expr* rej) const { return is_skolem(m_reject, rej); } - bool is_reject(expr* rej, expr*& s, expr*& idx, expr*& re, unsigned& i, eautomaton*& aut) { - return is_acc_rej(m_reject, rej, s, idx, re, i, aut); - } - bool is_acc_rej(symbol const& ar, expr* e, expr*& s, expr*& idx, expr*& re, unsigned& i, eautomaton*& aut); - expr_ref mk_step(expr* s, expr* tail, expr* re, unsigned i, unsigned j, expr* acc); + bool is_accept(expr* acc, expr*& s, expr*& idx, expr*& re, unsigned& i, eautomaton*& aut); + expr_ref mk_step(expr* s, expr* tail, expr* re, unsigned i, unsigned j, expr* t); bool is_step(expr* e, expr*& s, expr*& tail, expr*& re, expr*& i, expr*& j, expr*& t) const; bool is_step(expr* e) const; - void propagate_step(literal lit, expr* n); - bool add_reject2reject(expr* rej, bool& change); - bool add_accept2step(expr* acc, bool& change); - bool add_step2accept(expr* step, bool& change); - bool add_prefix2prefix(expr* e, bool& change); - bool add_suffix2suffix(expr* e, bool& change); - bool add_contains2contains(expr* e, bool& change); + bool is_max_unfolding(expr* e) const { return is_skolem(symbol("seq.max_unfolding_depth"), e); } + expr_ref mk_max_unfolding_depth() { + return mk_skolem(symbol("seq.max_unfolding_depth"), + m_autil.mk_int(m_max_unfolding_depth), + nullptr, nullptr, nullptr, m.mk_bool_sort()); + } void propagate_not_prefix(expr* e); - void propagate_not_prefix2(expr* e); void propagate_not_suffix(expr* e); void ensure_nth(literal lit, expr* s, expr* idx); bool canonizes(bool sign, expr* e); void propagate_non_empty(literal lit, expr* s); bool propagate_is_conc(expr* e, expr* conc); - void propagate_acc_rej_length(literal lit, expr* acc_rej); - bool propagate_automata(); - void add_atom(expr* e); + void propagate_step(literal lit, expr* n); + void propagate_accept(literal lit, expr* e); void new_eq_eh(dependency* dep, enode* n1, enode* n2); // diagnostics - void display_equations(std::ostream& out) const; - void display_equation(std::ostream& out, eq const& e) const; - void display_disequations(std::ostream& out) const; - void display_disequation(std::ostream& out, ne const& e) const; - void display_deps(std::ostream& out, dependency* deps) const; - void display_deps(std::ostream& out, literal_vector const& lits, enode_pair_vector const& eqs) const; - void display_nc(std::ostream& out, nc const& nc) const; + std::ostream& display_equations(std::ostream& out) const; + std::ostream& display_equation(std::ostream& out, eq const& e) const; + std::ostream& display_disequations(std::ostream& out) const; + std::ostream& display_disequation(std::ostream& out, ne const& e) const; + std::ostream& display_deps(std::ostream& out, dependency* deps) const; + std::ostream& display_deps(std::ostream& out, literal_vector const& lits, enode_pair_vector const& eqs) const; + std::ostream& display_nc(std::ostream& out, nc const& nc) const; public: theory_seq(ast_manager& m, theory_seq_params const & params); ~theory_seq() override; diff --git a/src/smt/theory_str.cpp b/src/smt/theory_str.cpp index aadcb63a7..02801648a 100644 --- a/src/smt/theory_str.cpp +++ b/src/smt/theory_str.cpp @@ -110,7 +110,7 @@ namespace smt { public: seq_expr_solver(ast_manager& m, smt_params& fp): m_kernel(m, fp) {} - virtual lbool check_sat(expr* e) { + lbool check_sat(expr* e) override { m_kernel.push(); m_kernel.assert_expr(e); lbool r = m_kernel.check(); @@ -505,7 +505,7 @@ namespace smt { app * a = mk_fresh_const(name.c_str(), int_sort); ctx.internalize(a, false); - SASSERT(ctx.get_enode(a) != NULL); + SASSERT(ctx.get_enode(a) != nullptr); SASSERT(ctx.e_internalized(a)); ctx.mark_as_relevant(a); // I'm assuming that this combination will do the correct thing in the integer theory. @@ -544,7 +544,7 @@ namespace smt { // I have a hunch that this may not get internalized for free... ctx.internalize(a, false); - SASSERT(ctx.get_enode(a) != NULL); + SASSERT(ctx.get_enode(a) != nullptr); SASSERT(ctx.e_internalized(a)); // this might help?? mk_var(ctx.get_enode(a)); @@ -566,7 +566,7 @@ namespace smt { m_trail.push_back(a); ctx.internalize(a, false); - SASSERT(ctx.get_enode(a) != NULL); + SASSERT(ctx.get_enode(a) != nullptr); SASSERT(ctx.e_internalized(a)); mk_var(ctx.get_enode(a)); m_basicstr_axiom_todo.push_back(ctx.get_enode(a)); @@ -617,7 +617,7 @@ namespace smt { app * a = mk_fresh_const(name.c_str(), string_sort); ctx.internalize(a, false); - SASSERT(ctx.get_enode(a) != NULL); + SASSERT(ctx.get_enode(a) != nullptr); // this might help?? mk_var(ctx.get_enode(a)); @@ -710,7 +710,7 @@ namespace smt { * Returns the simplified concatenation of two expressions, * where either both expressions are constant strings * or one expression is the empty string. - * If this precondition does not hold, the function returns NULL. + * If this precondition does not hold, the function returns nullptr. * (note: this function was strTheory::Concat()) */ expr * theory_str::mk_concat_const_str(expr * n1, expr * n2) { @@ -1661,53 +1661,66 @@ namespace smt { } } + // (str.replace s t t') is the string obtained by replacing the first occurrence + // of t in s, if any, by t'. Note that if t is empty, the result is to prepend + // t' to s; also, if t does not occur in s then the result is s. void theory_str::instantiate_axiom_Replace(enode * e) { context & ctx = get_context(); ast_manager & m = get_manager(); - app * expr = e->get_owner(); - if (axiomatized_terms.contains(expr)) { - TRACE("str", tout << "already set up Replace axiom for " << mk_pp(expr, m) << std::endl;); + app * ex = e->get_owner(); + if (axiomatized_terms.contains(ex)) { + TRACE("str", tout << "already set up Replace axiom for " << mk_pp(ex, m) << std::endl;); return; } - axiomatized_terms.insert(expr); + axiomatized_terms.insert(ex); - TRACE("str", tout << "instantiate Replace axiom for " << mk_pp(expr, m) << std::endl;); + TRACE("str", tout << "instantiate Replace axiom for " << mk_pp(ex, m) << std::endl;); expr_ref x1(mk_str_var("x1"), m); expr_ref x2(mk_str_var("x2"), m); expr_ref i1(mk_int_var("i1"), m); expr_ref result(mk_str_var("result"), m); + expr * replaceS; + expr * replaceT; + expr * replaceTPrime; + u.str.is_replace(ex, replaceS, replaceT, replaceTPrime); + + // t empty => result = (str.++ t' s) + expr_ref emptySrcAst(ctx.mk_eq_atom(replaceT, mk_string("")), m); + expr_ref prependTPrimeToS(ctx.mk_eq_atom(result, mk_concat(replaceTPrime, replaceS)), m); + // condAst = Contains(args[0], args[1]) - expr_ref condAst(mk_contains(expr->get_arg(0), expr->get_arg(1)), m); + expr_ref condAst(mk_contains(ex->get_arg(0), ex->get_arg(1)), m); // ----------------------- // true branch expr_ref_vector thenItems(m); // args[0] = x1 . args[1] . x2 - thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x1, mk_concat(expr->get_arg(1), x2)))); + thenItems.push_back(ctx.mk_eq_atom(ex->get_arg(0), mk_concat(x1, mk_concat(ex->get_arg(1), x2)))); // i1 = |x1| thenItems.push_back(ctx.mk_eq_atom(i1, mk_strlen(x1))); // args[0] = x3 . x4 /\ |x3| = |x1| + |args[1]| - 1 /\ ! contains(x3, args[1]) expr_ref x3(mk_str_var("x3"), m); expr_ref x4(mk_str_var("x4"), m); - expr_ref tmpLen(m_autil.mk_add(i1, mk_strlen(expr->get_arg(1)), mk_int(-1)), m); - thenItems.push_back(ctx.mk_eq_atom(expr->get_arg(0), mk_concat(x3, x4))); + expr_ref tmpLen(m_autil.mk_add(i1, mk_strlen(ex->get_arg(1)), mk_int(-1)), m); + thenItems.push_back(ctx.mk_eq_atom(ex->get_arg(0), mk_concat(x3, x4))); thenItems.push_back(ctx.mk_eq_atom(mk_strlen(x3), tmpLen)); - thenItems.push_back(mk_not(m, mk_contains(x3, expr->get_arg(1)))); - thenItems.push_back(ctx.mk_eq_atom(result, mk_concat(x1, mk_concat(expr->get_arg(2), x2)))); + thenItems.push_back(mk_not(m, mk_contains(x3, ex->get_arg(1)))); + thenItems.push_back(ctx.mk_eq_atom(result, mk_concat(x1, mk_concat(ex->get_arg(2), x2)))); // ----------------------- // false branch - expr_ref elseBranch(ctx.mk_eq_atom(result, expr->get_arg(0)), m); + expr_ref elseBranch(ctx.mk_eq_atom(result, ex->get_arg(0)), m); th_rewriter rw(m); - expr_ref breakdownAssert(m.mk_ite(condAst, m.mk_and(thenItems.size(), thenItems.c_ptr()), elseBranch), m); + expr_ref breakdownAssert(m.mk_ite(emptySrcAst, prependTPrimeToS, + m.mk_ite(condAst, mk_and(thenItems), elseBranch)), m); expr_ref breakdownAssert_rw(breakdownAssert, m); rw(breakdownAssert_rw); assert_axiom(breakdownAssert_rw); - expr_ref reduceToResult(ctx.mk_eq_atom(expr, result), m); + expr_ref reduceToResult(ctx.mk_eq_atom(ex, result), m); expr_ref reduceToResult_rw(reduceToResult, m); rw(reduceToResult_rw); assert_axiom(reduceToResult_rw); @@ -2148,7 +2161,7 @@ namespace smt { // Evaluates the concatenation (n1 . n2) with respect to // the current equivalence classes of n1 and n2. // Returns a constant string expression representing this concatenation - // if one can be determined, or NULL if this is not possible. + // if one can be determined, or nullptr if this is not possible. expr * theory_str::eval_concat(expr * n1, expr * n2) { bool n1HasEqcValue = false; bool n2HasEqcValue = false; @@ -2222,7 +2235,7 @@ namespace smt { for (enode_vector::iterator parent_it = current_parents.begin(); parent_it != current_parents.end(); ++parent_it) { enode * e_parent = *parent_it; - SASSERT(e_parent != NULL); + SASSERT(e_parent != nullptr); app * a_parent = e_parent->get_owner(); TRACE("str", tout << "considering parent " << mk_ismt2_pp(a_parent, m) << std::endl;); @@ -2501,7 +2514,7 @@ namespace smt { } } - if (resolvedMap.size() == 0) { + if (resolvedMap.empty()) { // no simplification possible return node; } else { @@ -4835,41 +4848,25 @@ namespace smt { return n; } - // from Z3: theory_seq.cpp - - static theory_mi_arith* get_th_arith(context& ctx, theory_id afid, expr* e) { - theory* th = ctx.get_theory(afid); - if (th && ctx.e_internalized(e)) { - return dynamic_cast(th); - } - else { - return nullptr; - } - } - bool theory_str::get_arith_value(expr* e, rational& val) const { - context& ctx = get_context(); - ast_manager & m = get_manager(); - // safety - if (!ctx.e_internalized(e)) { - return false; - } - // if an integer constant exists in the eqc, it should be the root - enode * en_e = ctx.get_enode(e); - enode * root_e = en_e->get_root(); - if (m_autil.is_numeral(root_e->get_owner(), val) && val.is_int()) { - TRACE("str", tout << mk_pp(e, m) << " ~= " << mk_pp(root_e->get_owner(), m) << std::endl;); - return true; - } else { - TRACE("str", tout << "root of eqc of " << mk_pp(e, m) << " is not a numeral" << std::endl;); - return false; - theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), e); - if (!tha) return false; - expr_ref val_e(m); - if (tha->get_value(root_e, val_e) && m_autil.is_numeral(val_e, val) && val.is_int()) return true; - return false; - } - } + context& ctx = get_context(); + ast_manager & m = get_manager(); + if (!ctx.e_internalized(e)) { + return false; + } + // check root of the eqc for an integer constant + // if an integer constant exists in the eqc, it should be the root + enode * en_e = ctx.get_enode(e); + enode * root_e = en_e->get_root(); + if (m_autil.is_numeral(root_e->get_owner(), val) && val.is_int()) { + TRACE("str", tout << mk_pp(e, m) << " ~= " << mk_pp(root_e->get_owner(), m) << std::endl;); + return true; + } else { + TRACE("str", tout << "root of eqc of " << mk_pp(e, m) << " is not a numeral" << std::endl;); + return false; + } + + } bool theory_str::lower_bound(expr* _e, rational& lo) { if (opt_DisableIntegerTheoryIntegration) { @@ -4877,12 +4874,10 @@ namespace smt { return false; } - context& ctx = get_context(); - ast_manager & m = get_manager(); - theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), _e); - expr_ref _lo(m); - if (!tha || !tha->get_lower(ctx.get_enode(_e), _lo)) return false; - return m_autil.is_numeral(_lo, lo) && lo.is_int(); + arith_value v(get_manager()); + v.init(&get_context()); + bool strict; + return v.get_lo_equiv(_e, lo, strict); } bool theory_str::upper_bound(expr* _e, rational& hi) { @@ -4891,12 +4886,10 @@ namespace smt { return false; } - context& ctx = get_context(); - ast_manager & m = get_manager(); - theory_mi_arith* tha = get_th_arith(ctx, m_autil.get_family_id(), _e); - expr_ref _hi(m); - if (!tha || !tha->get_upper(ctx.get_enode(_e), _hi)) return false; - return m_autil.is_numeral(_hi, hi) && hi.is_int(); + arith_value v(get_manager()); + v.init(&get_context()); + bool strict; + return v.get_up_equiv(_e, hi, strict); } bool theory_str::get_len_value(expr* e, rational& val) { @@ -4908,17 +4901,6 @@ namespace smt { context& ctx = get_context(); ast_manager & m = get_manager(); - theory* th = ctx.get_theory(m_autil.get_family_id()); - if (!th) { - TRACE("str", tout << "oops, can't get m_autil's theory" << std::endl;); - return false; - } - theory_mi_arith* tha = dynamic_cast(th); - if (!tha) { - TRACE("str", tout << "oops, can't cast to theory_mi_arith" << std::endl;); - return false; - } - TRACE("str", tout << "checking len value of " << mk_ismt2_pp(e, m) << std::endl;); rational val1; @@ -5107,7 +5089,7 @@ namespace smt { } } else { // ------------------------------------------------------------------------------------------------ - // subStr doesn't have an eqc contant value + // subStr doesn't have an eqc constant value // however, subStr equals to some concat(arg_1, arg_2, ..., arg_n) // if arg_j is a constant and is not a part of the strConst, it's sure that the contains is false // ** This check is needed here because the "strConst" and "strAst" may not be in a same eqc yet @@ -5485,7 +5467,7 @@ namespace smt { } if (implyR) { - if (litems1.size() == 0) { + if (litems1.empty()) { assert_axiom(implyR); } else { assert_implication(mk_and(litems1), implyR); @@ -5608,7 +5590,7 @@ namespace smt { tout << " " << mk_pp(el, m); } tout << std::endl; - if (constStrAst == NULL) { + if (constStrAst == nullptr) { tout << "constStrAst = NULL" << std::endl; } else { tout << "constStrAst = " << mk_pp(constStrAst, m) << std::endl; @@ -6745,8 +6727,8 @@ namespace smt { } unsigned theory_str::estimate_automata_intersection_difficulty(eautomaton * aut1, eautomaton * aut2) { - ENSURE(aut1 != NULL); - ENSURE(aut2 != NULL); + ENSURE(aut1 != nullptr); + ENSURE(aut2 != nullptr); return _qmul(aut1->num_states(), aut2->num_states()); } @@ -6999,7 +6981,7 @@ namespace smt { * and the equality with 0 is based on whether solutions of length 0 are allowed. */ void theory_str::find_automaton_initial_bounds(expr * str_in_re, eautomaton * aut) { - ENSURE(aut != NULL); + ENSURE(aut != nullptr); context & ctx = get_context(); ast_manager & m = get_manager(); @@ -7051,9 +7033,9 @@ namespace smt { * if it exists, or -1 otherwise. */ bool theory_str::refine_automaton_lower_bound(eautomaton * aut, rational current_lower_bound, rational & refined_lower_bound) { - ENSURE(aut != NULL); + ENSURE(aut != nullptr); - if (aut->final_states().size() < 1) { + if (aut->final_states().empty()) { // no solutions at all refined_lower_bound = rational::minus_one(); return false; @@ -7161,7 +7143,7 @@ namespace smt { * if a shorter solution exists, or -1 otherwise. */ bool theory_str::refine_automaton_upper_bound(eautomaton * aut, rational current_upper_bound, rational & refined_upper_bound) { - ENSURE(aut != NULL); + ENSURE(aut != nullptr); if (aut->final_states().empty()) { // no solutions at all! @@ -7237,20 +7219,18 @@ namespace smt { expr_ref theory_str::aut_path_rewrite_constraint(expr * cond, expr * ch_var) { context & ctx = get_context(); ast_manager & m = get_manager(); - bv_util bvu(m); expr_ref retval(m); - - rational char_val; - unsigned int bv_width; + + unsigned char_val = 0; expr * lhs; expr * rhs; - if (bvu.is_numeral(cond, char_val, bv_width)) { - SASSERT(char_val.is_nonneg() && char_val.get_unsigned() < 256); + if (u.is_const_char(cond, char_val)) { + SASSERT(char_val < 256); TRACE("str", tout << "rewrite character constant " << char_val << std::endl;); - zstring str_const(char_val.get_unsigned()); + zstring str_const(char_val); retval = u.str.mk_string(str_const); return retval; } else if (is_var(cond)) { @@ -7280,7 +7260,7 @@ namespace smt { return retval; } else { TRACE("str", tout << "ERROR: unrecognized automaton path constraint " << mk_pp(cond, m) << ", cannot translate" << std::endl;); - retval = NULL; + retval = nullptr; return retval; } } @@ -7293,7 +7273,7 @@ namespace smt { * are returned in `characterConstraints`. */ expr_ref theory_str::generate_regex_path_constraints(expr * stringTerm, eautomaton * aut, rational lenVal, expr_ref & characterConstraints) { - ENSURE(aut != NULL); + ENSURE(aut != nullptr); context & ctx = get_context(); ast_manager & m = get_manager(); @@ -7395,23 +7375,20 @@ namespace smt { } else if (mv.t()->is_range()) { expr_ref range_lo(mv.t()->get_lo(), m); expr_ref range_hi(mv.t()->get_hi(), m); - bv_util bvu(m); - rational lo_val, hi_val; - unsigned int bv_width; + unsigned lo_val, hi_val; - if (bvu.is_numeral(range_lo, lo_val, bv_width) && bvu.is_numeral(range_hi, hi_val, bv_width)) { + if (u.is_const_char(range_lo, lo_val) && u.is_const_char(range_hi, hi_val)) { TRACE("str", tout << "make range predicate from " << lo_val << " to " << hi_val << std::endl;); expr_ref cond_rhs(m); if (hi_val < lo_val) { - rational tmp = lo_val; - lo_val = hi_val; - hi_val = tmp; + // NSB: why? The range would be empty. + std::swap(lo_val, hi_val); } expr_ref_vector cond_rhs_terms(m); - for (unsigned i = lo_val.get_unsigned(); i <= hi_val.get_unsigned(); ++i) { + for (unsigned i = lo_val; i <= hi_val; ++i) { zstring str_const(i); expr_ref str_expr(u.str.mk_string(str_const), m); cond_rhs_terms.push_back(ctx.mk_eq_atom(ch, str_expr)); @@ -7519,15 +7496,12 @@ namespace smt { expr_ref newConcat(m); if (arg1 != a1 || arg2 != a2) { TRACE("str", tout << "resolved concat argument(s) to eqc string constants" << std::endl;); - int iPos = 0; expr_ref_vector item1(m); if (a1 != arg1) { item1.push_back(ctx.mk_eq_atom(a1, arg1)); - iPos += 1; } if (a2 != arg2) { item1.push_back(ctx.mk_eq_atom(a2, arg2)); - iPos += 1; } expr_ref implyL1(mk_and(item1), m); newConcat = mk_concat(arg1, arg2); @@ -7820,7 +7794,7 @@ namespace smt { generate_mutual_exclusion(arrangement_disjunction); } } /* (arg1Len != 1 || arg2Len != 1) */ - } /* if (Concat(arg1, arg2) == NULL) */ + } /* if (Concat(arg1, arg2) == nullptr) */ } } } @@ -8145,31 +8119,7 @@ namespace smt { // BEGIN new_eq_handler() in strTheory - { - rational nn1Len, nn2Len; - bool nn1Len_exists = get_len_value(lhs, nn1Len); - bool nn2Len_exists = get_len_value(rhs, nn2Len); - expr_ref emptyStr(mk_string(""), m); - - if (nn1Len_exists && nn1Len.is_zero()) { - if (!in_same_eqc(lhs, emptyStr) && rhs != emptyStr) { - expr_ref eql(ctx.mk_eq_atom(mk_strlen(lhs), mk_int(0)), m); - expr_ref eqr(ctx.mk_eq_atom(lhs, emptyStr), m); - expr_ref toAssert(ctx.mk_eq_atom(eql, eqr), m); - assert_axiom(toAssert); - } - } - - if (nn2Len_exists && nn2Len.is_zero()) { - if (!in_same_eqc(rhs, emptyStr) && lhs != emptyStr) { - expr_ref eql(ctx.mk_eq_atom(mk_strlen(rhs), mk_int(0)), m); - expr_ref eqr(ctx.mk_eq_atom(rhs, emptyStr), m); - expr_ref toAssert(ctx.mk_eq_atom(eql, eqr), m); - assert_axiom(toAssert); - } - } - } - + check_eqc_empty_string(lhs, rhs); instantiate_str_eq_length_axiom(ctx.get_enode(lhs), ctx.get_enode(rhs)); // group terms by equivalence class (groupNodeInEqc()) @@ -8221,62 +8171,17 @@ namespace smt { ); // step 1: Concat == Concat - int hasCommon = 0; - if (eqc_concat_lhs.size() != 0 && eqc_concat_rhs.size() != 0) { - std::set::iterator itor1 = eqc_concat_lhs.begin(); - std::set::iterator itor2 = eqc_concat_rhs.begin(); - for (; itor1 != eqc_concat_lhs.end(); itor1++) { - if (eqc_concat_rhs.find(*itor1) != eqc_concat_rhs.end()) { - hasCommon = 1; - break; - } - } - for (; itor2 != eqc_concat_rhs.end(); itor2++) { - if (eqc_concat_lhs.find(*itor2) != eqc_concat_lhs.end()) { - hasCommon = 1; - break; - } - } - if (hasCommon == 0) { - if (opt_ConcatOverlapAvoid) { - bool found = false; - // check each pair and take the first ones that won't immediately overlap - for (itor1 = eqc_concat_lhs.begin(); itor1 != eqc_concat_lhs.end() && !found; ++itor1) { - expr * concat_lhs = *itor1; - for (itor2 = eqc_concat_rhs.begin(); itor2 != eqc_concat_rhs.end() && !found; ++itor2) { - expr * concat_rhs = *itor2; - if (will_result_in_overlap(concat_lhs, concat_rhs)) { - TRACE("str", tout << "Concats " << mk_pp(concat_lhs, m) << " and " - << mk_pp(concat_rhs, m) << " will result in overlap; skipping." << std::endl;); - } else { - TRACE("str", tout << "Concats " << mk_pp(concat_lhs, m) << " and " - << mk_pp(concat_rhs, m) << " won't overlap. Simplifying here." << std::endl;); - simplify_concat_equality(concat_lhs, concat_rhs); - found = true; - break; - } - } - } - if (!found) { - TRACE("str", tout << "All pairs of concats expected to overlap, falling back." << std::endl;); - simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin())); - } - } else { - // default behaviour - simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin())); - } - } - } + check_eqc_concat_concat(eqc_concat_lhs, eqc_concat_rhs); // step 2: Concat == Constant - if (eqc_const_lhs.size() != 0) { + if (!eqc_const_lhs.empty()) { expr * conStr = *(eqc_const_lhs.begin()); std::set::iterator itor2 = eqc_concat_rhs.begin(); for (; itor2 != eqc_concat_rhs.end(); itor2++) { solve_concat_eq_str(*itor2, conStr); } - } else if (eqc_const_rhs.size() != 0) { + } else if (!eqc_const_rhs.empty()) { expr* conStr = *(eqc_const_rhs.begin()); std::set::iterator itor1 = eqc_concat_lhs.begin(); for (; itor1 != eqc_concat_lhs.end(); itor1++) { @@ -8319,6 +8224,86 @@ namespace smt { } + // Check that a string's length can be 0 iff it is the empty string. + void theory_str::check_eqc_empty_string(expr * lhs, expr * rhs) { + context & ctx = get_context(); + ast_manager & m = get_manager(); + + rational nn1Len, nn2Len; + bool nn1Len_exists = get_len_value(lhs, nn1Len); + bool nn2Len_exists = get_len_value(rhs, nn2Len); + expr_ref emptyStr(mk_string(""), m); + + if (nn1Len_exists && nn1Len.is_zero()) { + if (!in_same_eqc(lhs, emptyStr) && rhs != emptyStr) { + expr_ref eql(ctx.mk_eq_atom(mk_strlen(lhs), mk_int(0)), m); + expr_ref eqr(ctx.mk_eq_atom(lhs, emptyStr), m); + expr_ref toAssert(ctx.mk_eq_atom(eql, eqr), m); + assert_axiom(toAssert); + } + } + + if (nn2Len_exists && nn2Len.is_zero()) { + if (!in_same_eqc(rhs, emptyStr) && lhs != emptyStr) { + expr_ref eql(ctx.mk_eq_atom(mk_strlen(rhs), mk_int(0)), m); + expr_ref eqr(ctx.mk_eq_atom(rhs, emptyStr), m); + expr_ref toAssert(ctx.mk_eq_atom(eql, eqr), m); + assert_axiom(toAssert); + } + } + } + + void theory_str::check_eqc_concat_concat(std::set & eqc_concat_lhs, std::set & eqc_concat_rhs) { + ast_manager & m = get_manager(); + + int hasCommon = 0; + if (!eqc_concat_lhs.empty() && !eqc_concat_rhs.empty()) { + std::set::iterator itor1 = eqc_concat_lhs.begin(); + std::set::iterator itor2 = eqc_concat_rhs.begin(); + for (; itor1 != eqc_concat_lhs.end(); itor1++) { + if (eqc_concat_rhs.find(*itor1) != eqc_concat_rhs.end()) { + hasCommon = 1; + break; + } + } + for (; itor2 != eqc_concat_rhs.end(); itor2++) { + if (eqc_concat_lhs.find(*itor2) != eqc_concat_lhs.end()) { + hasCommon = 1; + break; + } + } + if (hasCommon == 0) { + if (opt_ConcatOverlapAvoid) { + bool found = false; + // check each pair and take the first ones that won't immediately overlap + for (itor1 = eqc_concat_lhs.begin(); itor1 != eqc_concat_lhs.end() && !found; ++itor1) { + expr * concat_lhs = *itor1; + for (itor2 = eqc_concat_rhs.begin(); itor2 != eqc_concat_rhs.end() && !found; ++itor2) { + expr * concat_rhs = *itor2; + if (will_result_in_overlap(concat_lhs, concat_rhs)) { + TRACE("str", tout << "Concats " << mk_pp(concat_lhs, m) << " and " + << mk_pp(concat_rhs, m) << " will result in overlap; skipping." << std::endl;); + } else { + TRACE("str", tout << "Concats " << mk_pp(concat_lhs, m) << " and " + << mk_pp(concat_rhs, m) << " won't overlap. Simplifying here." << std::endl;); + simplify_concat_equality(concat_lhs, concat_rhs); + found = true; + break; + } + } + } + if (!found) { + TRACE("str", tout << "All pairs of concats expected to overlap, falling back." << std::endl;); + simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin())); + } + } else { + // default behaviour + simplify_concat_equality(*(eqc_concat_lhs.begin()), *(eqc_concat_rhs.begin())); + } + } + } + } + void theory_str::set_up_axioms(expr * ex) { ast_manager & m = get_manager(); context & ctx = get_context(); @@ -8592,13 +8577,13 @@ namespace smt { obj_map >::iterator varItor = cut_var_map.begin(); while (varItor != cut_var_map.end()) { std::stack & val = cut_var_map[varItor->m_key]; - while ((val.size() > 0) && (val.top()->level != 0) && (val.top()->level >= sLevel)) { + while ((!val.empty()) && (val.top()->level != 0) && (val.top()->level >= sLevel)) { // TRACE("str", tout << "remove cut info for " << mk_pp(e, get_manager()) << std::endl; print_cut_var(e, tout);); // T_cut * aCut = val.top(); val.pop(); // dealloc(aCut); } - if (val.size() == 0) { + if (val.empty()) { cutvarmap_removes.insert(varItor->m_key); } varItor++; @@ -9424,22 +9409,22 @@ namespace smt { } } - if (depMap.size() == 0) { + if (depMap.empty()) { std::map::iterator itor = strVarMap.begin(); for (; itor != strVarMap.end(); itor++) { expr * var = get_alias_index_ast(aliasIndexMap, itor->first); if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) { freeVarMap[var] = 1; } else { - int lrConstainted = 0; + int lrConstrained = 0; std::map::iterator lrit = freeVarMap.begin(); for (; lrit != freeVarMap.end(); lrit++) { if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) { - lrConstainted = 1; + lrConstrained = 1; break; } } - if (lrConstainted == 0) { + if (lrConstrained == 0) { freeVarMap[var] = 1; } } @@ -9458,15 +9443,15 @@ namespace smt { if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) { freeVarMap[var] = 1; } else { - int lrConstainted = 0; + int lrConstrained = 0; std::map::iterator lrit = freeVarMap.begin(); for (; lrit != freeVarMap.end(); lrit++) { if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) { - lrConstainted = 1; + lrConstrained = 1; break; } } - if (lrConstainted == 0) { + if (lrConstrained == 0) { freeVarMap[var] = 1; } } @@ -9478,15 +9463,15 @@ namespace smt { if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) { freeVarMap[var] = 1; } else { - int lrConstainted = 0; + int lrConstrained = 0; std::map::iterator lrit = freeVarMap.begin(); for (; lrit != freeVarMap.end(); lrit++) { if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) { - lrConstainted = 1; + lrConstrained = 1; break; } } - if (lrConstainted == 0) { + if (lrConstrained == 0) { freeVarMap[var] = 1; } } @@ -9507,15 +9492,15 @@ namespace smt { if (lrConstrainedMap.find(var) == lrConstrainedMap.end()) { freeVarMap[var] = 1; } else { - int lrConstainted = 0; + int lrConstrained = 0; std::map::iterator lrit = freeVarMap.begin(); for (; lrit != freeVarMap.end(); lrit++) { if (lrConstrainedMap[var].find(lrit->first) != lrConstrainedMap[var].end()) { - lrConstainted = 1; + lrConstrained = 1; break; } } - if (lrConstainted == 0) { + if (lrConstrained == 0) { freeVarMap[var] = 1; } } @@ -9769,7 +9754,7 @@ namespace smt { expr_ref concatlenExpr (mk_strlen(concat), m) ; bool allLeafResolved = true; if (! get_arith_value(concatlenExpr, lenValue)) { - // the length fo concat is unresolved yet + // the length of concat is unresolved yet if (get_len_value(concat, lenValue)) { // but all leaf nodes have length information TRACE("str", tout << "* length pop-up: " << mk_ismt2_pp(concat, m) << "| = " << lenValue << std::endl;); @@ -9830,6 +9815,732 @@ namespace smt { } } + void theory_str::solve_regex_automata() { + context & ctx = get_context(); + ast_manager & m = get_manager(); + + // TODO since heuristics might fail, the "no progress" flag might need to be handled specially here + bool regex_axiom_add = false; + for (obj_hashtable::iterator it = regex_terms.begin(); it != regex_terms.end(); ++it) { + expr * str_in_re = *it; + expr * str = nullptr; + expr * re = nullptr; + u.str.is_in_re(str_in_re, str, re); + lbool current_assignment = ctx.get_assignment(str_in_re); + TRACE("str", tout << "regex term: " << mk_pp(str, m) << " in " << mk_pp(re, m) << " : " << current_assignment << std::endl;); + if (current_assignment == l_undef) { + continue; + } + + if (!regex_terms_with_length_constraints.contains(str_in_re)) { + if (current_assignment == l_true && check_regex_length_linearity(re)) { + TRACE("str", tout << "regex length constraints expected to be linear -- generating and asserting them" << std::endl;); + + if (regex_term_to_length_constraint.contains(str_in_re)) { + // use existing length constraint + expr * top_level_length_constraint = nullptr; + regex_term_to_length_constraint.find(str_in_re, top_level_length_constraint); + + ptr_vector extra_length_vars; + regex_term_to_extra_length_vars.find(str_in_re, extra_length_vars); + + assert_axiom(top_level_length_constraint); + for(ptr_vector::iterator it = extra_length_vars.begin(); it != extra_length_vars.end(); ++it) { + expr * v = *it; + refresh_theory_var(v); + expr_ref len_constraint(m_autil.mk_ge(v, m_autil.mk_numeral(rational::zero(), true)), m); + assert_axiom(len_constraint); + } + } else { + // generate new length constraint + expr_ref_vector extra_length_vars(m); + expr_ref _top_level_length_constraint = infer_all_regex_lengths(mk_strlen(str), re, extra_length_vars); + expr_ref top_level_length_constraint(_top_level_length_constraint, m); + th_rewriter rw(m); + rw(top_level_length_constraint); + TRACE("str", tout << "top-level length constraint: " << mk_pp(top_level_length_constraint, m) << std::endl;); + // assert and track length constraint + assert_axiom(top_level_length_constraint); + for(expr_ref_vector::iterator it = extra_length_vars.begin(); it != extra_length_vars.end(); ++it) { + expr * v = *it; + expr_ref len_constraint(m_autil.mk_ge(v, m_autil.mk_numeral(rational::zero(), true)), m); + assert_axiom(len_constraint); + } + + regex_term_to_length_constraint.insert(str_in_re, top_level_length_constraint); + ptr_vector vtmp; + for(expr_ref_vector::iterator it = extra_length_vars.begin(); it != extra_length_vars.end(); ++it) { + vtmp.push_back(*it); + } + regex_term_to_extra_length_vars.insert(str_in_re, vtmp); + } + + regex_terms_with_length_constraints.insert(str_in_re); + m_trail_stack.push(insert_obj_trail(regex_terms_with_length_constraints, str_in_re)); + regex_axiom_add = true; + } + } // re not in regex_terms_with_length_constraints + + rational exact_length_value; + if (get_len_value(str, exact_length_value)) { + TRACE("str", tout << "exact length of " << mk_pp(str, m) << " is " << exact_length_value << std::endl;); + + if (regex_terms_with_path_constraints.contains(str_in_re)) { + TRACE("str", tout << "term " << mk_pp(str_in_re, m) << " already has path constraints set up" << std::endl;); + continue; + } + + // find a consistent automaton for this term + bool found = false; + regex_automaton_under_assumptions assumption; + if (regex_automaton_assumptions.contains(re) && + !regex_automaton_assumptions[re].empty()){ + for (svector::iterator it = regex_automaton_assumptions[re].begin(); + it != regex_automaton_assumptions[re].end(); ++it) { + regex_automaton_under_assumptions autA = *it; + rational assumed_upper_bound, assumed_lower_bound; + bool assumes_upper_bound = autA.get_upper_bound(assumed_upper_bound); + bool assumes_lower_bound = autA.get_lower_bound(assumed_lower_bound); + if (!assumes_upper_bound && !assumes_lower_bound) { + // automaton with no assumptions is always usable + assumption = autA; + found = true; + break; + } + // TODO check consistency of bounds assumptions + } // foreach(a in regex_automaton_assumptions) + } + if (found) { + if (exact_length_value.is_zero()) { + // check consistency of 0-length solution with automaton + eautomaton * aut = assumption.get_automaton(); + bool zero_solution = false; + unsigned initial_state = aut->init(); + if (aut->is_final_state(initial_state)) { + zero_solution = true; + } else { + unsigned_vector eps_states; + aut->get_epsilon_closure(initial_state, eps_states); + for (unsigned_vector::iterator it = eps_states.begin(); it != eps_states.end(); ++it) { + unsigned state = *it; + if (aut->is_final_state(state)) { + zero_solution = true; + break; + } + } + } + + // now check polarity of automaton wrt. original term + if ( (current_assignment == l_true && !assumption.get_polarity()) + || (current_assignment == l_false && assumption.get_polarity())) { + // invert sense + zero_solution = !zero_solution; + } + + if (zero_solution) { + TRACE("str", tout << "zero-length solution OK -- asserting empty path constraint" << std::endl;); + expr_ref_vector lhs_terms(m); + if (current_assignment == l_true) { + lhs_terms.push_back(str_in_re); + } else { + lhs_terms.push_back(m.mk_not(str_in_re)); + } + lhs_terms.push_back(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(exact_length_value, true))); + expr_ref lhs(mk_and(lhs_terms), m); + expr_ref rhs(ctx.mk_eq_atom(str, mk_string("")), m); + assert_implication(lhs, rhs); + regex_terms_with_path_constraints.insert(str_in_re); + m_trail_stack.push(insert_obj_trail(regex_terms_with_path_constraints, str_in_re)); + } else { + TRACE("str", tout << "zero-length solution not admitted by this automaton -- asserting conflict clause" << std::endl;); + expr_ref_vector lhs_terms(m); + if (current_assignment == l_true) { + lhs_terms.push_back(str_in_re); + } else { + lhs_terms.push_back(m.mk_not(str_in_re)); + } + lhs_terms.push_back(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(exact_length_value, true))); + expr_ref lhs(mk_and(lhs_terms), m); + expr_ref conflict(m.mk_not(lhs), m); + assert_axiom(conflict); + } + regex_axiom_add = true; + regex_inc_counter(regex_length_attempt_count, re); + continue; + } else { + expr_ref pathConstraint(m); + expr_ref characterConstraints(m); + pathConstraint = generate_regex_path_constraints(str, assumption.get_automaton(), exact_length_value, characterConstraints); + TRACE("str", tout << "generated regex path constraint " << mk_pp(pathConstraint, m) << std::endl;); + TRACE("str", tout << "character constraints are " << mk_pp(characterConstraints, m) << std::endl;); + + expr_ref_vector lhs_terms(m); + if (current_assignment == l_true) { + lhs_terms.push_back(str_in_re); + } else { + lhs_terms.push_back(m.mk_not(str_in_re)); + } + lhs_terms.push_back(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(exact_length_value, true))); + expr_ref lhs(mk_and(lhs_terms), m); + + // If the path constraint comes out as "false", this means there are no paths of that length + // in the automaton. If the polarity is the same, we can assert a conflict clause. + // If the polarity is opposite, we ignore the path constraint. + + if (m.is_false(pathConstraint)) { + if ( (current_assignment == l_true && assumption.get_polarity()) + || (current_assignment == l_false && !assumption.get_polarity())) { + // automaton and constraint have same polarity -- assert conflict clause + TRACE("str", tout << "path constraint is false with matching polarity; asserting conflict clause" << std::endl;); + expr_ref conflict(m.mk_not(mk_and(lhs_terms)), m); + assert_axiom(conflict); + // don't set up "regex_terms_with_path_constraints" as a conflict clause is not a path constraint + } else { + // automaton and constraint have opposite polarity -- ignore path constraint + TRACE("str", tout << "path constraint is false with opposite polarity; ignoring path constraint" << std::endl;); + assert_implication(lhs, characterConstraints); + regex_terms_with_path_constraints.insert(str_in_re); + m_trail_stack.push(insert_obj_trail(regex_terms_with_path_constraints, str_in_re)); + } + regex_axiom_add = true; + } else { + // If the automaton was built with the same polarity as the constraint, + // assert directly. Otherwise, negate the path constraint + if ( (current_assignment == l_true && assumption.get_polarity()) + || (current_assignment == l_false && !assumption.get_polarity())) { + TRACE("str", tout << "automaton and regex term have same polarity" << std::endl;); + expr_ref rhs(m.mk_and(pathConstraint, characterConstraints), m); + assert_implication(lhs, rhs); + } else { + TRACE("str", tout << "automaton and regex term have opposite polarity" << std::endl;); + expr_ref rhs(m.mk_and(m.mk_not(pathConstraint), characterConstraints), m); + assert_implication(lhs, rhs); + } + regex_terms_with_path_constraints.insert(str_in_re); + m_trail_stack.push(insert_obj_trail(regex_terms_with_path_constraints, str_in_re)); + regex_axiom_add = true; + } + + // increment LengthAttemptCount + regex_inc_counter(regex_length_attempt_count, re); + + TRACE("str", + { + unsigned v = regex_get_counter(regex_length_attempt_count, re); + tout << "length attempt count for " << mk_pp(re, m) << " is " << v << std::endl; + }); + + continue; + } + } else { + // no automata available, or else all bounds assumptions are invalid + unsigned expected_complexity = estimate_regex_complexity(re); + if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold || regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold) { + CTRACE("str", regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold, + tout << "failed automaton threshold reached for " << mk_pp(str_in_re, m) << " -- automatically constructing full automaton" << std::endl;); + eautomaton * aut = m_mk_aut(re); + aut->compress(); + regex_automata.push_back(aut); + regex_automaton_under_assumptions new_aut(re, aut, true); + if (!regex_automaton_assumptions.contains(re)) { + regex_automaton_assumptions.insert(re, svector()); + } + regex_automaton_assumptions[re].push_back(new_aut); + TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); + regex_axiom_add = true; + find_automaton_initial_bounds(str_in_re, aut); + } else { + regex_inc_counter(regex_fail_count, str_in_re); + } + continue; + } + } // get_len_value() + expr_ref str_len(mk_strlen(str), m); + rational lower_bound_value; + rational upper_bound_value; + bool lower_bound_exists = lower_bound(str_len, lower_bound_value); + bool upper_bound_exists = upper_bound(str_len, upper_bound_value); + CTRACE("str", lower_bound_exists, tout << "lower bound of " << mk_pp(str, m) << " is " << lower_bound_value << std::endl;); + CTRACE("str", upper_bound_exists, tout << "upper bound of " << mk_pp(str, m) << " is " << upper_bound_value << std::endl;); + + bool new_lower_bound_info = true; + bool new_upper_bound_info = true; + // check last seen lower/upper bound to avoid performing duplicate work + if (regex_last_lower_bound.contains(str)) { + rational last_lb_value; + regex_last_lower_bound.find(str, last_lb_value); + if (last_lb_value == lower_bound_value) { + new_lower_bound_info = false; + } + } + if (regex_last_upper_bound.contains(str)) { + rational last_ub_value; + regex_last_upper_bound.find(str, last_ub_value); + if (last_ub_value == upper_bound_value) { + new_upper_bound_info = false; + } + } + + if (new_lower_bound_info) { + regex_last_lower_bound.insert(str, lower_bound_value); + } + if (new_upper_bound_info) { + regex_last_upper_bound.insert(str, upper_bound_value); + } + + if (upper_bound_exists && new_upper_bound_info) { + // check current assumptions + if (regex_automaton_assumptions.contains(re) && + !regex_automaton_assumptions[re].empty()){ + // one or more existing assumptions. + // see if the (current best) upper bound can be refined + // (note that if we have an automaton with no assumption, + // this automatically counts as best) + bool need_assumption = true; + regex_automaton_under_assumptions last_assumption; + rational last_ub = rational::minus_one(); + for (svector::iterator it = regex_automaton_assumptions[re].begin(); + it != regex_automaton_assumptions[re].end(); ++it) { + regex_automaton_under_assumptions autA = *it; + if ((current_assignment == l_true && autA.get_polarity() == false) + || (current_assignment == l_false && autA.get_polarity() == true)) { + // automaton uses incorrect polarity + continue; + } + rational this_ub; + if (autA.get_upper_bound(this_ub)) { + if (last_ub == rational::minus_one() || this_ub < last_ub) { + last_ub = this_ub; + last_assumption = autA; + } + } else { + need_assumption = false; + last_assumption = autA; + break; + } + } + if (!last_ub.is_minus_one() || !need_assumption) { + CTRACE("str", !need_assumption, tout << "using automaton with full length information" << std::endl;); + CTRACE("str", need_assumption, tout << "using automaton with assumed upper bound of " << last_ub << std::endl;); + + rational refined_upper_bound; + bool solution_at_upper_bound = refine_automaton_upper_bound(last_assumption.get_automaton(), + upper_bound_value, refined_upper_bound); + TRACE("str", tout << "refined upper bound is " << refined_upper_bound << + (solution_at_upper_bound?", solution at upper bound":", no solution at upper bound") << std::endl;); + + expr_ref_vector lhs(m); + if (current_assignment == l_false) { + lhs.push_back(m.mk_not(str_in_re)); + } else { + lhs.push_back(str_in_re); + } + if (need_assumption) { + lhs.push_back(m_autil.mk_le(str_len, m_autil.mk_numeral(last_ub, true))); + } + lhs.push_back(m_autil.mk_le(str_len, m_autil.mk_numeral(upper_bound_value, true))); + + expr_ref_vector rhs(m); + + if (solution_at_upper_bound) { + if (refined_upper_bound.is_minus_one()) { + // If there are solutions at the upper bound but not below it, make the bound exact. + rhs.push_back(ctx.mk_eq_atom(str_len, m_autil.mk_numeral(upper_bound_value, true))); + } else { + // If there are solutions at and below the upper bound, add an additional bound. + rhs.push_back(m.mk_or( + ctx.mk_eq_atom(str_len, m_autil.mk_numeral(upper_bound_value, true)), + m_autil.mk_le(str_len, m_autil.mk_numeral(refined_upper_bound, true)) + )); + } + } else { + if (refined_upper_bound.is_minus_one()) { + // If there are no solutions at or below the upper bound, assert a conflict clause. + rhs.push_back(m.mk_not(m_autil.mk_le(str_len, m_autil.mk_numeral(upper_bound_value, true)))); + } else { + // If there are solutions below the upper bound but not at it, refine the bound. + rhs.push_back(m_autil.mk_le(str_len, m_autil.mk_numeral(refined_upper_bound, true))); + } + } + + if (!rhs.empty()) { + expr_ref lhs_terms(mk_and(lhs), m); + expr_ref rhs_terms(mk_and(rhs), m); + assert_implication(lhs_terms, rhs_terms); + regex_axiom_add = true; + } + } + } else { + // no existing automata/assumptions. + // if it's easy to construct a full automaton for R, do so + unsigned expected_complexity = estimate_regex_complexity(re); + bool failureThresholdExceeded = (regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold); + if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold || failureThresholdExceeded) { + eautomaton * aut = m_mk_aut(re); + aut->compress(); + regex_automata.push_back(aut); + regex_automaton_under_assumptions new_aut(re, aut, true); + if (!regex_automaton_assumptions.contains(re)) { + regex_automaton_assumptions.insert(re, svector()); + } + regex_automaton_assumptions[re].push_back(new_aut); + TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); + regex_axiom_add = true; + find_automaton_initial_bounds(str_in_re, aut); + } else { + // TODO check negation? + // TODO construct a partial automaton for R to the given upper bound? + if (false) { + + } else { + regex_inc_counter(regex_fail_count, str_in_re); + } + } + continue; + } + // if we have *any* automaton for R, and the upper bound is not too large, + // finitize the automaton (if we have not already done so) and assert all solutions + if (upper_bound_value < 50) { // TODO better metric for threshold + // NOT_IMPLEMENTED_YET(); // TODO(mtrberzi) + } + } else { // !upper_bound_exists + // no upper bound information + if (lower_bound_exists && !lower_bound_value.is_zero() && new_lower_bound_info) { + // nonzero lower bound, no upper bound + + // check current assumptions + if (regex_automaton_assumptions.contains(re) && + !regex_automaton_assumptions[re].empty()){ + // one or more existing assumptions. + // see if the (current best) lower bound can be refined + // (note that if we have an automaton with no assumption, + // this automatically counts as best) + bool need_assumption = true; + regex_automaton_under_assumptions last_assumption; + rational last_lb = rational::zero(); // the default + for (svector::iterator it = regex_automaton_assumptions[re].begin(); + it != regex_automaton_assumptions[re].end(); ++it) { + regex_automaton_under_assumptions autA = *it; + if ((current_assignment == l_true && autA.get_polarity() == false) + || (current_assignment == l_false && autA.get_polarity() == true)) { + // automaton uses incorrect polarity + continue; + } + rational this_lb; + if (autA.get_lower_bound(this_lb)) { + if (this_lb > last_lb) { + last_lb = this_lb; + last_assumption = autA; + } + } else { + need_assumption = false; + last_assumption = autA; + break; + } + } + if (!last_lb.is_zero() || !need_assumption) { + CTRACE("str", !need_assumption, tout << "using automaton with full length information" << std::endl;); + CTRACE("str", need_assumption, tout << "using automaton with assumed lower bound of " << last_lb << std::endl;); + rational refined_lower_bound; + bool solution_at_lower_bound = refine_automaton_lower_bound(last_assumption.get_automaton(), + lower_bound_value, refined_lower_bound); + TRACE("str", tout << "refined lower bound is " << refined_lower_bound << + (solution_at_lower_bound?", solution at lower bound":", no solution at lower bound") << std::endl;); + + expr_ref_vector lhs(m); + if (current_assignment == l_false) { + lhs.push_back(m.mk_not(str_in_re)); + } else { + lhs.push_back(str_in_re); + } + if (need_assumption) { + lhs.push_back(m_autil.mk_ge(str_len, m_autil.mk_numeral(last_lb, true))); + } + lhs.push_back(m_autil.mk_ge(str_len, m_autil.mk_numeral(lower_bound_value, true))); + + expr_ref_vector rhs(m); + + if (solution_at_lower_bound) { + if (refined_lower_bound.is_minus_one()) { + // If there are solutions at the lower bound but not above it, make the bound exact. + rhs.push_back(ctx.mk_eq_atom(str_len, m_autil.mk_numeral(lower_bound_value, true))); + } else { + // If there are solutions at and above the lower bound, add an additional bound. + // DISABLED as this is causing non-termination in the integer solver. --mtrberzi + /* + rhs.push_back(m.mk_or( + ctx.mk_eq_atom(str_len, m_autil.mk_numeral(lower_bound_value, true)), + m_autil.mk_ge(str_len, m_autil.mk_numeral(refined_lower_bound, true)) + )); + */ + } + } else { + if (refined_lower_bound.is_minus_one()) { + // If there are no solutions at or above the lower bound, assert a conflict clause. + rhs.push_back(m.mk_not(m_autil.mk_ge(str_len, m_autil.mk_numeral(lower_bound_value, true)))); + } else { + // If there are solutions above the lower bound but not at it, refine the bound. + rhs.push_back(m_autil.mk_ge(str_len, m_autil.mk_numeral(refined_lower_bound, true))); + } + } + + if (!rhs.empty()) { + expr_ref lhs_terms(mk_and(lhs), m); + expr_ref rhs_terms(mk_and(rhs), m); + assert_implication(lhs_terms, rhs_terms); + regex_axiom_add = true; + } + } + } else { + // no existing automata/assumptions. + // if it's easy to construct a full automaton for R, do so + unsigned expected_complexity = estimate_regex_complexity(re); + bool failureThresholdExceeded = (regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold); + if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold || failureThresholdExceeded) { + eautomaton * aut = m_mk_aut(re); + aut->compress(); + regex_automata.push_back(aut); + regex_automaton_under_assumptions new_aut(re, aut, true); + if (!regex_automaton_assumptions.contains(re)) { + regex_automaton_assumptions.insert(re, svector()); + } + regex_automaton_assumptions[re].push_back(new_aut); + TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); + regex_axiom_add = true; + find_automaton_initial_bounds(str_in_re, aut); + } else { + // TODO check negation? + // TODO construct a partial automaton for R to the given lower bound? + if (false) { + + } else { + regex_inc_counter(regex_fail_count, str_in_re); + } + } + continue; + } + } else { // !lower_bound_exists + // no bounds information + // check for existing automata; + // try to construct an automaton if we don't have one yet + // and doing so without bounds is not difficult + bool existingAutomata = (regex_automaton_assumptions.contains(re) && !regex_automaton_assumptions[re].empty()); + bool failureThresholdExceeded = (regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold); + if (!existingAutomata) { + unsigned expected_complexity = estimate_regex_complexity(re); + if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold + || failureThresholdExceeded) { + eautomaton * aut = m_mk_aut(re); + aut->compress(); + regex_automata.push_back(aut); + regex_automaton_under_assumptions new_aut(re, aut, true); + if (!regex_automaton_assumptions.contains(re)) { + regex_automaton_assumptions.insert(re, svector()); + } + regex_automaton_assumptions[re].push_back(new_aut); + TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); + regex_axiom_add = true; + find_automaton_initial_bounds(str_in_re, aut); + } else { + regex_inc_counter(regex_fail_count, str_in_re); + } + } else { + regex_inc_counter(regex_fail_count, str_in_re); + } + } + } + } // foreach (entry in regex_terms) + + for (obj_map >::iterator it = regex_terms_by_string.begin(); + it != regex_terms_by_string.end(); ++it) { + // TODO do we need to check equivalence classes of strings here? + + expr * str = it->m_key; + ptr_vector str_in_re_terms = it->m_value; + + svector intersect_constraints; + // we may find empty intersection before checking every constraint; + // this vector keeps track of which ones actually take part in intersection + svector used_intersect_constraints; + + // choose an automaton/assumption for each assigned (str.in.re) + // that's consistent with the current length information + for (ptr_vector::iterator term_it = str_in_re_terms.begin(); + term_it != str_in_re_terms.end(); ++term_it) { + expr * _unused = nullptr; + expr * re = nullptr; + SASSERT(u.str.is_in_re(*term_it)); + u.str.is_in_re(*term_it, _unused, re); + + rational exact_len; + bool has_exact_len = get_len_value(str, exact_len); + + rational lb, ub; + bool has_lower_bound = lower_bound(mk_strlen(str), lb); + bool has_upper_bound = upper_bound(mk_strlen(str), ub); + + if (regex_automaton_assumptions.contains(re) && + !regex_automaton_assumptions[re].empty()){ + for (svector::iterator aut_it = regex_automaton_assumptions[re].begin(); + aut_it != regex_automaton_assumptions[re].end(); ++aut_it) { + regex_automaton_under_assumptions aut = *aut_it; + rational aut_ub; + bool assume_ub = aut.get_upper_bound(aut_ub); + rational aut_lb; + bool assume_lb = aut.get_lower_bound(aut_lb); + bool consistent = true; + + if (assume_ub) { + // check consistency of assumed upper bound + if (has_exact_len) { + if (exact_len > aut_ub) { + consistent = false; + } + } else { + if (has_upper_bound && ub > aut_ub) { + consistent = false; + } + } + } + + if (assume_lb) { + // check consistency of assumed lower bound + if (has_exact_len) { + if (exact_len < aut_lb) { + consistent = false; + } + } else { + if (has_lower_bound && lb < aut_lb) { + consistent = false; + } + } + } + + if (consistent) { + intersect_constraints.push_back(aut); + break; + } + } + } + } // foreach(term in str_in_re_terms) + + eautomaton * aut_inter = nullptr; + CTRACE("str", !intersect_constraints.empty(), tout << "check intersection of automata constraints for " << mk_pp(str, m) << std::endl;); + for (svector::iterator aut_it = intersect_constraints.begin(); + aut_it != intersect_constraints.end(); ++aut_it) { + regex_automaton_under_assumptions aut = *aut_it; + if (aut_inter == nullptr) { + // start somewhere + aut_inter = aut.get_automaton(); + used_intersect_constraints.push_back(aut); + continue; + } + + TRACE("str", + { + unsigned v = regex_get_counter(regex_length_attempt_count, aut.get_regex_term()); + tout << "length attempt count of " << mk_pp(aut.get_regex_term(), m) << " is " << v + << ", threshold is " << m_params.m_RegexAutomata_LengthAttemptThreshold << std::endl; + }); + + if (regex_get_counter(regex_length_attempt_count, aut.get_regex_term()) >= m_params.m_RegexAutomata_LengthAttemptThreshold) { + unsigned intersectionDifficulty = estimate_automata_intersection_difficulty(aut_inter, aut.get_automaton()); + TRACE("str", tout << "intersection difficulty is " << intersectionDifficulty << std::endl;); + if (intersectionDifficulty <= m_params.m_RegexAutomata_IntersectionDifficultyThreshold + || regex_get_counter(regex_intersection_fail_count, aut.get_regex_term()) >= m_params.m_RegexAutomata_FailedIntersectionThreshold) { + + expr * str_in_re_term(u.re.mk_in_re(str, aut.get_regex_term())); + lbool current_assignment = ctx.get_assignment(str_in_re_term); + // if the assignment is consistent with our assumption, use the automaton directly; + // otherwise, complement it (and save that automaton for next time) + // TODO we should cache these intermediate results + // TODO do we need to push the intermediates into a vector for deletion anyway? + if ( (current_assignment == l_true && aut.get_polarity()) + || (current_assignment == l_false && !aut.get_polarity())) { + aut_inter = m_mk_aut.mk_product(aut_inter, aut.get_automaton()); + m_automata.push_back(aut_inter); + } else { + // need to complement first + expr_ref rc(u.re.mk_complement(aut.get_regex_term()), m); + eautomaton * aut_c = m_mk_aut(rc); + regex_automata.push_back(aut_c); + // TODO is there any way to build a complement automaton from an existing one? + // this discards length information + aut_inter = m_mk_aut.mk_product(aut_inter, aut_c); + m_automata.push_back(aut_inter); + } + used_intersect_constraints.push_back(aut); + if (aut_inter->is_empty()) { + break; + } + } else { + // failed intersection + regex_inc_counter(regex_intersection_fail_count, aut.get_regex_term()); + } + } + } // foreach(entry in intersect_constraints) + if (aut_inter != nullptr) { + aut_inter->compress(); + } + TRACE("str", tout << "intersected " << used_intersect_constraints.size() << " constraints" << std::endl;); + + expr_ref_vector conflict_terms(m); + expr_ref conflict_lhs(m); + for (svector::iterator aut_it = used_intersect_constraints.begin(); + aut_it != used_intersect_constraints.end(); ++aut_it) { + regex_automaton_under_assumptions aut = *aut_it; + expr * str_in_re_term(u.re.mk_in_re(str, aut.get_regex_term())); + lbool current_assignment = ctx.get_assignment(str_in_re_term); + if (current_assignment == l_true) { + conflict_terms.push_back(str_in_re_term); + } else if (current_assignment == l_false) { + conflict_terms.push_back(m.mk_not(str_in_re_term)); + } + // add length assumptions, if any + rational ub; + if (aut.get_upper_bound(ub)) { + expr_ref ub_term(m_autil.mk_le(mk_strlen(str), m_autil.mk_numeral(ub, true)), m); + conflict_terms.push_back(ub_term); + } + rational lb; + if (aut.get_lower_bound(lb)) { + expr_ref lb_term(m_autil.mk_ge(mk_strlen(str), m_autil.mk_numeral(lb, true)), m); + conflict_terms.push_back(lb_term); + } + } + conflict_lhs = mk_and(conflict_terms); + + if (used_intersect_constraints.size() > 1 && aut_inter != nullptr) { + // check whether the intersection is only the empty string + unsigned initial_state = aut_inter->init(); + if (aut_inter->final_states().size() == 1 && aut_inter->is_final_state(initial_state)) { + // initial state is final and it is the only final state + // if there are no moves from the initial state, + // the only solution is the empty string + if (aut_inter->get_moves_from(initial_state).empty()) { + TRACE("str", tout << "product automaton only accepts empty string" << std::endl;); + expr_ref rhs1(ctx.mk_eq_atom(str, mk_string("")), m); + expr_ref rhs2(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(rational::zero(), true)), m); + expr_ref rhs(m.mk_and(rhs1, rhs2), m); + assert_implication(conflict_lhs, rhs); + regex_axiom_add = true; + } + } + } + + if (aut_inter != nullptr && aut_inter->is_empty()) { + TRACE("str", tout << "product automaton is empty; asserting conflict clause" << std::endl;); + expr_ref conflict_clause(m.mk_not(mk_and(conflict_terms)), m); + assert_axiom(conflict_clause); + add_persisted_axiom(conflict_clause); + regex_axiom_add = true; + } + } // foreach (entry in regex_terms_by_string) + if (regex_axiom_add) { + //return FC_CONTINUE; + } + } + final_check_status theory_str::final_check_eh() { context & ctx = get_context(); ast_manager & m = get_manager(); @@ -9904,7 +10615,6 @@ namespace smt { std::map > var_eq_concat_map; int conflictInDep = ctx_dep_analysis(varAppearInAssign, freeVar_map, unrollGroup_map, var_eq_concat_map); if (conflictInDep == -1) { - // return Z3_TRUE; return FC_DONE; } @@ -9939,8 +10649,10 @@ namespace smt { if (!u.str.is_string(concat_lhs)) { lhs_terms.push_back(ctx.mk_eq_atom(concat_lhs, concat_lhs_str)); } + if (!u.str.is_string(concat_rhs)) { lhs_terms.push_back(ctx.mk_eq_atom(concat_rhs, concat_rhs_str)); + } if (lhs_terms.empty()) { @@ -9977,726 +10689,7 @@ namespace smt { // regex automata if (m_params.m_RegexAutomata) { - // TODO since heuristics might fail, the "no progress" flag might need to be handled specially here - bool regex_axiom_add = false; - for (obj_hashtable::iterator it = regex_terms.begin(); it != regex_terms.end(); ++it) { - expr * str_in_re = *it; - expr * str = nullptr; - expr * re = nullptr; - u.str.is_in_re(str_in_re, str, re); - lbool current_assignment = ctx.get_assignment(str_in_re); - TRACE("str", tout << "regex term: " << mk_pp(str, m) << " in " << mk_pp(re, m) << " : " << current_assignment << std::endl;); - if (current_assignment == l_undef) { - continue; - } - - if (!regex_terms_with_length_constraints.contains(str_in_re)) { - if (current_assignment == l_true && check_regex_length_linearity(re)) { - TRACE("str", tout << "regex length constraints expected to be linear -- generating and asserting them" << std::endl;); - - if (regex_term_to_length_constraint.contains(str_in_re)) { - // use existing length constraint - expr * top_level_length_constraint = nullptr; - regex_term_to_length_constraint.find(str_in_re, top_level_length_constraint); - - ptr_vector extra_length_vars; - regex_term_to_extra_length_vars.find(str_in_re, extra_length_vars); - - assert_axiom(top_level_length_constraint); - for(ptr_vector::iterator it = extra_length_vars.begin(); it != extra_length_vars.end(); ++it) { - expr * v = *it; - refresh_theory_var(v); - expr_ref len_constraint(m_autil.mk_ge(v, m_autil.mk_numeral(rational::zero(), true)), m); - assert_axiom(len_constraint); - } - } else { - // generate new length constraint - expr_ref_vector extra_length_vars(m); - expr_ref _top_level_length_constraint = infer_all_regex_lengths(mk_strlen(str), re, extra_length_vars); - expr_ref top_level_length_constraint(_top_level_length_constraint, m); - th_rewriter rw(m); - rw(top_level_length_constraint); - TRACE("str", tout << "top-level length constraint: " << mk_pp(top_level_length_constraint, m) << std::endl;); - // assert and track length constraint - assert_axiom(top_level_length_constraint); - for(expr_ref_vector::iterator it = extra_length_vars.begin(); it != extra_length_vars.end(); ++it) { - expr * v = *it; - expr_ref len_constraint(m_autil.mk_ge(v, m_autil.mk_numeral(rational::zero(), true)), m); - assert_axiom(len_constraint); - } - - regex_term_to_length_constraint.insert(str_in_re, top_level_length_constraint); - ptr_vector vtmp; - for(expr_ref_vector::iterator it = extra_length_vars.begin(); it != extra_length_vars.end(); ++it) { - vtmp.push_back(*it); - } - regex_term_to_extra_length_vars.insert(str_in_re, vtmp); - } - - regex_terms_with_length_constraints.insert(str_in_re); - m_trail_stack.push(insert_obj_trail(regex_terms_with_length_constraints, str_in_re)); - regex_axiom_add = true; - } - } // re not in regex_terms_with_length_constraints - - rational exact_length_value; - if (get_len_value(str, exact_length_value)) { - TRACE("str", tout << "exact length of " << mk_pp(str, m) << " is " << exact_length_value << std::endl;); - - if (regex_terms_with_path_constraints.contains(str_in_re)) { - TRACE("str", tout << "term " << mk_pp(str_in_re, m) << " already has path constraints set up" << std::endl;); - continue; - } - - // find a consistent automaton for this term - bool found = false; - regex_automaton_under_assumptions assumption; - if (regex_automaton_assumptions.contains(re) && - !regex_automaton_assumptions[re].empty()){ - for (svector::iterator it = regex_automaton_assumptions[re].begin(); - it != regex_automaton_assumptions[re].end(); ++it) { - regex_automaton_under_assumptions autA = *it; - rational assumed_upper_bound, assumed_lower_bound; - bool assumes_upper_bound = autA.get_upper_bound(assumed_upper_bound); - bool assumes_lower_bound = autA.get_lower_bound(assumed_lower_bound); - if (!assumes_upper_bound && !assumes_lower_bound) { - // automaton with no assumptions is always usable - assumption = autA; - found = true; - break; - } - // TODO check consistency of bounds assumptions - } // foreach(a in regex_automaton_assumptions) - } - if (found) { - if (exact_length_value.is_zero()) { - // check consistency of 0-length solution with automaton - eautomaton * aut = assumption.get_automaton(); - bool zero_solution = false; - unsigned initial_state = aut->init(); - if (aut->is_final_state(initial_state)) { - zero_solution = true; - } else { - unsigned_vector eps_states; - aut->get_epsilon_closure(initial_state, eps_states); - for (unsigned_vector::iterator it = eps_states.begin(); it != eps_states.end(); ++it) { - unsigned state = *it; - if (aut->is_final_state(state)) { - zero_solution = true; - break; - } - } - } - - // now check polarity of automaton wrt. original term - if ( (current_assignment == l_true && !assumption.get_polarity()) - || (current_assignment == l_false && assumption.get_polarity())) { - // invert sense - zero_solution = !zero_solution; - } - - if (zero_solution) { - TRACE("str", tout << "zero-length solution OK -- asserting empty path constraint" << std::endl;); - expr_ref_vector lhs_terms(m); - if (current_assignment == l_true) { - lhs_terms.push_back(str_in_re); - } else { - lhs_terms.push_back(m.mk_not(str_in_re)); - } - lhs_terms.push_back(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(exact_length_value, true))); - expr_ref lhs(mk_and(lhs_terms), m); - expr_ref rhs(ctx.mk_eq_atom(str, mk_string("")), m); - assert_implication(lhs, rhs); - regex_terms_with_path_constraints.insert(str_in_re); - m_trail_stack.push(insert_obj_trail(regex_terms_with_path_constraints, str_in_re)); - } else { - TRACE("str", tout << "zero-length solution not admitted by this automaton -- asserting conflict clause" << std::endl;); - expr_ref_vector lhs_terms(m); - if (current_assignment == l_true) { - lhs_terms.push_back(str_in_re); - } else { - lhs_terms.push_back(m.mk_not(str_in_re)); - } - lhs_terms.push_back(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(exact_length_value, true))); - expr_ref lhs(mk_and(lhs_terms), m); - expr_ref conflict(m.mk_not(lhs), m); - assert_axiom(conflict); - } - regex_axiom_add = true; - regex_inc_counter(regex_length_attempt_count, re); - continue; - } else { - expr_ref pathConstraint(m); - expr_ref characterConstraints(m); - pathConstraint = generate_regex_path_constraints(str, assumption.get_automaton(), exact_length_value, characterConstraints); - TRACE("str", tout << "generated regex path constraint " << mk_pp(pathConstraint, m) << std::endl;); - TRACE("str", tout << "character constraints are " << mk_pp(characterConstraints, m) << std::endl;); - - expr_ref_vector lhs_terms(m); - if (current_assignment == l_true) { - lhs_terms.push_back(str_in_re); - } else { - lhs_terms.push_back(m.mk_not(str_in_re)); - } - lhs_terms.push_back(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(exact_length_value, true))); - expr_ref lhs(mk_and(lhs_terms), m); - - // If the path constraint comes out as "false", this means there are no paths of that length - // in the automaton. If the polarity is the same, we can assert a conflict clause. - // If the polarity is opposite, we ignore the path constraint. - - if (m.is_false(pathConstraint)) { - if ( (current_assignment == l_true && assumption.get_polarity()) - || (current_assignment == l_false && !assumption.get_polarity())) { - // automaton and constraint have same polarity -- assert conflict clause - TRACE("str", tout << "path constraint is false with matching polarity; asserting conflict clause" << std::endl;); - expr_ref conflict(m.mk_not(mk_and(lhs_terms)), m); - assert_axiom(conflict); - // don't set up "regex_terms_with_path_constraints" as a conflict clause is not a path constraint - } else { - // automaton and constraint have opposite polarity -- ignore path constraint - TRACE("str", tout << "path constraint is false with opposite polarity; ignoring path constraint" << std::endl;); - assert_implication(lhs, characterConstraints); - regex_terms_with_path_constraints.insert(str_in_re); - m_trail_stack.push(insert_obj_trail(regex_terms_with_path_constraints, str_in_re)); - } - regex_axiom_add = true; - } else { - // If the automaton was built with the same polarity as the constraint, - // assert directly. Otherwise, negate the path constraint - if ( (current_assignment == l_true && assumption.get_polarity()) - || (current_assignment == l_false && !assumption.get_polarity())) { - TRACE("str", tout << "automaton and regex term have same polarity" << std::endl;); - expr_ref rhs(m.mk_and(pathConstraint, characterConstraints), m); - assert_implication(lhs, rhs); - } else { - TRACE("str", tout << "automaton and regex term have opposite polarity" << std::endl;); - expr_ref rhs(m.mk_and(m.mk_not(pathConstraint), characterConstraints), m); - assert_implication(lhs, rhs); - } - regex_terms_with_path_constraints.insert(str_in_re); - m_trail_stack.push(insert_obj_trail(regex_terms_with_path_constraints, str_in_re)); - regex_axiom_add = true; - } - - // increment LengthAttemptCount - regex_inc_counter(regex_length_attempt_count, re); - - TRACE("str", - { - unsigned v = regex_get_counter(regex_length_attempt_count, re); - tout << "length attempt count for " << mk_pp(re, m) << " is " << v << std::endl; - }); - - continue; - } - } else { - // no automata available, or else all bounds assumptions are invalid - unsigned expected_complexity = estimate_regex_complexity(re); - if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold || regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold) { - CTRACE("str", regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold, - tout << "failed automaton threshold reached for " << mk_pp(str_in_re, m) << " -- automatically constructing full automaton" << std::endl;); - eautomaton * aut = m_mk_aut(re); - aut->compress(); - regex_automata.push_back(aut); - regex_automaton_under_assumptions new_aut(re, aut, true); - if (!regex_automaton_assumptions.contains(re)) { - regex_automaton_assumptions.insert(re, svector()); - } - regex_automaton_assumptions[re].push_back(new_aut); - TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); - regex_axiom_add = true; - find_automaton_initial_bounds(str_in_re, aut); - } else { - regex_inc_counter(regex_fail_count, str_in_re); - } - continue; - } - } // get_len_value() - expr_ref str_len(mk_strlen(str), m); - rational lower_bound_value; - rational upper_bound_value; - bool lower_bound_exists = lower_bound(str_len, lower_bound_value); - bool upper_bound_exists = upper_bound(str_len, upper_bound_value); - CTRACE("str", lower_bound_exists, tout << "lower bound of " << mk_pp(str, m) << " is " << lower_bound_value << std::endl;); - CTRACE("str", upper_bound_exists, tout << "upper bound of " << mk_pp(str, m) << " is " << upper_bound_value << std::endl;); - - bool new_lower_bound_info = true; - bool new_upper_bound_info = true; - // check last seen lower/upper bound to avoid performing duplicate work - if (regex_last_lower_bound.contains(str)) { - rational last_lb_value; - regex_last_lower_bound.find(str, last_lb_value); - if (last_lb_value == lower_bound_value) { - new_lower_bound_info = false; - } - } - if (regex_last_upper_bound.contains(str)) { - rational last_ub_value; - regex_last_upper_bound.find(str, last_ub_value); - if (last_ub_value == upper_bound_value) { - new_upper_bound_info = false; - } - } - - if (new_lower_bound_info) { - regex_last_lower_bound.insert(str, lower_bound_value); - } - if (new_upper_bound_info) { - regex_last_upper_bound.insert(str, upper_bound_value); - } - - if (upper_bound_exists && new_upper_bound_info) { - // check current assumptions - if (regex_automaton_assumptions.contains(re) && - !regex_automaton_assumptions[re].empty()){ - // one or more existing assumptions. - // see if the (current best) upper bound can be refined - // (note that if we have an automaton with no assumption, - // this automatically counts as best) - bool need_assumption = true; - regex_automaton_under_assumptions last_assumption; - rational last_ub = rational::minus_one(); - for (svector::iterator it = regex_automaton_assumptions[re].begin(); - it != regex_automaton_assumptions[re].end(); ++it) { - regex_automaton_under_assumptions autA = *it; - if ((current_assignment == l_true && autA.get_polarity() == false) - || (current_assignment == l_false && autA.get_polarity() == true)) { - // automaton uses incorrect polarity - continue; - } - rational this_ub; - if (autA.get_upper_bound(this_ub)) { - if (last_ub == rational::minus_one() || this_ub < last_ub) { - last_ub = this_ub; - last_assumption = autA; - } - } else { - need_assumption = false; - last_assumption = autA; - break; - } - } - if (!last_ub.is_minus_one() || !need_assumption) { - CTRACE("str", !need_assumption, tout << "using automaton with full length information" << std::endl;); - CTRACE("str", need_assumption, tout << "using automaton with assumed upper bound of " << last_ub << std::endl;); - - rational refined_upper_bound; - bool solution_at_upper_bound = refine_automaton_upper_bound(last_assumption.get_automaton(), - upper_bound_value, refined_upper_bound); - TRACE("str", tout << "refined upper bound is " << refined_upper_bound << - (solution_at_upper_bound?", solution at upper bound":", no solution at upper bound") << std::endl;); - - expr_ref_vector lhs(m); - if (current_assignment == l_false) { - lhs.push_back(m.mk_not(str_in_re)); - } else { - lhs.push_back(str_in_re); - } - if (need_assumption) { - lhs.push_back(m_autil.mk_le(str_len, m_autil.mk_numeral(last_ub, true))); - } - lhs.push_back(m_autil.mk_le(str_len, m_autil.mk_numeral(upper_bound_value, true))); - - expr_ref_vector rhs(m); - - if (solution_at_upper_bound) { - if (refined_upper_bound.is_minus_one()) { - // If there are solutions at the upper bound but not below it, make the bound exact. - rhs.push_back(ctx.mk_eq_atom(str_len, m_autil.mk_numeral(upper_bound_value, true))); - } else { - // If there are solutions at and below the upper bound, add an additional bound. - rhs.push_back(m.mk_or( - ctx.mk_eq_atom(str_len, m_autil.mk_numeral(upper_bound_value, true)), - m_autil.mk_le(str_len, m_autil.mk_numeral(refined_upper_bound, true)) - )); - } - } else { - if (refined_upper_bound.is_minus_one()) { - // If there are no solutions at or below the upper bound, assert a conflict clause. - rhs.push_back(m.mk_not(m_autil.mk_le(str_len, m_autil.mk_numeral(upper_bound_value, true)))); - } else { - // If there are solutions below the upper bound but not at it, refine the bound. - rhs.push_back(m_autil.mk_le(str_len, m_autil.mk_numeral(refined_upper_bound, true))); - } - } - - if (!rhs.empty()) { - expr_ref lhs_terms(mk_and(lhs), m); - expr_ref rhs_terms(mk_and(rhs), m); - assert_implication(lhs_terms, rhs_terms); - regex_axiom_add = true; - } - } - } else { - // no existing automata/assumptions. - // if it's easy to construct a full automaton for R, do so - unsigned expected_complexity = estimate_regex_complexity(re); - bool failureThresholdExceeded = (regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold); - if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold || failureThresholdExceeded) { - eautomaton * aut = m_mk_aut(re); - aut->compress(); - regex_automata.push_back(aut); - regex_automaton_under_assumptions new_aut(re, aut, true); - if (!regex_automaton_assumptions.contains(re)) { - regex_automaton_assumptions.insert(re, svector()); - } - regex_automaton_assumptions[re].push_back(new_aut); - TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); - regex_axiom_add = true; - find_automaton_initial_bounds(str_in_re, aut); - } else { - // TODO check negation? - // TODO construct a partial automaton for R to the given upper bound? - if (false) { - - } else { - regex_inc_counter(regex_fail_count, str_in_re); - } - } - continue; - } - // if we have *any* automaton for R, and the upper bound is not too large, - // finitize the automaton (if we have not already done so) and assert all solutions - if (upper_bound_value < 50) { // TODO better metric for threshold - // NOT_IMPLEMENTED_YET(); // TODO(mtrberzi) - } - } else { // !upper_bound_exists - // no upper bound information - if (lower_bound_exists && !lower_bound_value.is_zero() && new_lower_bound_info) { - // nonzero lower bound, no upper bound - - // check current assumptions - if (regex_automaton_assumptions.contains(re) && - !regex_automaton_assumptions[re].empty()){ - // one or more existing assumptions. - // see if the (current best) lower bound can be refined - // (note that if we have an automaton with no assumption, - // this automatically counts as best) - bool need_assumption = true; - regex_automaton_under_assumptions last_assumption; - rational last_lb = rational::zero(); // the default - for (svector::iterator it = regex_automaton_assumptions[re].begin(); - it != regex_automaton_assumptions[re].end(); ++it) { - regex_automaton_under_assumptions autA = *it; - if ((current_assignment == l_true && autA.get_polarity() == false) - || (current_assignment == l_false && autA.get_polarity() == true)) { - // automaton uses incorrect polarity - continue; - } - rational this_lb; - if (autA.get_lower_bound(this_lb)) { - if (this_lb > last_lb) { - last_lb = this_lb; - last_assumption = autA; - } - } else { - need_assumption = false; - last_assumption = autA; - break; - } - } - if (!last_lb.is_zero() || !need_assumption) { - CTRACE("str", !need_assumption, tout << "using automaton with full length information" << std::endl;); - CTRACE("str", need_assumption, tout << "using automaton with assumed lower bound of " << last_lb << std::endl;); - rational refined_lower_bound; - bool solution_at_lower_bound = refine_automaton_lower_bound(last_assumption.get_automaton(), - lower_bound_value, refined_lower_bound); - TRACE("str", tout << "refined lower bound is " << refined_lower_bound << - (solution_at_lower_bound?", solution at lower bound":", no solution at lower bound") << std::endl;); - - expr_ref_vector lhs(m); - if (current_assignment == l_false) { - lhs.push_back(m.mk_not(str_in_re)); - } else { - lhs.push_back(str_in_re); - } - if (need_assumption) { - lhs.push_back(m_autil.mk_ge(str_len, m_autil.mk_numeral(last_lb, true))); - } - lhs.push_back(m_autil.mk_ge(str_len, m_autil.mk_numeral(lower_bound_value, true))); - - expr_ref_vector rhs(m); - - if (solution_at_lower_bound) { - if (refined_lower_bound.is_minus_one()) { - // If there are solutions at the lower bound but not above it, make the bound exact. - rhs.push_back(ctx.mk_eq_atom(str_len, m_autil.mk_numeral(lower_bound_value, true))); - } else { - // If there are solutions at and above the lower bound, add an additional bound. - // DISABLED as this is causing non-termination in the integer solver. --mtrberzi - /* - rhs.push_back(m.mk_or( - ctx.mk_eq_atom(str_len, m_autil.mk_numeral(lower_bound_value, true)), - m_autil.mk_ge(str_len, m_autil.mk_numeral(refined_lower_bound, true)) - )); - */ - } - } else { - if (refined_lower_bound.is_minus_one()) { - // If there are no solutions at or above the lower bound, assert a conflict clause. - rhs.push_back(m.mk_not(m_autil.mk_ge(str_len, m_autil.mk_numeral(lower_bound_value, true)))); - } else { - // If there are solutions above the lower bound but not at it, refine the bound. - rhs.push_back(m_autil.mk_ge(str_len, m_autil.mk_numeral(refined_lower_bound, true))); - } - } - - if (!rhs.empty()) { - expr_ref lhs_terms(mk_and(lhs), m); - expr_ref rhs_terms(mk_and(rhs), m); - assert_implication(lhs_terms, rhs_terms); - regex_axiom_add = true; - } - } - } else { - // no existing automata/assumptions. - // if it's easy to construct a full automaton for R, do so - unsigned expected_complexity = estimate_regex_complexity(re); - bool failureThresholdExceeded = (regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold); - if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold || failureThresholdExceeded) { - eautomaton * aut = m_mk_aut(re); - aut->compress(); - regex_automata.push_back(aut); - regex_automaton_under_assumptions new_aut(re, aut, true); - if (!regex_automaton_assumptions.contains(re)) { - regex_automaton_assumptions.insert(re, svector()); - } - regex_automaton_assumptions[re].push_back(new_aut); - TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); - regex_axiom_add = true; - find_automaton_initial_bounds(str_in_re, aut); - } else { - // TODO check negation? - // TODO construct a partial automaton for R to the given lower bound? - if (false) { - - } else { - regex_inc_counter(regex_fail_count, str_in_re); - } - } - continue; - } - } else { // !lower_bound_exists - // no bounds information - // check for existing automata; - // try to construct an automaton if we don't have one yet - // and doing so without bounds is not difficult - bool existingAutomata = (regex_automaton_assumptions.contains(re) && !regex_automaton_assumptions[re].empty()); - bool failureThresholdExceeded = (regex_get_counter(regex_fail_count, str_in_re) >= m_params.m_RegexAutomata_FailedAutomatonThreshold); - if (!existingAutomata) { - unsigned expected_complexity = estimate_regex_complexity(re); - if (expected_complexity <= m_params.m_RegexAutomata_DifficultyThreshold - || failureThresholdExceeded) { - eautomaton * aut = m_mk_aut(re); - aut->compress(); - regex_automata.push_back(aut); - regex_automaton_under_assumptions new_aut(re, aut, true); - if (!regex_automaton_assumptions.contains(re)) { - regex_automaton_assumptions.insert(re, svector()); - } - regex_automaton_assumptions[re].push_back(new_aut); - TRACE("str", tout << "add new automaton for " << mk_pp(re, m) << ": no assumptions" << std::endl;); - regex_axiom_add = true; - find_automaton_initial_bounds(str_in_re, aut); - } else { - regex_inc_counter(regex_fail_count, str_in_re); - } - } else { - regex_inc_counter(regex_fail_count, str_in_re); - } - } - } - } // foreach (entry in regex_terms) - - for (obj_map >::iterator it = regex_terms_by_string.begin(); - it != regex_terms_by_string.end(); ++it) { - // TODO do we need to check equivalence classes of strings here? - - expr * str = it->m_key; - ptr_vector str_in_re_terms = it->m_value; - - svector intersect_constraints; - // we may find empty intersection before checking every constraint; - // this vector keeps track of which ones actually take part in intersection - svector used_intersect_constraints; - - // choose an automaton/assumption for each assigned (str.in.re) - // that's consistent with the current length information - for (ptr_vector::iterator term_it = str_in_re_terms.begin(); - term_it != str_in_re_terms.end(); ++term_it) { - expr * _unused = nullptr; - expr * re = nullptr; - SASSERT(u.str.is_in_re(*term_it)); - u.str.is_in_re(*term_it, _unused, re); - - rational exact_len; - bool has_exact_len = get_len_value(str, exact_len); - - rational lb, ub; - bool has_lower_bound = lower_bound(mk_strlen(str), lb); - bool has_upper_bound = upper_bound(mk_strlen(str), ub); - - if (regex_automaton_assumptions.contains(re) && - !regex_automaton_assumptions[re].empty()){ - for (svector::iterator aut_it = regex_automaton_assumptions[re].begin(); - aut_it != regex_automaton_assumptions[re].end(); ++aut_it) { - regex_automaton_under_assumptions aut = *aut_it; - rational aut_ub; - bool assume_ub = aut.get_upper_bound(aut_ub); - rational aut_lb; - bool assume_lb = aut.get_lower_bound(aut_lb); - bool consistent = true; - - if (assume_ub) { - // check consistency of assumed upper bound - if (has_exact_len) { - if (exact_len > aut_ub) { - consistent = false; - } - } else { - if (has_upper_bound && ub > aut_ub) { - consistent = false; - } - } - } - - if (assume_lb) { - // check consistency of assumed lower bound - if (has_exact_len) { - if (exact_len < aut_lb) { - consistent = false; - } - } else { - if (has_lower_bound && lb < aut_lb) { - consistent = false; - } - } - } - - if (consistent) { - intersect_constraints.push_back(aut); - break; - } - } - } - } // foreach(term in str_in_re_terms) - - eautomaton * aut_inter = NULL; - CTRACE("str", !intersect_constraints.empty(), tout << "check intersection of automata constraints for " << mk_pp(str, m) << std::endl;); - for (svector::iterator aut_it = intersect_constraints.begin(); - aut_it != intersect_constraints.end(); ++aut_it) { - regex_automaton_under_assumptions aut = *aut_it; - if (aut_inter == NULL) { - // start somewhere - aut_inter = aut.get_automaton(); - used_intersect_constraints.push_back(aut); - continue; - } - - TRACE("str", - { - unsigned v = regex_get_counter(regex_length_attempt_count, aut.get_regex_term()); - tout << "length attempt count of " << mk_pp(aut.get_regex_term(), m) << " is " << v - << ", threshold is " << m_params.m_RegexAutomata_LengthAttemptThreshold << std::endl; - }); - - if (regex_get_counter(regex_length_attempt_count, aut.get_regex_term()) >= m_params.m_RegexAutomata_LengthAttemptThreshold) { - unsigned intersectionDifficulty = estimate_automata_intersection_difficulty(aut_inter, aut.get_automaton()); - TRACE("str", tout << "intersection difficulty is " << intersectionDifficulty << std::endl;); - if (intersectionDifficulty <= m_params.m_RegexAutomata_IntersectionDifficultyThreshold - || regex_get_counter(regex_intersection_fail_count, aut.get_regex_term()) >= m_params.m_RegexAutomata_FailedIntersectionThreshold) { - - expr * str_in_re_term(u.re.mk_in_re(str, aut.get_regex_term())); - lbool current_assignment = ctx.get_assignment(str_in_re_term); - // if the assignment is consistent with our assumption, use the automaton directly; - // otherwise, complement it (and save that automaton for next time) - // TODO we should cache these intermediate results - // TODO do we need to push the intermediates into a vector for deletion anyway? - if ( (current_assignment == l_true && aut.get_polarity()) - || (current_assignment == l_false && !aut.get_polarity())) { - aut_inter = m_mk_aut.mk_product(aut_inter, aut.get_automaton()); - m_automata.push_back(aut_inter); - } else { - // need to complement first - expr_ref rc(u.re.mk_complement(aut.get_regex_term()), m); - eautomaton * aut_c = m_mk_aut(rc); - regex_automata.push_back(aut_c); - // TODO is there any way to build a complement automaton from an existing one? - // this discards length information - aut_inter = m_mk_aut.mk_product(aut_inter, aut_c); - m_automata.push_back(aut_inter); - } - used_intersect_constraints.push_back(aut); - if (aut_inter->is_empty()) { - break; - } - } else { - // failed intersection - regex_inc_counter(regex_intersection_fail_count, aut.get_regex_term()); - } - } - } // foreach(entry in intersect_constraints) - if (aut_inter != NULL) { - aut_inter->compress(); - } - TRACE("str", tout << "intersected " << used_intersect_constraints.size() << " constraints" << std::endl;); - - expr_ref_vector conflict_terms(m); - expr_ref conflict_lhs(m); - for (svector::iterator aut_it = used_intersect_constraints.begin(); - aut_it != used_intersect_constraints.end(); ++aut_it) { - regex_automaton_under_assumptions aut = *aut_it; - expr * str_in_re_term(u.re.mk_in_re(str, aut.get_regex_term())); - lbool current_assignment = ctx.get_assignment(str_in_re_term); - if (current_assignment == l_true) { - conflict_terms.push_back(str_in_re_term); - } else if (current_assignment == l_false) { - conflict_terms.push_back(m.mk_not(str_in_re_term)); - } - // add length assumptions, if any - rational ub; - if (aut.get_upper_bound(ub)) { - expr_ref ub_term(m_autil.mk_le(mk_strlen(str), m_autil.mk_numeral(ub, true)), m); - conflict_terms.push_back(ub_term); - } - rational lb; - if (aut.get_lower_bound(lb)) { - expr_ref lb_term(m_autil.mk_ge(mk_strlen(str), m_autil.mk_numeral(lb, true)), m); - conflict_terms.push_back(lb_term); - } - } - conflict_lhs = mk_and(conflict_terms); - - if (used_intersect_constraints.size() > 1 && aut_inter != NULL) { - // check whether the intersection is only the empty string - unsigned initial_state = aut_inter->init(); - if (aut_inter->final_states().size() == 1 && aut_inter->is_final_state(initial_state)) { - // initial state is final and it is the only final state - // if there are no moves from the initial state, - // the only solution is the empty string - if (aut_inter->get_moves_from(initial_state).empty()) { - TRACE("str", tout << "product automaton only accepts empty string" << std::endl;); - expr_ref rhs1(ctx.mk_eq_atom(str, mk_string("")), m); - expr_ref rhs2(ctx.mk_eq_atom(mk_strlen(str), m_autil.mk_numeral(rational::zero(), true)), m); - expr_ref rhs(m.mk_and(rhs1, rhs2), m); - assert_implication(conflict_lhs, rhs); - regex_axiom_add = true; - } - } - } - - if (aut_inter != NULL && aut_inter->is_empty()) { - TRACE("str", tout << "product automaton is empty; asserting conflict clause" << std::endl;); - expr_ref conflict_clause(m.mk_not(mk_and(conflict_terms)), m); - assert_axiom(conflict_clause); - add_persisted_axiom(conflict_clause); - regex_axiom_add = true; - } - } // foreach (entry in regex_terms_by_string) - if (regex_axiom_add) { - //return FC_CONTINUE; - } + solve_regex_automata(); } // RegexAutomata bool needToAssignFreeVars = false; @@ -10815,7 +10808,7 @@ namespace smt { expr * var = fvIt2->first; tmpSet.clear(); get_eqc_allUnroll(var, constValue, tmpSet); - if (tmpSet.size() > 0) { + if (!tmpSet.empty()) { fv_unrolls_map[var] = tmpSet; } } @@ -10949,7 +10942,7 @@ namespace smt { expr * var = fvIt1->first; fSimpUnroll.clear(); get_eqc_simpleUnroll(var, constValue, fSimpUnroll); - if (fSimpUnroll.size() == 0) { + if (fSimpUnroll.empty()) { gen_assign_unroll_reg(fv_unrolls_map[var]); } else { expr * toAssert = gen_assign_unroll_Str2Reg(var, fSimpUnroll); @@ -11562,7 +11555,7 @@ namespace smt { unroll_tries_map[var][unrolls].erase(e); } - if (unroll_tries_map[var][unrolls].size() == 0) { + if (unroll_tries_map[var][unrolls].empty()) { unroll_tries_map[var][unrolls].push_back(mk_unroll_test_var()); } @@ -11823,7 +11816,7 @@ namespace smt { expr_ref assertL(mk_and(and_items_LHS), m); SASSERT(assertL); expr * finalAxiom = m.mk_or(m.mk_not(assertL), lenTestAssert.get()); - SASSERT(finalAxiom != NULL); + SASSERT(finalAxiom != nullptr); TRACE("str", tout << "crash avoidance finalAxiom: " << mk_pp(finalAxiom, m) << std::endl;); return finalAxiom; } else { @@ -12109,7 +12102,7 @@ namespace smt { lenTester_fvar_map.insert(indicator, freeVar); expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum); - SASSERT(lenTestAssert != NULL); + SASSERT(lenTestAssert != nullptr); return lenTestAssert; } else { TRACE("str", tout << "found previous in-scope length assertions" << std::endl;); @@ -12215,7 +12208,7 @@ namespace smt { testNum = i + 1; } expr * lenTestAssert = gen_len_test_options(freeVar, indicator, testNum); - SASSERT(lenTestAssert != NULL); + SASSERT(lenTestAssert != nullptr); return lenTestAssert; } else { // if we are performing automata-based reasoning and the term associated with @@ -12231,7 +12224,7 @@ namespace smt { // - in the same EQC as freeVar if (term_appears_as_subterm(freeVar, re_str)) { TRACE("str", tout << "prevent value testing on free var " << mk_pp(freeVar, m) << " as it belongs to one or more regex constraints." << std::endl;); - return NULL; + return nullptr; } } } diff --git a/src/smt/theory_str.h b/src/smt/theory_str.h index 419084091..d93c73bed 100644 --- a/src/smt/theory_str.h +++ b/src/smt/theory_str.h @@ -30,6 +30,7 @@ #include "smt/params/theory_str_params.h" #include "smt/proto_model/value_factory.h" #include "smt/smt_model_generator.h" +#include "smt/smt_arith_value.h" #include #include #include @@ -164,7 +165,7 @@ protected: rational upper_bound; public: regex_automaton_under_assumptions() : - re_term(NULL), aut(NULL), polarity(false), + re_term(nullptr), aut(nullptr), polarity(false), assume_lower_bound(false), assume_upper_bound(false) {} regex_automaton_under_assumptions(expr * re_term, eautomaton * aut, bool polarity) : @@ -546,6 +547,7 @@ protected: void process_concat_eq_unroll(expr * concat, expr * unroll); // regex automata and length-aware regex + void solve_regex_automata(); unsigned estimate_regex_complexity(expr * re); unsigned estimate_regex_complexity_under_complement(expr * re); unsigned estimate_automata_intersection_difficulty(eautomaton * aut1, eautomaton * aut2); @@ -580,6 +582,8 @@ protected: bool can_concat_eq_str(expr * concat, zstring& str); bool can_concat_eq_concat(expr * concat1, expr * concat2); bool check_concat_len_in_eqc(expr * concat); + void check_eqc_empty_string(expr * lhs, expr * rhs); + void check_eqc_concat_concat(std::set & eqc_concat_lhs, std::set & eqc_concat_rhs); bool check_length_consistency(expr * n1, expr * n2); bool check_length_const_string(expr * n1, expr * constStr); bool check_length_eq_var_concat(expr * n1, expr * n2); diff --git a/src/smt/theory_utvpi_def.h b/src/smt/theory_utvpi_def.h index b051c504a..fba549412 100644 --- a/src/smt/theory_utvpi_def.h +++ b/src/smt/theory_utvpi_def.h @@ -618,7 +618,7 @@ namespace smt { th_var v1 = null_theory_var, v2 = null_theory_var; bool pos1 = true, pos2 = true; - if (terms.size() >= 1) { + if (!terms.empty()) { v1 = terms[0].first; pos1 = terms[0].second.is_one(); SASSERT(v1 != null_theory_var); diff --git a/src/smt/uses_theory.cpp b/src/smt/uses_theory.cpp index 517951a7b..64565dc78 100644 --- a/src/smt/uses_theory.cpp +++ b/src/smt/uses_theory.cpp @@ -41,7 +41,7 @@ bool uses_theory(expr * n, family_id fid, expr_mark & visited) { try { for_each_expr(p, visited, n); } - catch (uses_theory_ns::found) { + catch (const uses_theory_ns::found &) { return true; } return false; diff --git a/src/smt/watch_list.cpp b/src/smt/watch_list.cpp index 9835142f6..f95e1c571 100644 --- a/src/smt/watch_list.cpp +++ b/src/smt/watch_list.cpp @@ -21,7 +21,7 @@ Revision History: namespace smt { #define DEFAULT_WATCH_LIST_SIZE (sizeof(clause *) * 4) -#ifdef _AMD64_ +#if defined(__LP64__) || defined(_WIN64) // make sure data is aligned in 64 bit machines #define HEADER_SIZE (4 * sizeof(unsigned)) #else @@ -36,10 +36,10 @@ namespace smt { void watch_list::expand() { if (m_data == nullptr) { - unsigned size = DEFAULT_WATCH_LIST_SIZE + HEADER_SIZE; + unsigned size = DEFAULT_WATCH_LIST_SIZE + HEADER_SIZE; unsigned * mem = reinterpret_cast(alloc_svect(char, size)); -#ifdef _AMD64_ - ++mem; // make sure data is aligned in 64 bit machines +#if defined(__LP64__) || defined(_WIN64) + ++mem; // make sure data is aligned in 64 bit machines #endif *mem = 0; ++mem; @@ -61,10 +61,10 @@ namespace smt { unsigned new_capacity = (((curr_capacity * 3 + sizeof(clause *)) >> 1)+3)&~3U; unsigned * mem = reinterpret_cast(alloc_svect(char, new_capacity + HEADER_SIZE)); unsigned curr_end_cls = end_cls_core(); -#ifdef _AMD64_ - ++mem; // make sure data is aligned in 64 bit machines +#if defined(__LP64__) || defined(_WIN64) + ++mem; // make sure data is aligned in 64 bit machines #endif - *mem = curr_end_cls; + *mem = curr_end_cls; ++mem; SASSERT(bin_bytes <= new_capacity); unsigned new_begin_bin = new_capacity - bin_bytes; diff --git a/src/solver/check_sat_result.cpp b/src/solver/check_sat_result.cpp index 28e6afeca..7431618df 100644 --- a/src/solver/check_sat_result.cpp +++ b/src/solver/check_sat_result.cpp @@ -36,6 +36,7 @@ void check_sat_result::set_reason_unknown(event_handler& eh) { } } + simple_check_sat_result::simple_check_sat_result(ast_manager & m): m_core(m), m_proof(m) { diff --git a/src/solver/combined_solver.cpp b/src/solver/combined_solver.cpp index 61094c29c..e8fb34815 100644 --- a/src/solver/combined_solver.cpp +++ b/src/solver/combined_solver.cpp @@ -39,7 +39,7 @@ Notes: The object switches to incremental when: - push is used - - assertions are peformed after a check_sat + - assertions are performed after a check_sat - parameter ignore_solver1==false */ class combined_solver : public solver { diff --git a/src/solver/mus.cpp b/src/solver/mus.cpp index 094b27ed3..4ae93a52e 100644 --- a/src/solver/mus.cpp +++ b/src/solver/mus.cpp @@ -217,13 +217,12 @@ struct mus::imp { } expr_set mss_set; - for (unsigned i = 0; i < mss.size(); ++i) { - mss_set.insert(mss[i]); + for (expr* e : mss) { + mss_set.insert(e); } - expr_set::iterator it = min_core.begin(), end = min_core.end(); - for (; it != end; ++it) { - if (mss_set.contains(*it) && min_lit != *it) { - unknown.push_back(*it); + for (expr * e : min_core) { + if (mss_set.contains(e) && min_lit != e) { + unknown.push_back(e); } } core_literal = min_lit; diff --git a/src/solver/parallel_params.pyg b/src/solver/parallel_params.pyg index 2d58cbb81..cb37138ee 100644 --- a/src/solver/parallel_params.pyg +++ b/src/solver/parallel_params.pyg @@ -9,7 +9,7 @@ def_module_params('parallel', ('conquer.restart.max', UINT, 5, 'maximal number of restarts during conquer phase'), ('conquer.delay', UINT, 10, 'delay of cubes until applying conquer'), ('conquer.backtrack_frequency', UINT, 10, 'frequency to apply core minimization during conquer'), - ('simplify.exp', DOUBLE, 1, 'restart and inprocess max is multipled by simplify.exp ^ depth'), + ('simplify.exp', DOUBLE, 1, 'restart and inprocess max is multiplied by simplify.exp ^ depth'), ('simplify.restart.max', UINT, 5000, 'maximal number of restarts during simplification phase'), ('simplify.inprocess.max', UINT, 2, 'maximal number of inprocessing steps during simplification'), )) diff --git a/src/solver/parallel_tactic.cpp b/src/solver/parallel_tactic.cpp index 142ba4bb8..4ee93ff37 100644 --- a/src/solver/parallel_tactic.cpp +++ b/src/solver/parallel_tactic.cpp @@ -672,11 +672,11 @@ public: init(); } - void operator ()(const goal_ref & g,goal_ref_buffer & result) { + void operator ()(const goal_ref & g,goal_ref_buffer & result) override { fail_if_proof_generation("parallel-tactic", g); ast_manager& m = g->m(); solver* s = m_solver->translate(m, m_params); - solver_state* st = alloc(solver_state, 0, s, m_params); + solver_state* st = alloc(solver_state, nullptr, s, m_params); m_queue.add_task(st); expr_ref_vector clauses(m); ptr_vector assumptions; @@ -719,29 +719,29 @@ public: return pp.conquer_batch_size(); } - void cleanup() { + void cleanup() override { m_queue.reset(); } - tactic* translate(ast_manager& m) { + tactic* translate(ast_manager& m) override { solver* s = m_solver->translate(m, m_params); return alloc(parallel_tactic, s, m_params); } - virtual void updt_params(params_ref const & p) { + void updt_params(params_ref const & p) override { m_params.copy(p); parallel_params pp(p); m_conquer_delay = pp.conquer_delay(); } - virtual void collect_statistics(statistics & st) const { + void collect_statistics(statistics & st) const override { st.copy(m_stats); st.update("par unsat", m_num_unsat); st.update("par models", m_models.size()); st.update("par progress", m_progress); } - virtual void reset_statistics() { + void reset_statistics() override { m_stats.reset(); } }; diff --git a/src/solver/smt_logics.cpp b/src/solver/smt_logics.cpp index 59a9a1562..d0fd8f809 100644 --- a/src/solver/smt_logics.cpp +++ b/src/solver/smt_logics.cpp @@ -22,7 +22,7 @@ Revision History: bool smt_logics::supported_logic(symbol const & s) { - return logic_has_uf(s) || logic_is_all(s) || logic_has_fd(s) || + return logic_has_uf(s) || logic_is_allcsp(s) || logic_has_fd(s) || logic_has_arith(s) || logic_has_bv(s) || logic_has_array(s) || logic_has_seq(s) || logic_has_str(s) || logic_has_horn(s) || logic_has_fpa(s); @@ -83,7 +83,7 @@ bool smt_logics::logic_has_arith(symbol const & s) { s == "QF_FPBV" || s == "QF_BVFP" || s == "QF_S" || - s == "ALL" || + logic_is_allcsp(s) || s == "QF_FD" || s == "HORN" || s == "QF_FPLRA"; @@ -102,7 +102,7 @@ bool smt_logics::logic_has_bv(symbol const & s) { s == "QF_BVRE" || s == "QF_FPBV" || s == "QF_BVFP" || - s == "ALL" || + logic_is_allcsp(s) || s == "QF_FD" || s == "HORN"; } @@ -123,22 +123,22 @@ bool smt_logics::logic_has_array(symbol const & s) { s == "AUFNIRA" || s == "AUFBV" || s == "ABV" || - s == "ALL" || + logic_is_allcsp(s) || s == "QF_ABV" || s == "QF_AUFBV" || s == "HORN"; } bool smt_logics::logic_has_seq(symbol const & s) { - return s == "QF_BVRE" || s == "QF_S" || s == "ALL"; + return s == "QF_BVRE" || s == "QF_S" || logic_is_allcsp(s); } bool smt_logics::logic_has_str(symbol const & s) { - return s == "QF_S" || s == "ALL"; + return s == "QF_S" || logic_is_allcsp(s); } bool smt_logics::logic_has_fpa(symbol const & s) { - return s == "QF_FP" || s == "QF_FPBV" || s == "QF_BVFP" || s == "QF_FPLRA" || s == "ALL"; + return s == "QF_FP" || s == "QF_FPBV" || s == "QF_BVFP" || s == "QF_FPLRA" || logic_is_allcsp(s); } bool smt_logics::logic_has_uf(symbol const & s) { @@ -150,9 +150,10 @@ bool smt_logics::logic_has_horn(symbol const& s) { } bool smt_logics::logic_has_pb(symbol const& s) { - return s == "QF_FD" || s == "ALL" || logic_has_horn(s); + return s == "QF_FD" || logic_is_allcsp(s) || logic_has_horn(s); } bool smt_logics::logic_has_datatype(symbol const& s) { - return s == "QF_FD" || s == "ALL" || s == "QF_DT"; + return s == "QF_FD" || logic_is_allcsp(s) || s == "QF_DT"; } + diff --git a/src/solver/smt_logics.h b/src/solver/smt_logics.h index 702431cdd..4382f575b 100644 --- a/src/solver/smt_logics.h +++ b/src/solver/smt_logics.h @@ -25,6 +25,8 @@ public: static bool supported_logic(symbol const & s); static bool logic_has_reals_only(symbol const& l); static bool logic_is_all(symbol const& s) { return s == "ALL"; } + static bool logic_is_csp(symbol const& s) { return s == "CSP"; } + static bool logic_is_allcsp(symbol const& s) { return logic_is_all(s) || logic_is_csp(s); } static bool logic_has_uf(symbol const& s); static bool logic_has_arith(symbol const & s); static bool logic_has_bv(symbol const & s); diff --git a/src/solver/solver.cpp b/src/solver/solver.cpp index 4044c4a85..f8c2f8072 100644 --- a/src/solver/solver.cpp +++ b/src/solver/solver.cpp @@ -178,10 +178,19 @@ lbool solver::preferred_sat(expr_ref_vector const& asms, vector return check_sat(0, nullptr); } -bool solver::is_literal(ast_manager& m, expr* e) { - return is_uninterp_const(e) || (m.is_not(e, e) && is_uninterp_const(e)); + +static bool is_m_atom(ast_manager& m, expr* f) { + if (!is_app(f)) return true; + app* _f = to_app(f); + family_id bfid = m.get_basic_family_id(); + if (_f->get_family_id() != bfid) return true; + if (_f->get_num_args() > 0 && m.is_bool(_f->get_arg(0))) return false; + return m.is_eq(f) || m.is_distinct(f); } +bool solver::is_literal(ast_manager& m, expr* e) { + return is_m_atom(m, e) || (m.is_not(e, e) && is_m_atom(m, e)); +} void solver::assert_expr(expr* f) { expr_ref fml(f, get_manager()); @@ -199,8 +208,6 @@ void solver::assert_expr(expr* f, expr* t) { expr_ref fml(f, m); expr_ref a(t, m); if (m_enforce_model_conversion) { - IF_VERBOSE(0, verbose_stream() << "enforce model conversion\n";); - exit(0); model_converter_ref mc = get_model_converter(); if (mc) { (*mc)(fml); @@ -256,3 +263,40 @@ expr_ref_vector solver::get_units(ast_manager& m) { return result; } + + +expr_ref_vector solver::get_non_units(ast_manager& m) { + expr_ref_vector result(m), fmls(m); + get_assertions(fmls); + family_id bfid = m.get_basic_family_id(); + expr_mark marked; + unsigned sz0 = fmls.size(); + for (unsigned i = 0; i < fmls.size(); ++i) { + expr* f = fmls.get(i); + if (marked.is_marked(f)) continue; + marked.mark(f); + if (!is_app(f)) { + if (i >= sz0) result.push_back(f); + continue; + } + app* _f = to_app(f); + if (_f->get_family_id() == bfid) { + // basic objects are true/false/and/or/not/=/distinct + // and proof objects (that are not Boolean). + if (i < sz0 && m.is_not(f) && is_m_atom(m, _f->get_arg(0))) { + marked.mark(_f->get_arg(0)); + } + else if (_f->get_num_args() > 0 && m.is_bool(_f->get_arg(0))) { + fmls.append(_f->get_num_args(), _f->get_args()); + } + else if (i >= sz0 && is_m_atom(m, f)) { + result.push_back(f); + } + } + + else { + if (i >= sz0) result.push_back(f); + } + } + return result; +} diff --git a/src/solver/solver.h b/src/solver/solver.h index c371be284..7437a5a08 100644 --- a/src/solver/solver.h +++ b/src/solver/solver.h @@ -146,6 +146,8 @@ public: lbool check_sat(app_ref_vector const& asms) { return check_sat(asms.size(), (expr* const*)asms.c_ptr()); } + lbool check_sat() { return check_sat(0, nullptr); } + /** \brief Check satisfiability modulo a cube and a clause. @@ -236,6 +238,8 @@ public: */ expr_ref_vector get_units(ast_manager& m); + expr_ref_vector get_non_units(ast_manager& m); + class scoped_push { solver& s; bool m_nopop; diff --git a/src/solver/solver_na2as.cpp b/src/solver/solver_na2as.cpp index 41853b19a..a3fcd0e0b 100644 --- a/src/solver/solver_na2as.cpp +++ b/src/solver/solver_na2as.cpp @@ -31,7 +31,7 @@ solver_na2as::solver_na2as(ast_manager & m): solver_na2as::~solver_na2as() {} void solver_na2as::assert_expr_core2(expr * t, expr * a) { - if (a == 0) { + if (a == nullptr) { assert_expr_core(t); } else { diff --git a/src/solver/tactic2solver.cpp b/src/solver/tactic2solver.cpp index cf0c6f9bc..492ddd443 100644 --- a/src/solver/tactic2solver.cpp +++ b/src/solver/tactic2solver.cpp @@ -79,6 +79,7 @@ public: expr_ref_vector cube(expr_ref_vector& vars, unsigned ) override { + set_reason_unknown("cubing is not supported on tactics"); return expr_ref_vector(get_manager()); } @@ -169,7 +170,7 @@ lbool tactic2solver::check_sat_core(unsigned num_assumptions, expr * const * ass break; default: m_result->set_status(l_undef); - if (reason_unknown != "") + if (!reason_unknown.empty()) m_result->m_unknown = reason_unknown; if (num_assumptions == 0 && m_scopes.empty()) { m_assertions.reset(); diff --git a/src/tactic/arith/bv2real_rewriter.cpp b/src/tactic/arith/bv2real_rewriter.cpp index 5839ff7a2..67fca873e 100644 --- a/src/tactic/arith/bv2real_rewriter.cpp +++ b/src/tactic/arith/bv2real_rewriter.cpp @@ -89,7 +89,7 @@ bool bv2real_util::contains_bv2real(expr* e) const { try { for_each_expr(p, e); } - catch (contains_bv2real_proc::found) { + catch (const contains_bv2real_proc::found &) { return true; } return false; diff --git a/src/tactic/arith/degree_shift_tactic.cpp b/src/tactic/arith/degree_shift_tactic.cpp index c15285703..b713c3055 100644 --- a/src/tactic/arith/degree_shift_tactic.cpp +++ b/src/tactic/arith/degree_shift_tactic.cpp @@ -204,7 +204,7 @@ class degree_shift_tactic : public tactic { for (auto const& kv : m_var2degree) { SASSERT(kv.m_value.is_int()); SASSERT(kv.m_value >= rational(2)); - app * fresh = m.mk_fresh_const(0, kv.m_key->get_decl()->get_range()); + app * fresh = m.mk_fresh_const(nullptr, kv.m_key->get_decl()->get_range()); m_pinned.push_back(fresh); m_var2var.insert(kv.m_key, fresh); if (m_produce_models) { diff --git a/src/tactic/arith/fix_dl_var_tactic.cpp b/src/tactic/arith/fix_dl_var_tactic.cpp index 669ded49d..d198ce498 100644 --- a/src/tactic/arith/fix_dl_var_tactic.cpp +++ b/src/tactic/arith/fix_dl_var_tactic.cpp @@ -226,7 +226,7 @@ class fix_dl_var_tactic : public tactic { } return most_occs(); } - catch (failed) { + catch (const failed &) { return nullptr; } } diff --git a/src/tactic/arith/fm_tactic.cpp b/src/tactic/arith/fm_tactic.cpp index fc41f54a4..bd99e4303 100644 --- a/src/tactic/arith/fm_tactic.cpp +++ b/src/tactic/arith/fm_tactic.cpp @@ -1231,7 +1231,7 @@ class fm_tactic : public tactic { } // An integer variable x may be eliminated, if - // 1- All variables in the contraints it occur are integer. + // 1- All variables in the constraints it occur are integer. // 2- The coefficient of x in all lower bounds (or all upper bounds) is unit. bool can_eliminate(var x) const { if (!is_int(x)) diff --git a/src/tactic/arith/lia2card_tactic.cpp b/src/tactic/arith/lia2card_tactic.cpp index 88e4a5583..027b6d91c 100644 --- a/src/tactic/arith/lia2card_tactic.cpp +++ b/src/tactic/arith/lia2card_tactic.cpp @@ -36,7 +36,7 @@ class lia2card_tactic : public tactic { expr* m_expr; bound(unsigned lo, unsigned hi, expr* b): m_lo(lo), m_hi(hi), m_expr(b) {} - bound(): m_lo(0), m_hi(0), m_expr(0) {} + bound(): m_lo(0), m_hi(0), m_expr(nullptr) {} }; struct lia_rewriter_cfg : public default_rewriter_cfg { diff --git a/src/tactic/arith/lia2pb_tactic.cpp b/src/tactic/arith/lia2pb_tactic.cpp index db1c22866..c177f35be 100644 --- a/src/tactic/arith/lia2pb_tactic.cpp +++ b/src/tactic/arith/lia2pb_tactic.cpp @@ -156,7 +156,7 @@ class lia2pb_tactic : public tactic { } return true; } - catch (failed) { + catch (const failed &) { return false; } } diff --git a/src/tactic/arith/pb2bv_tactic.cpp b/src/tactic/arith/pb2bv_tactic.cpp index f36e3a6db..7a64c9f16 100644 --- a/src/tactic/arith/pb2bv_tactic.cpp +++ b/src/tactic/arith/pb2bv_tactic.cpp @@ -1034,7 +1034,7 @@ struct is_pb_probe : public probe { return true; } - catch (pb2bv_tactic::non_pb) { + catch (const pb2bv_tactic::non_pb &) { return false; } } diff --git a/src/tactic/arith/purify_arith_tactic.cpp b/src/tactic/arith/purify_arith_tactic.cpp index 67dadd34b..14b6c6b41 100644 --- a/src/tactic/arith/purify_arith_tactic.cpp +++ b/src/tactic/arith/purify_arith_tactic.cpp @@ -509,6 +509,9 @@ struct purify_arith_proc { return BR_DONE; } else { + expr_ref s(u().mk_sin(theta), m()); + expr_ref c(u().mk_cos(theta), m()); + push_cnstr(EQ(mk_real_one(), u().mk_add(u().mk_mul(s, s), u().mk_mul(c, c)))); return BR_FAILED; } } @@ -777,11 +780,10 @@ struct purify_arith_proc { if (produce_models && !m_sin_cos.empty()) { generic_model_converter* emc = alloc(generic_model_converter, m(), "purify_sin_cos"); mc = concat(mc.get(), emc); - obj_map >::iterator it = m_sin_cos.begin(), end = m_sin_cos.end(); - for (; it != end; ++it) { - emc->add(it->m_key->get_decl(), - m().mk_ite(u().mk_ge(it->m_value.first, mk_real_zero()), u().mk_acos(it->m_value.second), - u().mk_add(u().mk_acos(u().mk_uminus(it->m_value.second)), u().mk_pi()))); + for (auto const& kv : m_sin_cos) { + emc->add(kv.m_key->get_decl(), + m().mk_ite(u().mk_ge(kv.m_value.first, mk_real_zero()), u().mk_acos(kv.m_value.second), + u().mk_add(u().mk_acos(u().mk_uminus(kv.m_value.second)), u().mk_pi()))); } } diff --git a/src/tactic/bv/bit_blaster_model_converter.cpp b/src/tactic/bv/bit_blaster_model_converter.cpp index 5474700c3..be6ea8b7a 100644 --- a/src/tactic/bv/bit_blaster_model_converter.cpp +++ b/src/tactic/bv/bit_blaster_model_converter.cpp @@ -72,10 +72,8 @@ struct bit_blaster_model_converter : public model_converter { } TRACE("blaster_mc", tout << "bits that should not be included in the model:\n"; - obj_hashtable::iterator it = bits.begin(); - obj_hashtable::iterator end = bits.end(); - for (; it != end; ++it) { - tout << (*it)->get_name() << " "; + for (func_decl* f : bits) { + tout << f->get_name() << " "; } tout << "\n";); diff --git a/src/tactic/bv/bv1_blaster_tactic.cpp b/src/tactic/bv/bv1_blaster_tactic.cpp index b81bc5687..bf9ca4101 100644 --- a/src/tactic/bv/bv1_blaster_tactic.cpp +++ b/src/tactic/bv/bv1_blaster_tactic.cpp @@ -371,7 +371,7 @@ class bv1_blaster_tactic : public tactic { for_each_expr_core(proc, visited, f); } } - catch (not_target) { + catch (const not_target &) { return false; } return true; diff --git a/src/tactic/bv/bv_bound_chk_tactic.cpp b/src/tactic/bv/bv_bound_chk_tactic.cpp index 75b772720..cf35afef4 100644 --- a/src/tactic/bv/bv_bound_chk_tactic.cpp +++ b/src/tactic/bv/bv_bound_chk_tactic.cpp @@ -74,7 +74,7 @@ struct bv_bound_chk_rewriter_cfg : public default_rewriter_cfg { bv_bounds bvb(m()); const br_status rv = bvb.rewrite(m_bv_ineq_consistency_test_max, f, num, args, result); if (rv != BR_FAILED && (m_m.is_false(result) || m_m.is_true(result))) m_stats.m_unsats++; - else if (rv != BR_FAILED && bvb.singletons().size()) m_stats.m_singletons++; + else if (rv != BR_FAILED && !bvb.singletons().empty()) m_stats.m_singletons++; else if (rv != BR_FAILED && is_app(result) && to_app(result)->get_num_args() < num) m_stats.m_reduces++; return rv; } diff --git a/src/tactic/bv/bv_size_reduction_tactic.cpp b/src/tactic/bv/bv_size_reduction_tactic.cpp index 964102825..fd1d1499b 100644 --- a/src/tactic/bv/bv_size_reduction_tactic.cpp +++ b/src/tactic/bv/bv_size_reduction_tactic.cpp @@ -27,28 +27,8 @@ Notes: #include "tactic/generic_model_converter.h" #include "ast/ast_smt2_pp.h" +namespace { class bv_size_reduction_tactic : public tactic { - struct imp; - imp * m_imp; -public: - bv_size_reduction_tactic(ast_manager & m); - - tactic * translate(ast_manager & m) override { - return alloc(bv_size_reduction_tactic, m); - } - - ~bv_size_reduction_tactic() override; - - void operator()(goal_ref const & g, goal_ref_buffer & result) override; - - void cleanup() override; -}; - -tactic * mk_bv_size_reduction_tactic(ast_manager & m, params_ref const & p) { - return clean(alloc(bv_size_reduction_tactic, m)); -} - -struct bv_size_reduction_tactic::imp { typedef rational numeral; typedef generic_model_converter bv_size_reduction_mc; @@ -63,12 +43,29 @@ struct bv_size_reduction_tactic::imp { scoped_ptr m_replacer; bool m_produce_models; - imp(ast_manager & _m): - m(_m), +public: + bv_size_reduction_tactic(ast_manager & m) : + m(m), m_util(m), m_replacer(mk_default_expr_replacer(m)) { } + tactic * translate(ast_manager & m) override { + return alloc(bv_size_reduction_tactic, m); + } + + void operator()(goal_ref const & g, goal_ref_buffer & result) override; + + void cleanup() override { + m_signed_lowers.reset(); + m_signed_uppers.reset(); + m_unsigned_lowers.reset(); + m_unsigned_uppers.reset(); + m_mc = nullptr; + m_fmc = nullptr; + m_replacer->reset(); + } + void update_signed_lower(app * v, numeral const & k) { // k <= v obj_map::obj_map_entry * entry = m_signed_lowers.insert_if_not_there2(v, k); @@ -178,7 +175,7 @@ struct bv_size_reduction_tactic::imp { throw tactic_exception(m.limit().get_cancel_msg()); } - void operator()(goal & g, model_converter_ref & mc) { + void run(goal & g, model_converter_ref & mc) { if (g.inconsistent()) return; TRACE("before_bv_size_reduction", g.display(tout);); @@ -373,14 +370,6 @@ struct bv_size_reduction_tactic::imp { }; -bv_size_reduction_tactic::bv_size_reduction_tactic(ast_manager & m) { - m_imp = alloc(imp, m); -} - -bv_size_reduction_tactic::~bv_size_reduction_tactic() { - dealloc(m_imp); -} - void bv_size_reduction_tactic::operator()(goal_ref const & g, goal_ref_buffer & result) { SASSERT(g->is_well_sorted()); @@ -388,17 +377,14 @@ void bv_size_reduction_tactic::operator()(goal_ref const & g, fail_if_unsat_core_generation("bv-size-reduction", g); result.reset(); model_converter_ref mc; - m_imp->operator()(*(g.get()), mc); + run(*(g.get()), mc); g->inc_depth(); g->add(mc.get()); result.push_back(g.get()); SASSERT(g->is_well_sorted()); } - - -void bv_size_reduction_tactic::cleanup() { - ast_manager & m = m_imp->m; - m_imp->~imp(); - new (m_imp) imp(m); } +tactic * mk_bv_size_reduction_tactic(ast_manager & m, params_ref const & p) { + return clean(alloc(bv_size_reduction_tactic, m)); +} diff --git a/src/tactic/bv/bv_size_reduction_tactic.h b/src/tactic/bv/bv_size_reduction_tactic.h index 4a24a1d78..1bb512f3f 100644 --- a/src/tactic/bv/bv_size_reduction_tactic.h +++ b/src/tactic/bv/bv_size_reduction_tactic.h @@ -21,8 +21,7 @@ Author: Notes: --*/ -#ifndef BV_SIZE_REDUCTION_TACTIC_H_ -#define BV_SIZE_REDUCTION_TACTIC_H_ +#pragma once #include "util/params.h" class ast_manager; @@ -32,5 +31,3 @@ tactic * mk_bv_size_reduction_tactic(ast_manager & m, params_ref const & p = par /* ADD_TACTIC("reduce-bv-size", "try to reduce bit-vector sizes using inequalities.", "mk_bv_size_reduction_tactic(m, p)") */ - -#endif diff --git a/src/tactic/bv/bvarray2uf_rewriter.cpp b/src/tactic/bv/bvarray2uf_rewriter.cpp index 3ca296eb7..97947c03a 100644 --- a/src/tactic/bv/bvarray2uf_rewriter.cpp +++ b/src/tactic/bv/bvarray2uf_rewriter.cpp @@ -40,7 +40,7 @@ bvarray2uf_rewriter_cfg::bvarray2uf_rewriter_cfg(ast_manager & m, params_ref con m_fmc(nullptr), extra_assertions(m) { updt_params(p); - // We need to make sure that the mananger has the BV and array plugins loaded. + // We need to make sure that the manager has the BV and array plugins loaded. symbol s_bv("bv"); if (!m_manager.has_plugin(s_bv)) m_manager.register_plugin(s_bv, alloc(bv_decl_plugin)); diff --git a/src/tactic/bv/elim_small_bv_tactic.cpp b/src/tactic/bv/elim_small_bv_tactic.cpp index 0b5b98308..a9f94ca3f 100644 --- a/src/tactic/bv/elim_small_bv_tactic.cpp +++ b/src/tactic/bv/elim_small_bv_tactic.cpp @@ -28,6 +28,7 @@ Revision History: #include "tactic/bv/elim_small_bv_tactic.h" +namespace { class elim_small_bv_tactic : public tactic { struct rw_cfg : public default_rewriter_cfg { @@ -214,69 +215,24 @@ class elim_small_bv_tactic : public tactic { } }; - struct imp { - ast_manager & m; - rw m_rw; + ast_manager & m; + rw m_rw; + params_ref m_params; - imp(ast_manager & _m, params_ref const & p) : - m(_m), - m_rw(m, p) { - } - - void updt_params(params_ref const & p) { - m_rw.cfg().updt_params(p); - } - - void operator()(goal_ref const & g, goal_ref_buffer & result) { - SASSERT(g->is_well_sorted()); - tactic_report report("elim-small-bv", *g); - bool produce_proofs = g->proofs_enabled(); - fail_if_proof_generation("elim-small-bv", g); - fail_if_unsat_core_generation("elim-small-bv", g); - m_rw.cfg().m_produce_models = g->models_enabled(); - - m_rw.m_cfg.m_goal = g.get(); - expr_ref new_curr(m); - proof_ref new_pr(m); - unsigned size = g->size(); - for (unsigned idx = 0; idx < size; idx++) { - expr * curr = g->form(idx); - m_rw(curr, new_curr, new_pr); - if (produce_proofs) { - proof * pr = g->pr(idx); - new_pr = m.mk_modus_ponens(pr, new_pr); - } - g->update(idx, new_curr, new_pr, g->dep(idx)); - } - g->add(m_rw.m_cfg.m_mc.get()); - - report_tactic_progress(":elim-small-bv-num-eliminated", m_rw.m_cfg.m_num_eliminated); - g->inc_depth(); - result.push_back(g.get()); - TRACE("elim-small-bv", g->display(tout);); - SASSERT(g->is_well_sorted()); - } - }; - - imp * m_imp; - params_ref m_params; public: elim_small_bv_tactic(ast_manager & m, params_ref const & p) : + m(m), + m_rw(m, p), m_params(p) { - m_imp = alloc(imp, m, p); } tactic * translate(ast_manager & m) override { return alloc(elim_small_bv_tactic, m, m_params); } - ~elim_small_bv_tactic() override { - dealloc(m_imp); - } - void updt_params(params_ref const & p) override { m_params = p; - m_imp->m_rw.cfg().updt_params(p); + m_rw.cfg().updt_params(p); } void collect_param_descrs(param_descrs & r) override { @@ -285,18 +241,44 @@ public: r.insert("max_bits", CPK_UINT, "(default: 4) maximum bit-vector size of quantified bit-vectors to be eliminated."); } - void operator()(goal_ref const & in, + void operator()(goal_ref const & g, goal_ref_buffer & result) override { - (*m_imp)(in, result); + SASSERT(g->is_well_sorted()); + tactic_report report("elim-small-bv", *g); + bool produce_proofs = g->proofs_enabled(); + fail_if_proof_generation("elim-small-bv", g); + fail_if_unsat_core_generation("elim-small-bv", g); + m_rw.cfg().m_produce_models = g->models_enabled(); + + m_rw.m_cfg.m_goal = g.get(); + expr_ref new_curr(m); + proof_ref new_pr(m); + unsigned size = g->size(); + for (unsigned idx = 0; idx < size; idx++) { + expr * curr = g->form(idx); + m_rw(curr, new_curr, new_pr); + if (produce_proofs) { + proof * pr = g->pr(idx); + new_pr = m.mk_modus_ponens(pr, new_pr); + } + g->update(idx, new_curr, new_pr, g->dep(idx)); + } + g->add(m_rw.m_cfg.m_mc.get()); + + report_tactic_progress(":elim-small-bv-num-eliminated", m_rw.m_cfg.m_num_eliminated); + g->inc_depth(); + result.push_back(g.get()); + TRACE("elim-small-bv", g->display(tout);); + SASSERT(g->is_well_sorted()); } void cleanup() override { - ast_manager & m = m_imp->m; - m_imp->~imp(); - m_imp = new (m_imp) imp(m, m_params); + m_rw.~rw(); + new (&m_rw) rw(m, m_params); } }; +} tactic * mk_elim_small_bv_tactic(ast_manager & m, params_ref const & p) { return clean(alloc(elim_small_bv_tactic, m, p)); diff --git a/src/tactic/bv/elim_small_bv_tactic.h b/src/tactic/bv/elim_small_bv_tactic.h index 675ec3de7..e4a91f70f 100644 --- a/src/tactic/bv/elim_small_bv_tactic.h +++ b/src/tactic/bv/elim_small_bv_tactic.h @@ -16,8 +16,7 @@ Author: Revision History: --*/ -#ifndef ELIM_SMALL_BV_H_ -#define ELIM_SMALL_BV_H_ +#pragma once #include "util/params.h" class ast_manager; @@ -28,5 +27,3 @@ tactic * mk_elim_small_bv_tactic(ast_manager & m, params_ref const & p = params_ /* ADD_TACTIC("elim-small-bv", "eliminate small, quantified bit-vectors by expansion.", "mk_elim_small_bv_tactic(m, p)") */ - -#endif diff --git a/src/tactic/core/cofactor_elim_term_ite.cpp b/src/tactic/core/cofactor_elim_term_ite.cpp index 1b435791c..6afcdee41 100644 --- a/src/tactic/core/cofactor_elim_term_ite.cpp +++ b/src/tactic/core/cofactor_elim_term_ite.cpp @@ -197,7 +197,7 @@ struct cofactor_elim_term_ite::imp { switch (arg->get_kind()) { case AST_VAR: case AST_QUANTIFIER: - // ingore quantifiers + // ignore quantifiers break; case AST_APP: if (to_app(arg)->get_num_args() > 0) { @@ -264,7 +264,7 @@ struct cofactor_elim_term_ite::imp { switch (arg->get_kind()) { case AST_VAR: case AST_QUANTIFIER: - // ingore quantifiers + // ignore quantifiers break; case AST_APP: if (to_app(arg)->get_num_args() > 0) { diff --git a/src/tactic/core/elim_uncnstr_tactic.cpp b/src/tactic/core/elim_uncnstr_tactic.cpp index 577db30cd..5b77fb9a2 100644 --- a/src/tactic/core/elim_uncnstr_tactic.cpp +++ b/src/tactic/core/elim_uncnstr_tactic.cpp @@ -28,881 +28,864 @@ Notes: #include "ast/ast_smt2_pp.h" #include "ast/ast_ll_pp.h" +namespace { class elim_uncnstr_tactic : public tactic { - struct imp { - // unconstrained vars collector + // unconstrained vars collector - typedef generic_model_converter mc; + typedef generic_model_converter mc; - struct rw_cfg : public default_rewriter_cfg { - bool m_produce_proofs; - obj_hashtable & m_vars; - ref m_mc; - arith_util m_a_util; - bv_util m_bv_util; - array_util m_ar_util; - datatype_util m_dt_util; - app_ref_vector m_fresh_vars; - obj_map m_cache; - app_ref_vector m_cache_domain; - unsigned long long m_max_memory; - unsigned m_max_steps; - - rw_cfg(ast_manager & m, bool produce_proofs, obj_hashtable & vars, mc * _m, - unsigned long long max_memory, unsigned max_steps): - m_produce_proofs(produce_proofs), - m_vars(vars), - m_mc(_m), - m_a_util(m), - m_bv_util(m), - m_ar_util(m), - m_dt_util(m), - m_fresh_vars(m), - m_cache_domain(m), - m_max_memory(max_memory), - m_max_steps(max_steps) { - } - - ast_manager & m() const { return m_a_util.get_manager(); } - - bool max_steps_exceeded(unsigned num_steps) const { - cooperate("elim-uncnstr-vars"); - if (memory::get_allocation_size() > m_max_memory) - throw tactic_exception(TACTIC_MAX_MEMORY_MSG); - return num_steps > m_max_steps; - } - - bool uncnstr(expr * arg) const { - return m_vars.contains(arg); - } - - bool uncnstr(unsigned num, expr * const * args) const { - for (unsigned i = 0; i < num; i++) - if (!uncnstr(args[i])) - return false; - return true; - } - - /** - \brief Create a fresh variable for abstracting (f args[0] ... args[num-1]) - Return true if it a new variable was created, and false if the variable already existed for this - application. Store the variable in v - */ - bool mk_fresh_uncnstr_var_for(app * t, app * & v) { - if (m_cache.find(t, v)) { - return false; // variable already existed for this application - } - - v = m().mk_fresh_const(nullptr, m().get_sort(t)); - TRACE("elim_uncnstr_bug", tout << "eliminating:\n" << mk_ismt2_pp(t, m()) << "\n";); - TRACE("elim_uncnstr_bug_ll", tout << "eliminating:\n" << mk_bounded_pp(t, m()) << "\n";); - m_fresh_vars.push_back(v); - if (m_mc) m_mc->hide(v); - m_cache_domain.push_back(t); - m_cache.insert(t, v); - return true; - } - - bool mk_fresh_uncnstr_var_for(func_decl * f, unsigned num, expr * const * args, app * & v) { - return mk_fresh_uncnstr_var_for(m().mk_app(f, num, args), v); - } - - bool mk_fresh_uncnstr_var_for(func_decl * f, expr * arg1, expr * arg2, app * & v) { - return mk_fresh_uncnstr_var_for(m().mk_app(f, arg1, arg2), v); - } - - bool mk_fresh_uncnstr_var_for(func_decl * f, expr * arg, app * & v) { - return mk_fresh_uncnstr_var_for(m().mk_app(f, arg), v); - } - - void add_def(expr * v, expr * def) { - SASSERT(uncnstr(v)); - SASSERT(to_app(v)->get_num_args() == 0); - if (m_mc) - m_mc->add(to_app(v)->get_decl(), def); - } - - void add_defs(unsigned num, expr * const * args, expr * u, expr * identity) { - if (m_mc) { - add_def(args[0], u); - for (unsigned i = 1; i < num; i++) - add_def(args[i], identity); - } - } - - // return a term that is different from t. - bool mk_diff(expr * t, expr_ref & r) { - sort * s = m().get_sort(t); - if (m().is_bool(s)) { - r = m().mk_not(t); - return true; - } - family_id fid = s->get_family_id(); - if (fid == m_a_util.get_family_id()) { - r = m_a_util.mk_add(t, m_a_util.mk_numeral(rational(1), s)); - return true; - } - if (fid == m_bv_util.get_family_id()) { - r = m().mk_app(m_bv_util.get_family_id(), OP_BNOT, t); - return true; - } - if (fid == m_ar_util.get_family_id()) { - if (m().is_uninterp(get_array_range(s))) - return false; - unsigned arity = get_array_arity(s); - for (unsigned i = 0; i < arity; i++) - if (m().is_uninterp(get_array_domain(s, i))) - return false; - // building - // r = (store t i1 ... in d) - // where i1 ... in are arbitrary values - // and d is a term different from (select t i1 ... in) - ptr_buffer new_args; - new_args.push_back(t); - for (unsigned i = 0; i < arity; i++) - new_args.push_back(m().get_some_value(get_array_domain(s, i))); - expr_ref sel(m()); - sel = m().mk_app(fid, OP_SELECT, new_args.size(), new_args.c_ptr()); - expr_ref diff_sel(m()); - if (!mk_diff(sel, diff_sel)) - return false; - new_args.push_back(diff_sel); - r = m().mk_app(fid, OP_STORE, new_args.size(), new_args.c_ptr()); - return true; - } - if (fid == m_dt_util.get_family_id()) { - // In the current implementation, I only handle the case where - // the datatype has a recursive constructor. - ptr_vector const & constructors = *m_dt_util.get_datatype_constructors(s); - for (func_decl * constructor : constructors) { - unsigned num = constructor->get_arity(); - unsigned target = UINT_MAX; - for (unsigned i = 0; i < num; i++) { - sort * s_arg = constructor->get_domain(i); - if (s == s_arg) { - target = i; - continue; - } - if (m().is_uninterp(s_arg)) - break; - } - if (target == UINT_MAX) - continue; - // use the constructor the distinct term constructor(...,t,...) - ptr_buffer new_args; - for (unsigned i = 0; i < num; i++) { - if (i == target) { - new_args.push_back(t); - } - else { - new_args.push_back(m().get_some_value(constructor->get_domain(i))); - } - } - r = m().mk_app(constructor, new_args.size(), new_args.c_ptr()); - return true; - } - // TODO: handle more cases. + struct rw_cfg : public default_rewriter_cfg { + bool m_produce_proofs; + obj_hashtable & m_vars; + ref m_mc; + arith_util m_a_util; + bv_util m_bv_util; + array_util m_ar_util; + datatype_util m_dt_util; + app_ref_vector m_fresh_vars; + obj_map m_cache; + app_ref_vector m_cache_domain; + unsigned long long m_max_memory; + unsigned m_max_steps; + + rw_cfg(ast_manager & m, bool produce_proofs, obj_hashtable & vars, mc * _m, + unsigned long long max_memory, unsigned max_steps): + m_produce_proofs(produce_proofs), + m_vars(vars), + m_mc(_m), + m_a_util(m), + m_bv_util(m), + m_ar_util(m), + m_dt_util(m), + m_fresh_vars(m), + m_cache_domain(m), + m_max_memory(max_memory), + m_max_steps(max_steps) { + } + + ast_manager & m() const { return m_a_util.get_manager(); } + + bool max_steps_exceeded(unsigned num_steps) const { + cooperate("elim-uncnstr-vars"); + if (memory::get_allocation_size() > m_max_memory) + throw tactic_exception(TACTIC_MAX_MEMORY_MSG); + return num_steps > m_max_steps; + } + + bool uncnstr(expr * arg) const { + return m_vars.contains(arg); + } + + bool uncnstr(unsigned num, expr * const * args) const { + for (unsigned i = 0; i < num; i++) + if (!uncnstr(args[i])) return false; + return true; + } + + /** + \brief Create a fresh variable for abstracting (f args[0] ... args[num-1]) + Return true if it a new variable was created, and false if the variable already existed for this + application. Store the variable in v + */ + bool mk_fresh_uncnstr_var_for(app * t, app * & v) { + if (m_cache.find(t, v)) { + return false; // variable already existed for this application + } + + v = m().mk_fresh_const(nullptr, m().get_sort(t)); + TRACE("elim_uncnstr_bug", tout << "eliminating:\n" << mk_ismt2_pp(t, m()) << "\n";); + TRACE("elim_uncnstr_bug_ll", tout << "eliminating:\n" << mk_bounded_pp(t, m()) << "\n";); + m_fresh_vars.push_back(v); + if (m_mc) m_mc->hide(v); + m_cache_domain.push_back(t); + m_cache.insert(t, v); + return true; + } + + bool mk_fresh_uncnstr_var_for(func_decl * f, unsigned num, expr * const * args, app * & v) { + return mk_fresh_uncnstr_var_for(m().mk_app(f, num, args), v); + } + + bool mk_fresh_uncnstr_var_for(func_decl * f, expr * arg1, expr * arg2, app * & v) { + return mk_fresh_uncnstr_var_for(m().mk_app(f, arg1, arg2), v); + } + + bool mk_fresh_uncnstr_var_for(func_decl * f, expr * arg, app * & v) { + return mk_fresh_uncnstr_var_for(m().mk_app(f, arg), v); + } + + void add_def(expr * v, expr * def) { + SASSERT(uncnstr(v)); + SASSERT(to_app(v)->get_num_args() == 0); + if (m_mc) + m_mc->add(to_app(v)->get_decl(), def); + } + + void add_defs(unsigned num, expr * const * args, expr * u, expr * identity) { + if (m_mc) { + add_def(args[0], u); + for (unsigned i = 1; i < num; i++) + add_def(args[i], identity); + } + } + + // return a term that is different from t. + bool mk_diff(expr * t, expr_ref & r) { + sort * s = m().get_sort(t); + if (m().is_bool(s)) { + r = m().mk_not(t); + return true; + } + family_id fid = s->get_family_id(); + if (fid == m_a_util.get_family_id()) { + r = m_a_util.mk_add(t, m_a_util.mk_numeral(rational(1), s)); + return true; + } + if (fid == m_bv_util.get_family_id()) { + r = m().mk_app(m_bv_util.get_family_id(), OP_BNOT, t); + return true; + } + if (fid == m_ar_util.get_family_id()) { + if (m().is_uninterp(get_array_range(s))) + return false; + unsigned arity = get_array_arity(s); + for (unsigned i = 0; i < arity; i++) + if (m().is_uninterp(get_array_domain(s, i))) + return false; + // building + // r = (store t i1 ... in d) + // where i1 ... in are arbitrary values + // and d is a term different from (select t i1 ... in) + ptr_buffer new_args; + new_args.push_back(t); + for (unsigned i = 0; i < arity; i++) + new_args.push_back(m().get_some_value(get_array_domain(s, i))); + expr_ref sel(m()); + sel = m().mk_app(fid, OP_SELECT, new_args.size(), new_args.c_ptr()); + expr_ref diff_sel(m()); + if (!mk_diff(sel, diff_sel)) + return false; + new_args.push_back(diff_sel); + r = m().mk_app(fid, OP_STORE, new_args.size(), new_args.c_ptr()); + return true; + } + if (fid == m_dt_util.get_family_id()) { + // In the current implementation, I only handle the case where + // the datatype has a recursive constructor. + ptr_vector const & constructors = *m_dt_util.get_datatype_constructors(s); + for (func_decl * constructor : constructors) { + unsigned num = constructor->get_arity(); + unsigned target = UINT_MAX; + for (unsigned i = 0; i < num; i++) { + sort * s_arg = constructor->get_domain(i); + if (s == s_arg) { + target = i; + continue; + } + if (m().is_uninterp(s_arg)) + break; + } + if (target == UINT_MAX) + continue; + // use the constructor the distinct term constructor(...,t,...) + ptr_buffer new_args; + for (unsigned i = 0; i < num; i++) { + if (i == target) { + new_args.push_back(t); + } + else { + new_args.push_back(m().get_some_value(constructor->get_domain(i))); + } + } + r = m().mk_app(constructor, new_args.size(), new_args.c_ptr()); + return true; } + // TODO: handle more cases. return false; } + return false; + } - app * process_eq(func_decl * f, expr * arg1, expr * arg2) { - expr * v; - expr * t; - if (uncnstr(arg1)) { - v = arg1; - t = arg2; - } - else if (uncnstr(arg2)) { - v = arg2; - t = arg1; - } - else { - return nullptr; - } - - sort * s = m().get_sort(arg1); - - // Remark: - // I currently do not support unconstrained vars that have - // uninterpreted sorts, for the following reasons: - // - Soundness - // (forall ((x S) (y S)) (= x y)) - // (not (= c1 c2)) - // - // The constants c1 and c2 have only one occurrence in - // the formula above, but they are not really unconstrained. - // The quantifier forces S to have interpretations of size 1. - // If we replace (= c1 c2) with fresh k. The formula will - // become satisfiable. - // - // - Even if the formula is quantifier free, I would still - // have to build an interpretation for the eliminated - // variables. - // - if (!m().is_fully_interp(s)) - return nullptr; - - // If the interpreted sort has only one element, - // then it is unsound to eliminate the unconstrained variable in the equality - sort_size sz = s->get_num_elements(); - - if (sz.is_finite() && sz.size() <= 1) - return nullptr; - - if (!m_mc) { - // easy case, model generation is disabled. - app * u; - mk_fresh_uncnstr_var_for(f, arg1, arg2, u); - return u; - } - - expr_ref d(m()); - if (mk_diff(t, d)) { - app * u; - if (!mk_fresh_uncnstr_var_for(f, arg1, arg2, u)) - return u; - add_def(v, m().mk_ite(u, t, d)); - return u; - } + app * process_eq(func_decl * f, expr * arg1, expr * arg2) { + expr * v; + expr * t; + if (uncnstr(arg1)) { + v = arg1; + t = arg2; + } + else if (uncnstr(arg2)) { + v = arg2; + t = arg1; + } + else { return nullptr; } - app * process_basic_app(func_decl * f, unsigned num, expr * const * args) { - SASSERT(f->get_family_id() == m().get_basic_family_id()); - switch (f->get_decl_kind()) { - case OP_ITE: - SASSERT(num == 3); - if (uncnstr(args[1]) && uncnstr(args[2])) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - add_def(args[1], r); - add_def(args[2], r); - return r; - } - if (uncnstr(args[0]) && uncnstr(args[1])) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - add_def(args[0], m().mk_true()); - add_def(args[1], r); - return r; - } - if (uncnstr(args[0]) && uncnstr(args[2])) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - add_def(args[0], m().mk_false()); - add_def(args[2], r); - return r; - } - return nullptr; - case OP_NOT: - SASSERT(num == 1); - if (uncnstr(args[0])) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - if (m_mc) - add_def(args[0], m().mk_not(r)); - return r; - } - return nullptr; - case OP_AND: - if (num > 0 && uncnstr(num, args)) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - if (m_mc) - add_defs(num, args, r, m().mk_true()); - return r; - } - return nullptr; - case OP_OR: - if (num > 0 && uncnstr(num, args)) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - if (m_mc) - add_defs(num, args, r, m().mk_false()); - return r; - } - return nullptr; - case OP_EQ: - SASSERT(num == 2); - return process_eq(f, args[0], args[1]); - default: - return nullptr; - } + sort * s = m().get_sort(arg1); + + // Remark: + // I currently do not support unconstrained vars that have + // uninterpreted sorts, for the following reasons: + // - Soundness + // (forall ((x S) (y S)) (= x y)) + // (not (= c1 c2)) + // + // The constants c1 and c2 have only one occurrence in + // the formula above, but they are not really unconstrained. + // The quantifier forces S to have interpretations of size 1. + // If we replace (= c1 c2) with fresh k. The formula will + // become satisfiable. + // + // - Even if the formula is quantifier free, I would still + // have to build an interpretation for the eliminated + // variables. + // + if (!m().is_fully_interp(s)) + return nullptr; + + // If the interpreted sort has only one element, + // then it is unsound to eliminate the unconstrained variable in the equality + sort_size sz = s->get_num_elements(); + + if (sz.is_finite() && sz.size() <= 1) + return nullptr; + + if (!m_mc) { + // easy case, model generation is disabled. + app * u; + mk_fresh_uncnstr_var_for(f, arg1, arg2, u); + return u; } - - app * process_le_ge(func_decl * f, expr * arg1, expr * arg2, bool le) { - expr * v; - expr * t; - if (uncnstr(arg1)) { - v = arg1; - t = arg2; - } - else if (uncnstr(arg2)) { - v = arg2; - t = arg1; - le = !le; - } - else { - return nullptr; - } + + expr_ref d(m()); + if (mk_diff(t, d)) { app * u; if (!mk_fresh_uncnstr_var_for(f, arg1, arg2, u)) return u; - if (!m_mc) - return u; - // v = ite(u, t, t + 1) if le - // v = ite(u, t, t - 1) if !le - add_def(v, m().mk_ite(u, t, m_a_util.mk_add(t, m_a_util.mk_numeral(rational(le ? 1 : -1), m().get_sort(arg1))))); + add_def(v, m().mk_ite(u, t, d)); return u; } + return nullptr; + } + + app * process_basic_app(func_decl * f, unsigned num, expr * const * args) { + SASSERT(f->get_family_id() == m().get_basic_family_id()); + switch (f->get_decl_kind()) { + case OP_ITE: + SASSERT(num == 3); + if (uncnstr(args[1]) && uncnstr(args[2])) { + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + add_def(args[1], r); + add_def(args[2], r); + return r; + } + if (uncnstr(args[0]) && uncnstr(args[1])) { + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + add_def(args[0], m().mk_true()); + add_def(args[1], r); + return r; + } + if (uncnstr(args[0]) && uncnstr(args[2])) { + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + add_def(args[0], m().mk_false()); + add_def(args[2], r); + return r; + } + return nullptr; + case OP_NOT: + SASSERT(num == 1); + if (uncnstr(args[0])) { + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + if (m_mc) + add_def(args[0], m().mk_not(r)); + return r; + } + return nullptr; + case OP_AND: + if (num > 0 && uncnstr(num, args)) { + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + if (m_mc) + add_defs(num, args, r, m().mk_true()); + return r; + } + return nullptr; + case OP_OR: + if (num > 0 && uncnstr(num, args)) { + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + if (m_mc) + add_defs(num, args, r, m().mk_false()); + return r; + } + return nullptr; + case OP_EQ: + SASSERT(num == 2); + return process_eq(f, args[0], args[1]); + default: + return nullptr; + } + } - app * process_add(family_id fid, decl_kind add_k, decl_kind sub_k, unsigned num, expr * const * args) { - if (num == 0) - return nullptr; - unsigned i; - expr * v = nullptr; - for (i = 0; i < num; i++) { - expr * arg = args[i]; - if (uncnstr(arg)) { - v = arg; - break; - } - } - if (v == nullptr) - return nullptr; - app * u; - if (!mk_fresh_uncnstr_var_for(m().mk_app(fid, add_k, num, args), u)) - return u; - if (!m_mc) - return u; - ptr_buffer new_args; - for (unsigned j = 0; j < num; j++) { - if (j == i) - continue; - new_args.push_back(args[j]); - } - if (new_args.empty()) { - add_def(v, u); - } - else { - expr * rest; - if (new_args.size() == 1) - rest = new_args[0]; - else - rest = m().mk_app(fid, add_k, new_args.size(), new_args.c_ptr()); - add_def(v, m().mk_app(fid, sub_k, u, rest)); - } + app * process_le_ge(func_decl * f, expr * arg1, expr * arg2, bool le) { + expr * v; + expr * t; + if (uncnstr(arg1)) { + v = arg1; + t = arg2; + } + else if (uncnstr(arg2)) { + v = arg2; + t = arg1; + le = !le; + } + else { + return nullptr; + } + app * u; + if (!mk_fresh_uncnstr_var_for(f, arg1, arg2, u)) return u; - } - - app * process_arith_mul(func_decl * f, unsigned num, expr * const * args) { - if (num == 0) - return nullptr; - sort * s = m().get_sort(args[0]); - if (uncnstr(num, args)) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - if (m_mc) - add_defs(num, args, r, m_a_util.mk_numeral(rational(1), s)); - return r; - } - // c * v case for reals - bool is_int; - rational val; - if (num == 2 && uncnstr(args[1]) && m_a_util.is_numeral(args[0], val, is_int) && !is_int) { - if (val.is_zero()) - return nullptr; - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - if (m_mc) { - val = rational(1) / val; - add_def(args[1], m_a_util.mk_mul(m_a_util.mk_numeral(val, false), r)); - } - return r; - } + if (!m_mc) + return u; + // v = ite(u, t, t + 1) if le + // v = ite(u, t, t - 1) if !le + add_def(v, m().mk_ite(u, t, m_a_util.mk_add(t, m_a_util.mk_numeral(rational(le ? 1 : -1), m().get_sort(arg1))))); + return u; + } + + app * process_add(family_id fid, decl_kind add_k, decl_kind sub_k, unsigned num, expr * const * args) { + if (num == 0) return nullptr; - } - - app * process_arith_app(func_decl * f, unsigned num, expr * const * args) { - - SASSERT(f->get_family_id() == m_a_util.get_family_id()); - switch (f->get_decl_kind()) { - case OP_ADD: - return process_add(f->get_family_id(), OP_ADD, OP_SUB, num, args); - case OP_MUL: - return process_arith_mul(f, num, args); - case OP_LE: - SASSERT(num == 2); - return process_le_ge(f, args[0], args[1], true); - case OP_GE: - SASSERT(num == 2); - return process_le_ge(f, args[0], args[1], false); - default: - return nullptr; + unsigned i; + expr * v = nullptr; + for (i = 0; i < num; i++) { + expr * arg = args[i]; + if (uncnstr(arg)) { + v = arg; + break; } } - - app * process_bv_mul(func_decl * f, unsigned num, expr * const * args) { - if (num == 0) - return nullptr; - if (uncnstr(num, args)) { - sort * s = m().get_sort(args[0]); - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - if (m_mc) - add_defs(num, args, r, m_bv_util.mk_numeral(rational(1), s)); - return r; - } - // c * v (c is even) case - unsigned bv_size; - rational val; - rational inv; - if (num == 2 && - uncnstr(args[1]) && - m_bv_util.is_numeral(args[0], val, bv_size) && - m_bv_util.mult_inverse(val, bv_size, inv)) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - sort * s = m().get_sort(args[1]); - if (m_mc) - add_def(args[1], m_bv_util.mk_bv_mul(m_bv_util.mk_numeral(inv, s), r)); - return r; - } + if (v == nullptr) return nullptr; + app * u; + if (!mk_fresh_uncnstr_var_for(m().mk_app(fid, add_k, num, args), u)) + return u; + if (!m_mc) + return u; + ptr_buffer new_args; + for (unsigned j = 0; j < num; j++) { + if (j == i) + continue; + new_args.push_back(args[j]); } - - app * process_extract(func_decl * f, expr * arg) { - if (!uncnstr(arg)) - return nullptr; + if (new_args.empty()) { + add_def(v, u); + } + else { + expr * rest; + if (new_args.size() == 1) + rest = new_args[0]; + else + rest = m().mk_app(fid, add_k, new_args.size(), new_args.c_ptr()); + add_def(v, m().mk_app(fid, sub_k, u, rest)); + } + return u; + } + + app * process_arith_mul(func_decl * f, unsigned num, expr * const * args) { + if (num == 0) + return nullptr; + sort * s = m().get_sort(args[0]); + if (uncnstr(num, args)) { app * r; - if (!mk_fresh_uncnstr_var_for(f, arg, r)) + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) return r; - if (!m_mc) - return r; - unsigned high = m_bv_util.get_extract_high(f); - unsigned low = m_bv_util.get_extract_low(f); - unsigned bv_size = m_bv_util.get_bv_size(m().get_sort(arg)); - if (bv_size == high - low + 1) { - add_def(arg, r); - } - else { - ptr_buffer args; - if (high < bv_size - 1) - args.push_back(m_bv_util.mk_numeral(rational(0), bv_size - high - 1)); - args.push_back(r); - if (low > 0) - args.push_back(m_bv_util.mk_numeral(rational(0), low)); - add_def(arg, m_bv_util.mk_concat(args.size(), args.c_ptr())); - } + if (m_mc) + add_defs(num, args, r, m_a_util.mk_numeral(rational(1), s)); return r; } - - app * process_bv_div(func_decl * f, expr * arg1, expr * arg2) { - if (uncnstr(arg1) && uncnstr(arg2)) { - sort * s = m().get_sort(arg1); - app * r; - if (!mk_fresh_uncnstr_var_for(f, arg1, arg2, r)) - return r; - if (!m_mc) - return r; - add_def(arg1, r); - add_def(arg2, m_bv_util.mk_numeral(rational(1), s)); - return r; - } - return nullptr; - } - - app * process_concat(func_decl * f, unsigned num, expr * const * args) { - if (num == 0) - return nullptr; - if (!uncnstr(num, args)) + // c * v case for reals + bool is_int; + rational val; + if (num == 2 && uncnstr(args[1]) && m_a_util.is_numeral(args[0], val, is_int) && !is_int) { + if (val.is_zero()) return nullptr; app * r; if (!mk_fresh_uncnstr_var_for(f, num, args, r)) return r; if (m_mc) { - unsigned i = num; - unsigned low = 0; - while (i > 0) { - --i; - expr * arg = args[i]; - unsigned sz = m_bv_util.get_bv_size(arg); - add_def(arg, m_bv_util.mk_extract(low + sz - 1, low, r)); - low += sz; - } + val = rational(1) / val; + add_def(args[1], m_a_util.mk_mul(m_a_util.mk_numeral(val, false), r)); } return r; } + return nullptr; + } + + app * process_arith_app(func_decl * f, unsigned num, expr * const * args) { - app * process_bv_le(func_decl * f, expr * arg1, expr * arg2, bool is_signed) { - if (m_produce_proofs) { - // The result of bv_le is not just introducing a new fresh name, - // we need a side condition. - // TODO: the correct proof step - return nullptr; - } - if (uncnstr(arg1)) { - // v <= t - expr * v = arg1; - expr * t = arg2; - // v <= t ---> (u or t == MAX) u is fresh - // add definition v = ite(u or t == MAX, t, t+1) - unsigned bv_sz = m_bv_util.get_bv_size(arg1); - rational MAX; - if (is_signed) - MAX = rational::power_of_two(bv_sz - 1) - rational(1); - else - MAX = rational::power_of_two(bv_sz) - rational(1); - app * u; - bool is_new = mk_fresh_uncnstr_var_for(f, arg1, arg2, u); - app * r = m().mk_or(u, m().mk_eq(t, m_bv_util.mk_numeral(MAX, bv_sz))); - if (m_mc && is_new) - add_def(v, m().mk_ite(r, t, m_bv_util.mk_bv_add(t, m_bv_util.mk_numeral(rational(1), bv_sz)))); - return r; - } - if (uncnstr(arg2)) { - // v >= t - expr * v = arg2; - expr * t = arg1; - // v >= t ---> (u ot t == MIN) u is fresh - // add definition v = ite(u or t == MIN, t, t-1) - unsigned bv_sz = m_bv_util.get_bv_size(arg1); - rational MIN; - if (is_signed) - MIN = -rational::power_of_two(bv_sz - 1); - else - MIN = rational(0); - app * u; - bool is_new = mk_fresh_uncnstr_var_for(f, arg1, arg2, u); - app * r = m().mk_or(u, m().mk_eq(t, m_bv_util.mk_numeral(MIN, bv_sz))); - if (m_mc && is_new) - add_def(v, m().mk_ite(r, t, m_bv_util.mk_bv_sub(t, m_bv_util.mk_numeral(rational(1), bv_sz)))); - return r; - } + SASSERT(f->get_family_id() == m_a_util.get_family_id()); + switch (f->get_decl_kind()) { + case OP_ADD: + return process_add(f->get_family_id(), OP_ADD, OP_SUB, num, args); + case OP_MUL: + return process_arith_mul(f, num, args); + case OP_LE: + SASSERT(num == 2); + return process_le_ge(f, args[0], args[1], true); + case OP_GE: + SASSERT(num == 2); + return process_le_ge(f, args[0], args[1], false); + default: return nullptr; } - - app * process_bv_app(func_decl * f, unsigned num, expr * const * args) { - SASSERT(f->get_family_id() == m_bv_util.get_family_id()); - switch (f->get_decl_kind()) { - case OP_BADD: - return process_add(f->get_family_id(), OP_BADD, OP_BSUB, num, args); - case OP_BMUL: - return process_bv_mul(f, num, args); - case OP_BSDIV: - case OP_BUDIV: - case OP_BSDIV_I: - case OP_BUDIV_I: - SASSERT(num == 2); - return process_bv_div(f, args[0], args[1]); - case OP_SLEQ: - SASSERT(num == 2); - return process_bv_le(f, args[0], args[1], true); - case OP_ULEQ: - SASSERT(num == 2); - return process_bv_le(f, args[0], args[1], false); - case OP_CONCAT: - return process_concat(f, num, args); - case OP_EXTRACT: - SASSERT(num == 1); - return process_extract(f, args[0]); - case OP_BNOT: - SASSERT(num == 1); - if (uncnstr(args[0])) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - if (m_mc) - add_def(args[0], m().mk_app(f, r)); - return r; - } - return nullptr; - case OP_BOR: - if (num > 0 && uncnstr(num, args)) { - sort * s = m().get_sort(args[0]); - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - if (m_mc) - add_defs(num, args, r, m_bv_util.mk_numeral(rational(0), s)); - return r; - } - return nullptr; - default: - return nullptr; + } + + app * process_bv_mul(func_decl * f, unsigned num, expr * const * args) { + if (num == 0) + return nullptr; + if (uncnstr(num, args)) { + sort * s = m().get_sort(args[0]); + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + if (m_mc) + add_defs(num, args, r, m_bv_util.mk_numeral(rational(1), s)); + return r; + } + // c * v (c is even) case + unsigned bv_size; + rational val; + rational inv; + if (num == 2 && + uncnstr(args[1]) && + m_bv_util.is_numeral(args[0], val, bv_size) && + m_bv_util.mult_inverse(val, bv_size, inv)) { + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + sort * s = m().get_sort(args[1]); + if (m_mc) + add_def(args[1], m_bv_util.mk_bv_mul(m_bv_util.mk_numeral(inv, s), r)); + return r; + } + return nullptr; + } + + app * process_extract(func_decl * f, expr * arg) { + if (!uncnstr(arg)) + return nullptr; + app * r; + if (!mk_fresh_uncnstr_var_for(f, arg, r)) + return r; + if (!m_mc) + return r; + unsigned high = m_bv_util.get_extract_high(f); + unsigned low = m_bv_util.get_extract_low(f); + unsigned bv_size = m_bv_util.get_bv_size(m().get_sort(arg)); + if (bv_size == high - low + 1) { + add_def(arg, r); + } + else { + ptr_buffer args; + if (high < bv_size - 1) + args.push_back(m_bv_util.mk_numeral(rational(0), bv_size - high - 1)); + args.push_back(r); + if (low > 0) + args.push_back(m_bv_util.mk_numeral(rational(0), low)); + add_def(arg, m_bv_util.mk_concat(args.size(), args.c_ptr())); + } + return r; + } + + app * process_bv_div(func_decl * f, expr * arg1, expr * arg2) { + if (uncnstr(arg1) && uncnstr(arg2)) { + sort * s = m().get_sort(arg1); + app * r; + if (!mk_fresh_uncnstr_var_for(f, arg1, arg2, r)) + return r; + if (!m_mc) + return r; + add_def(arg1, r); + add_def(arg2, m_bv_util.mk_numeral(rational(1), s)); + return r; + } + return nullptr; + } + + app * process_concat(func_decl * f, unsigned num, expr * const * args) { + if (num == 0) + return nullptr; + if (!uncnstr(num, args)) + return nullptr; + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + if (m_mc) { + unsigned i = num; + unsigned low = 0; + while (i > 0) { + --i; + expr * arg = args[i]; + unsigned sz = m_bv_util.get_bv_size(arg); + add_def(arg, m_bv_util.mk_extract(low + sz - 1, low, r)); + low += sz; } } - - app * process_array_app(func_decl * f, unsigned num, expr * const * args) { - SASSERT(f->get_family_id() == m_ar_util.get_family_id()); - switch (f->get_decl_kind()) { - case OP_SELECT: - if (uncnstr(args[0])) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - sort * s = m().get_sort(args[0]); - if (m_mc) - add_def(args[0], m_ar_util.mk_const_array(s, r)); - return r; - } - return nullptr; - case OP_STORE: - if (uncnstr(args[0]) && uncnstr(args[num-1])) { - app * r; - if (!mk_fresh_uncnstr_var_for(f, num, args, r)) - return r; - if (m_mc) { - add_def(args[num-1], m().mk_app(m_ar_util.get_family_id(), OP_SELECT, num-1, args)); - add_def(args[0], r); - } - return r; - } - default: - return nullptr; - } - } - - app * process_datatype_app(func_decl * f, unsigned num, expr * const * args) { - if (m_dt_util.is_recognizer(f)) { - SASSERT(num == 1); - if (uncnstr(args[0])) { - if (!m_mc) { - app * r; - mk_fresh_uncnstr_var_for(f, num, args, r); - return r; - } - // TODO: handle model generation - } - } - else if (m_dt_util.is_accessor(f)) { - SASSERT(num == 1); - if (uncnstr(args[0])) { - if (!m_mc) { - app * r; - mk_fresh_uncnstr_var_for(f, num, args, r); - return r; - } - func_decl * c = m_dt_util.get_accessor_constructor(f); - for (unsigned i = 0; i < c->get_arity(); i++) - if (!m().is_fully_interp(c->get_domain(i))) - return nullptr; - app * u; - if (!mk_fresh_uncnstr_var_for(f, num, args, u)) - return u; - ptr_vector const & accs = *m_dt_util.get_constructor_accessors(c); - ptr_buffer new_args; - for (unsigned i = 0; i < accs.size(); i++) { - if (accs[i] == f) - new_args.push_back(u); - else - new_args.push_back(m().get_some_value(c->get_domain(i))); - } - add_def(args[0], m().mk_app(c, new_args.size(), new_args.c_ptr())); - return u; - } - } - else if (m_dt_util.is_constructor(f)) { - if (uncnstr(num, args)) { - app * u; - if (!mk_fresh_uncnstr_var_for(f, num, args, u)) - return u; - if (!m_mc) - return u; - ptr_vector const & accs = *m_dt_util.get_constructor_accessors(f); - for (unsigned i = 0; i < num; i++) { - add_def(args[i], m().mk_app(accs[i], u)); - } - return u; - } - } + return r; + } + + app * process_bv_le(func_decl * f, expr * arg1, expr * arg2, bool is_signed) { + if (m_produce_proofs) { + // The result of bv_le is not just introducing a new fresh name, + // we need a side condition. + // TODO: the correct proof step return nullptr; } - - br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) { - if (num == 0) - return BR_FAILED; - family_id fid = f->get_family_id(); - if (fid == null_family_id) - return BR_FAILED; - - for (unsigned i = 0; i < num; i++) { - if (!is_ground(args[i])) - return BR_FAILED; // non-ground terms are not handled. - } - - app * u = nullptr; - - if (fid == m().get_basic_family_id()) - u = process_basic_app(f, num, args); - else if (fid == m_a_util.get_family_id()) - u = process_arith_app(f, num, args); - else if (fid == m_bv_util.get_family_id()) - u = process_bv_app(f, num, args); - else if (fid == m_ar_util.get_family_id()) - u = process_array_app(f, num, args); - else if (fid == m_dt_util.get_family_id()) - u = process_datatype_app(f, num, args); - - if (u == nullptr) - return BR_FAILED; - - result = u; - if (m_produce_proofs) { - expr * s = m().mk_app(f, num, args); - expr * eq = m().mk_eq(s, u); - proof * pr1 = m().mk_def_intro(eq); - result_pr = m().mk_apply_def(s, u, pr1); - } - - return BR_DONE; - } - }; - - class rw : public rewriter_tpl { - rw_cfg m_cfg; - public: - rw(ast_manager & m, bool produce_proofs, obj_hashtable & vars, mc * _m, - unsigned long long max_memory, unsigned max_steps): - rewriter_tpl(m, produce_proofs, m_cfg), - m_cfg(m, produce_proofs, vars, _m, max_memory, max_steps) { - } - }; - - ast_manager & m_manager; - ref m_mc; - obj_hashtable m_vars; - scoped_ptr m_rw; - unsigned m_num_elim_apps; - unsigned long long m_max_memory; - unsigned m_max_steps; - - imp(ast_manager & m, params_ref const & p): - m_manager(m), - m_num_elim_apps(0) { - updt_params(p); - } - - void updt_params(params_ref const & p) { - m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX)); - m_max_steps = p.get_uint("max_steps", UINT_MAX); - } - - ast_manager & m() { return m_manager; } - - void init_mc(bool produce_models) { - m_mc = nullptr; - if (produce_models) { - m_mc = alloc(mc, m(), "elim_uncstr"); - } - } - - void init_rw(bool produce_proofs) { - m_rw = alloc(rw, m(), produce_proofs, m_vars, m_mc.get(), m_max_memory, m_max_steps); - } - - void operator()(goal_ref const & g, goal_ref_buffer & result) { - bool produce_proofs = g->proofs_enabled(); - - TRACE("elim_uncnstr_bug", g->display(tout);); - tactic_report report("elim-uncnstr-vars", *g); - m_vars.reset(); - collect_occs p; - p(*g, m_vars); - if (m_vars.empty()) { - result.push_back(g.get()); - // did not increase depth since it didn't do anything. - return; - } - bool modified = true; - TRACE("elim_uncnstr", tout << "unconstrained variables...\n"; - for (expr * v : m_vars) tout << mk_ismt2_pp(v, m()) << " "; - tout << "\n";); - init_mc(g->models_enabled()); - init_rw(produce_proofs); - - expr_ref new_f(m()); - proof_ref new_pr(m()); - unsigned round = 0; - unsigned size = g->size(); - unsigned idx = 0; - while (true) { - for (; idx < size; idx++) { - expr * f = g->form(idx); - m_rw->operator()(f, new_f, new_pr); - if (f == new_f) - continue; - modified = true; - if (produce_proofs) { - proof * pr = g->pr(idx); - new_pr = m().mk_modus_ponens(pr, new_pr); - } - g->update(idx, new_f, new_pr, g->dep(idx)); - } - if (!modified) { - if (round == 0) { - } - else { - m_num_elim_apps = m_rw->cfg().m_fresh_vars.size(); - g->add(m_mc.get()); - } - TRACE("elim_uncnstr", if (m_mc) m_mc->display(tout); else tout << "no mc\n";); - m_mc = nullptr; - m_rw = nullptr; - result.push_back(g.get()); - g->inc_depth(); - return; - } - modified = false; - round ++; - size = g->size(); - m_rw->reset(); // reset cache - m_vars.reset(); - { - collect_occs p; - p(*g, m_vars); - } - if (m_vars.empty()) - idx = size; // force to finish + if (uncnstr(arg1)) { + // v <= t + expr * v = arg1; + expr * t = arg2; + // v <= t ---> (u or t == MAX) u is fresh + // add definition v = ite(u or t == MAX, t, t+1) + unsigned bv_sz = m_bv_util.get_bv_size(arg1); + rational MAX; + if (is_signed) + MAX = rational::power_of_two(bv_sz - 1) - rational(1); else - idx = 0; + MAX = rational::power_of_two(bv_sz) - rational(1); + app * u; + bool is_new = mk_fresh_uncnstr_var_for(f, arg1, arg2, u); + app * r = m().mk_or(u, m().mk_eq(t, m_bv_util.mk_numeral(MAX, bv_sz))); + if (m_mc && is_new) + add_def(v, m().mk_ite(r, t, m_bv_util.mk_bv_add(t, m_bv_util.mk_numeral(rational(1), bv_sz)))); + return r; + } + if (uncnstr(arg2)) { + // v >= t + expr * v = arg2; + expr * t = arg1; + // v >= t ---> (u ot t == MIN) u is fresh + // add definition v = ite(u or t == MIN, t, t-1) + unsigned bv_sz = m_bv_util.get_bv_size(arg1); + rational MIN; + if (is_signed) + MIN = -rational::power_of_two(bv_sz - 1); + else + MIN = rational(0); + app * u; + bool is_new = mk_fresh_uncnstr_var_for(f, arg1, arg2, u); + app * r = m().mk_or(u, m().mk_eq(t, m_bv_util.mk_numeral(MIN, bv_sz))); + if (m_mc && is_new) + add_def(v, m().mk_ite(r, t, m_bv_util.mk_bv_sub(t, m_bv_util.mk_numeral(rational(1), bv_sz)))); + return r; + } + return nullptr; + } + + app * process_bv_app(func_decl * f, unsigned num, expr * const * args) { + SASSERT(f->get_family_id() == m_bv_util.get_family_id()); + switch (f->get_decl_kind()) { + case OP_BADD: + return process_add(f->get_family_id(), OP_BADD, OP_BSUB, num, args); + case OP_BMUL: + return process_bv_mul(f, num, args); + case OP_BSDIV: + case OP_BUDIV: + case OP_BSDIV_I: + case OP_BUDIV_I: + SASSERT(num == 2); + return process_bv_div(f, args[0], args[1]); + case OP_SLEQ: + SASSERT(num == 2); + return process_bv_le(f, args[0], args[1], true); + case OP_ULEQ: + SASSERT(num == 2); + return process_bv_le(f, args[0], args[1], false); + case OP_CONCAT: + return process_concat(f, num, args); + case OP_EXTRACT: + SASSERT(num == 1); + return process_extract(f, args[0]); + case OP_BNOT: + SASSERT(num == 1); + if (uncnstr(args[0])) { + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + if (m_mc) + add_def(args[0], m().mk_app(f, r)); + return r; + } + return nullptr; + case OP_BOR: + if (num > 0 && uncnstr(num, args)) { + sort * s = m().get_sort(args[0]); + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + if (m_mc) + add_defs(num, args, r, m_bv_util.mk_numeral(rational(0), s)); + return r; + } + return nullptr; + default: + return nullptr; } } + + app * process_array_app(func_decl * f, unsigned num, expr * const * args) { + SASSERT(f->get_family_id() == m_ar_util.get_family_id()); + switch (f->get_decl_kind()) { + case OP_SELECT: + if (uncnstr(args[0])) { + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + sort * s = m().get_sort(args[0]); + if (m_mc) + add_def(args[0], m_ar_util.mk_const_array(s, r)); + return r; + } + return nullptr; + case OP_STORE: + if (uncnstr(args[0]) && uncnstr(args[num-1])) { + app * r; + if (!mk_fresh_uncnstr_var_for(f, num, args, r)) + return r; + if (m_mc) { + add_def(args[num-1], m().mk_app(m_ar_util.get_family_id(), OP_SELECT, num-1, args)); + add_def(args[0], r); + } + return r; + } + default: + return nullptr; + } + } + + app * process_datatype_app(func_decl * f, unsigned num, expr * const * args) { + if (m_dt_util.is_recognizer(f)) { + SASSERT(num == 1); + if (uncnstr(args[0])) { + if (!m_mc) { + app * r; + mk_fresh_uncnstr_var_for(f, num, args, r); + return r; + } + // TODO: handle model generation + } + } + else if (m_dt_util.is_accessor(f)) { + SASSERT(num == 1); + if (uncnstr(args[0])) { + if (!m_mc) { + app * r; + mk_fresh_uncnstr_var_for(f, num, args, r); + return r; + } + func_decl * c = m_dt_util.get_accessor_constructor(f); + for (unsigned i = 0; i < c->get_arity(); i++) + if (!m().is_fully_interp(c->get_domain(i))) + return nullptr; + app * u; + if (!mk_fresh_uncnstr_var_for(f, num, args, u)) + return u; + ptr_vector const & accs = *m_dt_util.get_constructor_accessors(c); + ptr_buffer new_args; + for (unsigned i = 0; i < accs.size(); i++) { + if (accs[i] == f) + new_args.push_back(u); + else + new_args.push_back(m().get_some_value(c->get_domain(i))); + } + add_def(args[0], m().mk_app(c, new_args.size(), new_args.c_ptr())); + return u; + } + } + else if (m_dt_util.is_constructor(f)) { + if (uncnstr(num, args)) { + app * u; + if (!mk_fresh_uncnstr_var_for(f, num, args, u)) + return u; + if (!m_mc) + return u; + ptr_vector const & accs = *m_dt_util.get_constructor_accessors(f); + for (unsigned i = 0; i < num; i++) { + add_def(args[i], m().mk_app(accs[i], u)); + } + return u; + } + } + return nullptr; + } + + br_status reduce_app(func_decl * f, unsigned num, expr * const * args, expr_ref & result, proof_ref & result_pr) { + if (num == 0) + return BR_FAILED; + family_id fid = f->get_family_id(); + if (fid == null_family_id) + return BR_FAILED; + for (unsigned i = 0; i < num; i++) { + if (!is_ground(args[i])) + return BR_FAILED; // non-ground terms are not handled. + } + + app * u = nullptr; + + if (fid == m().get_basic_family_id()) + u = process_basic_app(f, num, args); + else if (fid == m_a_util.get_family_id()) + u = process_arith_app(f, num, args); + else if (fid == m_bv_util.get_family_id()) + u = process_bv_app(f, num, args); + else if (fid == m_ar_util.get_family_id()) + u = process_array_app(f, num, args); + else if (fid == m_dt_util.get_family_id()) + u = process_datatype_app(f, num, args); + + if (u == nullptr) + return BR_FAILED; + + result = u; + if (m_produce_proofs) { + expr * s = m().mk_app(f, num, args); + expr * eq = m().mk_eq(s, u); + proof * pr1 = m().mk_def_intro(eq); + result_pr = m().mk_apply_def(s, u, pr1); + } + + return BR_DONE; + } }; - imp * m_imp; + class rw : public rewriter_tpl { + rw_cfg m_cfg; + public: + rw(ast_manager & m, bool produce_proofs, obj_hashtable & vars, mc * _m, + unsigned long long max_memory, unsigned max_steps): + rewriter_tpl(m, produce_proofs, m_cfg), + m_cfg(m, produce_proofs, vars, _m, max_memory, max_steps) { + } + }; + + ast_manager & m_manager; + ref m_mc; + obj_hashtable m_vars; + scoped_ptr m_rw; + unsigned m_num_elim_apps = 0; + unsigned long long m_max_memory; + unsigned m_max_steps; + + ast_manager & m() { return m_manager; } + + void init_mc(bool produce_models) { + m_mc = nullptr; + if (produce_models) { + m_mc = alloc(mc, m(), "elim_uncstr"); + } + } + + void init_rw(bool produce_proofs) { + m_rw = alloc(rw, m(), produce_proofs, m_vars, m_mc.get(), m_max_memory, m_max_steps); + } + + void run(goal_ref const & g, goal_ref_buffer & result) { + bool produce_proofs = g->proofs_enabled(); + + TRACE("elim_uncnstr_bug", g->display(tout);); + tactic_report report("elim-uncnstr-vars", *g); + m_vars.reset(); + collect_occs p; + p(*g, m_vars); + if (m_vars.empty()) { + result.push_back(g.get()); + // did not increase depth since it didn't do anything. + return; + } + bool modified = true; + TRACE("elim_uncnstr", tout << "unconstrained variables...\n"; + for (expr * v : m_vars) tout << mk_ismt2_pp(v, m()) << " "; + tout << "\n";); + init_mc(g->models_enabled()); + init_rw(produce_proofs); + + expr_ref new_f(m()); + proof_ref new_pr(m()); + unsigned round = 0; + unsigned size = g->size(); + unsigned idx = 0; + while (true) { + for (; idx < size; idx++) { + expr * f = g->form(idx); + m_rw->operator()(f, new_f, new_pr); + if (f == new_f) + continue; + modified = true; + if (produce_proofs) { + proof * pr = g->pr(idx); + new_pr = m().mk_modus_ponens(pr, new_pr); + } + g->update(idx, new_f, new_pr, g->dep(idx)); + } + if (!modified) { + if (round == 0) { + } + else { + m_num_elim_apps = m_rw->cfg().m_fresh_vars.size(); + g->add(m_mc.get()); + } + TRACE("elim_uncnstr", if (m_mc) m_mc->display(tout); else tout << "no mc\n";); + m_mc = nullptr; + m_rw = nullptr; + result.push_back(g.get()); + g->inc_depth(); + return; + } + modified = false; + round ++; + size = g->size(); + m_rw->reset(); // reset cache + m_vars.reset(); + { + collect_occs p; + p(*g, m_vars); + } + if (m_vars.empty()) + idx = size; // force to finish + else + idx = 0; + } + } + params_ref m_params; public: elim_uncnstr_tactic(ast_manager & m, params_ref const & p): - m_params(p) { - m_imp = alloc(imp, m, p); + m_manager(m), m_params(p) { + updt_params(p); } tactic * translate(ast_manager & m) override { return alloc(elim_uncnstr_tactic, m, m_params); } - - ~elim_uncnstr_tactic() override { - dealloc(m_imp); - } void updt_params(params_ref const & p) override { m_params = p; - m_imp->updt_params(p); + m_max_memory = megabytes_to_bytes(p.get_uint("max_memory", UINT_MAX)); + m_max_steps = p.get_uint("max_steps", UINT_MAX); } void collect_param_descrs(param_descrs & r) override { @@ -912,32 +895,26 @@ public: void operator()(goal_ref const & g, goal_ref_buffer & result) override { - (*m_imp)(g, result); - report_tactic_progress(":num-elim-apps", get_num_elim_apps()); + run(g, result); + report_tactic_progress(":num-elim-apps", m_num_elim_apps); } void cleanup() override { - unsigned num_elim_apps = get_num_elim_apps(); - ast_manager & m = m_imp->m_manager; - imp * d = alloc(imp, m, m_params); - std::swap(d, m_imp); - dealloc(d); - m_imp->m_num_elim_apps = num_elim_apps; - } - - unsigned get_num_elim_apps() const { - return m_imp->m_num_elim_apps; + m_mc = nullptr; + m_rw = nullptr; + m_vars.reset(); } void collect_statistics(statistics & st) const override { - st.update("eliminated applications", get_num_elim_apps()); + st.update("eliminated applications", m_num_elim_apps); } void reset_statistics() override { - m_imp->m_num_elim_apps = 0; + m_num_elim_apps = 0; } }; +} tactic * mk_elim_uncnstr_tactic(ast_manager & m, params_ref const & p) { return clean(alloc(elim_uncnstr_tactic, m, p)); diff --git a/src/tactic/core/elim_uncnstr_tactic.h b/src/tactic/core/elim_uncnstr_tactic.h index 19f9021ac..5824a6974 100644 --- a/src/tactic/core/elim_uncnstr_tactic.h +++ b/src/tactic/core/elim_uncnstr_tactic.h @@ -16,8 +16,7 @@ Author: Notes: --*/ -#ifndef ELIM_UNCNSTR_TACTIC_H_ -#define ELIM_UNCNSTR_TACTIC_H_ +#pragma once #include "util/params.h" @@ -29,5 +28,3 @@ tactic * mk_elim_uncnstr_tactic(ast_manager & m, params_ref const & p = params_r /* ADD_TACTIC("elim-uncnstr", "eliminate application containing unconstrained variables.", "mk_elim_uncnstr_tactic(m, p)") */ -#endif - diff --git a/src/tactic/core/pb_preprocess_tactic.cpp b/src/tactic/core/pb_preprocess_tactic.cpp index 7f17c8dae..50d606197 100644 --- a/src/tactic/core/pb_preprocess_tactic.cpp +++ b/src/tactic/core/pb_preprocess_tactic.cpp @@ -273,8 +273,8 @@ private: } /** - \brief decompose large sums into smaller sums by intoducing - auxilary variables. + \brief decompose large sums into smaller sums by introducing + auxiliary variables. */ void decompose(goal_ref const& g) { expr_ref fml1(m), fml2(m); diff --git a/src/tactic/core/propagate_values_tactic.cpp b/src/tactic/core/propagate_values_tactic.cpp index 41e48d864..14c715f03 100644 --- a/src/tactic/core/propagate_values_tactic.cpp +++ b/src/tactic/core/propagate_values_tactic.cpp @@ -25,224 +25,206 @@ Revision History: #include "tactic/goal_shared_occs.h" #include "ast/pb_decl_plugin.h" +namespace { class propagate_values_tactic : public tactic { - struct imp { - ast_manager & m; - th_rewriter m_r; - scoped_ptr m_subst; - goal * m_goal; - goal_shared_occs m_occs; - unsigned m_idx; - unsigned m_max_rounds; - bool m_modified; - - imp(ast_manager & m, params_ref const & p): - m(m), - m_r(m, p), - m_goal(nullptr), - m_occs(m, true /* track atoms */) { - updt_params_core(p); - } + ast_manager & m; + th_rewriter m_r; + scoped_ptr m_subst; + goal * m_goal; + goal_shared_occs m_occs; + unsigned m_idx; + unsigned m_max_rounds; + bool m_modified; + params_ref m_params; - ~imp() { } + void updt_params_core(params_ref const & p) { + m_max_rounds = p.get_uint("max_rounds", 4); + } - void updt_params_core(params_ref const & p) { - m_max_rounds = p.get_uint("max_rounds", 4); - } - - void updt_params(params_ref const & p) { - m_r.updt_params(p); - updt_params_core(p); - } - - - bool is_shared(expr * t) { - return m_occs.is_shared(t); - } - - bool is_shared_neg(expr * t, expr * & atom) { - if (!m.is_not(t, atom)) - return false; - return is_shared(atom); - } + bool is_shared(expr * t) { + return m_occs.is_shared(t); + } - bool is_shared_eq(expr * t, expr * & lhs, expr * & value) { - expr* arg1, *arg2; - if (!m.is_eq(t, arg1, arg2)) - return false; - if (m.is_value(arg1) && is_shared(arg2)) { - lhs = arg2; - value = arg1; - return true; - } - if (m.is_value(arg2) && is_shared(arg1)) { - lhs = arg1; - value = arg2; - return true; - } + bool is_shared_neg(expr * t, expr * & atom) { + if (!m.is_not(t, atom)) return false; + return is_shared(atom); + } + + bool is_shared_eq(expr * t, expr * & lhs, expr * & value) { + expr* arg1, *arg2; + if (!m.is_eq(t, arg1, arg2)) + return false; + if (m.is_value(arg1) && is_shared(arg2)) { + lhs = arg2; + value = arg1; + return true; + } + if (m.is_value(arg2) && is_shared(arg1)) { + lhs = arg1; + value = arg2; + return true; + } + return false; + } + + void push_result(expr * new_curr, proof * new_pr) { + if (m_goal->proofs_enabled()) { + proof * pr = m_goal->pr(m_idx); + new_pr = m.mk_modus_ponens(pr, new_pr); } - void push_result(expr * new_curr, proof * new_pr) { - if (m_goal->proofs_enabled()) { - proof * pr = m_goal->pr(m_idx); - new_pr = m.mk_modus_ponens(pr, new_pr); + expr_dependency_ref new_d(m); + if (m_goal->unsat_core_enabled()) { + new_d = m_goal->dep(m_idx); + expr_dependency * used_d = m_r.get_used_dependencies(); + if (used_d != nullptr) { + new_d = m.mk_join(new_d, used_d); + m_r.reset_used_dependencies(); } - - expr_dependency_ref new_d(m); - if (m_goal->unsat_core_enabled()) { - new_d = m_goal->dep(m_idx); - expr_dependency * used_d = m_r.get_used_dependencies(); - if (used_d != nullptr) { - new_d = m.mk_join(new_d, used_d); - m_r.reset_used_dependencies(); + } + + m_goal->update(m_idx, new_curr, new_pr, new_d); + + if (is_shared(new_curr)) { + m_subst->insert(new_curr, m.mk_true(), m.mk_iff_true(new_pr), new_d); + } + expr * atom; + if (is_shared_neg(new_curr, atom)) { + m_subst->insert(atom, m.mk_false(), m.mk_iff_false(new_pr), new_d); + } + expr * lhs, * value; + if (is_shared_eq(new_curr, lhs, value)) { + TRACE("shallow_context_simplifier_bug", tout << "found eq:\n" << mk_ismt2_pp(new_curr, m) << "\n";); + m_subst->insert(lhs, value, new_pr, new_d); + } + } + + void process_current() { + expr * curr = m_goal->form(m_idx); + expr_ref new_curr(m); + proof_ref new_pr(m); + + if (!m_subst->empty()) { + m_r(curr, new_curr, new_pr); + } + else { + new_curr = curr; + if (m.proofs_enabled()) + new_pr = m.mk_reflexivity(curr); + } + + TRACE("shallow_context_simplifier_bug", tout << mk_ismt2_pp(curr, m) << "\n---->\n" << mk_ismt2_pp(new_curr, m) << "\n";); + if (new_curr != curr) { + m_modified = true; + //if (has_pb(curr)) + // IF_VERBOSE(0, verbose_stream() << mk_ismt2_pp(curr, m) << "\n---->\n" << mk_ismt2_pp(new_curr, m) << "\n"); + } + push_result(new_curr, new_pr); + } + + bool has_pb(expr* e) { + pb_util pb(m); + if (pb.is_ge(e)) return true; + if (m.is_or(e)) { + for (expr* a : *to_app(e)) { + if (pb.is_ge(a)) return true; + } + } + return false; + } + + void run(goal_ref const & g, goal_ref_buffer & result) { + SASSERT(g->is_well_sorted()); + tactic_report report("propagate-values", *g); + m_goal = g.get(); + + bool forward = true; + expr_ref new_curr(m); + proof_ref new_pr(m); + unsigned size = m_goal->size(); + m_idx = 0; + m_modified = false; + unsigned round = 0; + + + if (m_goal->inconsistent()) + goto end; + + if (m_max_rounds == 0) + goto end; + + m_subst = alloc(expr_substitution, m, g->unsat_core_enabled(), g->proofs_enabled()); + m_r.set_substitution(m_subst.get()); + m_occs(*m_goal); + + while (true) { + TRACE("propagate_values", tout << "while(true) loop\n"; m_goal->display_with_dependencies(tout);); + if (forward) { + for (; m_idx < size; m_idx++) { + process_current(); + if (m_goal->inconsistent()) + goto end; } - } - - m_goal->update(m_idx, new_curr, new_pr, new_d); - - if (is_shared(new_curr)) { - m_subst->insert(new_curr, m.mk_true(), m.mk_iff_true(new_pr), new_d); - } - expr * atom; - if (is_shared_neg(new_curr, atom)) { - m_subst->insert(atom, m.mk_false(), m.mk_iff_false(new_pr), new_d); - } - expr * lhs, * value; - if (is_shared_eq(new_curr, lhs, value)) { - TRACE("shallow_context_simplifier_bug", tout << "found eq:\n" << mk_ismt2_pp(new_curr, m) << "\n";); - m_subst->insert(lhs, value, new_pr, new_d); - } - } - - void process_current() { - expr * curr = m_goal->form(m_idx); - expr_ref new_curr(m); - proof_ref new_pr(m); - - if (!m_subst->empty()) { - m_r(curr, new_curr, new_pr); + if (m_subst->empty() && !m_modified) + goto end; + m_occs(*m_goal); + m_idx = m_goal->size(); + forward = false; + m_subst->reset(); + m_r.set_substitution(m_subst.get()); // reset, but keep substitution } else { - new_curr = curr; - if (m.proofs_enabled()) - new_pr = m.mk_reflexivity(curr); - } - - TRACE("shallow_context_simplifier_bug", tout << mk_ismt2_pp(curr, m) << "\n---->\n" << mk_ismt2_pp(new_curr, m) << "\n";); - if (new_curr != curr) { - m_modified = true; - //if (has_pb(curr)) - // IF_VERBOSE(0, verbose_stream() << mk_ismt2_pp(curr, m) << "\n---->\n" << mk_ismt2_pp(new_curr, m) << "\n"); - } - push_result(new_curr, new_pr); - } - - bool has_pb(expr* e) { - pb_util pb(m); - if (pb.is_ge(e)) return true; - if (m.is_or(e)) { - for (expr* a : *to_app(e)) { - if (pb.is_ge(a)) return true; - } - } - return false; - } - - void operator()(goal_ref const & g, - goal_ref_buffer & result) { - SASSERT(g->is_well_sorted()); - tactic_report report("propagate-values", *g); - m_goal = g.get(); - - bool forward = true; - expr_ref new_curr(m); - proof_ref new_pr(m); - unsigned size = m_goal->size(); - m_idx = 0; - m_modified = false; - unsigned round = 0; - - - if (m_goal->inconsistent()) - goto end; - - if (m_max_rounds == 0) - goto end; - - m_subst = alloc(expr_substitution, m, g->unsat_core_enabled(), g->proofs_enabled()); - m_r.set_substitution(m_subst.get()); - m_occs(*m_goal); - - while (true) { - TRACE("propagate_values", tout << "while(true) loop\n"; m_goal->display_with_dependencies(tout);); - if (forward) { - for (; m_idx < size; m_idx++) { - process_current(); - if (m_goal->inconsistent()) - goto end; - } - if (m_subst->empty() && !m_modified) + while (m_idx > 0) { + m_idx--; + process_current(); + if (m_goal->inconsistent()) goto end; - m_occs(*m_goal); - m_idx = m_goal->size(); - forward = false; - m_subst->reset(); - m_r.set_substitution(m_subst.get()); // reset, but keep substitution } - else { - while (m_idx > 0) { - m_idx--; - process_current(); - if (m_goal->inconsistent()) - goto end; - } - if (!m_modified) - goto end; - m_subst->reset(); - m_r.set_substitution(m_subst.get()); // reset, but keep substitution - m_modified = false; - m_occs(*m_goal); - m_idx = 0; - size = m_goal->size(); - forward = true; - } - round++; - if (round >= m_max_rounds) - break; - IF_VERBOSE(100, verbose_stream() << "starting new round, goal size: " << m_goal->num_exprs() << std::endl;); - TRACE("propagate_values", tout << "round finished\n"; m_goal->display(tout); tout << "\n";); + if (!m_modified) + goto end; + m_subst->reset(); + m_r.set_substitution(m_subst.get()); // reset, but keep substitution + m_modified = false; + m_occs(*m_goal); + m_idx = 0; + size = m_goal->size(); + forward = true; } - end: - m_goal->elim_redundancies(); - m_goal->inc_depth(); - result.push_back(m_goal); - SASSERT(m_goal->is_well_sorted()); - TRACE("propagate_values", tout << "end\n"; m_goal->display(tout);); - TRACE("propagate_values_core", m_goal->display_with_dependencies(tout);); - m_goal = nullptr; + round++; + if (round >= m_max_rounds) + break; + IF_VERBOSE(100, verbose_stream() << "starting new round, goal size: " << m_goal->num_exprs() << std::endl;); + TRACE("propagate_values", tout << "round finished\n"; m_goal->display(tout); tout << "\n";); } - }; + end: + m_goal->elim_redundancies(); + m_goal->inc_depth(); + result.push_back(m_goal); + SASSERT(m_goal->is_well_sorted()); + TRACE("propagate_values", tout << "end\n"; m_goal->display(tout);); + TRACE("propagate_values_core", m_goal->display_with_dependencies(tout);); + m_goal = nullptr; + } - imp * m_imp; - params_ref m_params; public: propagate_values_tactic(ast_manager & m, params_ref const & p): + m(m), + m_r(m, p), + m_goal(nullptr), + m_occs(m, true /* track atoms */), m_params(p) { - m_imp = alloc(imp, m, p); + updt_params_core(p); } tactic * translate(ast_manager & m) override { return alloc(propagate_values_tactic, m, m_params); } - - ~propagate_values_tactic() override { - dealloc(m_imp); - } void updt_params(params_ref const & p) override { m_params = p; - m_imp->updt_params(p); + m_r.updt_params(p); + updt_params_core(p); } void collect_param_descrs(param_descrs & r) override { @@ -252,7 +234,7 @@ public: void operator()(goal_ref const & in, goal_ref_buffer & result) override { try { - (*m_imp)(in, result); + run(in, result); } catch (rewriter_exception & ex) { throw tactic_exception(ex.msg()); @@ -260,15 +242,14 @@ public: } void cleanup() override { - ast_manager & m = m_imp->m; - params_ref p = std::move(m_params); - m_imp->~imp(); - new (m_imp) imp(m, p); + m_r.cleanup(); + m_subst = nullptr; + m_occs.cleanup(); } }; +} tactic * mk_propagate_values_tactic(ast_manager & m, params_ref const & p) { return alloc(propagate_values_tactic, m, p); } - diff --git a/src/tactic/core/propagate_values_tactic.h b/src/tactic/core/propagate_values_tactic.h index 635b0a36f..d9324ff82 100644 --- a/src/tactic/core/propagate_values_tactic.h +++ b/src/tactic/core/propagate_values_tactic.h @@ -17,8 +17,7 @@ Author: Revision History: --*/ -#ifndef PROPAGATE_VALUES_TACTIC_H_ -#define PROPAGATE_VALUES_TACTIC_H_ +#pragma once #include "util/params.h" class ast_manager; @@ -29,5 +28,3 @@ tactic * mk_propagate_values_tactic(ast_manager & m, params_ref const & p = para /* ADD_TACTIC("propagate-values", "propagate constants.", "mk_propagate_values_tactic(m, p)") */ - -#endif diff --git a/src/tactic/core/symmetry_reduce_tactic.cpp b/src/tactic/core/symmetry_reduce_tactic.cpp index d288adbc7..784686a5e 100644 --- a/src/tactic/core/symmetry_reduce_tactic.cpp +++ b/src/tactic/core/symmetry_reduce_tactic.cpp @@ -40,7 +40,7 @@ public: void operator()(goal_ref const & g, goal_ref_buffer & result) override; - virtual void cleanup() override; + void cleanup() override; }; class ac_rewriter { diff --git a/src/tactic/dependency_converter.cpp b/src/tactic/dependency_converter.cpp index 34c864526..dcd50717b 100644 --- a/src/tactic/dependency_converter.cpp +++ b/src/tactic/dependency_converter.cpp @@ -27,15 +27,15 @@ public: unit_dependency_converter(expr_dependency_ref& d) : m_dep(d) {} - virtual expr_dependency_ref operator()() { return m_dep; } + expr_dependency_ref operator()() override { return m_dep; } - virtual dependency_converter * translate(ast_translation & translator) { + dependency_converter * translate(ast_translation & translator) override { expr_dependency_translation tr(translator); expr_dependency_ref d(tr(m_dep), translator.to()); return alloc(unit_dependency_converter, d); } - virtual void display(std::ostream& out) { + void display(std::ostream& out) override { out << m_dep.get() << "\n"; } }; @@ -47,18 +47,18 @@ public: concat_dependency_converter(dependency_converter* c1, dependency_converter* c2) : m_dc1(c1), m_dc2(c2) {} - virtual expr_dependency_ref operator()() { + expr_dependency_ref operator()() override { expr_dependency_ref d1 = (*m_dc1)(); expr_dependency_ref d2 = (*m_dc2)(); ast_manager& m = d1.get_manager(); return expr_dependency_ref(m.mk_join(d1, d2), m); } - virtual dependency_converter * translate(ast_translation & translator) { + dependency_converter * translate(ast_translation & translator) override { return alloc(concat_dependency_converter, m_dc1->translate(translator), m_dc2->translate(translator)); } - virtual void display(std::ostream& out) { + void display(std::ostream& out) override { m_dc1->display(out); m_dc2->display(out); } @@ -73,7 +73,7 @@ public: for (unsigned i = 0; i < n; ++i) m_goals.push_back(goals[i]); } - virtual expr_dependency_ref operator()() { + expr_dependency_ref operator()() override { expr_dependency_ref result(m.mk_empty_dependencies(), m); for (goal_ref g : m_goals) { dependency_converter_ref dc = g->dc(); @@ -81,13 +81,13 @@ public: } return result; } - virtual dependency_converter * translate(ast_translation & translator) { + dependency_converter * translate(ast_translation & translator) override { goal_ref_buffer goals; for (goal_ref g : m_goals) goals.push_back(g->translate(translator)); return alloc(goal_dependency_converter, goals.size(), goals.c_ptr()); } - virtual void display(std::ostream& out) { out << "goal-dep\n"; } + void display(std::ostream& out) override { out << "goal-dep\n"; } }; diff --git a/src/tactic/fd_solver/enum2bv_solver.cpp b/src/tactic/fd_solver/enum2bv_solver.cpp index a864d9631..185f23d13 100644 --- a/src/tactic/fd_solver/enum2bv_solver.cpp +++ b/src/tactic/fd_solver/enum2bv_solver.cpp @@ -148,7 +148,7 @@ public: // translate enumeration constants to bit-vectors. for (expr* v : vars) { - func_decl* f = 0; + func_decl* f = nullptr; if (is_app(v) && is_uninterp_const(v) && m_rewriter.enum2bv().find(to_app(v)->get_decl(), f)) { bvars.push_back(m.mk_const(f)); } diff --git a/src/tactic/fd_solver/fd_solver.cpp b/src/tactic/fd_solver/fd_solver.cpp index 2af30b089..8e32b74d0 100644 --- a/src/tactic/fd_solver/fd_solver.cpp +++ b/src/tactic/fd_solver/fd_solver.cpp @@ -35,11 +35,18 @@ solver * mk_fd_solver(ast_manager & m, params_ref const & p, bool incremental_mo return s; } -tactic * mk_fd_tactic(ast_manager & m, params_ref const& p) { +static tactic * mk_seq_fd_tactic(ast_manager & m, params_ref const& p) { return mk_solver2tactic(mk_fd_solver(m, p, false)); } tactic * mk_parallel_qffd_tactic(ast_manager& m, params_ref const& p) { - solver* s = mk_fd_solver(m, p); - return mk_parallel_tactic(s, p); + return mk_parallel_tactic(mk_fd_solver(m, p), p); } + + +tactic * mk_fd_tactic(ast_manager & m, params_ref const& _p) { + parallel_params pp(_p); + params_ref p = _p; + return pp.enable() ? mk_parallel_qffd_tactic(m, p) : mk_seq_fd_tactic(m, p); +} + diff --git a/src/tactic/fpa/qffp_tactic.cpp b/src/tactic/fpa/qffp_tactic.cpp index 1c48fef38..97f05c17b 100644 --- a/src/tactic/fpa/qffp_tactic.cpp +++ b/src/tactic/fpa/qffp_tactic.cpp @@ -17,15 +17,16 @@ Notes: --*/ #include "tactic/tactical.h" -#include "tactic/core/simplify_tactic.h" -#include "tactic/bv/bit_blaster_tactic.h" -#include "sat/tactic/sat_tactic.h" #include "tactic/fpa/fpa2bv_tactic.h" -#include "smt/tactic/smt_tactic.h" +#include "tactic/core/simplify_tactic.h" #include "tactic/core/propagate_values_tactic.h" -#include "ackermannization/ackermannize_bv_tactic.h" #include "tactic/arith/probe_arith.h" +#include "tactic/bv/bit_blaster_tactic.h" #include "tactic/smtlogics/qfnra_tactic.h" +#include "sat/tactic/sat_tactic.h" +#include "sat/sat_solver/inc_sat_solver.h" +#include "smt/tactic/smt_tactic.h" +#include "ackermannization/ackermannize_bv_tactic.h" #include "tactic/fpa/qffp_tactic.h" @@ -94,11 +95,11 @@ tactic * mk_qffp_tactic(ast_manager & m, params_ref const & p) { using_params(mk_simplify_tactic(m, p), simp_p), cond(mk_is_propositional_probe(), cond(mk_produce_proofs_probe(), - mk_smt_tactic(p), // `sat' does not support proofs. - mk_sat_tactic(m, p)), + mk_smt_tactic(m, p), // `sat' does not support proofs. + mk_psat_tactic(m, p)), cond(mk_is_fp_qfnra_probe(), mk_qfnra_tactic(m, p), - mk_smt_tactic(p)))); + mk_smt_tactic(m, p)))); st->updt_params(p); return st; diff --git a/src/tactic/generic_model_converter.h b/src/tactic/generic_model_converter.h index c67dd5eff..750a22cd4 100644 --- a/src/tactic/generic_model_converter.h +++ b/src/tactic/generic_model_converter.h @@ -41,11 +41,11 @@ class generic_model_converter : public model_converter { public: generic_model_converter(ast_manager & m, char const* orig) : m(m), m_orig(orig) {} - virtual ~generic_model_converter(); + ~generic_model_converter() override; void hide(expr* e) { SASSERT(is_app(e) && to_app(e)->get_num_args() == 0); hide(to_app(e)->get_decl()); } - void hide(func_decl * f) { m_entries.push_back(entry(f, 0, m, HIDE)); } + void hide(func_decl * f) { m_entries.push_back(entry(f, nullptr, m, HIDE)); } void add(func_decl * d, expr* e); diff --git a/src/tactic/goal.h b/src/tactic/goal.h index 4125fab99..fa2f16eb6 100644 --- a/src/tactic/goal.h +++ b/src/tactic/goal.h @@ -195,7 +195,7 @@ bool test(goal const & g, Predicate & proc) { for (unsigned i = 0; i < sz; i++) quick_for_each_expr(proc, visited, g.form(i)); } - catch (typename Predicate::found) { + catch (const typename Predicate::found &) { return true; } return false; diff --git a/src/tactic/model_converter.h b/src/tactic/model_converter.h index 9c5b72830..73432219f 100644 --- a/src/tactic/model_converter.h +++ b/src/tactic/model_converter.h @@ -31,7 +31,7 @@ Notes: This property holds for both eval, that decides on a fixed value for constants that have no interpretation in m and for 'peval' - (partial eval) that retuns just the constants that are unfixed. + (partial eval) that returns just the constants that are unfixed. (in the model evaluator one can control this behavior using a configuration flag) @@ -48,7 +48,7 @@ Notes: mc(G) & F_s is SAT iff G & F is SAT For a model converter that is a sequence of definitions and removals - of functions we can obtain mc(G) by adding back or expanding definitinos + of functions we can obtain mc(G) by adding back or expanding definitions that are required to interpret G fully in the context of F_s. --*/ diff --git a/src/tactic/nlsat_smt/nl_purify_tactic.cpp b/src/tactic/nlsat_smt/nl_purify_tactic.cpp deleted file mode 100644 index 745b0352d..000000000 --- a/src/tactic/nlsat_smt/nl_purify_tactic.cpp +++ /dev/null @@ -1,799 +0,0 @@ -/*++ -Copyright (c) 2015 Microsoft Corporation - -Module Name: - - nl_purify_tactic.cpp - -Abstract: - - Tactic for purifying quantifier-free formulas that mix QF_NRA and other theories. - It is designed to allow cooprating between the nlsat solver and other theories - in a decoupled way. - - Let goal be formula F. - Let NL goal be formula G. - Assume F is in NNF. - Assume F does not contain mix of real/integers. - Assume F is quantifier-free (please, otherwise we need to reprocess from instantiated satisfiable formula) - - For each atomic nl formula f, - - introduce a propositional variable p - - replace f by p - - add clauses p => f to G - - For each interface term t, - - introduce interface variable v (or use t if it is already a variable) - - replace t by v - - Check satisfiability of G. - If satisfiable, then check assignment to p and interface equalities on F - If unsat: - Retrieve core and add core to G. - else: - For interface equalities from model of F that are not equal in G, add - For interface variables that are equal under one model, but not the other model, - create interface predicate p_vw => v = w, add to both F, G. - Add interface equations to assumptions, recheck F. - If unsat retrieve core add to G. - -Author: - - Nikolaj Bjorner (nbjorner) 2015-5-5. - -Revision History: - ---*/ -#include "tactic/tactical.h" -#include "tactic/nlsat_smt/nl_purify_tactic.h" -#include "smt/tactic/smt_tactic.h" -#include "ast/rewriter/rewriter.h" -#include "nlsat/tactic/nlsat_tactic.h" -#include "tactic/filter_model_converter.h" -#include "util/obj_pair_hashtable.h" -#include "ast/rewriter/rewriter_def.h" -#include "ast/ast_pp.h" -#include "util/trace.h" -#include "smt/smt_solver.h" -#include "solver/solver.h" -#include "model/model_smt2_pp.h" -#include "ast/rewriter/expr_safe_replace.h" -#include "ast/ast_util.h" -#include "solver/solver2tactic.h" - -class nl_purify_tactic : public tactic { - - enum polarity_t { - pol_pos, - pol_neg, - pol_dual - }; - - ast_manager & m; - arith_util m_util; - params_ref m_params; - bool m_produce_proofs; - ref m_fmc; - tactic_ref m_nl_tac; // nlsat tactic - goal_ref m_nl_g; // nlsat goal - ref m_solver; // SMT solver - expr_ref_vector m_eq_preds; // predicates for equality between pairs of interface variables - svector m_eq_values; // truth value of the equality predicates in nlsat - app_ref_vector m_new_reals; // interface real variables - app_ref_vector m_new_preds; // abstraction predicates for smt_solver (hide real constraints) - expr_ref_vector m_asms; // assumptions to pass to SMT solver - ptr_vector m_ctx_asms; // assumptions passed by context - obj_hashtable m_ctx_asms_set; // assumptions passed by context - obj_hashtable m_used_asms; - obj_map m_bool2dep; - obj_pair_map m_eq_pairs; // map pairs of interface variables to auxiliary predicates - obj_map m_interface_cache; // map of compound real expression to interface variable. - obj_map m_polarities; // polarities of sub-expressions - -public: - struct rw_cfg : public default_rewriter_cfg { - enum mode_t { - mode_interface_var, - mode_bool_preds - }; - ast_manager& m; - nl_purify_tactic & m_owner; - app_ref_vector& m_new_reals; - app_ref_vector& m_new_preds; - obj_map& m_polarities; - obj_map& m_interface_cache; - expr_ref_vector m_args; - proof_ref_vector m_proofs; - mode_t m_mode; - - rw_cfg(nl_purify_tactic & o): - m(o.m), - m_owner(o), - m_new_reals(o.m_new_reals), - m_new_preds(o.m_new_preds), - m_polarities(o.m_polarities), - m_interface_cache(o.m_interface_cache), - m_args(m), - m_proofs(m), - m_mode(mode_interface_var) { - } - - virtual ~rw_cfg() {} - - arith_util & u() { return m_owner.m_util; } - - expr * mk_interface_var(expr* arg, proof_ref& arg_pr) { - expr* r; - if (m_interface_cache.find(arg, r)) { - return r; - } - if (is_uninterp_const(arg)) { - m_interface_cache.insert(arg, arg); - return arg; - } - r = m.mk_fresh_const(nullptr, u().mk_real()); - m_new_reals.push_back(to_app(r)); - m_owner.m_fmc->insert(to_app(r)->get_decl()); - m_interface_cache.insert(arg, r); - expr_ref eq(m); - eq = m.mk_eq(r, arg); - if (is_real_expression(arg)) { - m_owner.m_nl_g->assert_expr(eq); // m.mk_oeq(r, arg) - } - else { - m_owner.m_solver->assert_expr(eq); - } - if (m_owner.m_produce_proofs) { - arg_pr = m.mk_oeq(arg, r); - } - return r; - } - - bool is_real_expression(expr* e) { - return is_app(e) && (to_app(e)->get_family_id() == u().get_family_id()); - } - - void mk_interface_bool(func_decl * f, unsigned num, expr* const* args, expr_ref& result, proof_ref& pr) { - expr_ref old_pred(m.mk_app(f, num, args), m); - polarity_t pol = m_polarities.find(old_pred); - result = m.mk_fresh_const(nullptr, m.mk_bool_sort()); - m_polarities.insert(result, pol); - m_new_preds.push_back(to_app(result)); - m_owner.m_fmc->insert(to_app(result)->get_decl()); - if (pol != pol_neg) { - m_owner.m_nl_g->assert_expr(m.mk_or(m.mk_not(result), old_pred)); - } - if (pol != pol_pos) { - m_owner.m_nl_g->assert_expr(m.mk_or(result, m.mk_not(old_pred))); - } - if (m_owner.m_produce_proofs) { - pr = m.mk_oeq(old_pred, result); - } - TRACE("nlsat_smt", tout << old_pred << " : " << result << "\n";); - } - - bool reduce_quantifier(quantifier * old_q, - expr * new_body, - expr * const * new_patterns, - expr * const * new_no_patterns, - expr_ref & result, - proof_ref & result_pr) { - throw tactic_exception("quantifiers are not supported in mixed-mode nlsat engine"); - } - - br_status reduce_app(func_decl * f, unsigned num, expr* const* args, expr_ref& result, proof_ref & pr) { - if (m_mode == mode_bool_preds) { - return reduce_app_bool(f, num, args, result, pr); - } - else { - return reduce_app_real(f, num, args, result, pr); - } - } - - br_status reduce_app_bool(func_decl * f, unsigned num, expr* const* args, expr_ref& result, proof_ref & pr) { - if (f->get_family_id() == m.get_basic_family_id()) { - if (f->get_decl_kind() == OP_EQ && u().is_real(args[0])) { - mk_interface_bool(f, num, args, result, pr); - return BR_DONE; - } - else { - return BR_FAILED; - } - } - if (f->get_family_id() == u().get_family_id()) { - switch (f->get_decl_kind()) { - case OP_LE: case OP_GE: case OP_LT: case OP_GT: - // these are the only real cases of non-linear atomic formulas besides equality. - mk_interface_bool(f, num, args, result, pr); - return BR_DONE; - default: - return BR_FAILED; - } - } - return BR_FAILED; - } - - // (+ (f x) y) - // (f (+ x y)) - // - bool is_arith_op(expr* e) { - return is_app(e) && to_app(e)->get_family_id() == u().get_family_id(); - } - - br_status reduce_app_real(func_decl * f, unsigned num, expr* const* args, expr_ref& result, proof_ref & pr) { - bool has_interface = false; - bool is_arith = false; - if (f->get_family_id() == u().get_family_id()) { - switch (f->get_decl_kind()) { - case OP_NUM: - case OP_IRRATIONAL_ALGEBRAIC_NUM: - return BR_FAILED; - default: - is_arith = true; - break; - } - } - m_args.reset(); - m_proofs.reset(); - for (unsigned i = 0; i < num; ++i) { - expr* arg = args[i]; - proof_ref arg_pr(m); - if (is_arith && !is_arith_op(arg)) { - has_interface = true; - m_args.push_back(mk_interface_var(arg, arg_pr)); - } - else if (!is_arith && u().is_real(arg)) { - has_interface = true; - m_args.push_back(mk_interface_var(arg, arg_pr)); - } - else { - m_args.push_back(arg); - } - if (arg_pr) { - m_proofs.push_back(arg_pr); - } - } - if (has_interface) { - result = m.mk_app(f, num, m_args.c_ptr()); - if (m_owner.m_produce_proofs) { - pr = m.mk_oeq_congruence(m.mk_app(f, num, args), to_app(result), m_proofs.size(), m_proofs.c_ptr()); - } - TRACE("nlsat_smt", tout << result << "\n";); - return BR_DONE; - } - else { - return BR_FAILED; - } - } - }; - -private: - - class rw : public rewriter_tpl { - rw_cfg m_cfg; - public: - rw(nl_purify_tactic & o): - rewriter_tpl(o.m, o.m_produce_proofs, m_cfg), - m_cfg(o) { - } - void set_bool_mode() { - m_cfg.m_mode = rw_cfg::mode_bool_preds; - } - void set_interface_var_mode() { - m_cfg.m_mode = rw_cfg::mode_interface_var; - } - }; - - - arith_util & u() { return m_util; } - - void check_point() { - if (m.canceled()) { - throw tactic_exception(Z3_CANCELED_MSG); - } - } - - void display_result(std::ostream& out, goal_ref_buffer const& result) { - for (unsigned i = 0; i < result.size(); ++i) { - result[i]->display_with_dependencies(out << "goal\n"); - } - } - - void update_eq_values(model_ref& mdl) { - expr_ref tmp(m); - for (unsigned i = 0; i < m_eq_preds.size(); ++i) { - expr* pred = m_eq_preds[i].get(); - m_eq_values[i] = l_undef; - if (mdl->eval(pred, tmp)) { - if (m.is_true(tmp)) { - m_eq_values[i] = l_true; - } - else if (m.is_false(tmp)) { - m_eq_values[i] = l_false; - } - } - } - } - - void solve( - goal_ref const& g, - goal_ref_buffer& result, - expr_dependency_ref& core, - model_converter_ref& mc) { - - while (true) { - check_point(); - TRACE("nlsat_smt", m_solver->display(tout << "SMT:\n"); m_nl_g->display(tout << "\nNL:\n"); ); - goal_ref tmp_nl = alloc(goal, m, true, false); - model_converter_ref nl_mc; - proof_converter_ref nl_pc; - expr_dependency_ref nl_core(m); - result.reset(); - tmp_nl->copy_from(*m_nl_g.get()); - (*m_nl_tac)(tmp_nl, result, nl_mc, nl_pc, nl_core); - - if (is_decided_unsat(result)) { - core2result(core, g, result); - TRACE("nlsat_smt", tout << "unsat\n";); - break; - } - if (!is_decided_sat(result)) { - TRACE("nlsat_smt", tout << "not a unit\n";); - break; - } - // extract evaluation on interface variables. - // assert booleans that evaluate to true. - // assert equalities between equal interface real variables. - - model_ref mdl_nl, mdl_smt; - if (nl_mc.get()) { - model_converter2model(m, nl_mc.get(), mdl_nl); - update_eq_values(mdl_nl); - enforce_equalities(mdl_nl, m_nl_g); - - setup_assumptions(mdl_nl); - - TRACE("nlsat_smt", - model_smt2_pp(tout << "nl model\n", m, *mdl_nl.get(), 0); - m_solver->display(tout << "smt goal:\n"); tout << "\n";); - } - result.reset(); - lbool r = m_solver->check_sat(m_asms.size(), m_asms.c_ptr()); - if (r == l_false) { - // extract the core from the result - ptr_vector ecore, asms; - expr_ref_vector clause(m); - expr_ref fml(m); - get_unsat_core(ecore, asms); - - // - // assumptions should also be used for the nlsat tactic, - // but since it does not support assumptions at this time - // we overapproximate the necessary core and accumulate - // all assumptions that are ever used. - // - for (unsigned i = 0; i < asms.size(); ++i) { - m_used_asms.insert(asms[i]); - } - if (ecore.empty()) { - core2result(core, g, result); - break; - } - for (unsigned i = 0; i < ecore.size(); ++i) { - clause.push_back(mk_not(m, ecore[i])); - } - fml = mk_or(m, clause.size(), clause.c_ptr()); - m_nl_g->assert_expr(fml); - continue; - } - else if (r == l_true) { - m_solver->get_model(mdl_smt); - if (enforce_equalities(mdl_smt, m_nl_g)) { - // SMT enforced a new equality that wasn't true for nlsat. - continue; - } - TRACE("nlsat_smt", - m_fmc->display(tout << "joint state is sat\n"); - nl_mc->display(tout << "nl\n");); - if (mdl_nl.get()) { - merge_models(*mdl_nl.get(), mdl_smt); - } - mc = m_fmc.get(); - apply(mc, mdl_smt, 0); - mc = model2model_converter(mdl_smt.get()); - result.push_back(alloc(goal, m)); - } - else { - TRACE("nlsat_smt", tout << "unknown\n";); - } - break; - } - TRACE("nlsat_smt", display_result(tout, result);); - } - - void get_unsat_core(ptr_vector& core, ptr_vector& asms) { - m_solver->get_unsat_core(core); - for (unsigned i = 0; i < core.size(); ++i) { - if (m_ctx_asms_set.contains(core[i])) { - asms.push_back(core[i]); - core[i] = core.back(); - core.pop_back(); - --i; - } - } - } - - void core2result(expr_dependency_ref & lcore, goal_ref const& g, goal_ref_buffer& result) { - result.reset(); - proof * pr = nullptr; - lcore = nullptr; - g->reset(); - obj_hashtable::iterator it = m_used_asms.begin(), end = m_used_asms.end(); - for (; it != end; ++it) { - lcore = m.mk_join(lcore, m.mk_leaf(m_bool2dep.find(*it))); - } - g->assert_expr(m.mk_false(), pr, lcore); - TRACE("nlsat_smt", g->display_with_dependencies(tout);); - result.push_back(g.get()); - } - - void setup_assumptions(model_ref& mdl) { - m_asms.reset(); - m_asms.append(m_ctx_asms.size(), m_ctx_asms.c_ptr()); - app_ref_vector const& fresh_preds = m_new_preds; - expr_ref tmp(m); - for (unsigned i = 0; i < fresh_preds.size(); ++i) { - expr* pred = fresh_preds[i]; - if (mdl->eval(pred, tmp)) { - polarity_t pol = m_polarities.find(pred); - // if assumptinon literals are used to satisfy NL state, - // we have to assume them when satisfying SMT state - if (pol != pol_neg && m.is_false(tmp)) { - m_asms.push_back(m.mk_not(pred)); - } - else if (pol != pol_pos && m.is_true(tmp)) { - m_asms.push_back(pred); - } - } - } - for (unsigned i = 0; i < m_eq_preds.size(); ++i) { - expr* pred = m_eq_preds[i].get(); - switch (m_eq_values[i]) { - case l_true: - m_asms.push_back(pred); - break; - case l_false: - m_asms.push_back(m.mk_not(pred)); - break; - default: - break; - } - } - TRACE("nlsat_smt", - tout << "assumptions:\n" << m_asms << "\n";); - } - - bool enforce_equalities(model_ref& mdl, goal_ref const& nl_g) { - TRACE("nlsat_smt", tout << "Enforce equalities " << m_interface_cache.size() << "\n";); - bool new_equality = false; - expr_ref_vector nums(m); - obj_map num2var; - obj_map::iterator it = m_interface_cache.begin(), end = m_interface_cache.end(); - for (; it != end; ++it) { - expr_ref r(m); - expr* v, *w, *pred; - w = it->m_value; - VERIFY(mdl->eval(w, r)); - TRACE("nlsat_smt", tout << mk_pp(w, m) << " |-> " << r << "\n";); - nums.push_back(r); - if (num2var.find(r, v)) { - if (!m_eq_pairs.find(v, w, pred)) { - pred = m.mk_fresh_const(nullptr, m.mk_bool_sort()); - m_eq_preds.push_back(pred); - m_eq_values.push_back(l_true); - m_fmc->insert(to_app(pred)->get_decl()); - nl_g->assert_expr(m.mk_or(m.mk_not(pred), m.mk_eq(w, v))); - nl_g->assert_expr(m.mk_or(pred, m.mk_not(m.mk_eq(w, v)))); - m_solver->assert_expr(m.mk_iff(pred, m.mk_eq(w, v))); - new_equality = true; - m_eq_pairs.insert(v, w, pred); - } - else { - // interface equality is already enforced. - } - } - else { - num2var.insert(r, w); - } - } - return new_equality; - } - - void merge_models(model const& mdl_nl, model_ref& mdl_smt) { - expr_safe_replace num2num(m); - expr_ref result(m), val2(m); - expr_ref_vector args(m); - unsigned sz = mdl_nl.get_num_constants(); - for (unsigned i = 0; i < sz; ++i) { - func_decl* v = mdl_nl.get_constant(i); - if (u().is_real(v->get_range())) { - expr* val = mdl_nl.get_const_interp(v); - if (mdl_smt->eval(v, val2)) { - if (val != val2) { - num2num.insert(val2, val); - } - } - } - } - sz = mdl_smt->get_num_functions(); - for (unsigned i = 0; i < sz; ++i) { - func_decl* f = mdl_smt->get_function(i); - if (has_real(f)) { - unsigned arity = f->get_arity(); - func_interp* f1 = mdl_smt->get_func_interp(f); - func_interp* f2 = alloc(func_interp, m, f->get_arity()); - for (unsigned j = 0; j < f1->num_entries(); ++j) { - args.reset(); - func_entry const* entry = f1->get_entry(j); - for (unsigned k = 0; k < arity; ++k) { - translate(num2num, entry->get_arg(k), result); - args.push_back(result); - } - translate(num2num, entry->get_result(), result); - f2->insert_entry(args.c_ptr(), result); - } - translate(num2num, f1->get_else(), result); - f2->set_else(result); - mdl_smt->register_decl(f, f2); - } - } - mdl_smt->copy_const_interps(mdl_nl); - } - - bool has_real(func_decl* f) { - for (unsigned i = 0; i < f->get_arity(); ++i) { - if (u().is_real(f->get_domain(i))) return true; - } - return u().is_real(f->get_range()); - } - - void translate(expr_safe_replace& num2num, expr* e, expr_ref& result) { - result = nullptr; - if (e) { - num2num(e, result); - } - } - - void get_polarities(goal const& g) { - ptr_vector forms; - svector pols; - unsigned sz = g.size(); - for (unsigned i = 0; i < sz; ++i) { - forms.push_back(g.form(i)); - pols.push_back(pol_pos); - } - polarity_t p, q; - while (!forms.empty()) { - expr* e = forms.back(); - p = pols.back(); - forms.pop_back(); - pols.pop_back(); - if (m_polarities.find(e, q)) { - if (p == q || q == pol_dual) continue; - p = pol_dual; - } - TRACE("nlsat_smt_verbose", tout << mk_pp(e, m) << "\n";); - m_polarities.insert(e, p); - if (is_quantifier(e) || is_var(e)) { - throw tactic_exception("nl-purify tactic does not support quantifiers"); - } - SASSERT(is_app(e)); - app* a = to_app(e); - func_decl* f = a->get_decl(); - if (f->get_family_id() == m.get_basic_family_id() && p != pol_dual) { - switch(f->get_decl_kind()) { - case OP_NOT: - p = neg(p); - break; - case OP_AND: - case OP_OR: - break; - default: - p = pol_dual; - break; - } - } - else { - p = pol_dual; - } - for (unsigned i = 0; i < a->get_num_args(); ++i) { - forms.push_back(a->get_arg(i)); - pols.push_back(p); - } - } - } - - polarity_t neg(polarity_t p) { - switch (p) { - case pol_pos: return pol_neg; - case pol_neg: return pol_pos; - case pol_dual: return pol_dual; - } - return pol_dual; - } - - polarity_t join(polarity_t p, polarity_t q) { - if (p == q) return p; - return pol_dual; - } - - void rewrite_goal(rw& r, goal_ref const& g) { - r.reset(); - expr_ref new_curr(m); - proof_ref new_pr(m); - unsigned sz = g->size(); - for (unsigned i = 0; i < sz; i++) { - expr * curr = g->form(i); - r(curr, new_curr, new_pr); - if (m_produce_proofs) { - proof * pr = g->pr(i); - new_pr = m.mk_modus_ponens(pr, new_pr); - } - g->update(i, new_curr, new_pr, g->dep(i)); - } - } - - void remove_pure_arith(goal_ref const& g) { - obj_map is_pure; - unsigned sz = g->size(); - for (unsigned i = 0; i < sz; i++) { - expr * curr = g->form(i); - if (is_pure_arithmetic(is_pure, curr)) { - m_nl_g->assert_expr(curr, g->pr(i), g->dep(i)); - g->update(i, m.mk_true(), g->pr(i), g->dep(i)); - } - } - } - - bool is_pure_arithmetic(obj_map& is_pure, expr* e0) { - ptr_vector todo; - todo.push_back(e0); - while (!todo.empty()) { - expr* e = todo.back(); - if (is_pure.contains(e)) { - todo.pop_back(); - continue; - } - if (!is_app(e)) { - todo.pop_back(); - is_pure.insert(e, false); - continue; - } - app* a = to_app(e); - bool pure = false, all_found = true, p; - pure |= (a->get_family_id() == u().get_family_id()) && u().is_real(a); - pure |= (m.is_eq(e) && u().is_real(a->get_arg(0))); - pure |= (a->get_family_id() == u().get_family_id()) && m.is_bool(a) && u().is_real(a->get_arg(0)); - pure |= (a->get_family_id() == m.get_basic_family_id()); - pure |= is_uninterp_const(a) && u().is_real(a); - for (unsigned i = 0; i < a->get_num_args(); ++i) { - if (!is_pure.find(a->get_arg(i), p)) { - todo.push_back(a->get_arg(i)); - all_found = false; - } - else { - pure &= p; - } - } - if (all_found) { - is_pure.insert(e, pure); - todo.pop_back(); - } - } - return is_pure.find(e0); - } - -public: - - nl_purify_tactic(ast_manager & m, params_ref const& p): - m(m), - m_util(m), - m_params(p), - m_fmc(nullptr), - m_nl_tac(mk_nlsat_tactic(m, p)), - m_nl_g(nullptr), - m_solver(mk_smt_solver(m, p, symbol::null)), - m_eq_preds(m), - m_new_reals(m), - m_new_preds(m), - m_asms(m) - {} - - ~nl_purify_tactic() override {} - - void updt_params(params_ref const & p) override { - m_params = p; - } - - tactic * translate(ast_manager& m) override { - return alloc(nl_purify_tactic, m, m_params); - } - - void collect_statistics(statistics & st) const override { - m_nl_tac->collect_statistics(st); - m_solver->collect_statistics(st); - } - - void reset_statistics() override { - m_nl_tac->reset_statistics(); - } - - - void cleanup() override { - m_solver = mk_smt_solver(m, m_params, symbol::null); - m_nl_tac->cleanup(); - m_eq_preds.reset(); - m_eq_values.reset(); - m_new_reals.reset(); - m_new_preds.reset(); - m_eq_pairs.reset(); - m_polarities.reset(); - m_ctx_asms.reset(); - m_ctx_asms_set.reset(); - m_used_asms.reset(); - m_bool2dep.reset(); - } - - void operator()(goal_ref const & g, - goal_ref_buffer & result, - model_converter_ref & mc, - proof_converter_ref & pc, - expr_dependency_ref & core) override { - - tactic_report report("qfufnl-purify", *g); - TRACE("nlsat_smt", g->display(tout);); - - m_produce_proofs = g->proofs_enabled(); - mc = nullptr; pc = nullptr; core = nullptr; - - fail_if_proof_generation("qfufnra-purify", g); - // fail_if_unsat_core_generation("qfufnra-purify", g); - rw r(*this); - expr_ref_vector clauses(m); - m_nl_g = alloc(goal, m, true, false); - m_fmc = alloc(filter_model_converter, m); - - // first hoist interface variables, - // then annotate subformulas by polarities, - // finally extract polynomial inequalities by - // creating a place-holder predicate inside the - // original goal and extracing pure nlsat clauses. - r.set_interface_var_mode(); - rewrite_goal(r, g); - if (!g->unsat_core_enabled()) { - remove_pure_arith(g); - } - get_polarities(*g.get()); - r.set_bool_mode(); - rewrite_goal(r, g); - - extract_clauses_and_dependencies(g, clauses, m_ctx_asms, m_bool2dep, m_fmc); - - TRACE("nlsat_smt", tout << clauses << "\n";); - - for (unsigned i = 0; i < m_ctx_asms.size(); ++i) { - m_ctx_asms_set.insert(m_ctx_asms[i]); - } - - for (unsigned i = 0; i < clauses.size(); ++i) { - m_solver->assert_expr(clauses[i].get()); - } - g->inc_depth(); - solve(g, result, core, mc); - } -}; - - -tactic * mk_nl_purify_tactic(ast_manager& m, params_ref const& p) { - return alloc(nl_purify_tactic, m, p); -} diff --git a/src/tactic/portfolio/default_tactic.cpp b/src/tactic/portfolio/default_tactic.cpp index 3e479524e..23334bf07 100644 --- a/src/tactic/portfolio/default_tactic.cpp +++ b/src/tactic/portfolio/default_tactic.cpp @@ -48,7 +48,7 @@ tactic * mk_default_tactic(ast_manager & m, params_ref const & p) { cond(mk_is_qffp_probe(), mk_qffp_tactic(m, p), cond(mk_is_qffplra_probe(), mk_qffplra_tactic(m, p), //cond(mk_is_qfufnra_probe(), mk_qfufnra_tactic(m, p), - mk_smt_tactic()))))))))))))), + mk_smt_tactic(m)))))))))))))), p); return st; } diff --git a/src/tactic/portfolio/smt_strategic_solver.cpp b/src/tactic/portfolio/smt_strategic_solver.cpp index 6718eb13f..fee3bed77 100644 --- a/src/tactic/portfolio/smt_strategic_solver.cpp +++ b/src/tactic/portfolio/smt_strategic_solver.cpp @@ -41,6 +41,9 @@ Notes: #include "sat/sat_solver/inc_sat_solver.h" #include "ast/rewriter/bv_rewriter.h" #include "solver/solver2tactic.h" +#include "solver/parallel_tactic.h" +#include "solver/parallel_params.hpp" + tactic * mk_tactic_for_logic(ast_manager & m, params_ref const & p, symbol const & logic) { @@ -99,7 +102,8 @@ tactic * mk_tactic_for_logic(ast_manager & m, params_ref const & p, symbol const } static solver* mk_special_solver_for_logic(ast_manager & m, params_ref const & p, symbol const& logic) { - if ((logic == "QF_FD" || logic == "SAT") && !m.proofs_enabled()) + parallel_params pp(p); + if ((logic == "QF_FD" || logic == "SAT") && !m.proofs_enabled() && !pp.enable()) return mk_fd_solver(m, p); return nullptr; } diff --git a/src/tactic/portfolio/solver2lookahead.cpp b/src/tactic/portfolio/solver2lookahead.cpp index 0c18ab079..63b28793d 100644 --- a/src/tactic/portfolio/solver2lookahead.cpp +++ b/src/tactic/portfolio/solver2lookahead.cpp @@ -20,5 +20,5 @@ Notes: #include "solver/solver.h" solver * mk_solver2lookahead(solver* s) { - return 0; + return nullptr; } diff --git a/src/tactic/probe.cpp b/src/tactic/probe.cpp index dcd1dc500..432c9d123 100644 --- a/src/tactic/probe.cpp +++ b/src/tactic/probe.cpp @@ -524,7 +524,7 @@ public: } return false; } - catch (found) { + catch (const found &) { return true; } } @@ -554,7 +554,7 @@ public: } return false; } - catch (found) { + catch (const found &) { return true; } } diff --git a/src/tactic/proof_converter.cpp b/src/tactic/proof_converter.cpp index f1a209487..faa9a36db 100644 --- a/src/tactic/proof_converter.cpp +++ b/src/tactic/proof_converter.cpp @@ -130,7 +130,7 @@ proof_ref apply(ast_manager & m, proof_converter_ref & pc1, proof_converter_ref_ for (unsigned i = 0; i < sz; i++) { proof_ref pr(m); SASSERT(pc2s[i]); // proof production is enabled - pr = pc2s[i]->operator()(m, 0, 0); + pr = pc2s[i]->operator()(m, 0, nullptr); prs.push_back(pr); } return (*pc1)(m, sz, prs.c_ptr()); diff --git a/src/tactic/sine_filter.cpp b/src/tactic/sine_filter.cpp index b1db12964..1612670a4 100644 --- a/src/tactic/sine_filter.cpp +++ b/src/tactic/sine_filter.cpp @@ -54,7 +54,7 @@ public: TRACE("sine", tout << new_forms.size();); g->reset(); for (unsigned i = 0; i < new_forms.size(); i++) { - g->assert_expr(new_forms.get(i), 0, 0); + g->assert_expr(new_forms.get(i), nullptr, nullptr); } g->inc_depth(); g->updt_prec(goal::OVER); diff --git a/src/tactic/sls/sls_engine.cpp b/src/tactic/sls/sls_engine.cpp index f5b5ec1b2..f55aa41aa 100644 --- a/src/tactic/sls/sls_engine.cpp +++ b/src/tactic/sls/sls_engine.cpp @@ -182,7 +182,7 @@ bool sls_engine::what_if( // Andreas: Had this idea on my last day. Maybe we could add a noise here similar to the one that worked so well for ucb assertion selection. // r += 0.0001 * m_tracker.get_random_uint(8); - // Andreas: For some reason it is important to use > here instead of >=. Probably related to prefering the LSB. + // Andreas: For some reason it is important to use > here instead of >=. Probably related to preferring the LSB. if (r > best_score) { best_score = r; best_const = fd_inx; @@ -440,7 +440,7 @@ lbool sls_engine::search() { // get candidate variables ptr_vector & to_evaluate = m_tracker.get_unsat_constants(m_assertions); - if (!to_evaluate.size()) + if (to_evaluate.empty()) { res = l_true; goto bailout; @@ -492,7 +492,7 @@ lbool sls_engine::search() { score = m_tracker.get_top_sum(); - // update assertion weights if a weigthing is enabled (sp < 1024) + // update assertion weights if a weighting is enabled (sp < 1024) if (m_paws) { for (unsigned i = 0; i < sz; i++) diff --git a/src/tactic/sls/sls_tracker.h b/src/tactic/sls/sls_tracker.h index b730e78da..e10c91729 100644 --- a/src/tactic/sls/sls_tracker.h +++ b/src/tactic/sls/sls_tracker.h @@ -1003,7 +1003,7 @@ public: } ptr_vector & get_unsat_constants_walksat(expr * e) { - if (!e || m_temp_constants.size()) + if (!e || !m_temp_constants.empty()) return m_temp_constants; ptr_vector const & this_decls = m_constants_occ.find(e); unsigned sz = this_decls.size(); diff --git a/src/tactic/smtlogics/nra_tactic.cpp b/src/tactic/smtlogics/nra_tactic.cpp index a9b32e5a8..8aefad0a0 100644 --- a/src/tactic/smtlogics/nra_tactic.cpp +++ b/src/tactic/smtlogics/nra_tactic.cpp @@ -44,7 +44,7 @@ tactic * mk_nra_tactic(ast_manager & m, params_ref const& p) { try_for(mk_qfnra_nlsat_tactic(m, p1), 10000), mk_qfnra_nlsat_tactic(m, p2)), or_else(mk_nlqsat_tactic(m, p), - mk_smt_tactic(p)) + mk_smt_tactic(m, p)) )); } diff --git a/src/tactic/smtlogics/qfaufbv_tactic.cpp b/src/tactic/smtlogics/qfaufbv_tactic.cpp index 601f872aa..b35bc1f20 100644 --- a/src/tactic/smtlogics/qfaufbv_tactic.cpp +++ b/src/tactic/smtlogics/qfaufbv_tactic.cpp @@ -57,7 +57,7 @@ tactic * mk_qfaufbv_tactic(ast_manager & m, params_ref const & p) { ); tactic * st = using_params(and_then(preamble_st, - using_params(mk_smt_tactic(), solver_p)), + using_params(mk_smt_tactic(m), solver_p)), main_p); st->updt_params(p); diff --git a/src/tactic/smtlogics/qfauflia_tactic.cpp b/src/tactic/smtlogics/qfauflia_tactic.cpp index 4a0e9eb34..206914a0f 100644 --- a/src/tactic/smtlogics/qfauflia_tactic.cpp +++ b/src/tactic/smtlogics/qfauflia_tactic.cpp @@ -45,7 +45,7 @@ tactic * mk_qfauflia_tactic(ast_manager & m, params_ref const & p) { ); tactic * st = and_then(using_params(preamble_st, main_p), - using_params(mk_smt_tactic(), solver_p)); + using_params(mk_smt_tactic(m), solver_p)); st->updt_params(p); return st; diff --git a/src/tactic/smtlogics/qfbv_tactic.cpp b/src/tactic/smtlogics/qfbv_tactic.cpp index a8ad95319..11d05cde6 100644 --- a/src/tactic/smtlogics/qfbv_tactic.cpp +++ b/src/tactic/smtlogics/qfbv_tactic.cpp @@ -36,7 +36,7 @@ Notes: static tactic * mk_qfbv_preamble(ast_manager& m, params_ref const& p) { params_ref solve_eq_p; - // conservative guassian elimination. + // conservative gaussian elimination. solve_eq_p.set_uint("solve_eqs_max_occs", 2); params_ref simp2_p = p; @@ -121,9 +121,9 @@ static tactic * mk_qfbv_tactic(ast_manager& m, params_ref const & p, tactic* sat tactic * mk_qfbv_tactic(ast_manager & m, params_ref const & p) { tactic * new_sat = cond(mk_produce_proofs_probe(), - and_then(mk_simplify_tactic(m), mk_smt_tactic()), + and_then(mk_simplify_tactic(m), mk_smt_tactic(m)), mk_psat_tactic(m, p)); - return mk_qfbv_tactic(m, p, new_sat, mk_psmt_tactic(m, p)); + return mk_qfbv_tactic(m, p, new_sat, mk_smt_tactic(m, p)); } diff --git a/src/tactic/smtlogics/qfidl_tactic.cpp b/src/tactic/smtlogics/qfidl_tactic.cpp index a34a25e67..109089c2e 100644 --- a/src/tactic/smtlogics/qfidl_tactic.cpp +++ b/src/tactic/smtlogics/qfidl_tactic.cpp @@ -101,9 +101,9 @@ tactic * mk_qfidl_tactic(ast_manager & m, params_ref const & p) { using_params(and_then(preamble_st, or_else(using_params(mk_diff_neq_tactic(m), diff_neq_p), try2bv, - mk_smt_tactic())), + mk_smt_tactic(m))), main_p), - mk_smt_tactic()); + mk_smt_tactic(m)); st->updt_params(p); diff --git a/src/tactic/smtlogics/qflia_tactic.cpp b/src/tactic/smtlogics/qflia_tactic.cpp index eed4e4425..d2fcc922d 100644 --- a/src/tactic/smtlogics/qflia_tactic.cpp +++ b/src/tactic/smtlogics/qflia_tactic.cpp @@ -58,21 +58,21 @@ probe * mk_is_quasi_pb_probe() { } // Create SMT solver that does not use cuts -static tactic * mk_no_cut_smt_tactic(unsigned rs) { +static tactic * mk_no_cut_smt_tactic(ast_manager& m, unsigned rs) { params_ref solver_p; solver_p.set_sym(symbol("smt.logic"), symbol("QF_LIA")); // force smt_setup to use the new solver solver_p.set_uint("arith.branch_cut_ratio", 10000000); solver_p.set_uint("random_seed", rs); - return annotate_tactic("no-cut-smt-tactic", using_params(mk_smt_tactic_using(false), solver_p)); + return annotate_tactic("no-cut-smt-tactic", using_params(mk_smt_tactic_using(m, false), solver_p)); } // Create SMT solver that does not use cuts -static tactic * mk_no_cut_no_relevancy_smt_tactic(unsigned rs) { +static tactic * mk_no_cut_no_relevancy_smt_tactic(ast_manager& m, unsigned rs) { params_ref solver_p; solver_p.set_uint("arith.branch_cut_ratio", 10000000); solver_p.set_uint("random_seed", rs); solver_p.set_uint("relevancy", 0); - return annotate_tactic("no-cut-relevancy-tactic", using_params(mk_smt_tactic_using(false), solver_p)); + return annotate_tactic("no-cut-relevancy-tactic", using_params(mk_smt_tactic_using(m, false), solver_p)); } static tactic * mk_bv2sat_tactic(ast_manager & m) { @@ -155,10 +155,10 @@ static tactic * mk_ilp_model_finder_tactic(ast_manager & m) { fail_if(mk_produce_unsat_cores_probe()), mk_propagate_ineqs_tactic(m), or_else(// try_for(mk_mip_tactic(m), 5000), - try_for(mk_no_cut_smt_tactic(100), 2000), + try_for(mk_no_cut_smt_tactic(m, 100), 2000), and_then(using_params(mk_add_bounds_tactic(m), add_bounds_p1), try_for(mk_lia2sat_tactic(m), 5000)), - try_for(mk_no_cut_smt_tactic(200), 5000), + try_for(mk_no_cut_smt_tactic(m, 200), 5000), and_then(using_params(mk_add_bounds_tactic(m), add_bounds_p2), try_for(mk_lia2sat_tactic(m), 10000)) // , mk_mip_tactic(m) @@ -170,9 +170,9 @@ static tactic * mk_bounded_tactic(ast_manager & m) { return annotate_tactic( "bounded-tactic", and_then(fail_if(mk_is_unbounded_probe()), - or_else(try_for(mk_no_cut_smt_tactic(100), 5000), - try_for(mk_no_cut_no_relevancy_smt_tactic(200), 5000), - try_for(mk_no_cut_smt_tactic(300), 15000) + or_else(try_for(mk_no_cut_smt_tactic(m, 100), 5000), + try_for(mk_no_cut_no_relevancy_smt_tactic(m, 200), 5000), + try_for(mk_no_cut_smt_tactic(m, 300), 15000) ), mk_fail_if_undecided_tactic())); } @@ -218,7 +218,7 @@ tactic * mk_qflia_tactic(ast_manager & m, params_ref const & p) { using_params(mk_lia2sat_tactic(m), quasi_pb_p), mk_fail_if_undecided_tactic()), mk_bounded_tactic(m), - mk_smt_tactic())), + mk_smt_tactic(m))), main_p); diff --git a/src/tactic/smtlogics/qflra_tactic.cpp b/src/tactic/smtlogics/qflra_tactic.cpp index b44ace7b1..90532cef6 100644 --- a/src/tactic/smtlogics/qflra_tactic.cpp +++ b/src/tactic/smtlogics/qflra_tactic.cpp @@ -68,7 +68,7 @@ tactic * mk_qflra_tactic(ast_manager & m, params_ref const & p) { #endif // return using_params(or_else(mip, - // using_params(mk_smt_tactic(), pivot_p)), + // using_params(mk_smt_tactic(m), pivot_p)), // p); #if 0 @@ -82,7 +82,7 @@ tactic * mk_qflra_tactic(ast_manager & m, params_ref const & p) { using_params(mk_smt_tactic(), simplex_1), using_params(mk_smt_tactic(), simplex_2)); #else - return using_params(using_params(mk_smt_tactic(), pivot_p), p); + return using_params(using_params(mk_smt_tactic(m), pivot_p), p); #endif } diff --git a/src/tactic/smtlogics/qfnia_tactic.cpp b/src/tactic/smtlogics/qfnia_tactic.cpp index b92e08006..d28034a1d 100644 --- a/src/tactic/smtlogics/qfnia_tactic.cpp +++ b/src/tactic/smtlogics/qfnia_tactic.cpp @@ -105,7 +105,7 @@ static tactic * mk_qfnia_nlsat_solver(ast_manager & m, params_ref const & p) { static tactic * mk_qfnia_smt_solver(ast_manager& m, params_ref const& p) { params_ref simp_p = p; simp_p.set_bool("som", true); // expand into sums of monomials - return and_then(using_params(mk_simplify_tactic(m), simp_p), mk_smt_tactic()); + return and_then(using_params(mk_simplify_tactic(m), simp_p), mk_smt_tactic(m)); } tactic * mk_qfnia_tactic(ast_manager & m, params_ref const & p) { @@ -116,5 +116,6 @@ tactic * mk_qfnia_tactic(ast_manager & m, params_ref const & p) { or_else(mk_qfnia_sat_solver(m, p), try_for(mk_qfnia_smt_solver(m, p), 2000), mk_qfnia_nlsat_solver(m, p), - mk_qfnia_smt_solver(m, p))); + mk_qfnia_smt_solver(m, p)) + ); } diff --git a/src/tactic/smtlogics/qfnra_tactic.cpp b/src/tactic/smtlogics/qfnra_tactic.cpp index cc01950a2..7d93abe25 100644 --- a/src/tactic/smtlogics/qfnra_tactic.cpp +++ b/src/tactic/smtlogics/qfnra_tactic.cpp @@ -28,7 +28,7 @@ static tactic * mk_qfnra_sat_solver(ast_manager& m, params_ref const& p, unsigne nra2sat_p.set_uint("nla2bv_max_bv_size", p.get_uint("nla2bv_max_bv_size", bv_size)); return and_then(mk_nla2bv_tactic(m, nra2sat_p), - mk_smt_tactic(), + mk_smt_tactic(m), mk_fail_if_undecided_tactic()); } @@ -47,7 +47,7 @@ tactic * mk_qfnra_tactic(ast_manager & m, params_ref const& p) { or_else(try_for(mk_qfnra_nlsat_tactic(m, p0), 5000), try_for(mk_qfnra_nlsat_tactic(m, p1), 10000), mk_qfnra_sat_solver(m, p, 4), - and_then(try_for(mk_smt_tactic(), 5000), mk_fail_if_undecided_tactic()), + and_then(try_for(mk_smt_tactic(m), 5000), mk_fail_if_undecided_tactic()), mk_qfnra_sat_solver(m, p, 6), mk_qfnra_nlsat_tactic(m, p2))); } diff --git a/src/tactic/smtlogics/qfuf_tactic.cpp b/src/tactic/smtlogics/qfuf_tactic.cpp index 2de9612c6..6af75b13f 100644 --- a/src/tactic/smtlogics/qfuf_tactic.cpp +++ b/src/tactic/smtlogics/qfuf_tactic.cpp @@ -34,7 +34,7 @@ tactic * mk_qfuf_tactic(ast_manager & m, params_ref const & p) { mk_solve_eqs_tactic(m, p), using_params(mk_simplify_tactic(m, p), s2_p), if_no_proofs(if_no_unsat_cores(mk_symmetry_reduce_tactic(m, p))), - mk_smt_tactic(p)); + mk_smt_tactic(m, p)); } diff --git a/src/tactic/smtlogics/qfufbv_tactic.cpp b/src/tactic/smtlogics/qfufbv_tactic.cpp index a4e169856..8dd77cba2 100644 --- a/src/tactic/smtlogics/qfufbv_tactic.cpp +++ b/src/tactic/smtlogics/qfufbv_tactic.cpp @@ -121,7 +121,7 @@ private: tactic_ref t = mk_qfaufbv_tactic(m_m, m_p); sat = mk_tactic2solver(m_m, t.get(), m_p); } - SASSERT(sat != NULL); + SASSERT(sat != nullptr); sat->set_produce_models(true); return sat; } @@ -176,7 +176,7 @@ tactic * mk_qfufbv_tactic(ast_manager & m, params_ref const & p) { tactic * const preamble_st = mk_qfufbv_preamble(m, p); tactic * st = using_params(and_then(preamble_st, - cond(mk_is_qfbv_probe(), mk_qfbv_tactic(m), mk_smt_tactic())), + cond(mk_is_qfbv_probe(), mk_qfbv_tactic(m), mk_smt_tactic(m))), main_p); st->updt_params(p); @@ -188,5 +188,5 @@ tactic * mk_qfufbv_ackr_tactic(ast_manager & m, params_ref const & p) { tactic * const actual_tactic = alloc(qfufbv_ackr_tactic, m, p); return and_then(preamble_t, - cond(mk_is_qfufbv_probe(), actual_tactic, mk_smt_tactic())); + cond(mk_is_qfufbv_probe(), actual_tactic, mk_smt_tactic(m))); } diff --git a/src/tactic/smtlogics/quant_tactics.cpp b/src/tactic/smtlogics/quant_tactics.cpp index 8438d1a32..910a5d53c 100644 --- a/src/tactic/smtlogics/quant_tactics.cpp +++ b/src/tactic/smtlogics/quant_tactics.cpp @@ -64,14 +64,14 @@ static tactic * mk_no_solve_eq_preprocessor(ast_manager & m) { tactic * mk_ufnia_tactic(ast_manager & m, params_ref const & p) { tactic * st = and_then(mk_no_solve_eq_preprocessor(m), mk_qe_lite_tactic(m, p), - mk_smt_tactic()); + mk_smt_tactic(m)); st->updt_params(p); return st; } tactic * mk_uflra_tactic(ast_manager & m, params_ref const & p) { tactic * st = and_then(mk_quant_preprocessor(m), - mk_smt_tactic()); + mk_smt_tactic(m)); st->updt_params(p); return st; } @@ -82,23 +82,23 @@ tactic * mk_auflia_tactic(ast_manager & m, params_ref const & p) { TRACE("qi_cost", qi_p.display(tout); tout << "\n" << qi_p.get_str("qi.cost", "") << "\n";); tactic * st = and_then(mk_no_solve_eq_preprocessor(m), or_else(and_then(fail_if(mk_gt(mk_num_exprs_probe(), mk_const_probe(static_cast(128)))), - using_params(mk_smt_tactic(), qi_p), + using_params(mk_smt_tactic(m), qi_p), mk_fail_if_undecided_tactic()), - mk_smt_tactic())); + mk_smt_tactic(m))); st->updt_params(p); return st; } tactic * mk_auflira_tactic(ast_manager & m, params_ref const & p) { tactic * st = and_then(mk_quant_preprocessor(m), - mk_smt_tactic()); + mk_smt_tactic(m)); st->updt_params(p); return st; } tactic * mk_aufnira_tactic(ast_manager & m, params_ref const & p) { tactic * st = and_then(mk_quant_preprocessor(m), - mk_smt_tactic()); + mk_smt_tactic(m)); st->updt_params(p); return st; } @@ -109,9 +109,9 @@ tactic * mk_lra_tactic(ast_manager & m, params_ref const & p) { cond(mk_has_quantifier_probe(), cond(mk_is_lira_probe(), or_else(mk_qsat_tactic(m, p), - and_then(mk_qe_tactic(m), mk_smt_tactic())), - mk_smt_tactic()), - mk_smt_tactic())); + and_then(mk_qe_tactic(m), mk_smt_tactic(m))), + mk_smt_tactic(m)), + mk_smt_tactic(m))); st->updt_params(p); return st; } diff --git a/src/tactic/tactic.cpp b/src/tactic/tactic.cpp index 3b3c2444f..4a51c701a 100644 --- a/src/tactic/tactic.cpp +++ b/src/tactic/tactic.cpp @@ -191,7 +191,7 @@ lbool check_sat(tactic & t, goal_ref & g, model_ref & md, labels_vec & labels, p return l_false; } else { - if (models_enabled && r.size() >= 1) { + if (models_enabled && !r.empty()) { model_converter_ref mc = r[0]->mc(); model_converter2model(m, mc.get(), md); if (mc) diff --git a/src/tactic/tactic.h b/src/tactic/tactic.h index 92cc7315f..dd6557dcc 100644 --- a/src/tactic/tactic.h +++ b/src/tactic/tactic.h @@ -78,7 +78,6 @@ protected: friend class nary_tactical; friend class binary_tactical; friend class unary_tactical; - friend class nl_purify_tactic; }; diff --git a/src/tactic/tactical.cpp b/src/tactic/tactical.cpp index 43087f50f..98f6be343 100644 --- a/src/tactic/tactical.cpp +++ b/src/tactic/tactical.cpp @@ -636,7 +636,7 @@ public: else { SASSERT(is_decided_unsat(r2)); - if (cores_enabled && r2[0]->dep(0) != 0) { + if (cores_enabled && r2[0]->dep(0) != nullptr) { expr_dependency_ref * new_dep = alloc(expr_dependency_ref, new_m); *new_dep = r2[0]->dep(0); core_buffer.set(i, new_dep); @@ -674,7 +674,7 @@ public: ast_translation translator(*(managers[i]), m, false); goal_ref_buffer * r = goals_vect[i]; unsigned j = result.size(); - if (r != 0) { + if (r != nullptr) { for (unsigned k = 0; k < r->size(); k++) { result.push_back((*r)[k]->translate(translator)); } @@ -744,7 +744,7 @@ public: SASSERT(t); } - virtual ~unary_tactical() { } + ~unary_tactical() override { } void operator()(goal_ref const & in, goal_ref_buffer& result) override { m_t->operator()(in, result); @@ -1003,7 +1003,7 @@ public: SASSERT(m_p); } - virtual ~cond_tactical() {} + ~cond_tactical() override {} void operator()(goal_ref const & in, goal_ref_buffer & result) override { if (m_p->operator()(*(in.get())).is_true()) @@ -1035,7 +1035,7 @@ public: SASSERT(m_p); } - virtual ~fail_if_tactic() {} + ~fail_if_tactic() override {} void cleanup() override {} diff --git a/src/tactic/ufbv/ufbv_rewriter.cpp b/src/tactic/ufbv/ufbv_rewriter.cpp index ee8a4605b..66a26be00 100644 --- a/src/tactic/ufbv/ufbv_rewriter.cpp +++ b/src/tactic/ufbv/ufbv_rewriter.cpp @@ -870,7 +870,7 @@ bool ufbv_rewriter::match_subst::match_args(app * lhs, expr * const * args) { m_cache.insert(p); continue; } - catch (match_args_aux_proc::no_match) { + catch (const match_args_aux_proc::no_match &) { return false; } } diff --git a/src/tactic/ufbv/ufbv_tactic.cpp b/src/tactic/ufbv/ufbv_tactic.cpp index 1fb4486ec..09b2bd00c 100644 --- a/src/tactic/ufbv/ufbv_tactic.cpp +++ b/src/tactic/ufbv/ufbv_tactic.cpp @@ -67,7 +67,7 @@ tactic * mk_ufbv_tactic(ast_manager & m, params_ref const & p) { main_p.set_bool("elim_and", true); tactic * t = and_then(repeat(mk_ufbv_preprocessor_tactic(m, main_p), 2), - mk_smt_tactic_using(false, main_p)); + mk_smt_tactic_using(m, false, main_p)); t->updt_params(p); diff --git a/src/test/arith_rewriter.cpp b/src/test/arith_rewriter.cpp index d0a110c4f..da49e58dc 100644 --- a/src/test/arith_rewriter.cpp +++ b/src/test/arith_rewriter.cpp @@ -1,4 +1,3 @@ - /*++ Copyright (c) 2015 Microsoft Corporation @@ -26,8 +25,8 @@ static expr_ref parse_fml(ast_manager& m, char const* str) { << "(assert " << str << ")\n"; std::istringstream is(buffer.str()); VERIFY(parse_smt2_commands(ctx, is)); - ENSURE(ctx.begin_assertions() != ctx.end_assertions()); - result = *ctx.begin_assertions(); + ENSURE(!ctx.assertions().empty()); + result = ctx.assertions().get(0); return result; } diff --git a/src/test/ast.cpp b/src/test/ast.cpp index 59bdfc8e4..0826306f2 100644 --- a/src/test/ast.cpp +++ b/src/test/ast.cpp @@ -44,7 +44,7 @@ static void tst1() { // ast_ref v3 (m.mk_var(1), m); // ENSURE(v1 != v2); // ENSURE(v1 == v3); -// TRACE("ast", tout << "reseting v1\n";); +// TRACE("ast", tout << "resetting v1\n";); // v1.reset(); // TRACE("ast", tout << "overwriting v3\n";); // v3 = v2; diff --git a/src/test/bit_vector.cpp b/src/test/bit_vector.cpp index 487f6cdd0..db6270b35 100644 --- a/src/test/bit_vector.cpp +++ b/src/test/bit_vector.cpp @@ -35,7 +35,7 @@ static void tst1() { } else if (op <= 3) { ENSURE(v1.size() == v2.size()); - if (v1.size() > 0) { + if (!v1.empty()) { bool val = (rand()%2) != 0; unsigned idx = rand()%v1.size(); ENSURE(v1.get(idx) == v2[idx]); @@ -46,7 +46,7 @@ static void tst1() { } else if (op <= 4) { ENSURE(v1.size() == v2.size()); - if (v1.size() > 0) { + if (!v1.empty()) { unsigned idx = rand()%v1.size(); VERIFY(v1.get(idx) == v2[idx]); } diff --git a/src/test/chashtable.cpp b/src/test/chashtable.cpp index 0ccf2c177..8e4dadf99 100644 --- a/src/test/chashtable.cpp +++ b/src/test/chashtable.cpp @@ -102,7 +102,7 @@ static void tst3() { ENSURE(t.contains(12)); t.erase(12); t.erase(10); - ENSURE(t.size() == 0); + ENSURE(t.empty()); ENSURE(t.empty()); ENSURE(t.used_slots() == 0); t.insert(10); diff --git a/src/test/cnf_backbones.cpp b/src/test/cnf_backbones.cpp index 50584c90c..10f3e56a7 100644 --- a/src/test/cnf_backbones.cpp +++ b/src/test/cnf_backbones.cpp @@ -238,10 +238,10 @@ static void cnf_backbones(bool use_chunk, char const* file_name) { std::cerr << "(error \"failed to open file '" << file_name << "'\")" << std::endl; exit(ERR_OPEN_FILE); } - parse_dimacs(in, solver); + if (!parse_dimacs(in, std::cerr, solver)) return; } else { - parse_dimacs(std::cin, solver); + if (!parse_dimacs(std::cin, std::cerr, solver)) return; } IF_VERBOSE(20, solver.display_status(verbose_stream());); diff --git a/src/test/ddnf.cpp b/src/test/ddnf.cpp index 003e5bdb8..b1bb624a2 100644 --- a/src/test/ddnf.cpp +++ b/src/test/ddnf.cpp @@ -15,7 +15,7 @@ Copyright (c) 2015 Microsoft Corporation #include /* -TBD: count number of nodes, number of operations accross all insertions +TBD: count number of nodes, number of operations across all insertions */ void read_nums(std::istream& is, unsigned & x, unsigned& y) { diff --git a/src/test/dl_table.cpp b/src/test/dl_table.cpp index 326be5d04..8eb864f7b 100644 --- a/src/test/dl_table.cpp +++ b/src/test/dl_table.cpp @@ -1,8 +1,6 @@ /*++ Copyright (c) 2015 Microsoft Corporation --*/ -#if defined(_WINDOWS) || defined(_CYGWIN) - #include "muz/base/dl_context.h" #include "muz/rel/dl_table.h" #include "muz/fp/dl_register_engine.h" @@ -98,7 +96,3 @@ void test_dl_bitvector_table() { void tst_dl_table() { test_dl_bitvector_table(); } -#else -void tst_dl_table() { -} -#endif diff --git a/src/test/fuzzing/expr_delta.h b/src/test/fuzzing/expr_delta.h index d69ed33f1..f59e4c4d5 100644 --- a/src/test/fuzzing/expr_delta.h +++ b/src/test/fuzzing/expr_delta.h @@ -33,7 +33,7 @@ public: // // Create the n'th delta in dfs mode. - // resturn 'true' if a delta was obtained. + // return 'true' if a delta was obtained. // bool delta_dfs(unsigned n, expr_ref_vector& result); diff --git a/src/test/heap.cpp b/src/test/heap.cpp index 2c77b939e..6a5bc7b9f 100644 --- a/src/test/heap.cpp +++ b/src/test/heap.cpp @@ -88,7 +88,7 @@ static void tst2() { int_heap2 h(N); for (int i = 0; i < N * 10; i++) { - if (i % 1 == 0) std::cout << "i: " << i << std::endl; + // if (i % 1 == 0) std::cout << "i: " << i << std::endl; if (i % 1000 == 0) std::cout << "i: " << i << std::endl; int cmd = heap_rand() % 10; if (cmd <= 3) { diff --git a/src/test/lp/argument_parser.h b/src/test/lp/argument_parser.h index c8566ce34..f2a74f122 100644 --- a/src/test/lp/argument_parser.h +++ b/src/test/lp/argument_parser.h @@ -112,41 +112,41 @@ public: std::string usage_string() { std::string ret = ""; std::vector unknown_options; - for (auto t : m_free_args) { + for (const auto & t : m_free_args) { if (starts_with(t, "-") || starts_with(t, "\\")) { unknown_options.push_back(t); } } - if (unknown_options.size()) { + if (!unknown_options.empty()) { ret = "Unknown options:"; } - for (auto unknownOption : unknown_options) { + for (const auto & unknownOption : unknown_options) { ret += unknownOption; ret += ","; } ret += "\n"; ret += "Usage:\n"; for (auto allowed_option : m_options) - ret += allowed_option.first + " " + (allowed_option.second.size() == 0 ? std::string("") : std::string("/") + allowed_option.second) + std::string("\n"); + ret += allowed_option.first + " " + (allowed_option.second.empty() ? std::string("") : std::string("/") + allowed_option.second) + std::string("\n"); for (auto s : m_options_with_after_string) { - ret += s.first + " " + (s.second.size() == 0? " \"option value\"":("\""+ s.second+"\"")) + "\n"; + ret += s.first + " " + (s.second.empty()? " \"option value\"":("\""+ s.second+"\"")) + "\n"; } return ret; } void print() { - if (m_used_options.size() == 0 && m_used_options_with_after_string.size() == 0 && m_free_args.size() == 0) { + if (m_used_options.empty() && m_used_options_with_after_string.empty() && m_free_args.empty()) { std::cout << "no options are given" << std::endl; return; } std::cout << "options are: " << std::endl; - for (std::string s : m_used_options) { + for (const std::string & s : m_used_options) { std::cout << s << std::endl; } for (auto & t : m_used_options_with_after_string) { std::cout << t.first << " " << t.second << std::endl; } - if (m_free_args.size() > 0) { + if (!m_free_args.empty()) { std::cout << "free arguments are: " << std::endl; for (auto & t : m_free_args) { std::cout << t << " " << std::endl; diff --git a/src/test/lp/gomory_test.h b/src/test/lp/gomory_test.h index 03ad5b187..972466dc3 100644 --- a/src/test/lp/gomory_test.h +++ b/src/test/lp/gomory_test.h @@ -1,4 +1,5 @@ namespace lp { +#include "util/lp/lp_utils.h" struct gomory_test { gomory_test( std::function name_function_p, @@ -88,7 +89,7 @@ struct gomory_test { lp_assert(is_int(x_j)); lp_assert(!a.is_int()); lp_assert(f_0 > zero_of_type() && f_0 < one_of_type()); - mpq f_j = int_solver::fractional_part(a); + mpq f_j = fractional_part(a); TRACE("gomory_cut_detail", tout << a << " x_j = " << x_j << ", k = " << k << "\n"; tout << "f_j: " << f_j << "\n"; @@ -184,7 +185,6 @@ struct gomory_test { } void print_term(lar_term & t, std::ostream & out) { - lp_assert(is_zero(t.m_v)); vector> row; for (auto p : t.m_coeffs) row.push_back(std::make_pair(p.second, p.first)); @@ -206,7 +206,7 @@ struct gomory_test { unsigned x_j; mpq a; bool some_int_columns = false; - mpq f_0 = int_solver::fractional_part(get_value(inf_col)); + mpq f_0 = fractional_part(get_value(inf_col)); mpq one_min_f_0 = 1 - f_0; for ( auto pp : row) { a = pp.first; diff --git a/src/test/lp/lp.cpp b/src/test/lp/lp.cpp index 6e418fe68..f43aff668 100644 --- a/src/test/lp/lp.cpp +++ b/src/test/lp/lp.cpp @@ -117,7 +117,7 @@ void test_matrix(square_sparse_matrix & a) { } void tst1() { - std::cout << "testing the minimial matrix with 1 row and 1 column" << std::endl; + std::cout << "testing the minimal matrix with 1 row and 1 column" << std::endl; square_sparse_matrix m0(1, 1); m0.set(0, 0, 1); // print_matrix(m0); @@ -192,7 +192,7 @@ void tst1() { // print_matrix(m10by9); } -vector allocate_basis_heading(unsigned count) { // the rest of initilization will be handled by lu_QR +vector allocate_basis_heading(unsigned count) { // the rest of initialization will be handled by lu_QR vector basis_heading(count, -1); return basis_heading; } @@ -850,7 +850,7 @@ void fill_uniformly(dense_matrix & m, unsigned dim) { } } -void square_sparse_matrix_with_permutaions_test() { +void square_sparse_matrix_with_permutations_test() { unsigned dim = 4; square_sparse_matrix m(dim, dim); fill_uniformly(m, dim); @@ -1023,7 +1023,7 @@ void test_dense_matrix() { -vector> vector_of_permutaions() { +vector> vector_of_permutations() { vector> ret; { permutation_matrix p0(5); @@ -1058,7 +1058,7 @@ void test_apply_reverse_from_right_to_perm(permutation_matrix & } void test_apply_reverse_from_right() { - auto vec = vector_of_permutaions(); + auto vec = vector_of_permutations(); for (unsigned i = 0; i < vec.size(); i++) { test_apply_reverse_from_right_to_perm(vec[i]); } @@ -1091,7 +1091,7 @@ void lp_solver_test() { bool get_int_from_args_parser(const char * option, argument_parser & args_parser, unsigned & n) { std::string s = args_parser.get_option_value(option); - if (s.size() > 0) { + if (!s.empty()) { n = atoi(s.c_str()); return true; } @@ -1100,7 +1100,7 @@ bool get_int_from_args_parser(const char * option, argument_parser & args_parser bool get_double_from_args_parser(const char * option, argument_parser & args_parser, double & n) { std::string s = args_parser.get_option_value(option); - if (s.size() > 0) { + if (!s.empty()) { n = atof(s.c_str()); return true; } @@ -1161,14 +1161,14 @@ void setup_solver(unsigned max_iterations, unsigned time_limit, bool look_for_mi bool values_are_one_percent_close(double a, double b); void print_x(mps_reader & reader, lp_solver * solver) { - for (auto name : reader.column_names()) { + for (const auto & name : reader.column_names()) { std::cout << name << "=" << solver->get_column_value_by_name(name) << ' '; } std::cout << std::endl; } void compare_solutions(mps_reader & reader, lp_solver * solver, lp_solver * solver0) { - for (auto name : reader.column_names()) { + for (const auto & name : reader.column_names()) { double a = solver->get_column_value_by_name(name); double b = solver0->get_column_value_by_name(name); if (!values_are_one_percent_close(a, b)) { @@ -1299,7 +1299,7 @@ void solve_mps_in_rational(std::string file_name, bool dual, argument_parser & / std::cout << "status is " << lp_status_to_string(solver->get_status()) << std::endl; if (solver->get_status() == lp_status::OPTIMAL) { if (reader.column_names().size() < 20) { - for (auto name : reader.column_names()) { + for (const auto & name : reader.column_names()) { std::cout << name << "=" << solver->get_column_value_by_name(name).get_double() << ' '; } } @@ -1414,7 +1414,7 @@ void solve_mps_with_known_solution(std::string file_name, std::unordered_map * get_solution_from_glpsol_output(std::s return nullptr; } auto split = string_split(s, " \t", false); - if (split.size() == 0) { + if (split.empty()) { return ret; } @@ -1901,17 +1901,17 @@ void setup_args_parser(argument_parser & parser) { parser.add_option_with_after_string_with_help("--density", "the percentage of non-zeroes in the matrix below which it is not dense"); parser.add_option_with_after_string_with_help("--harris_toler", "harris tolerance"); parser.add_option_with_help_string("--test_swaps", "test row swaps with a permutation"); - parser.add_option_with_help_string("--test_perm", "test permutaions"); + parser.add_option_with_help_string("--test_perm", "test permutations"); parser.add_option_with_after_string_with_help("--checklu", "the file name for lu checking"); parser.add_option_with_after_string_with_help("--partial_pivot", "the partial pivot constant, a number somewhere between 10 and 100"); parser.add_option_with_after_string_with_help("--percent_for_enter", "which percent of columns check for entering column"); - parser.add_option_with_help_string("--totalinf", "minimizes the total infeasibility instead of diminishin infeasibility of the rows"); + parser.add_option_with_help_string("--totalinf", "minimizes the total infeasibility instead of diminishing infeasibility of the rows"); parser.add_option_with_after_string_with_help("--rep_frq", "the report frequency, in how many iterations print the cost and other info "); parser.add_option_with_help_string("--smt", "smt file format"); parser.add_option_with_after_string_with_help("--filelist", "the file containing the list of files"); parser.add_option_with_after_string_with_help("--file", "the input file name"); parser.add_option_with_after_string_with_help("--random_seed", "random seed"); - parser.add_option_with_help_string("--bp", "bound propogation"); + parser.add_option_with_help_string("--bp", "bound propagation"); parser.add_option_with_help_string("--min", "will look for the minimum for the given file if --file is used; the default is looking for the max"); parser.add_option_with_help_string("--max", "will look for the maximum for the given file if --file is used; it is the default behavior"); parser.add_option_with_after_string_with_help("--max_iters", "maximum total iterations in a core solver stage"); @@ -1932,7 +1932,7 @@ void setup_args_parser(argument_parser & parser) { parser.add_option_with_help_string("--lar", "test lar_solver"); parser.add_option_with_after_string_with_help("--maxng", "max iterations without progress"); parser.add_option_with_help_string("-tbq", "test binary queue"); - parser.add_option_with_help_string("--randomize_lar", "test randomize funclionality"); + parser.add_option_with_help_string("--randomize_lar", "test randomize functionality"); parser.add_option_with_help_string("--smap", "test stacked_map"); parser.add_option_with_help_string("--term", "simple term test"); parser.add_option_with_help_string("--eti"," run a small evidence test for total infeasibility scenario"); @@ -2050,14 +2050,14 @@ void finalize(unsigned ret) { void get_time_limit_and_max_iters_from_parser(argument_parser & args_parser, unsigned & time_limit, unsigned & max_iters) { std::string s = args_parser.get_option_value("--max_iters"); - if (s.size() > 0) { + if (!s.empty()) { max_iters = atoi(s.c_str()); } else { max_iters = 0; } std::string time_limit_string = args_parser.get_option_value("--time_limit"); - if (time_limit_string.size() > 0) { + if (!time_limit_string.empty()) { time_limit = atoi(time_limit_string.c_str()); } else { time_limit = 0; @@ -2156,7 +2156,7 @@ double get_lp_tst_cost(std::string file_name) { cost_string = str; } } - if (cost_string.size() == 0) { + if (cost_string.empty()) { std::cout << "cannot find the cost line in " << file_name << std::endl; throw 0; } @@ -2369,7 +2369,7 @@ void test_files_from_directory(std::string test_file_dir, argument_parser & args std::unordered_map get_solution_map(lp_solver * lps, mps_reader & reader) { std::unordered_map ret; - for (auto it : reader.column_names()) { + for (const auto & it : reader.column_names()) { ret[it] = lps->get_column_value_by_name(it); } return ret; @@ -2377,7 +2377,7 @@ std::unordered_map get_solution_map(lp_solver * reader) { std::string maxng = args_parser.get_option_value("--maxng"); - if (maxng.size() > 0) { + if (!maxng.empty()) { solver->settings().max_number_of_iterations_with_no_improvements = atoi(maxng.c_str()); } if (args_parser.option_is_used("-pd")){ @@ -2385,7 +2385,7 @@ void run_lar_solver(argument_parser & args_parser, lar_solver * solver, mps_read } std::string iter = args_parser.get_option_value("--max_iters"); - if (iter.size() > 0) { + if (!iter.empty()) { solver->settings().max_total_number_of_iterations = atoi(iter.c_str()); } if (args_parser.option_is_used("--compare_with_primal")){ @@ -2470,7 +2470,7 @@ vector get_file_names_from_file_list(std::string filelist) { std::string s = read_line(end, file); if (end) break; - if (s.size() == 0) + if (s.empty()) break; ret.push_back(s); } while (true); @@ -2480,14 +2480,14 @@ vector get_file_names_from_file_list(std::string filelist) { void test_lar_solver(argument_parser & args_parser) { std::string file_name = args_parser.get_option_value("--file"); - if (file_name.size() > 0) { + if (!file_name.empty()) { test_lar_on_file(file_name, args_parser); return; } std::string file_list = args_parser.get_option_value("--filelist"); - if (file_list.size() > 0) { - for (std::string fn : get_file_names_from_file_list(file_list)) + if (!file_list.empty()) { + for (const std::string & fn : get_file_names_from_file_list(file_list)) test_lar_on_file(fn, args_parser); return; } @@ -2667,13 +2667,20 @@ void test_term() { lar_solver solver; unsigned _x = 0; unsigned _y = 1; + unsigned _one = 2; var_index x = solver.add_var(_x, false); var_index y = solver.add_var(_y, false); + var_index one = solver.add_var(_one, false); + + vector> term_one; + term_one.push_back(std::make_pair((int)1, one)); + solver.add_constraint(term_one, lconstraint_kind::EQ, mpq(0)); vector> term_ls; term_ls.push_back(std::pair((int)1, x)); term_ls.push_back(std::pair((int)1, y)); - var_index z = solver.add_term(term_ls, mpq(3)); + term_ls.push_back(std::make_pair((int)3, one)); + var_index z = solver.add_term(term_ls); vector> ls; ls.push_back(std::pair((int)1, x)); @@ -2743,10 +2750,10 @@ void test_bound_propagation_one_small_sample1() { vector> coeffs; coeffs.push_back(std::pair(1, a)); coeffs.push_back(std::pair(-1, c)); - ls.add_term(coeffs, zero_of_type()); + ls.add_term(coeffs); coeffs.pop_back(); coeffs.push_back(std::pair(-1, b)); - ls.add_term(coeffs, zero_of_type()); + ls.add_term(coeffs); coeffs.clear(); coeffs.push_back(std::pair(1, a)); coeffs.push_back(std::pair(-1, b)); @@ -3485,12 +3492,12 @@ void test_maximize_term() { vector> term_ls; term_ls.push_back(std::pair((int)1, x)); term_ls.push_back(std::pair((int)-1, y)); - unsigned term_x_min_y = solver.add_term(term_ls, mpq(0)); + unsigned term_x_min_y = solver.add_term(term_ls); term_ls.clear(); term_ls.push_back(std::pair((int)2, x)); term_ls.push_back(std::pair((int)2, y)); - unsigned term_2x_pl_2y = solver.add_term(term_ls, mpq(0)); + unsigned term_2x_pl_2y = solver.add_term(term_ls); solver.add_var_bound(term_x_min_y, LE, zero_of_type()); solver.add_var_bound(term_2x_pl_2y, LE, mpq((int)5)); solver.find_feasible_solution(); @@ -3502,8 +3509,7 @@ void test_maximize_term() { std::cout<< "v[" << p.first << "] = " << p.second << std::endl; } std::cout << "calling int_solver\n"; - lar_term t; mpq k; explanation ex; bool upper; - lia_move lm = i_solver.check(t, k, ex, upper); + lia_move lm = i_solver.check(); VERIFY(lm == lia_move::sat); impq term_max; lp_status st = solver.maximize_term(term_2x_pl_2y, term_max); @@ -3594,7 +3600,7 @@ void test_lp_local(int argn, char**argv) { std::string lufile = args_parser.get_option_value("--checklu"); - if (lufile.size()) { + if (!lufile.empty()) { check_lu_from_file(lufile); return finalize(0); } @@ -3617,8 +3623,8 @@ void test_lp_local(int argn, char**argv) { return finalize(0); } std::string file_list = args_parser.get_option_value("--filelist"); - if (file_list.size() > 0) { - for (std::string fn : get_file_names_from_file_list(file_list)) + if (!file_list.empty()) { + for (const std::string & fn : get_file_names_from_file_list(file_list)) solve_mps(fn, args_parser); return finalize(0); } @@ -3698,7 +3704,7 @@ void test_lp_local(int argn, char**argv) { bool dual = args_parser.option_is_used("--dual"); bool solve_for_rational = args_parser.option_is_used("--mpq"); std::string file_name = args_parser.get_option_value("--file"); - if (file_name.size() > 0) { + if (!file_name.empty()) { solve_mps(file_name, args_parser.option_is_used("--min"), max_iters, time_limit, solve_for_rational, dual, args_parser.option_is_used("--compare_with_primal"), args_parser); ret = 0; return finalize(ret); @@ -3716,7 +3722,7 @@ void test_lp_local(int argn, char**argv) { test_init_U(); test_replace_column(); #ifdef Z3DEBUG - square_sparse_matrix_with_permutaions_test(); + square_sparse_matrix_with_permutations_test(); test_dense_matrix(); test_swap_operations(); test_permutations(); diff --git a/src/test/lp/smt_reader.h b/src/test/lp/smt_reader.h index 16f44e3b3..4bce99765 100644 --- a/src/test/lp/smt_reader.h +++ b/src/test/lp/smt_reader.h @@ -52,7 +52,7 @@ namespace lp { std::string m_head; std::vector m_elems; void print() { - if (m_elems.size()) { + if (!m_elems.empty()) { std::cout << '('; std::cout << m_head << ' '; for (auto & el : m_elems) @@ -133,7 +133,7 @@ namespace lp { lm.m_head = m_line.substr(0, separator); m_line = m_line.substr(lm.m_head.size()); eat_blanks(); - while (m_line.size()) { + while (!m_line.empty()) { if (m_line[0] == '(') { lisp_elem el; fill_nested_elem(el); @@ -152,7 +152,7 @@ namespace lp { } void eat_blanks() { - while (m_line.size()) { + while (!m_line.empty()) { if (m_line[0] == ' ') m_line = m_line.substr(1); else @@ -193,19 +193,19 @@ namespace lp { } } - void adjust_rigth_side(formula_constraint & /* c*/, lisp_elem & /*el*/) { + void adjust_right_side(formula_constraint & /* c*/, lisp_elem & /*el*/) { // lp_assert(el.m_head == "0"); // do nothing for the time being } void set_constraint_coeffs(formula_constraint & c, lisp_elem & el) { lp_assert(el.m_elems.size() == 2); set_constraint_coeffs_on_coeff_element(c, el.m_elems[0]); - adjust_rigth_side(c, el.m_elems[1]); + adjust_right_side(c, el.m_elems[1]); } bool is_integer(std::string & s) { - if (s.size() == 0) return false; + if (s.empty()) return false; return atoi(s.c_str()) != 0 || isdigit(s.c_str()[0]); } diff --git a/src/test/main.cpp b/src/test/main.cpp index d330610d9..4aeee185b 100644 --- a/src/test/main.cpp +++ b/src/test/main.cpp @@ -78,11 +78,11 @@ void parse_cmd_line_args(int argc, char ** argv, bool& do_display_usage, bool& t int i = 1; while (i < argc) { char * arg = argv[i]; - char * eq_pos = 0; + char * eq_pos = nullptr; if (arg[0] == '-' || arg[0] == '/') { char * opt_name = arg + 1; - char * opt_arg = 0; + char * opt_arg = nullptr; char * colon = strchr(arg, ':'); if (colon) { opt_arg = colon + 1; @@ -97,7 +97,7 @@ void parse_cmd_line_args(int argc, char ** argv, bool& do_display_usage, bool& t else if (strcmp(opt_name, "v") == 0) { if (!opt_arg) error("option argument (/v:level) is missing."); - long lvl = strtol(opt_arg, 0, 10); + long lvl = strtol(opt_arg, nullptr, 10); set_verbosity_level(lvl); } else if (strcmp(opt_name, "w") == 0) { @@ -143,7 +143,6 @@ int main(int argc, char ** argv) { bool test_all = false; parse_cmd_line_args(argc, argv, do_display_usage, test_all); TST(random); - TST(vector); TST(symbol_table); TST(region); TST(symbol); @@ -213,6 +212,7 @@ int main(int argc, char ** argv) { if (test_all) return 0; TST(ext_numeral); TST(interval); + TST(vector); TST(f2n); TST(hwf); TST(trigo); diff --git a/src/test/no_overflow.cpp b/src/test/no_overflow.cpp index bb87b1d30..eb26866a5 100644 --- a/src/test/no_overflow.cpp +++ b/src/test/no_overflow.cpp @@ -530,7 +530,7 @@ void test_div(unsigned bvsize) { Z3_del_context(ctx); } -typedef Z3_ast (Z3_API *NO_OVFL_ARITH_FUNC)(Z3_context ctx, Z3_ast t1, Z3_ast t2, Z3_bool is_signed); +typedef Z3_ast (Z3_API *NO_OVFL_ARITH_FUNC)(Z3_context ctx, Z3_ast t1, Z3_ast t2, bool is_signed); typedef Z3_ast (Z3_API *ARITH_FUNC)(Z3_context ctx, Z3_ast t1, Z3_ast t2); typedef enum { OVFL_FUNC, UDFL_FUNC } overflow_type; @@ -546,11 +546,11 @@ typedef struct { bool sign_compar; // whether signed comparison should be used even for unsigned operation } Equivalence_params; -Z3_ast Z3_API Z3_mk_bvsdiv_no_overflow_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2, Z3_bool is_signed) { +Z3_ast Z3_API Z3_mk_bvsdiv_no_overflow_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2, bool is_signed) { return Z3_mk_bvsdiv_no_overflow(ctx, t1, t2); } -Z3_ast Z3_API Z3_mk_bvneg_no_overflow_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2, Z3_bool is_signed) { +Z3_ast Z3_API Z3_mk_bvneg_no_overflow_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2, bool is_signed) { return Z3_mk_bvneg_no_overflow(ctx, t1); } @@ -558,15 +558,15 @@ Z3_ast Z3_API Z3_mk_bvneg_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2) { return Z3_mk_bvneg(ctx, t1); } -Z3_ast Z3_API Z3_mk_bvadd_no_underflow_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2, Z3_bool is_signed) { +Z3_ast Z3_API Z3_mk_bvadd_no_underflow_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2, bool is_signed) { return Z3_mk_bvadd_no_underflow(ctx, t1, t2); } -Z3_ast Z3_API Z3_mk_bvsub_no_overflow_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2, Z3_bool is_signed) { +Z3_ast Z3_API Z3_mk_bvsub_no_overflow_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2, bool is_signed) { return Z3_mk_bvsub_no_overflow(ctx, t1, t2); } -Z3_ast Z3_API Z3_mk_bvmul_no_underflow_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2, Z3_bool is_signed) { +Z3_ast Z3_API Z3_mk_bvmul_no_underflow_wrapper(Z3_context ctx, Z3_ast t1, Z3_ast t2, bool is_signed) { return Z3_mk_bvmul_no_underflow(ctx, t1, t2); } @@ -662,7 +662,7 @@ void test_equiv(Equivalence_params params, unsigned bvsize, bool is_signed) { // Z3_solver_assert(ctx, s, Z3_mk_eq(ctx, t2, Z3_mk_numeral(ctx, "1", bv))); // //TEST_NO_UNDERFLOW; // Z3_solver_assert(ctx, s, test_udfl); -// ENSURE(Z3_check(ctx) == Z3_TRUE); +// ENSURE(Z3_check(ctx) == true); // Z3_solver_pop(ctx, s, 1); // // Z3_del_config(cfg); diff --git a/src/test/pb2bv.cpp b/src/test/pb2bv.cpp index 493d81bb7..623f7c9f1 100644 --- a/src/test/pb2bv.cpp +++ b/src/test/pb2bv.cpp @@ -18,6 +18,7 @@ Copyright (c) 2015 Microsoft Corporation #include "ast/rewriter/th_rewriter.h" #include "tactic/fd_solver/fd_solver.h" #include "solver/solver.h" +#include "ast/arith_decl_plugin.h" static void test1() { ast_manager m; @@ -194,9 +195,20 @@ static void test3() { } } +static void test4() { + ast_manager m; + reg_decl_plugins(m); + arith_util arith(m); + expr_ref a(m.mk_const(symbol("a"), arith.mk_int()), m); + expr_ref b(m.mk_const(symbol("b"), arith.mk_int()), m); + expr_ref eq(m.mk_eq(a,b), m); + std::cout << "is_atom: " << is_atom(m, eq) << "\n"; +} + void tst_pb2bv() { test1(); test2(); test3(); + test4(); } diff --git a/src/test/polynorm.cpp b/src/test/polynorm.cpp index ef01bd27d..58481938b 100644 --- a/src/test/polynorm.cpp +++ b/src/test/polynorm.cpp @@ -25,8 +25,7 @@ static expr_ref parse_fml(ast_manager& m, char const* str) { << "(assert " << str << ")\n"; std::istringstream is(buffer.str()); VERIFY(parse_smt2_commands(ctx, is)); - ENSURE(ctx.begin_assertions() != ctx.end_assertions()); - result = *ctx.begin_assertions(); + result = ctx.assertions().get(0); return result; } diff --git a/src/test/qe_arith.cpp b/src/test/qe_arith.cpp index 031912c46..2b1b9686c 100644 --- a/src/test/qe_arith.cpp +++ b/src/test/qe_arith.cpp @@ -37,8 +37,7 @@ static expr_ref parse_fml(ast_manager& m, char const* str) { << "(assert " << str << ")\n"; std::istringstream is(buffer.str()); VERIFY(parse_smt2_commands(ctx, is)); - ENSURE(ctx.begin_assertions() != ctx.end_assertions()); - result = *ctx.begin_assertions(); + result = ctx.assertions().get(0); return result; } diff --git a/src/test/quant_solve.cpp b/src/test/quant_solve.cpp index 04a75c42e..d0c616166 100644 --- a/src/test/quant_solve.cpp +++ b/src/test/quant_solve.cpp @@ -131,8 +131,7 @@ static expr_ref parse_fml(ast_manager& m, char const* str) { << "(assert " << str << ")\n"; std::istringstream is(buffer.str()); VERIFY(parse_smt2_commands(ctx, is)); - ENSURE(ctx.begin_assertions() != ctx.end_assertions()); - result = *ctx.begin_assertions(); + result = ctx.assertions().get(0); return result; } diff --git a/src/test/sat_local_search.cpp b/src/test/sat_local_search.cpp index 1116c5420..ad982d024 100644 --- a/src/test/sat_local_search.cpp +++ b/src/test/sat_local_search.cpp @@ -7,7 +7,7 @@ static bool build_instance(char const * filename, sat::solver& s, sat::local_search& local_search) { char line[16383]; - // for temperally storage + // for temporary storage std::ifstream infile(filename); //if (infile == NULL) //linux @@ -28,7 +28,7 @@ static bool build_instance(char const * filename, sat::solver& s, sat::local_sea sat::literal_vector lits; // process objective function: - // read coefficents + // read coefficients infile >> cur_term; while (cur_term != 0) { coefficients.push_back(cur_term); @@ -43,7 +43,7 @@ static bool build_instance(char const * filename, sat::solver& s, sat::local_sea } if (lits.size() != coefficients.size()) { - std::cout << "Objective function format error. They have different lenghts.\n"; + std::cout << "Objective function format error. They have different lengths.\n"; return false; } diff --git a/src/test/sat_lookahead.cpp b/src/test/sat_lookahead.cpp index fccbe8eed..23c4a4738 100644 --- a/src/test/sat_lookahead.cpp +++ b/src/test/sat_lookahead.cpp @@ -34,7 +34,8 @@ void tst_sat_lookahead(char ** argv, int argc, int& i) { std::cerr << "(error \"failed to open file '" << file_name << "'\")" << std::endl; exit(ERR_OPEN_FILE); } - parse_dimacs(in, solver); + if (!parse_dimacs(in, std::cerr, solver)) + return; } sat::lookahead lh(solver); diff --git a/src/test/smt2print_parse.cpp b/src/test/smt2print_parse.cpp index 99ffb726c..81b7ba1e9 100644 --- a/src/test/smt2print_parse.cpp +++ b/src/test/smt2print_parse.cpp @@ -19,7 +19,7 @@ void test_print(Z3_context ctx, Z3_ast_vector av) { Z3_ast a = Z3_mk_and(ctx, Z3_ast_vector_size(ctx, av), args); Z3_inc_ref(ctx, a); delete[] args; - char const* spec1 = Z3_benchmark_to_smtlib_string(ctx, "test", 0, 0, 0, 0, 0, a); + char const* spec1 = Z3_benchmark_to_smtlib_string(ctx, "test", nullptr, nullptr, nullptr, 0, nullptr, a); Z3_dec_ref(ctx, a); std::cout << "spec1: benchmark->string\n" << spec1 << "\n"; diff --git a/src/test/theory_pb.cpp b/src/test/theory_pb.cpp index 7010b96d0..f0604df73 100644 --- a/src/test/theory_pb.cpp +++ b/src/test/theory_pb.cpp @@ -11,7 +11,7 @@ Copyright (c) 2015 Microsoft Corporation #include "smt/theory_pb.h" #include "ast/rewriter/th_rewriter.h" -unsigned populate_literals(unsigned k, smt::literal_vector& lits) { +static unsigned populate_literals(unsigned k, smt::literal_vector& lits) { ENSURE(k < (1u << lits.size())); unsigned t = 0; for (unsigned i = 0; i < lits.size(); ++i) { @@ -84,6 +84,7 @@ private: } std::cout << "(assert " << fml << ")\n"; ctx.assert_expr(fml); + std::cout << ";asserted\n"; } @@ -138,11 +139,8 @@ void tst_theory_pb() { unsigned k = populate_literals(i, lits); std::cout << "k:" << k << " " << N << "\n"; std::cout.flush(); - TRACE("pb", tout << "k " << k << ": "; - for (unsigned j = 0; j < lits.size(); ++j) { - tout << lits[j] << " "; - } - tout << "\n";); + TRACE("pb", tout << "k " << k << ": " << lits << "\n";); + { smt::context ctx(m, params); ctx.push(); diff --git a/src/test/upolynomial.cpp b/src/test/upolynomial.cpp index fa106fe3f..f8500dfa9 100644 --- a/src/test/upolynomial.cpp +++ b/src/test/upolynomial.cpp @@ -891,6 +891,7 @@ static void tst_fact(polynomial_ref const & p, unsigned num_distinct_factors, up for (unsigned i = 0; i < fs.distinct_factors(); i++) { std::cout << "*("; um.display(std::cout, fs[i]); std::cout << ")^" << fs.get_degree(i) << std::endl; } + std::cout << fs.distinct_factors() << " " << num_distinct_factors << "\n"; ENSURE(fs.distinct_factors() == num_distinct_factors); upolynomial::scoped_numeral_vector _r(um); fs.multiply(_r); @@ -906,10 +907,10 @@ static void tst_fact() { x0 = m.mk_polynomial(m.mk_var()); tst_fact((x0^4) + (x0^2) - 20, 3); tst_fact((x0^4) + (x0^2) - 20, 1, upolynomial::factor_params(5, 1, 1000)); - tst_fact((x0^4) + (x0^2) - 20, 3, upolynomial::factor_params(7, 1, 1000)); + tst_fact((x0^4) + (x0^2) - 20, 1, upolynomial::factor_params(7, 1, 1000)); tst_fact((x0^70) - 6*(x0^65) - (x0^60) + 60*(x0^55) - 54*(x0^50) - 230*(x0^45) + 274*(x0^40) + 542*(x0^35) - 615*(x0^30) - 1120*(x0^25) + 1500*(x0^20) - 160*(x0^15) - 395*(x0^10) + 76*(x0^5) + 34, 1, upolynomial::factor_params(3, 1, 20)); - tst_fact((x0^70) - 6*(x0^65) - (x0^60) + 60*(x0^55) - 54*(x0^50) - 230*(x0^45) + 274*(x0^40) + 542*(x0^35) - 615*(x0^30) - 1120*(x0^25) + 1500*(x0^20) - 160*(x0^15) - 395*(x0^10) + 76*(x0^5) + 34, 2, upolynomial::factor_params(3, 1, 72)); - tst_fact((x0^70) - 6*(x0^65) - (x0^60) + 60*(x0^55) - 54*(x0^50) - 230*(x0^45) + 274*(x0^40) + 542*(x0^35) - 615*(x0^30) - 1120*(x0^25) + 1500*(x0^20) - 160*(x0^15) - 395*(x0^10) + 76*(x0^5) + 34, 3, upolynomial::factor_params(3, 1, 80)); + tst_fact((x0^70) - 6*(x0^65) - (x0^60) + 60*(x0^55) - 54*(x0^50) - 230*(x0^45) + 274*(x0^40) + 542*(x0^35) - 615*(x0^30) - 1120*(x0^25) + 1500*(x0^20) - 160*(x0^15) - 395*(x0^10) + 76*(x0^5) + 34, 1, upolynomial::factor_params(3, 1, 72)); + tst_fact((x0^70) - 6*(x0^65) - (x0^60) + 60*(x0^55) - 54*(x0^50) - 230*(x0^45) + 274*(x0^40) + 542*(x0^35) - 615*(x0^30) - 1120*(x0^25) + 1500*(x0^20) - 160*(x0^15) - 395*(x0^10) + 76*(x0^5) + 34, 1, upolynomial::factor_params(3, 1, 80)); tst_fact( (x0^10) - 10*(x0^8) + 38*(x0^6) - 2*(x0^5) - 100*(x0^4) - 40*(x0^3) + 121*(x0^2) - 38*x0 - 17, 1); tst_fact( (x0^4) - 404*(x0^2) + 39204, 2); tst_fact(((x0^5) - (x0^2) + 1)*((-1)*x0 + 1)*((x0^2) - 2*x0 + 3), 3); diff --git a/src/test/vector.cpp b/src/test/vector.cpp index 4632a9c29..c9a93dee4 100644 --- a/src/test/vector.cpp +++ b/src/test/vector.cpp @@ -41,7 +41,7 @@ static void tst1() { v1.pop_back(); } ENSURE(v1.empty()); - ENSURE(v1.size() == 0); + ENSURE(v1.empty()); unsigned i = 1000000000; while (true) { std::cout << "resize " << i << "\n"; diff --git a/src/util/CMakeLists.txt b/src/util/CMakeLists.txt index 85b6f955c..b6abb785f 100644 --- a/src/util/CMakeLists.txt +++ b/src/util/CMakeLists.txt @@ -1,11 +1,12 @@ -if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/version.h") - message(FATAL_ERROR "\"${CMAKE_CURRENT_SOURCE_DIR}/version.h\"" +if (EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/z3_version.h") + message(FATAL_ERROR "\"${CMAKE_CURRENT_SOURCE_DIR}/z3_version.h\"" ${z3_polluted_tree_msg} ) endif() set(Z3_FULL_VERSION "\"${Z3_FULL_VERSION_STR}\"") -configure_file(version.h.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/version.h) +configure_file(z3_version.h.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/z3_version.h) + z3_add_component(util SOURCES diff --git a/src/util/array.h b/src/util/array.h index cf82e123c..9f0321777 100644 --- a/src/util/array.h +++ b/src/util/array.h @@ -154,7 +154,7 @@ public: return static_cast(reinterpret_cast(m_data)[SIZE_IDX]); } - bool empty() const { return m_data == 0; } + bool empty() const { return m_data == nullptr; } T & operator[](unsigned idx) { SASSERT(idx < size()); diff --git a/src/util/bit_util.cpp b/src/util/bit_util.cpp index a38f42fdd..fdca2dc83 100644 --- a/src/util/bit_util.cpp +++ b/src/util/bit_util.cpp @@ -126,7 +126,7 @@ unsigned ntz(unsigned sz, unsigned const * data) { /** \brief dst <- src - Trucate if src_sz > dst_sz. + Truncate if src_sz > dst_sz. Fill range [src_sz, dst_sz) of dst with zeros if dst_sz > src_sz. */ void copy(unsigned src_sz, unsigned const * src, diff --git a/src/util/bit_util.h b/src/util/bit_util.h index 5729e8eed..7a0923400 100644 --- a/src/util/bit_util.h +++ b/src/util/bit_util.h @@ -48,7 +48,7 @@ unsigned ntz(unsigned sz, unsigned const * data); /** \brief dst <- src - Trucate if src_sz > dst_sz. + Truncate if src_sz > dst_sz. Fill range [src_sz, dst_sz) of dst with zeros if dst_sz > src_sz. */ void copy(unsigned src_sz, unsigned const * src, unsigned dst_sz, unsigned * dst); @@ -87,7 +87,7 @@ void shr(unsigned sz, unsigned const * src, unsigned k, unsigned * dst); \brief dst <- src >> k Store in dst the result of shifting src k bits to the right. - Trucate if src_sz > dst_sz. + Truncate if src_sz > dst_sz. Fill range [src_sz, dst_sz) of dst with zeros if dst_sz > src_sz. \pre src_sz != 0 diff --git a/src/util/chashtable.h b/src/util/chashtable.h index 9bc5988e5..e49ac3bd4 100644 --- a/src/util/chashtable.h +++ b/src/util/chashtable.h @@ -31,6 +31,7 @@ Revision History: #include "util/memory_manager.h" #include "util/debug.h" #include "util/trace.h" +#include "util/tptr.h" #ifdef Z3DEBUG #include "util/hashtable.h" #endif @@ -54,8 +55,9 @@ protected: cell * m_next; T m_data; cell():m_next(reinterpret_cast(1)) {} - bool is_free() const { return m_next == reinterpret_cast(1); } - void mark_free() { m_next = reinterpret_cast(1); } + bool is_free() const { return GET_TAG(m_next) == 1; } + void mark_free() { m_next = TAG(cell*, m_next, 1); } + void unmark_free() { m_next = UNTAG(cell*, m_next); } }; cell * m_table; // array of cells. @@ -70,6 +72,7 @@ protected: #endif cell * m_next_cell; cell * m_free_cell; + cell * m_tofree_cell; unsigned get_hash(T const & d) const { return HashProc::operator()(d); } bool equals(T const & e1, T const & e2) const { return EqProc::operator()(e1, e2); } @@ -171,6 +174,7 @@ protected: m_slots = new_slots; m_next_cell = next_cell; m_free_cell = nullptr; + m_tofree_cell = nullptr; CASSERT("chashtable", check_invariant()); return; } @@ -204,6 +208,12 @@ protected: m_free_cell = c; } + void push_recycle_cell(cell* c) { + SASSERT(c < m_table + m_capacity); + c->m_next = m_tofree_cell; + m_tofree_cell = c; + } + void init(unsigned slots, unsigned cellar) { m_capacity = slots + cellar; m_table = alloc_table(m_capacity); @@ -212,6 +222,7 @@ protected: m_size = 0; m_next_cell = m_table + slots; m_free_cell = nullptr; + m_tofree_cell = nullptr; } public: diff --git a/src/util/debug.cpp b/src/util/debug.cpp index 4434cb19f..3e40e412c 100644 --- a/src/util/debug.cpp +++ b/src/util/debug.cpp @@ -69,7 +69,7 @@ bool is_debug_enabled(const char * tag) { return g_enabled_debug_tags->contains(const_cast(tag)); } -#ifndef _WINDOWS +#if !defined(_WINDOWS) && !defined(NO_Z3_DEBUGGER) void invoke_gdb() { char buffer[1024]; int * x = nullptr; diff --git a/src/util/gparams.cpp b/src/util/gparams.cpp index 4ba3b3b5c..9ab3123a2 100644 --- a/src/util/gparams.cpp +++ b/src/util/gparams.cpp @@ -520,7 +520,7 @@ public: try { symbol m, p; normalize(name, m, p); - std::cout << name << " " << m << " " << p << "\n"; + out << name << " " << m << " " << p << "\n"; param_descrs * d; if (m == symbol::null) { d = &get_param_descrs(); diff --git a/src/util/hwf.cpp b/src/util/hwf.cpp index b8f481329..4a7a0b7e4 100644 --- a/src/util/hwf.cpp +++ b/src/util/hwf.cpp @@ -45,7 +45,7 @@ Revision History: // For SSE2, it is best to use compiler intrinsics because this makes it completely // clear to the compiler what instructions should be used. E.g., for sqrt(), the Windows compiler selects // the x87 FPU, even when /arch:SSE2 is on. -// Luckily, these are kind of standardized, at least for Windows/Linux/OSX. +// Luckily, these are kind of standardized, at least for Windows/Linux/macOS. #ifdef __clang__ #undef USE_INTRINSICS #endif @@ -61,7 +61,7 @@ hwf_manager::hwf_manager() : m_mpz_manager(m_mpq_manager) { #ifdef _WINDOWS -#if defined(_AMD64_) || defined(_M_IA64) +#if defined(_WIN64) // Precision control is not supported on x64. // See: http://msdn.microsoft.com/en-us/library/e9b52ceh(VS.110).aspx // CMW: I think this is okay though, the compiler will chose the right instructions @@ -75,14 +75,14 @@ hwf_manager::hwf_manager() : #endif #endif #else - // OSX/Linux: Nothing. + // macOS/Linux: Nothing. #endif // We only set the precision of the FPU here in the constructor. At the moment, there are no // other parts of the code that could overwrite this, and Windows takes care of context switches. // CMW: I'm not sure what happens on CPUs with hyper-threading (since the FPU is shared). - // I have yet to discover whether Linux and OSX save the FPU state when switching context. + // I have yet to discover whether Linux and macOS save the FPU state when switching context. // As long as we stick to using the SSE2 FPU though, there shouldn't be any problems with respect // to the precision (not sure about the rounding modes though). } @@ -279,7 +279,7 @@ void hwf_manager::fma(mpf_rounding_mode rm, hwf const & x, hwf const & y, hwf co #endif #endif #else - // Linux, OSX + // Linux, macOS o.value = ::fma(x.value, y.value, z.value); #endif #endif @@ -303,7 +303,7 @@ void hwf_manager::round_to_integral(mpf_rounding_mode rm, hwf const & x, hwf & o // CMW: modf is not the right function here. // modf(x.value, &o.value); - // According to the Intel Architecture manual, the x87-instrunction FRNDINT is the + // According to the Intel Architecture manual, the x87-instruction FRNDINT is the // same in 32-bit and 64-bit mode. The _mm_round_* intrinsics are SSE4 extensions. #ifdef _WINDOWS #if defined(USE_INTRINSICS) && \ @@ -331,7 +331,7 @@ void hwf_manager::round_to_integral(mpf_rounding_mode rm, hwf const & x, hwf & o } #endif #else - // Linux, OSX. + // Linux, macOS. o.value = nearbyint(x.value); #endif } @@ -557,7 +557,7 @@ void hwf_manager::mk_ninf(hwf & o) { } #ifdef _WINDOWS -#if defined(_AMD64_) || defined(_M_IA64) +#if defined(_WIN64) #ifdef USE_INTRINSICS #define SETRM(RM) _MM_SET_ROUNDING_MODE(RM) #else @@ -623,7 +623,7 @@ void hwf_manager::set_rounding_mode(mpf_rounding_mode rm) UNREACHABLE(); // Note: MPF_ROUND_NEAREST_TAWAY is not supported by the hardware! } #endif -#else // OSX/Linux +#else // macOS/Linux switch (rm) { case MPF_ROUND_NEAREST_TEVEN: SETRM(FE_TONEAREST); diff --git a/src/util/list.h b/src/util/list.h index 075d5a0e1..82ca73308 100644 --- a/src/util/list.h +++ b/src/util/list.h @@ -68,7 +68,7 @@ unsigned length(list * l) { } /** - \brief Non destructive apppend operation. The new nodes are allocated + \brief Non destructive append operation. The new nodes are allocated using the given region allocator. */ template diff --git a/src/util/lp/CMakeLists.txt b/src/util/lp/CMakeLists.txt index bde6ed93a..edb73fdab 100644 --- a/src/util/lp/CMakeLists.txt +++ b/src/util/lp/CMakeLists.txt @@ -2,10 +2,11 @@ z3_add_component(lp SOURCES binary_heap_priority_queue.cpp binary_heap_upair_queue.cpp - bound_propagator.cpp + lp_bound_propagator.cpp core_solver_pretty_printer.cpp dense_matrix.cpp eta_matrix.cpp + gomory.cpp indexed_vector.cpp int_solver.cpp lar_solver.cpp diff --git a/src/util/lp/binary_heap_priority_queue_def.h b/src/util/lp/binary_heap_priority_queue_def.h index 232959c83..d0a08c27d 100644 --- a/src/util/lp/binary_heap_priority_queue_def.h +++ b/src/util/lp/binary_heap_priority_queue_def.h @@ -76,7 +76,7 @@ template void binary_heap_priority_queue::remove(unsigned o) { put_at(o_in_heap, m_heap[m_heap_size--]); if (m_priorities[m_heap[o_in_heap]] > priority_of_o) { fix_heap_under(o_in_heap); - } else { // we need to propogate the m_heap[o_in_heap] up + } else { // we need to propagate the m_heap[o_in_heap] up unsigned i = o_in_heap; while (i > 1) { unsigned ip = i >> 1; diff --git a/src/util/lp/bound_analyzer_on_row.h b/src/util/lp/bound_analyzer_on_row.h index 549c8e5ce..a20b4850a 100644 --- a/src/util/lp/bound_analyzer_on_row.h +++ b/src/util/lp/bound_analyzer_on_row.h @@ -270,7 +270,7 @@ public : } } - // // it is the coefficent before the bounded column + // // it is the coefficient before the bounded column // void provide_evidence(bool coeff_is_pos) { // /* // auto & be = m_ibounds.back(); diff --git a/src/util/lp/column_info.h b/src/util/lp/column_info.h index 407f40dfc..2a38900c1 100644 --- a/src/util/lp/column_info.h +++ b/src/util/lp/column_info.h @@ -69,16 +69,6 @@ public: m_column_index(static_cast(-1)) {} - column_info(unsigned column_index) : - m_lower_bound_is_set(false), - m_lower_bound_is_strict(false), - m_upper_bound_is_set (false), - m_upper_bound_is_strict (false), - m_is_fixed(false), - m_cost(numeric_traits::zero()), - m_column_index(column_index) { - } - column_info(const column_info & ci) { m_name = ci.m_name; m_lower_bound_is_set = ci.m_lower_bound_is_set; diff --git a/src/util/lp/column_namer.h b/src/util/lp/column_namer.h index e6e8e53a2..51baf445f 100644 --- a/src/util/lp/column_namer.h +++ b/src/util/lp/column_namer.h @@ -33,29 +33,6 @@ public: print_linear_combination_of_column_indices(coeff, out); } - template - void print_linear_combination_of_column_indices_only(const vector> & coeffs, std::ostream & out) const { - bool first = true; - for (const auto & it : coeffs) { - auto val = it.first; - if (first) { - first = false; - } else { - if (numeric_traits::is_pos(val)) { - out << " + "; - } else { - out << " - "; - val = -val; - } - } - if (val == -numeric_traits::one()) - out << " - "; - else if (val != numeric_traits::one()) - out << T_to_string(val); - - out << "v" << it.second; - } - } template diff --git a/src/util/lp/core_solver_pretty_printer_def.h b/src/util/lp/core_solver_pretty_printer_def.h index dcf3e0a11..5453c6085 100644 --- a/src/util/lp/core_solver_pretty_printer_def.h +++ b/src/util/lp/core_solver_pretty_printer_def.h @@ -183,7 +183,7 @@ template unsigned core_solver_pretty_printer:: ge } if (!m_core_solver.use_tableau()) { w = std::max(w, (unsigned)T_to_string(m_exact_column_norms[column]).size()); - if (m_core_solver.m_column_norms.size() > 0) + if (!m_core_solver.m_column_norms.empty()) w = std::max(w, (unsigned)T_to_string(m_core_solver.m_column_norms[column]).size()); } return w; @@ -339,7 +339,7 @@ template void core_solver_pretty_printer::print() print_lows(); print_upps(); print_exact_norms(); - if (m_core_solver.m_column_norms.size() > 0) + if (!m_core_solver.m_column_norms.empty()) print_approx_norms(); m_out << std::endl; } diff --git a/src/util/lp/eta_matrix_def.h b/src/util/lp/eta_matrix_def.h index 5c7661e24..774cc89dc 100644 --- a/src/util/lp/eta_matrix_def.h +++ b/src/util/lp/eta_matrix_def.h @@ -81,7 +81,7 @@ void eta_matrix::apply_from_right(vector & w) { } template void eta_matrix::apply_from_right(indexed_vector & w) { - if (w.m_index.size() == 0) + if (w.m_index.empty()) return; #ifdef Z3DEBUG // vector wcopy(w.m_data); diff --git a/src/util/lp/general_matrix.h b/src/util/lp/general_matrix.h index 1c643161a..f6f93c705 100644 --- a/src/util/lp/general_matrix.h +++ b/src/util/lp/general_matrix.h @@ -51,7 +51,7 @@ public: unsigned row_count() const { return m_data.size(); } - unsigned column_count() const { return m_data.size() > 0? m_data[0].size() : 0; } + unsigned column_count() const { return !m_data.empty()? m_data[0].size() : 0; } class ref_row { general_matrix& m_matrix; diff --git a/src/util/lp/gomory.cpp b/src/util/lp/gomory.cpp new file mode 100644 index 000000000..ad1c02625 --- /dev/null +++ b/src/util/lp/gomory.cpp @@ -0,0 +1,341 @@ +/*++ + Copyright (c) 2017 Microsoft Corporation + + Module Name: + + + + Abstract: + + + + Author: + Nikolaj Bjorner (nbjorner) + Lev Nachmanson (levnach) + + Revision History: + + + --*/ +#include "util/lp/gomory.h" +#include "util/lp/int_solver.h" +#include "util/lp/lar_solver.h" +#include "util/lp/lp_utils.h" +namespace lp { + +class gomory::imp { + lar_term & m_t; // the term to return in the cut + mpq & m_k; // the right side of the cut + explanation& m_ex; // the conflict explanation + unsigned m_inf_col; // a basis column which has to be an integer but has a non integral value + const row_strip& m_row; + const int_solver& m_int_solver; + mpq m_lcm_den; + mpq m_f; + mpq m_one_minus_f; + mpq m_fj; + mpq m_one_minus_fj; + + const impq & get_value(unsigned j) const { return m_int_solver.get_value(j); } + bool is_real(unsigned j) const { return m_int_solver.is_real(j); } + bool at_lower(unsigned j) const { return m_int_solver.at_lower(j); } + bool at_upper(unsigned j) const { return m_int_solver.at_upper(j); } + const impq & lower_bound(unsigned j) const { return m_int_solver.lower_bound(j); } + const impq & upper_bound(unsigned j) const { return m_int_solver.upper_bound(j); } + constraint_index column_lower_bound_constraint(unsigned j) const { return m_int_solver.column_lower_bound_constraint(j); } + constraint_index column_upper_bound_constraint(unsigned j) const { return m_int_solver.column_upper_bound_constraint(j); } + bool column_is_fixed(unsigned j) const { return m_int_solver.m_lar_solver->column_is_fixed(j); } + + void int_case_in_gomory_cut(unsigned j) { + lp_assert(is_int(j) && m_fj.is_pos()); + TRACE("gomory_cut_detail", + tout << " k = " << m_k; + tout << ", fj: " << m_fj << ", "; + tout << (at_lower(j)?"at_lower":"at_upper")<< std::endl; + ); + mpq new_a; + if (at_lower(j)) { + new_a = m_fj <= m_one_minus_f ? m_fj / m_one_minus_f : ((1 - m_fj) / m_f); + lp_assert(new_a.is_pos()); + m_k.addmul(new_a, lower_bound(j).x); + m_ex.push_justification(column_lower_bound_constraint(j)); + } + else { + lp_assert(at_upper(j)); + // the upper terms are inverted: therefore we have the minus + new_a = - (m_fj <= m_f ? m_fj / m_f : ((1 - m_fj) / m_one_minus_f)); + lp_assert(new_a.is_neg()); + m_k.addmul(new_a, upper_bound(j).x); + m_ex.push_justification(column_upper_bound_constraint(j)); + } + m_t.add_monomial(new_a, j); + m_lcm_den = lcm(m_lcm_den, denominator(new_a)); + TRACE("gomory_cut_detail", tout << "v" << j << " new_a = " << new_a << ", k = " << m_k << ", m_lcm_den = " << m_lcm_den << "\n";); + } + + void real_case_in_gomory_cut(const mpq & a, unsigned j) { + TRACE("gomory_cut_detail_real", tout << "real\n";); + mpq new_a; + if (at_lower(j)) { + if (a.is_pos()) { + new_a = a / m_one_minus_f; + } + else { + new_a = - a / m_f; + } + m_k.addmul(new_a, lower_bound(j).x); // is it a faster operation than + // k += lower_bound(j).x * new_a; + m_ex.push_justification(column_lower_bound_constraint(j)); + } + else { + lp_assert(at_upper(j)); + if (a.is_pos()) { + new_a = - a / m_f; + } + else { + new_a = a / m_one_minus_f; + } + m_k.addmul(new_a, upper_bound(j).x); // k += upper_bound(j).x * new_a; + m_ex.push_justification(column_upper_bound_constraint(j)); + } + TRACE("gomory_cut_detail_real", tout << a << "*v" << j << " k: " << m_k << "\n";); + m_t.add_monomial(new_a, j); + } + + lia_move report_conflict_from_gomory_cut() { + lp_assert(m_k.is_pos()); + // conflict 0 >= k where k is positive + m_k.neg(); // returning 0 <= -k + return lia_move::conflict; + } + + void adjust_term_and_k_for_some_ints_case_gomory() { + lp_assert(!m_t.is_empty()); + // k = 1 + sum of m_t at bounds + auto pol = m_t.coeffs_as_vector(); + m_t.clear(); + if (pol.size() == 1) { + TRACE("gomory_cut_detail", tout << "pol.size() is 1" << std::endl;); + unsigned v = pol[0].second; + lp_assert(is_int(v)); + const mpq& a = pol[0].first; + m_k /= a; + if (a.is_pos()) { // we have av >= k + if (!m_k.is_int()) + m_k = ceil(m_k); + // switch size + m_t.add_monomial(- mpq(1), v); + m_k.neg(); + } else { + if (!m_k.is_int()) + m_k = floor(m_k); + m_t.add_monomial(mpq(1), v); + } + } else { + m_lcm_den = lcm(m_lcm_den, denominator(m_k)); + lp_assert(m_lcm_den.is_pos()); + TRACE("gomory_cut_detail", tout << "pol.size() > 1 den: " << m_lcm_den << std::endl;); + if (!m_lcm_den.is_one()) { + // normalize coefficients of integer parameters to be integers. + for (auto & pi: pol) { + pi.first *= m_lcm_den; + SASSERT(!is_int(pi.second) || pi.first.is_int()); + } + m_k *= m_lcm_den; + } + // negate everything to return -pol <= -m_k + for (const auto & pi: pol) { + TRACE("gomory_cut", tout << pi.first << "* " << "v" << pi.second << "\n";); + m_t.add_monomial(-pi.first, pi.second); + } + m_k.neg(); + } + TRACE("gomory_cut_detail", tout << "k = " << m_k << std::endl;); + lp_assert(m_k.is_int()); + } + + std::string var_name(unsigned j) const { + return std::string("x") + std::to_string(j); + } + + std::ostream& dump_coeff_val(std::ostream & out, const mpq & a) const { + if (a.is_int()) { + out << a; + } + else if ( a >= zero_of_type()) + out << "(/ " << numerator(a) << " " << denominator(a) << ")"; + else { + out << "(- ( / " << numerator(-a) << " " << denominator(-a) << "))"; + } + return out; + } + + template + void dump_coeff(std::ostream & out, const T& c) const { + out << "( * "; + dump_coeff_val(out, c.coeff()); + out << " " << var_name(c.var()) << ")"; + } + + std::ostream& dump_row_coefficients(std::ostream & out) const { + mpq lc(1); + for (const auto& p : m_row) { + lc = lcm(lc, denominator(p.coeff())); + } + for (const auto& p : m_row) { + dump_coeff_val(out << " (* ", p.coeff()*lc) << " " << var_name(p.var()) << ")"; + } + return out; + } + + void dump_the_row(std::ostream& out) const { + out << "; the row, excluding fixed vars\n"; + out << "(assert ( = ( +"; + dump_row_coefficients(out) << ") 0))\n"; + } + + void dump_declaration(std::ostream& out, unsigned v) const { + out << "(declare-const " << var_name(v) << (is_int(v) ? " Int" : " Real") << ")\n"; + } + + void dump_declarations(std::ostream& out) const { + // for a column j the var name is vj + for (const auto & p : m_row) { + dump_declaration(out, p.var()); + } + for (const auto& p : m_t) { + unsigned v = p.var(); + if (m_int_solver.m_lar_solver->is_term(v)) { + dump_declaration(out, v); + } + } + } + + void dump_lower_bound_expl(std::ostream & out, unsigned j) const { + out << "(assert (>= " << var_name(j) << " " << lower_bound(j).x << "))\n"; + } + void dump_upper_bound_expl(std::ostream & out, unsigned j) const { + out << "(assert (<= " << var_name(j) << " " << upper_bound(j).x << "))\n"; + } + + void dump_explanations(std::ostream& out) const { + for (const auto & p : m_row) { + unsigned j = p.var(); + if (j == m_inf_col || (!is_real(j) && p.coeff().is_int())) { + continue; + } + else if (at_lower(j)) { + dump_lower_bound_expl(out, j); + } else { + lp_assert(at_upper(j)); + dump_upper_bound_expl(out, j); + } + } + } + + std::ostream& dump_term_coefficients(std::ostream & out) const { + for (const auto& p : m_t) { + dump_coeff(out, p); + } + return out; + } + + std::ostream& dump_term_sum(std::ostream & out) const { + return dump_term_coefficients(out << "(+ ") << ")"; + } + + std::ostream& dump_term_le_k(std::ostream & out) const { + return dump_term_sum(out << "(<= ") << " " << m_k << ")"; + } + + void dump_the_cut_assert(std::ostream & out) const { + dump_term_le_k(out << "(assert (not ") << "))\n"; + } + + + void dump_cut_and_constraints_as_smt_lemma(std::ostream& out) const { + dump_declarations(out); + dump_the_row(out); + dump_explanations(out); + dump_the_cut_assert(out); + out << "(check-sat)\n"; + } +public: + lia_move create_cut() { + TRACE("gomory_cut", + tout << "applying cut at:\n"; print_linear_combination_of_column_indices_only(m_row, tout); tout << std::endl; + for (auto & p : m_row) { + m_int_solver.m_lar_solver->m_mpq_lar_core_solver.m_r_solver.print_column_info(p.var(), tout); + } + tout << "inf_col = " << m_inf_col << std::endl; + ); + + // gomory will be t <= k and the current solution has a property t > k + m_k = 1; + m_t.clear(); + mpq m_lcm_den(1); + bool some_int_columns = false; + mpq m_f = fractional_part(get_value(m_inf_col)); + TRACE("gomory_cut_detail", tout << "m_f: " << m_f << ", "; + tout << "1 - m_f: " << 1 - m_f << ", get_value(m_inf_col).x - m_f = " << get_value(m_inf_col).x - m_f;); + lp_assert(m_f.is_pos() && (get_value(m_inf_col).x - m_f).is_int()); + + mpq one_min_m_f = 1 - m_f; + for (const auto & p : m_row) { + unsigned j = p.var(); + if (j == m_inf_col) { + lp_assert(p.coeff() == one_of_type()); + TRACE("gomory_cut_detail", tout << "seeing basic var";); + continue; + } + + // use -p.coeff() to make the format compatible with the format used in: Integrating Simplex with DPLL(T) + if (is_real(j)) { + real_case_in_gomory_cut(- p.coeff(), j); + } else { + if (p.coeff().is_int()) { + // m_fj will be zero and no monomial will be added + continue; + } + some_int_columns = true; + m_fj = fractional_part(-p.coeff()); + m_one_minus_fj = 1 - m_fj; + int_case_in_gomory_cut(j); + } + } + + if (m_t.is_empty()) + return report_conflict_from_gomory_cut(); + if (some_int_columns) + adjust_term_and_k_for_some_ints_case_gomory(); + lp_assert(m_int_solver.current_solution_is_inf_on_cut()); + TRACE("gomory_cut_detail", dump_cut_and_constraints_as_smt_lemma(tout);); + m_int_solver.m_lar_solver->subs_term_columns(m_t); + TRACE("gomory_cut", print_linear_combination_of_column_indices_only(m_t, tout << "gomory cut:"); tout << " <= " << m_k << std::endl;); + return lia_move::cut; + } + + imp(lar_term & t, mpq & k, explanation& ex, unsigned basic_inf_int_j, const row_strip& row, const int_solver& int_slv ) : + m_t(t), + m_k(k), + m_ex(ex), + m_inf_col(basic_inf_int_j), + m_row(row), + m_int_solver(int_slv), + m_lcm_den(1), + m_f(fractional_part(get_value(basic_inf_int_j).x)), + m_one_minus_f(1 - m_f) {} + +}; + +lia_move gomory::create_cut() { + return m_imp->create_cut(); +} + +gomory::gomory(lar_term & t, mpq & k, explanation& ex, unsigned basic_inf_int_j, const row_strip& row, const int_solver& s) { + m_imp = alloc(imp, t, k, ex, basic_inf_int_j, row, s); +} + +gomory::~gomory() { dealloc(m_imp); } + +} diff --git a/src/util/lp/gomory.h b/src/util/lp/gomory.h new file mode 100644 index 000000000..acb5f04fd --- /dev/null +++ b/src/util/lp/gomory.h @@ -0,0 +1,34 @@ +/*++ +Copyright (c) 2017 Microsoft Corporation + +Module Name: + + + +Abstract: + + + +Author: + Nikolaj Bjorner (nbjorner) + Lev Nachmanson (levnach) + +Revision History: +--*/ +#pragma once +#include "util/lp/lar_term.h" +#include "util/lp/lia_move.h" +#include "util/lp/explanation.h" +#include "util/lp/static_matrix.h" + +namespace lp { +class int_solver; +class gomory { + class imp; + imp *m_imp; +public : + gomory(lar_term & t, mpq & k, explanation& ex, unsigned basic_inf_int_j, const row_strip& row, const int_solver& s); + lia_move create_cut(); + ~gomory(); +}; +} diff --git a/src/util/lp/int_solver.cpp b/src/util/lp/int_solver.cpp index a77c202a0..0967c6cc6 100644 --- a/src/util/lp/int_solver.cpp +++ b/src/util/lp/int_solver.cpp @@ -8,6 +8,7 @@ #include "util/lp/lp_utils.h" #include #include "util/lp/monomial.h" +#include "util/lp/gomory.h" namespace lp { @@ -101,10 +102,7 @@ bool int_solver::is_gomory_cut_target(const row_strip& row) { unsigned j; for (const auto & p : row) { j = p.var(); - if (is_base(j)) continue; - if (!at_bound(j)) - return false; - if (!is_zero(get_value(j).y)) { + if (!is_base(j) && (!at_bound(j) || !is_zero(get_value(j).y))) { TRACE("gomory_cut", tout << "row is not gomory cut target:\n"; display_column(tout, j); tout << "infinitesimal: " << !is_zero(get_value(j).y) << "\n";); @@ -115,36 +113,6 @@ bool int_solver::is_gomory_cut_target(const row_strip& row) { } -void int_solver::real_case_in_gomory_cut(const mpq & a, unsigned x_j, const mpq& f_0, const mpq& one_minus_f_0) { - TRACE("gomory_cut_detail_real", tout << "real\n";); - mpq new_a; - if (at_low(x_j)) { - if (a.is_pos()) { - new_a = a / one_minus_f_0; - } - else { - new_a = a / f_0; - new_a.neg(); - } - m_k->addmul(new_a, lower_bound(x_j).x); // is it a faster operation than - // k += lower_bound(x_j).x * new_a; - m_ex->push_justification(column_lower_bound_constraint(x_j), new_a); - } - else { - lp_assert(at_upper(x_j)); - if (a.is_pos()) { - new_a = a / f_0; - new_a.neg(); // the upper terms are inverted. - } - else { - new_a = a / one_minus_f_0; - } - m_k->addmul(new_a, upper_bound(x_j).x); // k += upper_bound(x_j).x * new_a; - m_ex->push_justification(column_upper_bound_constraint(x_j), new_a); - } - TRACE("gomory_cut_detail_real", tout << a << "*v" << x_j << " k: " << *m_k << "\n";); - m_t->add_monomial(new_a, x_j); -} constraint_index int_solver::column_upper_bound_constraint(unsigned j) const { return m_lar_solver->get_column_upper_bound_witness(j); @@ -155,221 +123,31 @@ constraint_index int_solver::column_lower_bound_constraint(unsigned j) const { } -void int_solver::int_case_in_gomory_cut(const mpq & a, unsigned x_j, - mpq & lcm_den, const mpq& f_0, const mpq& one_minus_f_0) { - lp_assert(is_int(x_j)); - lp_assert(!a.is_int()); - mpq f_j = fractional_part(a); - TRACE("gomory_cut_detail", - tout << a << " x_j" << x_j << " k = " << *m_k << "\n"; - tout << "f_j: " << f_j << "\n"; - tout << "f_0: " << f_0 << "\n"; - tout << "1 - f_0: " << 1 - f_0 << "\n"; - tout << "at_low(" << x_j << ") = " << at_low(x_j) << std::endl; - ); - lp_assert (!f_j.is_zero()); - mpq new_a; - if (at_low(x_j)) { - if (f_j <= one_minus_f_0) { - new_a = f_j / one_minus_f_0; - } - else { - new_a = (1 - f_j) / f_0; - } - m_k->addmul(new_a, lower_bound(x_j).x); - m_ex->push_justification(column_lower_bound_constraint(x_j), new_a); - } - else { - lp_assert(at_upper(x_j)); - if (f_j <= f_0) { - new_a = f_j / f_0; - } - else { - new_a = (mpq(1) - f_j) / one_minus_f_0; - } - new_a.neg(); // the upper terms are inverted - m_k->addmul(new_a, upper_bound(x_j).x); - m_ex->push_justification(column_upper_bound_constraint(x_j), new_a); - } - TRACE("gomory_cut_detail", tout << "new_a: " << new_a << " k: " << *m_k << "\n";); - m_t->add_monomial(new_a, x_j); - lcm_den = lcm(lcm_den, denominator(new_a)); -} - -lia_move int_solver::report_conflict_from_gomory_cut() { - TRACE("empty_pol",); - lp_assert(m_k->is_pos()); - // conflict 0 >= k where k is positive - m_k->neg(); // returning 0 <= -k - return lia_move::conflict; -} - -void int_solver::gomory_cut_adjust_t_and_k(vector> & pol, - lar_term & t, - mpq &k, - bool some_ints, - mpq & lcm_den) { - if (!some_ints) - return; - - t.clear(); - if (pol.size() == 1) { - unsigned v = pol[0].second; - lp_assert(is_int(v)); - bool k_is_int = k.is_int(); - const mpq& a = pol[0].first; - k /= a; - if (a.is_pos()) { // we have av >= k - if (!k_is_int) - k = ceil(k); - // switch size - t.add_monomial(- mpq(1), v); - k.neg(); - } else { - if (!k_is_int) - k = floor(k); - t.add_monomial(mpq(1), v); - } - } else if (some_ints) { - lcm_den = lcm(lcm_den, denominator(k)); - lp_assert(lcm_den.is_pos()); - if (!lcm_den.is_one()) { - // normalize coefficients of integer parameters to be integers. - for (auto & pi: pol) { - pi.first *= lcm_den; - SASSERT(!is_int(pi.second) || pi.first.is_int()); - } - k *= lcm_den; - } - // negate everything to return -pol <= -k - for (const auto & pi: pol) - t.add_monomial(-pi.first, pi.second); - k.neg(); - } -} - bool int_solver::current_solution_is_inf_on_cut() const { const auto & x = m_lar_solver->m_mpq_lar_core_solver.m_r_x; - impq v = m_t->apply(x); - mpq sign = *m_upper ? one_of_type() : -one_of_type(); - CTRACE("current_solution_is_inf_on_cut", v * sign <= (*m_k) * sign, - tout << "m_upper = " << *m_upper << std::endl; - tout << "v = " << v << ", k = " << (*m_k) << std::endl; + impq v = m_t.apply(x); + mpq sign = m_upper ? one_of_type() : -one_of_type(); + CTRACE("current_solution_is_inf_on_cut", v * sign <= m_k * sign, + tout << "m_upper = " << m_upper << std::endl; + tout << "v = " << v << ", k = " << m_k << std::endl; ); - return v * sign > (*m_k) * sign; + return v * sign > m_k * sign; } -void int_solver::adjust_term_and_k_for_some_ints_case_gomory(mpq &lcm_den) { - lp_assert(!m_t->is_empty()); - auto pol = m_t->coeffs_as_vector(); - m_t->clear(); - if (pol.size() == 1) { - TRACE("gomory_cut_detail", tout << "pol.size() is 1" << std::endl;); - unsigned v = pol[0].second; - lp_assert(is_int(v)); - const mpq& a = pol[0].first; - (*m_k) /= a; - if (a.is_pos()) { // we have av >= k - if (!(*m_k).is_int()) - (*m_k) = ceil((*m_k)); - // switch size - m_t->add_monomial(- mpq(1), v); - (*m_k).neg(); - } else { - if (!(*m_k).is_int()) - (*m_k) = floor((*m_k)); - m_t->add_monomial(mpq(1), v); - } - } else { - TRACE("gomory_cut_detail", tout << "pol.size() > 1" << std::endl;); - lcm_den = lcm(lcm_den, denominator((*m_k))); - lp_assert(lcm_den.is_pos()); - if (!lcm_den.is_one()) { - // normalize coefficients of integer parameters to be integers. - for (auto & pi: pol) { - pi.first *= lcm_den; - SASSERT(!is_int(pi.second) || pi.first.is_int()); - } - (*m_k) *= lcm_den; - } - // negate everything to return -pol <= -(*m_k) - for (const auto & pi: pol) - m_t->add_monomial(-pi.first, pi.second); - (*m_k).neg(); - } - TRACE("gomory_cut_detail", tout << "k = " << (*m_k) << std::endl;); - lp_assert((*m_k).is_int()); -} - - - - lia_move int_solver::mk_gomory_cut( unsigned inf_col, const row_strip & row) { - lp_assert(column_is_int_inf(inf_col)); - TRACE("gomory_cut", - tout << "applying cut at:\n"; m_lar_solver->print_row(row, tout); tout << std::endl; - for (auto & p : row) { - m_lar_solver->m_mpq_lar_core_solver.m_r_solver.print_column_info(p.var(), tout); - } - tout << "inf_col = " << inf_col << std::endl; - ); - - // gomory will be t <= k and the current solution has a property t > k - *m_k = 1; - mpq lcm_den(1); - unsigned x_j; - mpq a; - bool some_int_columns = false; - mpq f_0 = int_solver::fractional_part(get_value(inf_col)); - mpq one_min_f_0 = 1 - f_0; - for (const auto & p : row) { - x_j = p.var(); - if (x_j == inf_col) - continue; - // make the format compatible with the format used in: Integrating Simplex with DPLL(T) - a = p.coeff(); - a.neg(); - if (is_real(x_j)) - real_case_in_gomory_cut(a, x_j, f_0, one_min_f_0); - else if (!a.is_int()) { // f_j will be zero and no monomial will be added - some_int_columns = true; - int_case_in_gomory_cut(a, x_j, lcm_den, f_0, one_min_f_0); - } - } - - if (m_t->is_empty()) - return report_conflict_from_gomory_cut(); - if (some_int_columns) - adjust_term_and_k_for_some_ints_case_gomory(lcm_den); - - lp_assert(current_solution_is_inf_on_cut()); - m_lar_solver->subs_term_columns(*m_t); - TRACE("gomory_cut", tout<<"precut:"; m_lar_solver->print_term(*m_t, tout); tout << " <= " << *m_k << std::endl;); - return lia_move::cut; -} - -int int_solver::find_free_var_in_gomory_row(const row_strip& row) { - unsigned j; - for (const auto & p : row) { - j = p.var(); - if (!is_base(j) && is_free(j)) - return static_cast(j); - } - return -1; + gomory gc(m_t, m_k, m_ex, inf_col, row, *this); + return gc.create_cut(); } lia_move int_solver::proceed_with_gomory_cut(unsigned j) { const row_strip& row = m_lar_solver->get_row(row_of_basic_column(j)); - if (-1 != find_free_var_in_gomory_row(row)) - return lia_move::undef; - if (!is_gomory_cut_target(row)) - return lia_move::undef; + return create_branch_on_column(j); - *m_upper = true; + m_upper = true; return mk_gomory_cut(j, row); } @@ -394,17 +172,19 @@ typedef monomial mono; // this will allow to enable and disable tracking of the pivot rows -struct pivoted_rows_tracking_control { - lar_solver * m_lar_solver; - bool m_track_pivoted_rows; - pivoted_rows_tracking_control(lar_solver* ls) : +struct check_return_helper { + lar_solver * m_lar_solver; + const lia_move & m_r; + bool m_track_pivoted_rows; + check_return_helper(lar_solver* ls, const lia_move& r) : m_lar_solver(ls), + m_r(r), m_track_pivoted_rows(ls->get_track_pivoted_rows()) { TRACE("pivoted_rows", tout << "pivoted rows = " << ls->m_mpq_lar_core_solver.m_r_solver.m_pivoted_rows->size() << std::endl;); m_lar_solver->set_track_pivoted_rows(false); } - ~pivoted_rows_tracking_control() { + ~check_return_helper() { TRACE("pivoted_rows", tout << "pivoted rows = " << m_lar_solver->m_mpq_lar_core_solver.m_r_solver.m_pivoted_rows->size() << std::endl;); m_lar_solver->set_track_pivoted_rows(m_track_pivoted_rows); } @@ -589,21 +369,21 @@ lia_move int_solver::make_hnf_cut() { #else vector x0; #endif - lia_move r = m_hnf_cutter.create_cut(*m_t, *m_k, *m_ex, *m_upper, x0); + lia_move r = m_hnf_cutter.create_cut(m_t, m_k, m_ex, m_upper, x0); if (r == lia_move::cut) { TRACE("hnf_cut", - m_lar_solver->print_term(*m_t, tout << "cut:"); - tout << " <= " << *m_k << std::endl; + m_lar_solver->print_term(m_t, tout << "cut:"); + tout << " <= " << m_k << std::endl; for (unsigned i : m_hnf_cutter.constraints_for_explanation()) { m_lar_solver->print_constraint(i, tout); } ); lp_assert(current_solution_is_inf_on_cut()); settings().st().m_hnf_cuts++; - m_ex->clear(); + m_ex.clear(); for (unsigned i : m_hnf_cutter.constraints_for_explanation()) { - m_ex->push_justification(i); + m_ex.push_justification(i); } } return r; @@ -619,14 +399,17 @@ lia_move int_solver::hnf_cut() { return lia_move::undef; } -lia_move int_solver::check(lar_term& t, mpq& k, explanation& ex, bool & upper) { +lia_move int_solver::check() { if (!has_inf_int()) return lia_move::sat; - m_t = &t; m_k = &k; m_ex = &ex; m_upper = &upper; + m_t.clear(); + m_k.reset(); + m_ex.clear(); + m_upper = false; lia_move r = run_gcd_test(); if (r != lia_move::undef) return r; - pivoted_rows_tracking_control pc(m_lar_solver); + check_return_helper pc(m_lar_solver, r); if(settings().m_int_pivot_fixed_vars_from_basis) m_lar_solver->pivot_fixed_vars_from_basis(); @@ -862,8 +645,8 @@ bool int_solver::gcd_test_for_row(static_matrix> & A, uns void int_solver::add_to_explanation_from_fixed_or_boxed_column(unsigned j) { constraint_index lc, uc; m_lar_solver->get_bound_constraint_witnesses_for_column(j, lc, uc); - m_ex->m_explanation.push_back(std::make_pair(mpq(1), lc)); - m_ex->m_explanation.push_back(std::make_pair(mpq(1), uc)); + m_ex.m_explanation.push_back(std::make_pair(mpq(1), lc)); + m_ex.m_explanation.push_back(std::make_pair(mpq(1), uc)); } void int_solver::fill_explanation_from_fixed_columns(const row_strip & row) { for (const auto & c : row) { @@ -1126,7 +909,7 @@ bool int_solver::at_bound(unsigned j) const { } } -bool int_solver::at_low(unsigned j) const { +bool int_solver::at_lower(unsigned j) const { auto & mpq_solver = m_lar_solver->m_mpq_lar_core_solver.m_r_solver; switch (mpq_solver.m_column_types[j] ) { case column_type::fixed: @@ -1258,20 +1041,20 @@ const impq& int_solver::lower_bound(unsigned j) const { lia_move int_solver::create_branch_on_column(int j) { TRACE("check_main_int", tout << "branching" << std::endl;); - lp_assert(m_t->is_empty()); + lp_assert(m_t.is_empty()); lp_assert(j != -1); - m_t->add_monomial(mpq(1), m_lar_solver->adjust_column_index_to_term_index(j)); + m_t.add_monomial(mpq(1), m_lar_solver->adjust_column_index_to_term_index(j)); if (is_free(j)) { - *m_upper = true; - *m_k = mpq(0); + m_upper = true; + m_k = mpq(0); } else { - *m_upper = left_branch_is_more_narrow_than_right(j); - *m_k = *m_upper? floor(get_value(j)) : ceil(get_value(j)); + m_upper = left_branch_is_more_narrow_than_right(j); + m_k = m_upper? floor(get_value(j)) : ceil(get_value(j)); } TRACE("arith_int", tout << "branching v" << j << " = " << get_value(j) << "\n"; display_column(tout, j); - tout << "k = " << *m_k << std::endl; + tout << "k = " << m_k << std::endl; ); return lia_move::branch; diff --git a/src/util/lp/int_solver.h b/src/util/lp/int_solver.h index ec708918d..17ce20481 100644 --- a/src/util/lp/int_solver.h +++ b/src/util/lp/int_solver.h @@ -39,20 +39,31 @@ public: // fields lar_solver *m_lar_solver; unsigned m_number_of_calls; - lar_term *m_t; // the term to return in the cut - mpq *m_k; // the right side of the cut - explanation *m_ex; // the conflict explanation - bool *m_upper; // we have a cut m_t*x <= k if m_upper is true nad m_t*x >= k otherwise + lar_term m_t; // the term to return in the cut + mpq m_k; // the right side of the cut + explanation m_ex; // the conflict explanation + bool m_upper; // we have a cut m_t*x <= k if m_upper is true nad m_t*x >= k otherwise hnf_cutter m_hnf_cutter; // methods int_solver(lar_solver* lp); // main function to check that the solution provided by lar_solver is valid for integral values, // or provide a way of how it can be adjusted. - lia_move check(lar_term& t, mpq& k, explanation& ex, bool & upper); + lia_move check(); + lar_term const& get_term() const { return m_t; } + mpq const& get_offset() const { return m_k; } + explanation const& get_explanation() const { return m_ex; } + bool is_upper() const { return m_upper; } + bool move_non_basic_column_to_bounds(unsigned j); - lia_move check_wrapper(lar_term& t, mpq& k, explanation& ex); bool is_base(unsigned j) const; + bool is_real(unsigned j) const; + const impq & lower_bound(unsigned j) const; + const impq & upper_bound(unsigned j) const; + bool is_int(unsigned j) const; + const impq & get_value(unsigned j) const; + bool at_lower(unsigned j) const; + bool at_upper(unsigned j) const; private: @@ -79,10 +90,7 @@ private: void add_to_explanation_from_fixed_or_boxed_column(unsigned j); lia_move patch_nbasic_columns(); bool get_freedom_interval_for_column(unsigned j, bool & inf_l, impq & l, bool & inf_u, impq & u, mpq & m); - const impq & lower_bound(unsigned j) const; - const impq & upper_bound(unsigned j) const; - bool is_int(unsigned j) const; - bool is_real(unsigned j) const; +private: bool is_boxed(unsigned j) const; bool is_fixed(unsigned j) const; bool is_free(unsigned j) const; @@ -91,7 +99,6 @@ private: void set_value_for_nbasic_column_ignore_old_values(unsigned j, const impq & new_val); bool non_basic_columns_are_at_bounds() const; bool is_feasible() const; - const impq & get_value(unsigned j) const; bool column_is_int_inf(unsigned j) const; void trace_inf_rows() const; lia_move branch_or_sat(); @@ -104,39 +111,22 @@ private: bool move_non_basic_columns_to_bounds(); void branch_infeasible_int_var(unsigned); lia_move mk_gomory_cut(unsigned inf_col, const row_strip& row); - lia_move report_conflict_from_gomory_cut(); - void adjust_term_and_k_for_some_ints_case_gomory(mpq& lcm_den); lia_move proceed_with_gomory_cut(unsigned j); - int find_free_var_in_gomory_row(const row_strip& ); bool is_gomory_cut_target(const row_strip&); bool at_bound(unsigned j) const; - bool at_low(unsigned j) const; - bool at_upper(unsigned j) const; bool has_low(unsigned j) const; bool has_upper(unsigned j) const; unsigned row_of_basic_column(unsigned j) const; - inline static bool is_rational(const impq & n) { - return is_zero(n.y); - } public: void display_column(std::ostream & out, unsigned j) const; - inline static - mpq fractional_part(const impq & n) { - lp_assert(is_rational(n)); - return n.x - floor(n.x); - } -private: - void real_case_in_gomory_cut(const mpq & a, unsigned x_j, const mpq& f_0, const mpq& one_minus_f_0); - void int_case_in_gomory_cut(const mpq & a, unsigned x_j, mpq & lcm_den, const mpq& f_0, const mpq& one_minus_f_0); constraint_index column_upper_bound_constraint(unsigned j) const; constraint_index column_lower_bound_constraint(unsigned j) const; - void display_row_info(std::ostream & out, unsigned row_index) const; - void gomory_cut_adjust_t_and_k(vector> & pol, lar_term & t, mpq &k, bool num_ints, mpq &lcm_den); bool current_solution_is_inf_on_cut() const; -public: + bool shift_var(unsigned j, unsigned range); private: + void display_row_info(std::ostream & out, unsigned row_index) const; unsigned random(); bool has_inf_int() const; lia_move create_branch_on_column(int j); @@ -161,5 +151,5 @@ public: bool hnf_has_var_with_non_integral_value() const; bool hnf_cutter_is_full() const; void patch_nbasic_column(unsigned j, bool patch_only_int_vals); -}; + }; } diff --git a/src/util/lp/lar_constraints.h b/src/util/lp/lar_constraints.h index ac15028bb..6305089b4 100644 --- a/src/util/lp/lar_constraints.h +++ b/src/util/lp/lar_constraints.h @@ -75,7 +75,7 @@ struct lar_term_constraint: public lar_base_constraint { } unsigned size() const override { return m_term->size();} lar_term_constraint(const lar_term *t, lconstraint_kind kind, const mpq& right_side) : lar_base_constraint(kind, right_side), m_term(t) { } - mpq get_free_coeff_of_left_side() const override { return m_term->m_v;} + // mpq get_free_coeff_of_left_side() const override { return m_term->m_v;} }; diff --git a/src/util/lp/lar_core_solver.h b/src/util/lp/lar_core_solver.h index 904550339..52290c69a 100644 --- a/src/util/lp/lar_core_solver.h +++ b/src/util/lp/lar_core_solver.h @@ -817,7 +817,7 @@ public: } - const bool column_is_bounded(unsigned j) const { + bool column_is_bounded(unsigned j) const { switch(m_column_types()[j]) { case column_type::fixed: case column_type::boxed: diff --git a/src/util/lp/lar_solver.cpp b/src/util/lp/lar_solver.cpp index 654eb7017..31e9d2654 100644 --- a/src/util/lp/lar_solver.cpp +++ b/src/util/lp/lar_solver.cpp @@ -27,7 +27,7 @@ void clear() {lp_assert(false); // not implemented } -lar_solver::lar_solver() : m_status(lp_status::OPTIMAL), +lar_solver::lar_solver() : m_status(lp_status::UNKNOWN), m_infeasible_column_index(-1), m_terms_start_index(1000000), m_mpq_lar_core_solver(m_settings, *this), @@ -71,7 +71,7 @@ bool lar_solver::sizes_are_correct() const { } -void lar_solver::print_implied_bound(const implied_bound& be, std::ostream & out) const { +std::ostream& lar_solver::print_implied_bound(const implied_bound& be, std::ostream & out) const { out << "implied bound\n"; unsigned v = be.m_j; if (is_term(v)) { @@ -83,6 +83,7 @@ void lar_solver::print_implied_bound(const implied_bound& be, std::ostream & out } out << " " << lconstraint_kind_string(be.kind()) << " " << be.m_bound << std::endl; out << "end of implied bound" << std::endl; + return out; } bool lar_solver::implied_bound_is_correctly_explained(implied_bound const & be, const vector> & explanation) const { @@ -136,7 +137,7 @@ bool lar_solver::implied_bound_is_correctly_explained(implied_bound const & be, kind = static_cast(-kind); } rs_of_evidence /= ratio; - rs_of_evidence += t->m_v * ratio; + // rs_of_evidence += t->m_v * ratio; } return kind == be.kind() && rs_of_evidence == be.m_bound; @@ -376,7 +377,7 @@ void lar_solver::pop(unsigned k) { m_settings.simplex_strategy() = m_simplex_strategy; lp_assert(sizes_are_correct()); lp_assert((!m_settings.use_tableau()) || m_mpq_lar_core_solver.m_r_solver.reduced_costs_are_correct_tableau()); - m_status = m_mpq_lar_core_solver.m_r_solver.current_x_is_feasible()? lp_status::OPTIMAL: lp_status::UNKNOWN; + set_status(lp_status::UNKNOWN); } vector lar_solver::get_all_constraint_indices() const { @@ -601,7 +602,7 @@ void lar_solver::register_monoid_in_map(std::unordered_map & coe void lar_solver::substitute_terms_in_linear_expression(const vector>& left_side_with_terms, - vector> &left_side, mpq & free_coeff) const { + vector> &left_side) const { std::unordered_map coeffs; for (auto & t : left_side_with_terms) { unsigned j = t.second; @@ -612,7 +613,6 @@ void lar_solver::substitute_terms_in_linear_expression(const vector & ci) { return false; } -column_type lar_solver::get_column_type(const column_info & ci) { - auto ret = ci.get_column_type_no_flipping(); - if (ret == column_type::boxed) { // changing boxed to fixed because of the no span - if (ci.get_lower_bound() == ci.get_upper_bound()) - ret = column_type::fixed; - } - return ret; +column_type lar_solver::get_column_type(unsigned j) const{ + return m_mpq_lar_core_solver.m_column_types[j]; } std::string lar_solver::get_column_name(unsigned j) const { @@ -954,9 +949,9 @@ bool lar_solver::constraint_holds(const lar_base_constraint & constr, std::unord mpq left_side_val = get_left_side_val(constr, var_map); switch (constr.m_kind) { case LE: return left_side_val <= constr.m_right_side; - case LT: return left_side_val < constr.m_right_side; + case LT: return left_side_val < constr.m_right_side; case GE: return left_side_val >= constr.m_right_side; - case GT: return left_side_val > constr.m_right_side; + case GT: return left_side_val > constr.m_right_side; case EQ: return left_side_val == constr.m_right_side; default: lp_unreachable(); @@ -975,8 +970,10 @@ bool lar_solver::the_relations_are_of_same_type(const vectorm_kind); if (kind == GT || kind == LT) strict = true; - if (kind == GE || kind == GT) n_of_G++; - else if (kind == LE || kind == LT) n_of_L++; + if (kind == GE || kind == GT) + n_of_G++; + else if (kind == LE || kind == LT) + n_of_L++; } the_kind_of_sum = n_of_G ? GE : (n_of_L ? LE : EQ); if (strict) @@ -1116,7 +1113,7 @@ bool lar_solver::has_upper_bound(var_index var, constraint_index& ci, mpq& value bool lar_solver::has_value(var_index var, mpq& value) const { if (is_term(var)) { lar_term const& t = get_term(var); - value = t.m_v; + value = 0; for (auto const& cv : t) { impq const& r = get_column_value(cv.var()); if (!numeric_traits::is_zero(r.y)) return false; @@ -1177,6 +1174,7 @@ void lar_solver::get_model(std::unordered_map & variable_values) std::unordered_set set_of_different_pairs; std::unordered_set set_of_different_singles; delta = m_mpq_lar_core_solver.find_delta_for_strict_bounds(delta); + TRACE("get_model", tout << "delta=" << delta << "size = " << m_mpq_lar_core_solver.m_r_x.size() << std::endl;); for (i = 0; i < m_mpq_lar_core_solver.m_r_x.size(); i++ ) { const numeric_pair & rp = m_mpq_lar_core_solver.m_r_x[i]; set_of_different_pairs.insert(rp); @@ -1208,42 +1206,40 @@ std::string lar_solver::get_variable_name(var_index vi) const { } // ********** print region start -void lar_solver::print_constraint(constraint_index ci, std::ostream & out) const { +std::ostream& lar_solver::print_constraint(constraint_index ci, std::ostream & out) const { if (ci >= m_constraints.size()) { out << "constraint " << T_to_string(ci) << " is not found"; out << std::endl; - return; + return out; } - print_constraint(m_constraints[ci], out); + return print_constraint(m_constraints[ci], out); } -void lar_solver::print_constraints(std::ostream& out) const { +std::ostream& lar_solver::print_constraints(std::ostream& out) const { out << "number of constraints = " << m_constraints.size() << std::endl; for (auto c : m_constraints) { print_constraint(c, out); } + return out; } -void lar_solver::print_terms(std::ostream& out) const { +std::ostream& lar_solver::print_terms(std::ostream& out) const { for (auto it : m_terms) { - print_term(*it, out); - out << "\n"; + print_term(*it, out) << "\n"; } + return out; } -void lar_solver::print_left_side_of_constraint(const lar_base_constraint * c, std::ostream & out) const { +std::ostream& lar_solver::print_left_side_of_constraint(const lar_base_constraint * c, std::ostream & out) const { print_linear_combination_of_column_indices(c->get_left_side_coefficients(), out); mpq free_coeff = c->get_free_coeff_of_left_side(); if (!is_zero(free_coeff)) out << " + " << free_coeff; - + return out; } -void lar_solver::print_term(lar_term const& term, std::ostream & out) const { - if (!numeric_traits::is_zero(term.m_v)) { - out << term.m_v << " + "; - } +std::ostream& lar_solver::print_term(lar_term const& term, std::ostream & out) const { bool first = true; for (const auto p : term) { mpq val = p.coeff(); @@ -1263,14 +1259,12 @@ void lar_solver::print_term(lar_term const& term, std::ostream & out) const { out << T_to_string(val); out << this->get_column_name(p.var()); } - + return out; } -void lar_solver::print_term_as_indices(lar_term const& term, std::ostream & out) const { - if (!numeric_traits::is_zero(term.m_v)) { - out << term.m_v << " + "; - } - print_linear_combination_of_column_indices_only(term.coeffs_as_vector(), out); +std::ostream& lar_solver::print_term_as_indices(lar_term const& term, std::ostream & out) const { + print_linear_combination_of_column_indices_only(term, out); + return out; } mpq lar_solver::get_left_side_val(const lar_base_constraint & cns, const std::unordered_map & var_map) const { @@ -1284,9 +1278,10 @@ mpq lar_solver::get_left_side_val(const lar_base_constraint & cns, const std::u return ret; } -void lar_solver::print_constraint(const lar_base_constraint * c, std::ostream & out) const { +std::ostream& lar_solver::print_constraint(const lar_base_constraint * c, std::ostream & out) const { print_left_side_of_constraint(c, out); out << " " << lconstraint_kind_string(c->m_kind) << " " << c->m_right_side << std::endl; + return out; } void lar_solver::fill_var_set_for_random_update(unsigned sz, var_index const * vars, vector& column_list) { @@ -1492,7 +1487,7 @@ bool lar_solver::term_is_int(const lar_term * t) const { for (auto const & p : t->m_coeffs) if (! (column_is_int(p.first) && p.second.is_int())) return false; - return t->m_v.is_int(); + return true; } bool lar_solver::var_is_int(var_index v) const { @@ -1593,17 +1588,13 @@ void lar_solver::add_new_var_to_core_fields_for_mpq(bool register_in_basis) { } -var_index lar_solver::add_term_undecided(const vector> & coeffs, - const mpq &m_v) { - push_and_register_term(new lar_term(coeffs, m_v)); +var_index lar_solver::add_term_undecided(const vector> & coeffs) { + push_and_register_term(new lar_term(coeffs)); return m_terms_start_index + m_terms.size() - 1; } #if Z3DEBUG_CHECK_UNIQUE_TERMS -bool lar_solver::term_coeffs_are_ok(const vector> & coeffs, const mpq& v) { - if (coeffs.empty()) { - return is_zero(v); - } +bool lar_solver::term_coeffs_are_ok(const vector> & coeffs) { for (const auto & p : coeffs) { if (column_is_real(p.second)) @@ -1638,12 +1629,11 @@ void lar_solver::push_and_register_term(lar_term* t) { } // terms -var_index lar_solver::add_term(const vector> & coeffs, - const mpq &m_v) { +var_index lar_solver::add_term(const vector> & coeffs) { if (strategy_is_undecided()) - return add_term_undecided(coeffs, m_v); + return add_term_undecided(coeffs); - push_and_register_term(new lar_term(coeffs, m_v)); + push_and_register_term(new lar_term(coeffs)); unsigned adjusted_term_index = m_terms.size() - 1; var_index ret = m_terms_start_index + adjusted_term_index; if (use_tableau() && !coeffs.empty()) { @@ -1656,7 +1646,7 @@ var_index lar_solver::add_term(const vector> & coeffs, } void lar_solver::add_row_from_term_no_constraint(const lar_term * term, unsigned term_ext_index) { - TRACE("dump_terms", print_term(*term, tout); tout << std::endl;); + TRACE("dump_terms", print_term(*term, tout) << std::endl;); register_new_ext_var_index(term_ext_index, term_is_int(term)); // j will be a new variable unsigned j = A_r().column_count(); @@ -1738,9 +1728,8 @@ void lar_solver::add_var_bound_on_constraint_for_term(var_index j, lconstraint_k // lp_assert(!term_is_int(m_terms[adjusted_term_index]) || right_side.is_int()); unsigned term_j; if (m_var_register.external_is_used(j, term_j)) { - mpq rs = right_side - m_terms[adjusted_term_index]->m_v; m_constraints.push_back(new lar_term_constraint(m_terms[adjusted_term_index], kind, right_side)); - update_column_type_and_bound(term_j, kind, rs, ci); + update_column_type_and_bound(term_j, kind, right_side, ci); } else { add_constraint_from_term_and_create_new_column_row(j, m_terms[adjusted_term_index], kind, right_side); @@ -1749,11 +1738,10 @@ void lar_solver::add_var_bound_on_constraint_for_term(var_index j, lconstraint_k constraint_index lar_solver::add_constraint(const vector>& left_side_with_terms, lconstraint_kind kind_par, const mpq& right_side_parm) { vector> left_side; - mpq rs = -right_side_parm; - substitute_terms_in_linear_expression(left_side_with_terms, left_side, rs); - unsigned term_index = add_term(left_side, zero_of_type()); + substitute_terms_in_linear_expression(left_side_with_terms, left_side); + unsigned term_index = add_term(left_side); constraint_index ci = m_constraints.size(); - add_var_bound_on_constraint_for_term(term_index, kind_par, -rs, ci); + add_var_bound_on_constraint_for_term(term_index, kind_par, right_side_parm, ci); return ci; } @@ -1762,7 +1750,7 @@ void lar_solver::add_constraint_from_term_and_create_new_column_row(unsigned ter add_row_from_term_no_constraint(term, term_j); unsigned j = A_r().column_count() - 1; - update_column_type_and_bound(j, kind, right_side - term->m_v, m_constraints.size()); + update_column_type_and_bound(j, kind, right_side, m_constraints.size()); m_constraints.push_back(new lar_term_constraint(term, kind, right_side)); lp_assert(A_r().column_count() == m_mpq_lar_core_solver.m_r_solver.m_costs.size()); } @@ -1964,7 +1952,6 @@ void lar_solver::update_boxed_column_type_and_bound(var_index j, lconstraint_kin if (up < m_mpq_lar_core_solver.m_r_lower_bounds[j]) { m_status = lp_status::INFEASIBLE; - lp_assert(false); m_infeasible_column_index = j; } else { @@ -2261,6 +2248,7 @@ void lar_solver::set_cut_strategy(unsigned cut_frequency) { } } + } // namespace lp diff --git a/src/util/lp/lar_solver.h b/src/util/lp/lar_solver.h index 283c13c38..7af9cfacb 100644 --- a/src/util/lp/lar_solver.h +++ b/src/util/lp/lar_solver.h @@ -94,7 +94,6 @@ class lar_solver : public column_namer { var_register m_var_register; stacked_vector m_columns_to_ul_pairs; vector m_constraints; -private: stacked_value m_constraint_count; // the set of column indices j such that bounds have changed for j int_set m_columns_with_changed_bound; @@ -164,13 +163,11 @@ public: // terms - var_index add_term(const vector> & coeffs, - const mpq &m_v); + var_index add_term(const vector> & coeffs); - var_index add_term_undecided(const vector> & coeffs, - const mpq &m_v); + var_index add_term_undecided(const vector> & coeffs); - bool term_coeffs_are_ok(const vector> & coeffs, const mpq& v); + bool term_coeffs_are_ok(const vector> & coeffs); void push_and_register_term(lar_term* t); void add_row_for_term(const lar_term * term, unsigned term_ext_index); @@ -208,7 +205,10 @@ public: void update_lower_bound_column_type_and_bound(var_index j, lconstraint_kind kind, const mpq & right_side, constraint_index ci); void update_fixed_column_type_and_bound(var_index j, lconstraint_kind kind, const mpq & right_side, constraint_index ci); + //end of init region + + lp_settings & settings(); lp_settings const & settings() const; @@ -227,9 +227,7 @@ public: bool use_lu() const; bool sizes_are_correct() const; - - void print_implied_bound(const implied_bound& be, std::ostream & out) const; - + bool implied_bound_is_correctly_explained(implied_bound const & be, const vector> & explanation) const; void analyze_new_bounds_on_row( @@ -238,8 +236,7 @@ public: void analyze_new_bounds_on_row_tableau( unsigned row_index, - bound_propagator & bp - ); + bound_propagator & bp); void substitute_basis_var_in_terms_for_row(unsigned i); @@ -331,7 +328,7 @@ public: void substitute_terms_in_linear_expression( const vector>& left_side_with_terms, - vector> &left_side, mpq & free_coeff) const; + vector> &left_side) const; void detect_rows_of_bound_change_column_for_nbasic_column(unsigned j); @@ -397,9 +394,9 @@ public: bool try_to_set_fixed(column_info & ci); - column_type get_column_type(const column_info & ci); + column_type get_column_type(unsigned j) const; - std::string get_column_name(unsigned j) const; + std::string get_column_name(unsigned j) const override; bool all_constrained_variables_are_registered(const vector>& left_side); @@ -436,30 +433,33 @@ public: int inf_sign) const; - void get_model(std::unordered_map & variable_values) const; void get_model_do_not_care_about_diff_vars(std::unordered_map & variable_values) const; std::string get_variable_name(var_index vi) const; - // ********** print region start - void print_constraint(constraint_index ci, std::ostream & out) const; + // print utilities - void print_constraints(std::ostream& out) const ; + std::ostream& print_constraint(constraint_index ci, std::ostream & out) const; - void print_terms(std::ostream& out) const; + std::ostream& print_constraints(std::ostream& out) const ; - void print_left_side_of_constraint(const lar_base_constraint * c, std::ostream & out) const; + std::ostream& print_terms(std::ostream& out) const; - void print_term(lar_term const& term, std::ostream & out) const; + std::ostream& print_left_side_of_constraint(const lar_base_constraint * c, std::ostream & out) const; - void print_term_as_indices(lar_term const& term, std::ostream & out) const; + std::ostream& print_term(lar_term const& term, std::ostream & out) const; + std::ostream& print_term_as_indices(lar_term const& term, std::ostream & out) const; + + std::ostream& print_constraint(const lar_base_constraint * c, std::ostream & out) const; + + std::ostream& print_implied_bound(const implied_bound& be, std::ostream & out) const; + + mpq get_left_side_val(const lar_base_constraint & cns, const std::unordered_map & var_map) const; - void print_constraint(const lar_base_constraint * c, std::ostream & out) const; - void fill_var_set_for_random_update(unsigned sz, var_index const * vars, vector& column_list); void random_update(unsigned sz, var_index const * vars); diff --git a/src/util/lp/lar_term.h b/src/util/lp/lar_term.h index 519847848..64243f4e2 100644 --- a/src/util/lp/lar_term.h +++ b/src/util/lp/lar_term.h @@ -21,9 +21,9 @@ #include "util/lp/indexed_vector.h" namespace lp { struct lar_term { - // the term evaluates to sum of m_coeffs + m_v + // the term evaluates to sum of m_coeffs std::unordered_map m_coeffs; - mpq m_v; + // mpq m_v; lar_term() {} void add_monomial(const mpq& c, unsigned j) { auto it = m_coeffs.find(j); @@ -37,7 +37,7 @@ struct lar_term { } bool is_empty() const { - return m_coeffs.size() == 0 && is_zero(m_v); + return m_coeffs.empty(); // && is_zero(m_v); } unsigned size() const { return static_cast(m_coeffs.size()); } @@ -46,8 +46,7 @@ struct lar_term { return m_coeffs; } - lar_term(const vector>& coeffs, - const mpq & v) : m_v(v) { + lar_term(const vector>& coeffs) { for (const auto & p : coeffs) { add_monomial(p.first, p.second); } @@ -87,7 +86,7 @@ struct lar_term { template T apply(const vector& x) const { - T ret = T(m_v); + T ret(0); for (const auto & t : m_coeffs) { ret += t.second * x[t.first]; } @@ -96,7 +95,6 @@ struct lar_term { void clear() { m_coeffs.clear(); - m_v = zero_of_type(); } struct ival { diff --git a/src/util/lp/bound_propagator.cpp b/src/util/lp/lp_bound_propagator.cpp similarity index 93% rename from src/util/lp/bound_propagator.cpp rename to src/util/lp/lp_bound_propagator.cpp index c4fa2aefa..a5c7c976a 100644 --- a/src/util/lp/bound_propagator.cpp +++ b/src/util/lp/lp_bound_propagator.cpp @@ -17,10 +17,6 @@ const impq & bound_propagator::get_upper_bound(unsigned j) const { } void bound_propagator::try_add_bound(mpq v, unsigned j, bool is_low, bool coeff_before_j_is_pos, unsigned row_or_term_index, bool strict) { j = m_lar_solver.adjust_column_index_to_term_index(j); - if (m_lar_solver.is_term(j)) { - // lp treats terms as not having a free coefficient, restoring it below for the outside consumption - v += m_lar_solver.get_term(j).m_v; - } lconstraint_kind kind = is_low? GE : LE; if (strict) diff --git a/src/util/lp/lp_core_solver_base.cpp b/src/util/lp/lp_core_solver_base.cpp index 00c1322c2..e71f65d5d 100644 --- a/src/util/lp/lp_core_solver_base.cpp +++ b/src/util/lp/lp_core_solver_base.cpp @@ -84,6 +84,7 @@ template lp::lp_core_solver_base >::lp_core_s const vector >&); template bool lp::lp_core_solver_base >::print_statistics_with_cost_and_check_that_the_time_is_over(lp::numeric_pair, std::ostream&); template void lp::lp_core_solver_base >::snap_xN_to_bounds_and_fill_xB(); +template void lp::lp_core_solver_base >::solve_Ax_eq_b(); template void lp::lp_core_solver_base >::solve_Bd(unsigned int); template bool lp::lp_core_solver_base >::update_basis_and_x(int, int, lp::numeric_pair const&); template void lp::lp_core_solver_base >::update_x(unsigned int, const lp::numeric_pair&); diff --git a/src/util/lp/lp_core_solver_base.h b/src/util/lp/lp_core_solver_base.h index 41b6fe31d..9a6549917 100644 --- a/src/util/lp/lp_core_solver_base.h +++ b/src/util/lp/lp_core_solver_base.h @@ -577,7 +577,7 @@ public: } void print_column_info(unsigned j, std::ostream & out) const { - out << "j = " << j << ", name = "<< column_name(j); + out << "j = " << j << ",\tname = "<< column_name(j) << "\t"; switch (m_column_types[j]) { case column_type::fixed: case column_type::boxed: @@ -596,11 +596,11 @@ public: lp_assert(false); } // out << "basis heading = " << m_basis_heading[j] << std::endl; - out << " x = " << m_x[j]; + out << "\tx = " << m_x[j]; if (m_basis_heading[j] >= 0) out << " base\n"; else - out << " nbas\n"; + out << " \n"; } bool column_is_free(unsigned j) const { return this->m_column_type[j] == free; } diff --git a/src/util/lp/lp_core_solver_base_def.h b/src/util/lp/lp_core_solver_base_def.h index c3a0a0a00..6844ab839 100644 --- a/src/util/lp/lp_core_solver_base_def.h +++ b/src/util/lp/lp_core_solver_base_def.h @@ -74,7 +74,7 @@ lp_core_solver_base(static_matrix & A, } template void lp_core_solver_base:: -allocate_basis_heading() { // the rest of initilization will be handled by the factorization class +allocate_basis_heading() { // the rest of initialization will be handled by the factorization class init_basis_heading_and_non_basic_columns_vector(); lp_assert(basis_heading_is_correct()); } diff --git a/src/util/lp/lp_dual_core_solver_def.h b/src/util/lp/lp_dual_core_solver_def.h index 86e6231fc..984f2e560 100644 --- a/src/util/lp/lp_dual_core_solver_def.h +++ b/src/util/lp/lp_dual_core_solver_def.h @@ -276,7 +276,7 @@ template bool lp_dual_core_solver::can_be_breakpo bool grawing = m_sign_of_alpha_r * this->m_pivot_row[j] > 0; return lower_bound == grawing; } - case column_type::fixed: // is always dual feasible so we ingore it + case column_type::fixed: // is always dual feasible so we ignore it return false; case column_type::free_column: return true; @@ -665,7 +665,7 @@ template bool lp_dual_core_solver::ratio_test() { m_flipped_boxed.clear(); int initial_delta_sign = m_delta >= numeric_traits::zero()? 1: -1; do { - if (m_breakpoint_set.size() == 0) { + if (m_breakpoint_set.empty()) { set_status_to_tentative_dual_unbounded_or_dual_unbounded(); return false; } @@ -697,7 +697,7 @@ template void lp_dual_core_solver::update_d_and_x this->m_d[j] -= m_theta_D * this->m_pivot_row[j]; } this->m_d[m_p] = - m_theta_D; - if (m_flipped_boxed.size() > 0) { + if (!m_flipped_boxed.empty()) { process_flipped(); update_xb_after_bound_flips(); } diff --git a/src/util/lp/lp_primal_core_solver_def.h b/src/util/lp/lp_primal_core_solver_def.h index 1e9edbd31..a43764172 100644 --- a/src/util/lp/lp_primal_core_solver_def.h +++ b/src/util/lp/lp_primal_core_solver_def.h @@ -284,7 +284,7 @@ template int lp_primal_core_solver::advance_on_so break; } else { if ((numeric_traits::precise() == false) || ( numeric_traits::is_zero(slope_at_entering) && this->m_settings.random_next() % 2 == 0)) { - // it is not cost benefitial to advance the delta more, so just break to increas the randomness + // it is not cost beneficial to advance the delta more, so just break to increase the randomness break; } } @@ -504,7 +504,7 @@ lp_primal_core_solver::get_bound_on_variable_and_update_leaving_precisely( X tt = - (this->m_lower_bounds[j] - this->m_x[j]) / m; if (numeric_traits::is_neg(tt)) tt = zero_of_type(); - if (leavings.size() == 0 || tt < t || (tt == t && m > abs_of_d_of_leaving)) { + if (leavings.empty() || tt < t || (tt == t && m > abs_of_d_of_leaving)) { t = tt; abs_of_d_of_leaving = m; leavings.clear(); @@ -524,7 +524,7 @@ lp_primal_core_solver::get_bound_on_variable_and_update_leaving_precisely( X tt = (this->m_upper_bounds[j] - this->m_x[j]) / m; if (numeric_traits::is_neg(tt)) tt = zero_of_type(); - if (leavings.size() == 0 || tt < t || (tt == t && - m > abs_of_d_of_leaving)) { + if (leavings.empty() || tt < t || (tt == t && - m > abs_of_d_of_leaving)) { t = tt; abs_of_d_of_leaving = - m; leavings.clear(); @@ -612,7 +612,7 @@ template int lp_primal_core_solver::refresh_re return 2; // abort entering } else { if (refreshed_cost > -m_epsilon_of_reduced_cost) - return 2; // abort entiring + return 2; // abort entering } return 1; // go on with this entering } else { @@ -621,7 +621,7 @@ template int lp_primal_core_solver::refresh_re return 2; // abort entering } else { if (refreshed_cost > -m_epsilon_of_reduced_cost) - return 2; // abort entiring + return 2; // abort entering } } return 0; @@ -1238,6 +1238,7 @@ template void lp_primal_core_solver::print_column break; case column_type::free_column: out << "( _" << this->m_x[j] << "_)" << std::endl; + break; default: lp_unreachable(); } diff --git a/src/util/lp/lp_settings.h b/src/util/lp/lp_settings.h index dd19df23a..d0bdc284d 100644 --- a/src/util/lp/lp_settings.h +++ b/src/util/lp/lp_settings.h @@ -68,7 +68,7 @@ enum class lp_status { CANCELLED }; -// when the ratio of the vector lenth to domain size to is greater than the return value we switch to solve_By_for_T_indexed_only +// when the ratio of the vector length to domain size to is greater than the return value we switch to solve_By_for_T_indexed_only template unsigned ratio_of_index_size_to_all_size() { if (numeric_traits::precise()) @@ -145,7 +145,7 @@ public: double pivot_epsilon; // see Chatal, page 115 double positive_price_epsilon; - // a quatation "if some choice of the entering vairable leads to an eta matrix + // a quotation "if some choice of the entering variable leads to an eta matrix // whose diagonal element in the eta column is less than e2 (entering_diag_epsilon) in magnitude, the this choice is rejected ... double entering_diag_epsilon; int c_partial_pivoting; // this is the constant c from page 410 @@ -357,7 +357,7 @@ public: } #ifdef Z3DEBUG - static unsigned ddd; // used for debugging +static unsigned ddd; // used for debugging #endif }; // end of lp_settings class @@ -433,7 +433,15 @@ inline void ensure_increasing(vector & v) { } } +inline static bool is_rational(const impq & n) { return is_zero(n.y); } +inline static mpq fractional_part(const impq & n) { + lp_assert(is_rational(n)); + return n.x - floor(n.x); +} +inline static mpq fractional_part(const mpq & n) { + return n - floor(n); +} #if Z3DEBUG bool D(); diff --git a/src/util/lp/lp_solver_def.h b/src/util/lp/lp_solver_def.h index 10c7a6feb..21a86efba 100644 --- a/src/util/lp/lp_solver_def.h +++ b/src/util/lp/lp_solver_def.h @@ -24,7 +24,7 @@ Revision History: namespace lp { template column_info * lp_solver::get_or_create_column_info(unsigned column) { auto it = m_map_from_var_index_to_column_info.find(column); - return (it == m_map_from_var_index_to_column_info.end())? (m_map_from_var_index_to_column_info[column] = new column_info(static_cast(-1))) : it->second; + return (it == m_map_from_var_index_to_column_info.end())? (m_map_from_var_index_to_column_info[column] = new column_info()) : it->second; } template @@ -103,7 +103,7 @@ template void lp_solver::flip_costs() { template bool lp_solver::problem_is_empty() { for (auto & c : m_A_values) - if (c.second.size()) + if (!c.second.empty()) return false; return true; } @@ -387,7 +387,7 @@ template unsigned lp_solver::try_to_remove_some_r return 0; } } - if (rows_to_delete.size() > 0) { + if (!rows_to_delete.empty()) { for (unsigned k : rows_to_delete) { m_A_values.erase(k); } diff --git a/src/util/lp/lp_utils.h b/src/util/lp/lp_utils.h index e776092a2..573fc319c 100644 --- a/src/util/lp/lp_utils.h +++ b/src/util/lp/lp_utils.h @@ -50,11 +50,34 @@ bool contains(const std::unordered_map & map, const A& key) { namespace lp { - - inline void throw_exception(std::string && str) { - throw default_exception(std::move(str)); +template +void print_linear_combination_of_column_indices_only(const T & coeffs, std::ostream & out) { + bool first = true; + for (const auto & it : coeffs) { + auto val = it.coeff(); + if (first) { + first = false; + } else { + if (val.is_pos()) { + out << " + "; + } else { + out << " - "; + val = -val; + } + } + if (val == 1) + out << " "; + else + out << T_to_string(val); + + out << "x" << it.var(); } - typedef z3_exception exception; +} + +inline void throw_exception(std::string && str) { + throw default_exception(std::move(str)); +} +typedef z3_exception exception; #define lp_assert(_x_) { SASSERT(_x_); } inline void lp_unreachable() { lp_assert(false); } diff --git a/src/util/lp/matrix_def.h b/src/util/lp/matrix_def.h index 361540cae..b74e59443 100644 --- a/src/util/lp/matrix_def.h +++ b/src/util/lp/matrix_def.h @@ -97,7 +97,7 @@ void print_matrix_with_widths(vector> & A, vector void print_string_matrix(vector> & A, std::ostream & out, unsigned blanks_in_front) { vector widths; - if (A.size() > 0) + if (!A.empty()) for (unsigned j = 0; j < A[0].size(); j++) { widths.push_back(get_width_of_column(j, A)); } diff --git a/src/util/lp/mps_reader.h b/src/util/lp/mps_reader.h index 09762cd5e..2ef07af6e 100644 --- a/src/util/lp/mps_reader.h +++ b/src/util/lp/mps_reader.h @@ -220,7 +220,7 @@ class mps_reader { *m_message_stream << "cannot read from file" << std::endl; } m_line_number++; - if (m_line.size() != 0 && m_line[0] != '*' && !all_white_space()) + if (!m_line.empty() && m_line[0] != '*' && !all_white_space()) break; } } @@ -514,7 +514,7 @@ class mps_reader { lp_assert(m_line.size() >= 14); vector bound_string = split_and_trim(m_line.substr(name_offset, m_line.size())); - if (bound_string.size() == 0) { + if (bound_string.empty()) { set_m_ok_to_false(); (*m_message_stream) << "error at line " << m_line_number << std::endl; throw m_line; diff --git a/src/util/lp/nra_solver.cpp b/src/util/lp/nra_solver.cpp index 0d28058e8..200bdd2bc 100644 --- a/src/util/lp/nra_solver.cpp +++ b/src/util/lp/nra_solver.cpp @@ -154,7 +154,7 @@ namespace nra { polynomial::polynomial* ps[1] = { p }; bool even[1] = { false }; nlsat::literal lit = m_nlsat->mk_ineq_literal(nlsat::atom::kind::EQ, 1, ps, even); - m_nlsat->mk_clause(1, &lit, 0); + m_nlsat->mk_clause(1, &lit, nullptr); } void add_constraint(unsigned idx) { diff --git a/src/util/lp/numeric_pair.h b/src/util/lp/numeric_pair.h index e98d76cbb..ed740d645 100644 --- a/src/util/lp/numeric_pair.h +++ b/src/util/lp/numeric_pair.h @@ -57,10 +57,10 @@ public: template <> class numeric_traits { public: static bool precise() { return true; } - static int const zero() { return 0; } - static int const one() { return 1; } + static int zero() { return 0; } + static int one() { return 1; } static bool is_zero(int v) { return v == 0; } - static double const get_double(int const & d) { return d; } + static double get_double(int const & d) { return d; } static bool is_int(int) {return true;} static bool is_pos(int j) {return j > 0;} static bool is_neg(int j) {return j < 0;} diff --git a/src/util/lp/scaler_def.h b/src/util/lp/scaler_def.h index 2710f89bf..4c9784a43 100644 --- a/src/util/lp/scaler_def.h +++ b/src/util/lp/scaler_def.h @@ -126,7 +126,7 @@ template void scaler::scale_once_for_ratio() { T max_ratio_on_rows = get_max_ratio_on_rows(); T max_ratio_on_columns = get_max_ratio_on_columns(); bool scale_rows_first = max_ratio_on_rows > max_ratio_on_columns; - // if max_ratio_on_columns is the largerst then the rows are in worser shape then columns + // if max_ratio_on_columns is the largest then the rows are in worse shape than columns if (scale_rows_first) { scale_rows_with_geometric_mean(); scale_columns_with_geometric_mean(); diff --git a/src/util/lp/square_sparse_matrix_def.h b/src/util/lp/square_sparse_matrix_def.h index 791bdb6ae..2fc101666 100644 --- a/src/util/lp/square_sparse_matrix_def.h +++ b/src/util/lp/square_sparse_matrix_def.h @@ -186,7 +186,7 @@ void square_sparse_matrix::init_row_headers() { } template -void square_sparse_matrix::init_column_headers() { // we alway have only square square_sparse_matrix +void square_sparse_matrix::init_column_headers() { // we always have only square square_sparse_matrix for (unsigned l = 0; l < m_row_permutation.size(); l++) { m_columns.push_back(col_header()); } @@ -248,7 +248,7 @@ void square_sparse_matrix::put_max_index_to_0(vector> & r template void square_sparse_matrix::set_max_in_row(vector> & row_vals) { - if (row_vals.size() == 0) + if (row_vals.empty()) return; T max_val = abs(row_vals[0].m_value); unsigned max_index = 0; @@ -386,7 +386,7 @@ bool square_sparse_matrix::set_row_from_work_vector_and_clean_work_vector_ } work_vec.m_index.clear(); auto & row_vals = m_rows[i0]; - if (row_vals.size() == 0) { + if (row_vals.empty()) { return false; } set_max_in_row(row_vals); // it helps to find larger pivots diff --git a/src/util/lp/static_matrix.h b/src/util/lp/static_matrix.h index bb6cdefc8..1a0ee1bdc 100644 --- a/src/util/lp/static_matrix.h +++ b/src/util/lp/static_matrix.h @@ -93,7 +93,7 @@ public: unsigned m_row; public: ref_row(const static_matrix & m, unsigned row): m_matrix(m), m_row(row) {} - const T operator[](unsigned col) const { return m_matrix.get_elem(m_row, col); } + T operator[](unsigned col) const { return m_matrix.get_elem(m_row, col); } }; public: diff --git a/src/util/machine.h b/src/util/machine.h index 70baee41e..1ccff6330 100644 --- a/src/util/machine.h +++ b/src/util/machine.h @@ -20,7 +20,7 @@ Revision History: #ifndef MACHINE_H_ #define MACHINE_H_ -#ifdef _AMD64_ +#if defined(__LP64__) || defined(_WIN64) #define PTR_ALIGNMENT 3 #else #define PTR_ALIGNMENT 2 diff --git a/src/util/memory_manager.cpp b/src/util/memory_manager.cpp index 0a1d360c8..6ef94e880 100644 --- a/src/util/memory_manager.cpp +++ b/src/util/memory_manager.cpp @@ -18,7 +18,7 @@ Copyright (c) 2015 Microsoft Corporation // ADD_INITIALIZER('rational::initialize();') // ADD_FINALIZER('rational::finalize();') // Thus, any executable or shared object (DLL) that depends on rational.h -// will have an automalically generated file mem_initializer.cpp containing +// will have an automatically generated file mem_initializer.cpp containing // mem_initialize() // mem_finalize() // and these functions will include the statements: @@ -242,13 +242,13 @@ void * memory::allocate(char const* file, int line, char const* obj, size_t s) { #define SYNCH_THRESHOLD 100000 #ifdef _WINDOWS -// Actually this is VS specific instead of Windows specific. +// This is VS2013 specific instead of Windows specific. +// It can go away with VS2017 builds __declspec(thread) long long g_memory_thread_alloc_size = 0; __declspec(thread) long long g_memory_thread_alloc_count = 0; #else -// GCC style -__thread long long g_memory_thread_alloc_size = 0; -__thread long long g_memory_thread_alloc_count = 0; +thread_local long long g_memory_thread_alloc_size = 0; +thread_local long long g_memory_thread_alloc_count = 0; #endif static void synchronize_counters(bool allocating) { @@ -292,8 +292,10 @@ void memory::deallocate(void * p) { void * memory::allocate(size_t s) { s = s + sizeof(size_t); // we allocate an extra field! void * r = malloc(s); - if (r == 0) + if (r == 0) { throw_out_of_memory(); + return nullptr; + } *(static_cast(r)) = s; g_memory_thread_alloc_size += s; g_memory_thread_alloc_count += 1; @@ -317,8 +319,10 @@ void* memory::reallocate(void *p, size_t s) { } void *r = realloc(real_p, s); - if (r == 0) + if (r == 0) { throw_out_of_memory(); + return nullptr; + } *(static_cast(r)) = s; return static_cast(r) + 1; // we return a pointer to the location after the extra field } @@ -361,8 +365,10 @@ void * memory::allocate(size_t s) { if (counts_exceeded) throw_alloc_counts_exceeded(); void * r = malloc(s); - if (r == nullptr) + if (r == nullptr) { throw_out_of_memory(); + return nullptr; + } *(static_cast(r)) = s; return static_cast(r) + 1; // we return a pointer to the location after the extra field } @@ -389,8 +395,10 @@ void* memory::reallocate(void *p, size_t s) { if (counts_exceeded) throw_alloc_counts_exceeded(); void *r = realloc(real_p, s); - if (r == nullptr) + if (r == nullptr) { throw_out_of_memory(); + return nullptr; + } *(static_cast(r)) = s; return static_cast(r) + 1; // we return a pointer to the location after the extra field } diff --git a/src/util/memory_manager.h b/src/util/memory_manager.h index 5cb7dc467..94b969531 100644 --- a/src/util/memory_manager.h +++ b/src/util/memory_manager.h @@ -27,8 +27,9 @@ Revision History: # define __has_builtin(x) 0 #endif + #ifdef __GNUC__ -# if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 || __has_builtin(returns_nonnull) +# if ((__GNUC__ * 100 + __GNUC_MINOR__) >= 409 || __has_builtin(returns_nonnull)) && !defined(__INTEL_COMPILER) # define GCC_RET_NON_NULL __attribute__((returns_nonnull)) # else # define GCC_RET_NON_NULL diff --git a/src/util/mpf.cpp b/src/util/mpf.cpp index 7549a7bb3..49335467d 100644 --- a/src/util/mpf.cpp +++ b/src/util/mpf.cpp @@ -952,7 +952,7 @@ void my_mpz_sqrt(unsynch_mpz_manager & m, unsigned sbits, bool odd_exp, mpz & in scoped_mpz lower(m), upper(m); scoped_mpz mid(m), product(m), diff(m); // we have lower <= a.significand <= upper and we need 1.[52+3 bits] in the bounds. - // since we comapre upper*upper to a.significand further down, we need a.significand + // since we compare upper*upper to a.significand further down, we need a.significand // to be of twice the size. m.set(lower, 1); m.mul2k(lower, sbits+2-1); @@ -978,7 +978,7 @@ void my_mpz_sqrt(unsynch_mpz_manager & m, unsigned sbits, bool odd_exp, mpz & in } else { STRACE("mpf_dbg", tout << "choosing upper" << std::endl;); - m.set(o, upper); // chosing upper is like a sticky bit here. + m.set(o, upper); // choosing upper is like a sticky bit here. } break; } diff --git a/src/util/mpn.cpp b/src/util/mpn.cpp index b8cab4a9f..25445bc89 100644 --- a/src/util/mpn.cpp +++ b/src/util/mpn.cpp @@ -381,7 +381,7 @@ char * mpn_manager::to_string(mpn_digit const * a, size_t const lng, char * buf, div_1(t_numer, t_denom[0], &temp[0]); div_unnormalize(t_numer, t_denom, d, &rem); buf[j++] = '0' + rem; - while (temp.size() > 0 && temp.back() == 0) + while (!temp.empty() && temp.back() == 0) temp.pop_back(); } buf[j] = 0; diff --git a/src/util/mpn.h b/src/util/mpn.h index a5d3c30d8..bae972b0c 100644 --- a/src/util/mpn.h +++ b/src/util/mpn.h @@ -37,31 +37,31 @@ public: mpn_manager(); ~mpn_manager(); - int compare(mpn_digit const * a, size_t const lnga, - mpn_digit const * b, size_t const lngb) const; + int compare(mpn_digit const * a, size_t lnga, + mpn_digit const * b, size_t lngb) const; - bool add(mpn_digit const * a, size_t const lnga, - mpn_digit const * b, size_t const lngb, - mpn_digit *c, size_t const lngc_alloc, + bool add(mpn_digit const * a, size_t lnga, + mpn_digit const * b, size_t lngb, + mpn_digit *c, size_t lngc_alloc, size_t * plngc) const; - bool sub(mpn_digit const * a, size_t const lnga, - mpn_digit const * b, size_t const lngb, + bool sub(mpn_digit const * a, size_t lnga, + mpn_digit const * b, size_t lngb, mpn_digit * c, mpn_digit * pborrow) const; - bool mul(mpn_digit const * a, size_t const lnga, - mpn_digit const * b, size_t const lngb, + bool mul(mpn_digit const * a, size_t lnga, + mpn_digit const * b, size_t lngb, mpn_digit * c) const; - bool div(mpn_digit const * numer, size_t const lnum, - mpn_digit const * denom, size_t const lden, + bool div(mpn_digit const * numer, size_t lnum, + mpn_digit const * denom, size_t lden, mpn_digit * quot, mpn_digit * rem); - char * to_string(mpn_digit const * a, size_t const lng, - char * buf, size_t const lbuf) const; + char * to_string(mpn_digit const * a, size_t lng, + char * buf, size_t lbuf) const; private: - #ifdef _AMD64_ + #if defined(__LP64__) || defined(_WIN64) class mpn_sbuffer : public sbuffer { public: mpn_sbuffer() : sbuffer() {} @@ -88,29 +88,29 @@ private: static const mpn_digit zero; mpn_sbuffer u, v, t_ms, t_ab; - void display_raw(std::ostream & out, mpn_digit const * a, size_t const lng) const; + void display_raw(std::ostream & out, mpn_digit const * a, size_t lng) const; - size_t div_normalize(mpn_digit const * numer, size_t const lnum, - mpn_digit const * denom, size_t const lden, + size_t div_normalize(mpn_digit const * numer, size_t lnum, + mpn_digit const * denom, size_t lden, mpn_sbuffer & n_numer, mpn_sbuffer & n_denom) const; void div_unnormalize(mpn_sbuffer & numer, mpn_sbuffer & denom, - size_t const d, mpn_digit * rem) const; + size_t d, mpn_digit * rem) const; - bool div_1(mpn_sbuffer & numer, mpn_digit const denom, + bool div_1(mpn_sbuffer & numer, mpn_digit denom, mpn_digit * quot) const; bool div_n(mpn_sbuffer & numer, mpn_sbuffer const & denom, mpn_digit * quot, mpn_digit * rem, mpn_sbuffer & ms, mpn_sbuffer & ab) const; - void trace(mpn_digit const * a, size_t const lnga, - mpn_digit const * b, size_t const lngb, + void trace(mpn_digit const * a, size_t lnga, + mpn_digit const * b, size_t lngb, const char * op) const; - void trace(mpn_digit const * a, size_t const lnga) const; - void trace_nl(mpn_digit const * a, size_t const lnga) const; + void trace(mpn_digit const * a, size_t lnga) const; + void trace_nl(mpn_digit const * a, size_t lnga) const; }; #endif diff --git a/src/util/mpz.cpp b/src/util/mpz.cpp index 32a074eb3..0d3a6040d 100644 --- a/src/util/mpz.cpp +++ b/src/util/mpz.cpp @@ -30,7 +30,6 @@ Revision History: #else #error No multi-precision library selected. #endif -#include // Available GCD algorithms // #define EUCLID_GCD @@ -46,13 +45,18 @@ Revision History: #define LEHMER_GCD #endif +#ifdef _WINDOWS +// This is needed for _tzcnt_u32 and friends. +#include +#endif + #if defined(__GNUC__) #define _trailing_zeros32(X) __builtin_ctz(X) #else #define _trailing_zeros32(X) _tzcnt_u32(X) #endif -#if defined(_AMD64_) +#if defined(__LP64__) || defined(_WIN64) #if defined(__GNUC__) #define _trailing_zeros64(X) __builtin_ctzll(X) #else diff --git a/src/util/obj_ref.h b/src/util/obj_ref.h index 885601375..8908f2cdd 100644 --- a/src/util/obj_ref.h +++ b/src/util/obj_ref.h @@ -115,7 +115,7 @@ public: */ T * steal() { T * r = m_obj; - m_obj = 0; + m_obj = nullptr; return r; } }; diff --git a/src/util/obj_ref_hashtable.h b/src/util/obj_ref_hashtable.h index 23a2a1867..80d198607 100644 --- a/src/util/obj_ref_hashtable.h +++ b/src/util/obj_ref_hashtable.h @@ -7,7 +7,7 @@ Module Name: Abstract: - corresponding obj_map with reference count managment. + corresponding obj_map with reference count management. Author: diff --git a/src/util/params.cpp b/src/util/params.cpp index d7e05cb00..43f53514a 100644 --- a/src/util/params.cpp +++ b/src/util/params.cpp @@ -161,19 +161,15 @@ struct param_descrs::imp { void display(std::ostream & out, unsigned indent, bool smt2_style, bool include_descr) const { svector names; - dictionary::iterator it = m_info.begin(); - dictionary::iterator end = m_info.end(); - for (; it != end; ++it) { - names.push_back(it->m_key); + for (auto const& kv : m_info) { + names.push_back(kv.m_key); } std::sort(names.begin(), names.end(), lt()); - svector::iterator it2 = names.begin(); - svector::iterator end2 = names.end(); - for (; it2 != end2; ++it2) { + for (symbol const& name : names) { for (unsigned i = 0; i < indent; i++) out << " "; if (smt2_style) out << ':'; - char const * s = it2->bare_str(); + char const * s = name.bare_str(); unsigned n = static_cast(strlen(s)); for (unsigned i = 0; i < n; i++) { if (smt2_style && s[i] == '_') @@ -186,7 +182,7 @@ struct param_descrs::imp { out << s[i]; } info d; - m_info.find(*it2, d); + m_info.find(name, d); SASSERT(d.m_descr); out << " (" << d.m_kind << ")"; if (include_descr) @@ -198,10 +194,8 @@ struct param_descrs::imp { } void copy(param_descrs & other) { - dictionary::iterator it = other.m_imp->m_info.begin(); - dictionary::iterator end = other.m_imp->m_info.end(); - for (; it != end; ++it) { - insert(it->m_key, it->m_value.m_kind, it->m_value.m_descr, it->m_value.m_default, it->m_value.m_module); + for (auto const& kv : other.m_imp->m_info) { + insert(kv.m_key, kv.m_value.m_kind, kv.m_value.m_descr, kv.m_value.m_default, kv.m_value.m_module); } } @@ -346,24 +340,22 @@ public: void reset(symbol const & k); void reset(char const * k); - void validate(param_descrs const & p) { - svector::iterator it = m_entries.begin(); - svector::iterator end = m_entries.end(); + void validate(param_descrs const & p) { symbol suffix, prefix; - for (; it != end; ++it) { - param_kind expected = p.get_kind_in_module(it->first); + for (params::entry& e : m_entries) { + param_kind expected = p.get_kind_in_module(e.first); if (expected == CPK_INVALID) { std::stringstream strm; - strm << "unknown parameter '" << it->first.str() << "'\n"; + strm << "unknown parameter '" << e.first.str() << "'\n"; strm << "Legal parameters are:\n"; p.display(strm, 2, false, false); throw default_exception(strm.str()); } - if (it->second.m_kind != expected && - !(it->second.m_kind == CPK_UINT && expected == CPK_NUMERAL)) { + if (e.second.m_kind != expected && + !(e.second.m_kind == CPK_UINT && expected == CPK_NUMERAL)) { std::stringstream strm; - strm << "Parameter " << it->first.str() << " was given argument of type "; - strm << it->second.m_kind << ", expected " << expected; + strm << "Parameter " << e.first.str() << " was given argument of type "; + strm << e.second.m_kind << ", expected " << expected; throw default_exception(strm.str()); } } @@ -405,28 +397,26 @@ public: void display(std::ostream & out) const { out << "(params"; - svector::const_iterator it = m_entries.begin(); - svector::const_iterator end = m_entries.end(); - for (; it != end; ++it) { - out << " " << it->first; - switch (it->second.m_kind) { + for (params::entry const& e : m_entries) { + out << " " << e.first; + switch (e.second.m_kind) { case CPK_BOOL: - out << " " << (it->second.m_bool_value?"true":"false"); + out << " " << (e.second.m_bool_value?"true":"false"); break; case CPK_UINT: - out << " " <second.m_uint_value; + out << " " <second.m_double_value; + out << " " << e.second.m_double_value; break; case CPK_NUMERAL: - out << " " << *(it->second.m_rat_value); + out << " " << *(e.second.m_rat_value); break; case CPK_SYMBOL: - out << " " << symbol::mk_symbol_from_c_ptr(it->second.m_sym_value); + out << " " << symbol::mk_symbol_from_c_ptr(e.second.m_sym_value); break; case CPK_STRING: - out << " " << it->second.m_str_value; + out << " " << e.second.m_str_value; break; default: UNREACHABLE(); @@ -437,31 +427,29 @@ public: } void display_smt2(std::ostream & out, char const* module, param_descrs& descrs) const { - svector::const_iterator it = m_entries.begin(); - svector::const_iterator end = m_entries.end(); - for (; it != end; ++it) { - if (!descrs.contains(it->first)) continue; + for (params::entry const& e : m_entries) { + if (!descrs.contains(e.first)) continue; out << "(set-option :"; out << module << "."; - out << it->first; - switch (it->second.m_kind) { + out << e.first; + switch (e.second.m_kind) { case CPK_BOOL: - out << " " << (it->second.m_bool_value?"true":"false"); + out << " " << (e.second.m_bool_value?"true":"false"); break; case CPK_UINT: - out << " " <second.m_uint_value; + out << " " <second.m_double_value; + out << " " << e.second.m_double_value; break; case CPK_NUMERAL: - out << " " << *(it->second.m_rat_value); + out << " " << *(e.second.m_rat_value); break; case CPK_SYMBOL: - out << " " << symbol::mk_symbol_from_c_ptr(it->second.m_sym_value); + out << " " << symbol::mk_symbol_from_c_ptr(e.second.m_sym_value); break; case CPK_STRING: - out << " " << it->second.m_str_value; + out << " " << e.second.m_str_value; break; default: UNREACHABLE(); @@ -472,29 +460,27 @@ public: } void display(std::ostream & out, symbol const & k) const { - svector::const_iterator it = m_entries.begin(); - svector::const_iterator end = m_entries.end(); - for (; it != end; ++it) { - if (it->first != k) + for (params::entry const& e : m_entries) { + if (e.first != k) continue; - switch (it->second.m_kind) { + switch (e.second.m_kind) { case CPK_BOOL: - out << (it->second.m_bool_value?"true":"false"); + out << (e.second.m_bool_value?"true":"false"); return; case CPK_UINT: - out << it->second.m_uint_value; + out << e.second.m_uint_value; return; case CPK_DOUBLE: - out << it->second.m_double_value; + out << e.second.m_double_value; return; case CPK_NUMERAL: - out << *(it->second.m_rat_value); + out << *(e.second.m_rat_value); return; case CPK_SYMBOL: - out << symbol::mk_symbol_from_c_ptr(it->second.m_sym_value); + out << symbol::mk_symbol_from_c_ptr(e.second.m_sym_value); return; case CPK_STRING: - out << it->second.m_str_value; + out << e.second.m_str_value; return; default: out << "internal"; @@ -786,6 +772,7 @@ void params::del_values() { return false; \ } + bool params::contains(symbol const & k) const { CONTAINS(k); } diff --git a/src/util/ref_vector.h b/src/util/ref_vector.h index 1e6525a06..d0e9a8f55 100644 --- a/src/util/ref_vector.h +++ b/src/util/ref_vector.h @@ -186,6 +186,7 @@ public: std::swap(m_nodes[i], m_nodes[sz-i-1]); } } + }; template @@ -304,6 +305,77 @@ public: // prevent abuse: ref_vector & operator=(ref_vector const & other) = delete; + + bool operator==(ref_vector const& other) const { + if (other.size() != this->size()) return false; + for (unsigned i = this->size(); i-- > 0; ) { + if (other[i] != (*this)[i]) return false; + } + return true; + } + + bool operator!=(ref_vector const& other) const { + return !(*this == other); + } + + bool forall(std::function& predicate) const { + for (T* t : *this) + if (!predicate(t)) + return false; + return true; + } + + bool exists(std::function& predicate) const { + for (T* t : *this) + if (predicate(t)) + return true; + return false; + } + + ref_vector filter_pure(std::function& predicate) const { + ref_vector result(m()); + for (T* t : *this) + if (predicate(t)) + result.push_back(t); + return result; + } + +#if 0 + // TBD: + ref_vector& filter_update(std::function& predicate) { + unsigned j = 0; + for (auto& t : *this) + if (predicate(t)) + set(j++, t); + shrink(j); + return *this; + } +#endif + + template + vector mapv_pure(std::function& f) const { + vector result; + for (T* t : *this) + result.push_back(f(t)); + return result; + } + + ref_vector map_pure(std::function& f) const { + ref_vector result(m()); + for (T* t : *this) + result.push_back(f(t)); + return result; + } + + ref_vector& map_update(std::function& f) { + unsigned j = 0; + for (T* t : *this) + set(j++, f(t)); + return *this; + } + + + }; template diff --git a/src/util/scoped_ptr_vector.h b/src/util/scoped_ptr_vector.h index 920ecb2c9..52272389a 100644 --- a/src/util/scoped_ptr_vector.h +++ b/src/util/scoped_ptr_vector.h @@ -31,6 +31,7 @@ public: void reset() { std::for_each(m_vector.begin(), m_vector.end(), delete_proc()); m_vector.reset(); } void push_back(T * ptr) { m_vector.push_back(ptr); } void pop_back() { SASSERT(!empty()); set(size()-1, nullptr); m_vector.pop_back(); } + T * back() const { return m_vector.back(); } T * operator[](unsigned idx) const { return m_vector[idx]; } void set(unsigned idx, T * ptr) { if (m_vector[idx] == ptr) @@ -51,6 +52,13 @@ public: push_back(nullptr); } } + //!< swap last element with given pointer + void swap_back(scoped_ptr & ptr) { + SASSERT(!empty()); + T * tmp = ptr.detach(); + ptr = m_vector.back(); + m_vector[m_vector.size()-1] = tmp; + } }; #endif diff --git a/src/util/scoped_timer.cpp b/src/util/scoped_timer.cpp index 8078c46ee..871356d25 100644 --- a/src/util/scoped_timer.cpp +++ b/src/util/scoped_timer.cpp @@ -27,7 +27,7 @@ Revision History: // Windows #include #elif defined(__APPLE__) && defined(__MACH__) -// Mac OS X +// macOS #include #include #include @@ -59,7 +59,7 @@ struct scoped_timer::imp { HANDLE m_timer; bool m_first; #elif defined(__APPLE__) && defined(__MACH__) - // Mac OS X + // macOS pthread_t m_thread_id; pthread_attr_t m_attributes; unsigned m_interval; @@ -89,7 +89,7 @@ struct scoped_timer::imp { } } #elif defined(__APPLE__) && defined(__MACH__) - // Mac OS X + // macOS static void * thread_func(void * arg) { scoped_timer::imp * st = static_cast(arg); @@ -146,14 +146,14 @@ struct scoped_timer::imp { #if defined(_WINDOWS) || defined(_CYGWIN) m_first = true; CreateTimerQueueTimer(&m_timer, - NULL, + nullptr, abort_proc, this, 0, ms, WT_EXECUTEINTIMERTHREAD); #elif defined(__APPLE__) && defined(__MACH__) - // Mac OS X + // macOS m_interval = ms?ms:0xFFFFFFFF; if (pthread_attr_init(&m_attributes) != 0) throw default_exception("failed to initialize timer thread attributes"); @@ -180,9 +180,9 @@ struct scoped_timer::imp { m_ms = ms; m_initialized = false; m_signal_sent = false; - ENSURE(pthread_mutex_init(&m_mutex, NULL) == 0); - ENSURE(pthread_cond_init(&m_cond, NULL) == 0); - ENSURE(pthread_create(&m_thread_id, NULL, &thread_func, this) == 0); + ENSURE(pthread_mutex_init(&m_mutex, nullptr) == 0); + ENSURE(pthread_cond_init(&m_cond, nullptr) == 0); + ENSURE(pthread_create(&m_thread_id, nullptr, &thread_func, this) == 0); #else // Other platforms #endif @@ -190,11 +190,11 @@ struct scoped_timer::imp { ~imp() { #if defined(_WINDOWS) || defined(_CYGWIN) - DeleteTimerQueueTimer(NULL, + DeleteTimerQueueTimer(nullptr, m_timer, INVALID_HANDLE_VALUE); #elif defined(__APPLE__) && defined(__MACH__) - // Mac OS X + // macOS // If the waiting-thread is not up and waiting yet, // we can make sure that it finishes quickly by @@ -242,7 +242,7 @@ struct scoped_timer::imp { // Perform signal outside of lock to avoid waking timing thread twice. pthread_cond_signal(&m_cond); - pthread_join(m_thread_id, NULL); + pthread_join(m_thread_id, nullptr); pthread_cond_destroy(&m_cond); pthread_mutex_destroy(&m_mutex); #else diff --git a/src/util/stopwatch.h b/src/util/stopwatch.h index c606824b4..a11a87484 100644 --- a/src/util/stopwatch.h +++ b/src/util/stopwatch.h @@ -20,7 +20,7 @@ Revision History: #ifndef STOPWATCH_H_ #define STOPWATCH_H_ -#if defined(_WINDOWS) || defined(_CYGWIN) +#if defined(_WINDOWS) || defined(_CYGWIN) || defined(_MINGW) // Does this redefinition work? @@ -70,7 +70,7 @@ public: #undef min -#elif defined(__APPLE__) && defined (__MACH__) // Mac OS X +#elif defined(__APPLE__) && defined (__MACH__) // macOS #include #include diff --git a/src/util/symbol.h b/src/util/symbol.h index 40844cf3b..90a4eeb38 100644 --- a/src/util/symbol.h +++ b/src/util/symbol.h @@ -56,7 +56,7 @@ public: explicit symbol(char const * d); explicit symbol(unsigned idx): m_data(BOXTAGINT(char const *, idx, 1)) { -#ifndef _AMD64_ +#if !defined(__LP64__) && !defined(_WIN64) SASSERT(idx < (SIZE_MAX >> PTR_ALIGNMENT)); #endif } diff --git a/src/util/trace.h b/src/util/trace.h index 1a245036f..77c66afd4 100644 --- a/src/util/trace.h +++ b/src/util/trace.h @@ -24,10 +24,6 @@ Revision History: #undef max #undef min #endif -#ifdef __APPLE__ -#undef max -#undef min -#endif #include #ifdef _TRACE diff --git a/src/util/trail.h b/src/util/trail.h index b9f4602c7..fadafe724 100644 --- a/src/util/trail.h +++ b/src/util/trail.h @@ -143,6 +143,17 @@ public: }; +template +class insert_ref_map : public trail { + Mgr& m; + M& m_map; + D m_obj; +public: + insert_ref_map(Mgr& m, M& t, D o) : m(m), m_map(t), m_obj(o) {} + virtual ~insert_ref_map() {} + virtual void undo(Ctx & ctx) { m_map.remove(m_obj); m.dec_ref(m_obj); } +}; + template class push_back_vector : public trail { diff --git a/src/util/uint_set.h b/src/util/uint_set.h index 0f3715cb1..202df1039 100644 --- a/src/util/uint_set.h +++ b/src/util/uint_set.h @@ -269,10 +269,10 @@ public: void remove(unsigned v) { if (contains(v)) { m_in_set[v] = false; - unsigned i = 0; - for (i = 0; i < m_set.size() && m_set[i] != v; ++i) + unsigned i = m_set.size(); + for (; i > 0 && m_set[--i] != v; ) ; - SASSERT(i < m_set.size()); + SASSERT(m_set[i] == v); m_set[i] = m_set.back(); m_set.pop_back(); } diff --git a/src/util/util.h b/src/util/util.h index b9f3bdc28..0ca02bc84 100644 --- a/src/util/util.h +++ b/src/util/util.h @@ -63,14 +63,6 @@ static_assert(sizeof(int64_t) == 8, "64 bits"); #define VEC2PTR(_x_) ((_x_).size() ? &(_x_)[0] : 0) -#ifdef _WINDOWS -// Disable thread local declspec as it seems to not work downlevel. -// #define THREAD_LOCAL __declspec(thread) -#define THREAD_LOCAL -#else -#define THREAD_LOCAL -#endif - #ifdef _MSC_VER # define STD_CALL __cdecl #else diff --git a/src/util/vector.h b/src/util/vector.h index edcee7449..acbcd1357 100644 --- a/src/util/vector.h +++ b/src/util/vector.h @@ -28,6 +28,7 @@ Revision History: #include #include #include +#include #include "util/memory_manager.h" #include "util/hash.h" #include "util/z3_exception.h" @@ -230,6 +231,51 @@ public: return *this; } + bool containsp(std::function& predicate) const { + for (auto const& t : *this) + if (predicate(t)) + return true; + return false; + } + + /** + * retain elements that satisfy predicate. aka 'where'. + */ + vector filter_pure(std::function& predicate) const { + vector result; + for (auto& t : *this) + if (predicate(t)) + result.push_back(t); + return result; + } + + vector& filter_update(std::function& predicate) { + unsigned j = 0; + for (auto& t : *this) + if (predicate(t)) + set(j++, t); + shrink(j); + return *this; + } + + /** + * update elements using f, aka 'select' + */ + template + vector map_pure(std::function& f) const { + vector result; + for (auto& t : *this) + result.push_back(f(t)); + return result; + } + + vector& map_update(std::function& f) { + unsigned j = 0; + for (auto& t : *this) + set(j++, f(t)); + return *this; + } + void reset() { if (m_data) { if (CallDestructors) { diff --git a/src/util/warning.cpp b/src/util/warning.cpp index 6184db880..5ffc38527 100644 --- a/src/util/warning.cpp +++ b/src/util/warning.cpp @@ -16,8 +16,8 @@ Author: Revision History: --*/ -#include -#include +#include +#include #include "util/error_codes.h" #include "util/util.h" @@ -25,7 +25,6 @@ Revision History: #include "util/vector.h" #ifdef _WINDOWS -#define PRF sprintf_s #define VPRF vsprintf_s void STD_CALL myInvalidParameterHandler( @@ -54,7 +53,6 @@ void STD_CALL myInvalidParameterHandler( #else -#define PRF snprintf #define VPRF vsnprintf #define BEGIN_ERR_HANDLER() {} #define END_ERR_HANDLER() {} @@ -64,7 +62,6 @@ static bool g_warning_msgs = true; static bool g_use_std_stdout = false; static std::ostream* g_error_stream = nullptr; static std::ostream* g_warning_stream = nullptr; -static bool g_show_error_msg_prefix = true; void send_warnings_to_stdout(bool flag) { g_use_std_stdout = flag; @@ -82,61 +79,24 @@ void set_warning_stream(std::ostream* strm) { g_warning_stream = strm; } -void disable_error_msg_prefix() { - g_show_error_msg_prefix = false; -} - -#if 0 -// [Leo]: Do we need this? -static void string2ostream(std::ostream& out, char const* msg) { - svector buff; - buff.resize(10); - BEGIN_ERR_HANDLER(); - while (true) { - int nc = PRF(buff.c_ptr(), buff.size(), msg); - if (nc >= 0 && nc < static_cast(buff.size())) - break; // success - buff.resize(buff.size()*2 + 1); - } - END_ERR_HANDLER(); - out << buff.c_ptr(); -} -#endif - void format2ostream(std::ostream & out, char const* msg, va_list args) { svector buff; -#if !defined(_WINDOWS) && defined(_AMD64_) - // see comment below. - buff.resize(1024); -#else - buff.resize(128); -#endif BEGIN_ERR_HANDLER(); - while (true) { - int nc = VPRF(buff.c_ptr(), buff.size(), msg, args); -#if !defined(_WINDOWS) && defined(_AMD64_) - // For some strange reason, on Linux 64-bit version, va_list args is reset by vsnprintf. - // Z3 crashes when trying to use va_list args again. - // Hack: I truncate the message instead of expanding the buffer to make sure that - // va_list args is only used once. - END_ERR_HANDLER(); - if (nc < 0) { - // vsnprintf didn't work, so we just print the msg - out << msg; - return; - } - if (nc >= static_cast(buff.size())) { - // truncate the message - buff[buff.size() - 1] = 0; - } - out << buff.c_ptr(); - return; + + va_list args_copy; + va_copy(args_copy, args); +#ifdef _WINDOWS + size_t msg_len = _vscprintf(msg, args_copy); #else - if (nc >= 0 && nc < static_cast(buff.size())) - break; // success - buff.resize(buff.size()*2 + 1); + size_t msg_len = vsnprintf(nullptr, 0, msg, args_copy); #endif - } + va_end(args_copy); + + // +1 is for NUL termination. + buff.resize(static_cast(msg_len + 1)); + + VPRF(buff.c_ptr(), buff.size(), msg, args); + END_ERR_HANDLER(); out << buff.c_ptr(); } diff --git a/src/util/warning.h b/src/util/warning.h index 15f1a1757..2bcc7512b 100644 --- a/src/util/warning.h +++ b/src/util/warning.h @@ -31,30 +31,7 @@ void set_warning_stream(std::ostream* strm); void warning_msg(const char * msg, ...); -void disable_error_msg_prefix(); - void format2ostream(std::ostream& out, char const* fmt, va_list args); -class warning_displayer { - const char * m_msg; - bool m_displayed; -public: - warning_displayer(const char * msg): - m_msg(msg), - m_displayed(false) { - } - - void sign() { - if (!m_displayed) { - warning_msg(m_msg); - m_displayed = true; - } - } - - void reset() { - m_displayed = false; - } -}; - #endif /* WARNING_H_ */ diff --git a/src/util/version.h.cmake.in b/src/util/z3_version.h.cmake.in similarity index 100% rename from src/util/version.h.cmake.in rename to src/util/z3_version.h.cmake.in diff --git a/src/util/version.h.in b/src/util/z3_version.h.in similarity index 100% rename from src/util/version.h.in rename to src/util/z3_version.h.in